Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "net/dcsctp/packet/sctp_packet.h"
#include <cstdint>
#include <utility>
#include <vector>
#include "api/array_view.h"
#include "net/dcsctp/common/internal_types.h"
#include "net/dcsctp/common/math.h"
#include "net/dcsctp/packet/chunk/abort_chunk.h"
#include "net/dcsctp/packet/chunk/cookie_ack_chunk.h"
#include "net/dcsctp/packet/chunk/data_chunk.h"
#include "net/dcsctp/packet/chunk/init_chunk.h"
#include "net/dcsctp/packet/chunk/sack_chunk.h"
#include "net/dcsctp/packet/error_cause/error_cause.h"
#include "net/dcsctp/packet/error_cause/user_initiated_abort_cause.h"
#include "net/dcsctp/packet/parameter/parameter.h"
#include "net/dcsctp/packet/tlv_trait.h"
#include "net/dcsctp/public/dcsctp_options.h"
#include "net/dcsctp/testing/testing_macros.h"
#include "rtc_base/gunit.h"
#include "test/gmock.h"
namespace dcsctp {
namespace {
using ::testing::ElementsAre;
using ::testing::SizeIs;
constexpr VerificationTag kVerificationTag = VerificationTag(0x12345678);
constexpr DcSctpOptions kVerifyChecksumOptions =
DcSctpOptions{.disable_checksum_verification = false,
.zero_checksum_alternate_error_detection_method =
ZeroChecksumAlternateErrorDetectionMethod::None()};
TEST(SctpPacketTest, DeserializeSimplePacketFromCapture) {
/*
Stream Control Transmission Protocol, Src Port: 5000 (5000), Dst Port: 5000
(5000) Source port: 5000 Destination port: 5000 Verification tag: 0x00000000
[Association index: 1]
Checksum: 0xaa019d33 [unverified]
[Checksum Status: Unverified]
INIT chunk (Outbound streams: 1000, inbound streams: 1000)
Chunk type: INIT (1)
Chunk flags: 0x00
Chunk length: 90
Initiate tag: 0x0eddca08
Advertised receiver window credit (a_rwnd): 131072
Number of outbound streams: 1000
Number of inbound streams: 1000
Initial TSN: 1426601527
ECN parameter
Parameter type: ECN (0x8000)
Parameter length: 4
Forward TSN supported parameter
Parameter type: Forward TSN supported (0xc000)
Parameter length: 4
Supported Extensions parameter (Supported types: FORWARD_TSN, AUTH,
ASCONF, ASCONF_ACK, RE_CONFIG) Parameter type: Supported Extensions
(0x8008) Parameter length: 9 Supported chunk type: FORWARD_TSN (192) Supported
chunk type: AUTH (15) Supported chunk type: ASCONF (193) Supported chunk type:
ASCONF_ACK (128) Supported chunk type: RE_CONFIG (130) Parameter padding:
000000 Random parameter Parameter type: Random (0x8002) Parameter length: 36
Random number: c5a86155090e6f420050634cc8d6b908dfd53e17c99cb143…
Requested HMAC Algorithm parameter (Supported HMACs: SHA-1)
Parameter type: Requested HMAC Algorithm (0x8004)
Parameter length: 6
HMAC identifier: SHA-1 (1)
Parameter padding: 0000
Authenticated Chunk list parameter (Chunk types to be authenticated:
ASCONF_ACK, ASCONF) Parameter type: Authenticated Chunk list
(0x8003) Parameter length: 6 Chunk type: ASCONF_ACK (128) Chunk type: ASCONF
(193) Chunk padding: 0000
*/
uint8_t data[] = {
0x13, 0x88, 0x13, 0x88, 0x00, 0x00, 0x00, 0x00, 0xaa, 0x01, 0x9d, 0x33,
0x01, 0x00, 0x00, 0x5a, 0x0e, 0xdd, 0xca, 0x08, 0x00, 0x02, 0x00, 0x00,
0x03, 0xe8, 0x03, 0xe8, 0x55, 0x08, 0x36, 0x37, 0x80, 0x00, 0x00, 0x04,
0xc0, 0x00, 0x00, 0x04, 0x80, 0x08, 0x00, 0x09, 0xc0, 0x0f, 0xc1, 0x80,
0x82, 0x00, 0x00, 0x00, 0x80, 0x02, 0x00, 0x24, 0xc5, 0xa8, 0x61, 0x55,
0x09, 0x0e, 0x6f, 0x42, 0x00, 0x50, 0x63, 0x4c, 0xc8, 0xd6, 0xb9, 0x08,
0xdf, 0xd5, 0x3e, 0x17, 0xc9, 0x9c, 0xb1, 0x43, 0x28, 0x4e, 0xaf, 0x64,
0x68, 0x2a, 0xc2, 0x97, 0x80, 0x04, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00,
0x80, 0x03, 0x00, 0x06, 0x80, 0xc1, 0x00, 0x00};
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket packet,
SctpPacket::Parse(data, kVerifyChecksumOptions));
EXPECT_EQ(packet.common_header().source_port, 5000);
EXPECT_EQ(packet.common_header().destination_port, 5000);
EXPECT_EQ(packet.common_header().verification_tag, VerificationTag(0));
EXPECT_EQ(packet.common_header().checksum, 0xaa019d33);
EXPECT_THAT(packet.descriptors(), SizeIs(1));
EXPECT_EQ(packet.descriptors()[0].type, InitChunk::kType);
ASSERT_HAS_VALUE_AND_ASSIGN(InitChunk init,
InitChunk::Parse(packet.descriptors()[0].data));
EXPECT_EQ(init.initial_tsn(), TSN(1426601527));
}
TEST(SctpPacketTest, DeserializePacketWithTwoChunks) {
/*
Stream Control Transmission Protocol, Src Port: 1234 (1234),
Dst Port: 4321 (4321)
Source port: 1234
Destination port: 4321
Verification tag: 0x697e3a4e
[Association index: 3]
Checksum: 0xc06e8b36 [unverified]
[Checksum Status: Unverified]
COOKIE_ACK chunk
Chunk type: COOKIE_ACK (11)
Chunk flags: 0x00
Chunk length: 4
SACK chunk (Cumulative TSN: 2930332242, a_rwnd: 131072,
gaps: 0, duplicate TSNs: 0)
Chunk type: SACK (3)
Chunk flags: 0x00
Chunk length: 16
Cumulative TSN ACK: 2930332242
Advertised receiver window credit (a_rwnd): 131072
Number of gap acknowledgement blocks: 0
Number of duplicated TSNs: 0
*/
uint8_t data[] = {0x04, 0xd2, 0x10, 0xe1, 0x69, 0x7e, 0x3a, 0x4e,
0xc0, 0x6e, 0x8b, 0x36, 0x0b, 0x00, 0x00, 0x04,
0x03, 0x00, 0x00, 0x10, 0xae, 0xa9, 0x52, 0x52,
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket packet,
SctpPacket::Parse(data, kVerifyChecksumOptions));
EXPECT_EQ(packet.common_header().source_port, 1234);
EXPECT_EQ(packet.common_header().destination_port, 4321);
EXPECT_EQ(packet.common_header().verification_tag,
VerificationTag(0x697e3a4eu));
EXPECT_EQ(packet.common_header().checksum, 0xc06e8b36u);
EXPECT_THAT(packet.descriptors(), SizeIs(2));
EXPECT_EQ(packet.descriptors()[0].type, CookieAckChunk::kType);
EXPECT_EQ(packet.descriptors()[1].type, SackChunk::kType);
ASSERT_HAS_VALUE_AND_ASSIGN(
CookieAckChunk cookie_ack,
CookieAckChunk::Parse(packet.descriptors()[0].data));
ASSERT_HAS_VALUE_AND_ASSIGN(SackChunk sack,
SackChunk::Parse(packet.descriptors()[1].data));
}
TEST(SctpPacketTest, DeserializePacketWithWrongChecksum) {
/*
Stream Control Transmission Protocol, Src Port: 5000 (5000),
Dst Port: 5000 (5000)
Source port: 5000
Destination port: 5000
Verification tag: 0x0eddca08
[Association index: 1]
Checksum: 0x2a81f531 [unverified]
[Checksum Status: Unverified]
SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072,
gaps: 0, duplicate TSNs: 0)
Chunk type: SACK (3)
Chunk flags: 0x00
Chunk length: 16
Cumulative TSN ACK: 1426601536
Advertised receiver window credit (a_rwnd): 131072
Number of gap acknowledgement blocks: 0
Number of duplicated TSNs: 0
*/
uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x2a, 0x81,
0xf5, 0x31, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40,
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
EXPECT_FALSE(SctpPacket::Parse(data, kVerifyChecksumOptions).has_value());
}
TEST(SctpPacketTest, DeserializePacketDontValidateChecksum) {
/*
Stream Control Transmission Protocol, Src Port: 5000 (5000),
Dst Port: 5000 (5000)
Source port: 5000
Destination port: 5000
Verification tag: 0x0eddca08
[Association index: 1]
Checksum: 0x2a81f531 [unverified]
[Checksum Status: Unverified]
SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072,
gaps: 0, duplicate TSNs: 0)
Chunk type: SACK (3)
Chunk flags: 0x00
Chunk length: 16
Cumulative TSN ACK: 1426601536
Advertised receiver window credit (a_rwnd): 131072
Number of gap acknowledgement blocks: 0
Number of duplicated TSNs: 0
*/
uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x2a, 0x81,
0xf5, 0x31, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40,
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
ASSERT_HAS_VALUE_AND_ASSIGN(
SctpPacket packet,
SctpPacket::Parse(
data, {.disable_checksum_verification = true,
.zero_checksum_alternate_error_detection_method =
ZeroChecksumAlternateErrorDetectionMethod::None()}));
EXPECT_EQ(packet.common_header().source_port, 5000);
EXPECT_EQ(packet.common_header().destination_port, 5000);
EXPECT_EQ(packet.common_header().verification_tag,
VerificationTag(0x0eddca08u));
EXPECT_EQ(packet.common_header().checksum, 0x2a81f531u);
}
TEST(SctpPacketTest, SerializeAndDeserializeSingleChunk) {
SctpPacket::Builder b(kVerificationTag, {});
InitChunk init(/*initiate_tag=*/VerificationTag(123), /*a_rwnd=*/456,
/*nbr_outbound_streams=*/65535,
/*nbr_inbound_streams=*/65534, /*initial_tsn=*/TSN(789),
/*parameters=*/Parameters());
b.Add(init);
std::vector<uint8_t> serialized = b.Build();
ASSERT_HAS_VALUE_AND_ASSIGN(
SctpPacket packet, SctpPacket::Parse(serialized, kVerifyChecksumOptions));
EXPECT_EQ(packet.common_header().verification_tag, kVerificationTag);
ASSERT_THAT(packet.descriptors(), SizeIs(1));
EXPECT_EQ(packet.descriptors()[0].type, InitChunk::kType);
ASSERT_HAS_VALUE_AND_ASSIGN(InitChunk deserialized,
InitChunk::Parse(packet.descriptors()[0].data));
EXPECT_EQ(deserialized.initiate_tag(), VerificationTag(123));
EXPECT_EQ(deserialized.a_rwnd(), 456u);
EXPECT_EQ(deserialized.nbr_outbound_streams(), 65535u);
EXPECT_EQ(deserialized.nbr_inbound_streams(), 65534u);
EXPECT_EQ(deserialized.initial_tsn(), TSN(789));
}
TEST(SctpPacketTest, SerializeAndDeserializeThreeChunks) {
SctpPacket::Builder b(kVerificationTag, {});
b.Add(SackChunk(/*cumulative_tsn_ack=*/TSN(999), /*a_rwnd=*/456,
{SackChunk::GapAckBlock(2, 3)},
/*duplicate_tsns=*/{TSN(1), TSN(2), TSN(3)}));
b.Add(DataChunk(TSN(123), StreamID(456), SSN(789), PPID(9090),
/*payload=*/{1, 2, 3, 4, 5},
/*options=*/{}));
b.Add(DataChunk(TSN(124), StreamID(654), SSN(987), PPID(909),
/*payload=*/{5, 4, 3, 3, 1},
/*options=*/{}));
std::vector<uint8_t> serialized = b.Build();
ASSERT_HAS_VALUE_AND_ASSIGN(
SctpPacket packet, SctpPacket::Parse(serialized, kVerifyChecksumOptions));
EXPECT_EQ(packet.common_header().verification_tag, kVerificationTag);
ASSERT_THAT(packet.descriptors(), SizeIs(3));
EXPECT_EQ(packet.descriptors()[0].type, SackChunk::kType);
EXPECT_EQ(packet.descriptors()[1].type, DataChunk::kType);
EXPECT_EQ(packet.descriptors()[2].type, DataChunk::kType);
ASSERT_HAS_VALUE_AND_ASSIGN(SackChunk sack,
SackChunk::Parse(packet.descriptors()[0].data));
EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(999));
EXPECT_EQ(sack.a_rwnd(), 456u);
ASSERT_HAS_VALUE_AND_ASSIGN(DataChunk data1,
DataChunk::Parse(packet.descriptors()[1].data));
EXPECT_EQ(data1.tsn(), TSN(123));
ASSERT_HAS_VALUE_AND_ASSIGN(DataChunk data2,
DataChunk::Parse(packet.descriptors()[2].data));
EXPECT_EQ(data2.tsn(), TSN(124));
}
TEST(SctpPacketTest, ParseAbortWithEmptyCause) {
SctpPacket::Builder b(kVerificationTag, {});
b.Add(AbortChunk(
/*filled_in_verification_tag=*/true,
Parameters::Builder().Add(UserInitiatedAbortCause("")).Build()));
ASSERT_HAS_VALUE_AND_ASSIGN(
SctpPacket packet, SctpPacket::Parse(b.Build(), kVerifyChecksumOptions));
EXPECT_EQ(packet.common_header().verification_tag, kVerificationTag);
ASSERT_THAT(packet.descriptors(), SizeIs(1));
EXPECT_EQ(packet.descriptors()[0].type, AbortChunk::kType);
ASSERT_HAS_VALUE_AND_ASSIGN(AbortChunk abort,
AbortChunk::Parse(packet.descriptors()[0].data));
ASSERT_HAS_VALUE_AND_ASSIGN(
UserInitiatedAbortCause cause,
abort.error_causes().get<UserInitiatedAbortCause>());
EXPECT_EQ(cause.upper_layer_abort_reason(), "");
}
TEST(SctpPacketTest, DetectPacketWithZeroSizeChunk) {
uint8_t data[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x0a, 0x0a, 0x5c,
0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00};
EXPECT_FALSE(SctpPacket::Parse(data, kVerifyChecksumOptions).has_value());
}
TEST(SctpPacketTest, ReturnsCorrectSpaceAvailableToStayWithinMTU) {
DcSctpOptions options;
options.mtu = 1191;
SctpPacket::Builder builder(VerificationTag(123), options);
// Chunks will be padded to an even 4 bytes, so the maximum packet size should
// be rounded down.
const size_t kMaxPacketSize = RoundDownTo4(options.mtu);
EXPECT_EQ(kMaxPacketSize, 1188u);
const size_t kSctpHeaderSize = 12;
EXPECT_EQ(builder.bytes_remaining(), kMaxPacketSize - kSctpHeaderSize);
EXPECT_EQ(builder.bytes_remaining(), 1176u);
// Add a smaller packet first.
DataChunk::Options data_options;
std::vector<uint8_t> payload1(183);
builder.Add(
DataChunk(TSN(1), StreamID(1), SSN(0), PPID(53), payload1, data_options));
size_t chunk1_size = RoundUpTo4(DataChunk::kHeaderSize + payload1.size());
EXPECT_EQ(builder.bytes_remaining(),
kMaxPacketSize - kSctpHeaderSize - chunk1_size);
EXPECT_EQ(builder.bytes_remaining(), 976u); // Hand-calculated.
std::vector<uint8_t> payload2(957);
builder.Add(
DataChunk(TSN(1), StreamID(1), SSN(0), PPID(53), payload2, data_options));
size_t chunk2_size = RoundUpTo4(DataChunk::kHeaderSize + payload2.size());
EXPECT_EQ(builder.bytes_remaining(),
kMaxPacketSize - kSctpHeaderSize - chunk1_size - chunk2_size);
EXPECT_EQ(builder.bytes_remaining(), 0u); // Hand-calculated.
}
TEST(SctpPacketTest, AcceptsZeroSetZeroChecksum) {
/*
Stream Control Transmission Protocol, Src Port: 5000 (5000),
Dst Port: 5000 (5000)
Source port: 5000
Destination port: 5000
Verification tag: 0x0eddca08
[Association index: 1]
Checksum: 0x00000000 [unverified]
[Checksum Status: Unverified]
SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072,
gaps: 0, duplicate TSNs: 0)
Chunk type: SACK (3)
Chunk flags: 0x00
Chunk length: 16
Cumulative TSN ACK: 1426601536
Advertised receiver window credit (a_rwnd): 131072
Number of gap acknowledgement blocks: 0
Number of duplicated TSNs: 0
*/
uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x00, 0x00,
0x00, 0x00, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40,
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
ASSERT_HAS_VALUE_AND_ASSIGN(
SctpPacket packet,
SctpPacket::Parse(
data,
{.disable_checksum_verification = false,
.zero_checksum_alternate_error_detection_method =
ZeroChecksumAlternateErrorDetectionMethod::LowerLayerDtls()}));
EXPECT_EQ(packet.common_header().source_port, 5000);
EXPECT_EQ(packet.common_header().destination_port, 5000);
EXPECT_EQ(packet.common_header().verification_tag,
VerificationTag(0x0eddca08u));
EXPECT_EQ(packet.common_header().checksum, 0x00000000u);
}
TEST(SctpPacketTest, RejectsNonZeroIncorrectChecksumWhenZeroChecksumIsActive) {
/*
Stream Control Transmission Protocol, Src Port: 5000 (5000),
Dst Port: 5000 (5000)
Source port: 5000
Destination port: 5000
Verification tag: 0x0eddca08
[Association index: 1]
Checksum: 0x00000001 [unverified]
[Checksum Status: Unverified]
SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072,
gaps: 0, duplicate TSNs: 0)
Chunk type: SACK (3)
Chunk flags: 0x00
Chunk length: 16
Cumulative TSN ACK: 1426601536
Advertised receiver window credit (a_rwnd): 131072
Number of gap acknowledgement blocks: 0
Number of duplicated TSNs: 0
*/
uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x01, 0x00,
0x00, 0x00, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40,
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
EXPECT_FALSE(
SctpPacket::Parse(
data,
{.disable_checksum_verification = false,
.zero_checksum_alternate_error_detection_method =
ZeroChecksumAlternateErrorDetectionMethod::LowerLayerDtls()})
.has_value());
}
TEST(SctpPacketTest, WritePacketWithCalculatedChecksum) {
SctpPacket::Builder b(kVerificationTag, {});
b.Add(SackChunk(/*cumulative_tsn_ack=*/TSN(999), /*a_rwnd=*/456,
/*gap_ack_blocks=*/{},
/*duplicate_tsns=*/{}));
EXPECT_THAT(b.Build(),
ElementsAre(0x13, 0x88, 0x13, 0x88, 0x12, 0x34, 0x56, 0x78, //
0x07, 0xe8, 0x38, 0x77, // checksum
0x03, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0xe7, 0x00,
0x00, 0x01, 0xc8, 0x00, 0x00, 0x00, 0x00));
}
TEST(SctpPacketTest, WritePacketWithZeroChecksum) {
SctpPacket::Builder b(kVerificationTag, {});
b.Add(SackChunk(/*cumulative_tsn_ack=*/TSN(999), /*a_rwnd=*/456,
/*gap_ack_blocks=*/{},
/*duplicate_tsns=*/{}));
EXPECT_THAT(b.Build(/*write_checksum=*/false),
ElementsAre(0x13, 0x88, 0x13, 0x88, 0x12, 0x34, 0x56, 0x78, //
0x00, 0x00, 0x00, 0x00, // checksum
0x03, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0xe7, 0x00,
0x00, 0x01, 0xc8, 0x00, 0x00, 0x00, 0x00));
}
} // namespace
} // namespace dcsctp