mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
webrtc/net/dcsctp/packet/sctp_packet_test.cc
Victor Boivie 2bfb5db548 dcsctp: Update zero checksum option to v-06 draft 
https://datatracker.ietf.org/doc/draft-ietf-tsvwg-sctp-zero-checksum/06/

The previous implementation was for version 00, and since then changes
have been made. The chunk that is used to negotiate this capability has
now grown to include an additional property - the sender's alternate
error detection method.

Bug: webrtc:14997
Change-Id: I78043d187b79f40bbadbcba02eae6eedf54f30f9
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/336380
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Victor Boivie <boivie@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41759}
2024-02-19 10:25:17 +00:00

452 lines
18 KiB
C++
Raw Permalink Blame History

/*
* 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
Reference in a new issue View git blame Copy permalink