def test_long_header_then_short_header(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL, fully padded
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
builder.start_frame(QuicFrameType.CRYPTO)
builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 1280)
# ONE_RTT, fully padded
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 1253)
builder.start_frame(QuicFrameType.STREAM_BASE)
builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 2)
self.assertEqual(len(datagrams[0]), 1280)
self.assertEqual(len(datagrams[1]), 1280)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=1280,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
in_flight=True,
is_ack_eliciting=True,
is_crypto_packet=False,
packet_number=1,
sent_bytes=1280,
),
],
)
def test_short_header_max_total_bytes_1(self):
"""
max_total_bytes doesn't allow any packets.
"""
builder = create_builder()
builder.max_total_bytes = 11
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
with self.assertRaises(QuicPacketBuilderStop):
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
def test_encrypt_short_server(self):
pair = CryptoPair()
pair.send.setup(
INITIAL_CIPHER_SUITE,
binascii.unhexlify(
"310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
),
)
packet = pair.encrypt_packet(SHORT_SERVER_PLAIN_HEADER,
SHORT_SERVER_PLAIN_PAYLOAD)
self.assertEqual(packet, SHORT_SERVER_ENCRYPTED_PACKET)
def test_encrypt_chacha20(self):
pair = CryptoPair()
pair.send.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
packet = pair.encrypt_packet(CHACHA20_CLIENT_PLAIN_HEADER,
CHACHA20_CLIENT_PLAIN_PAYLOAD)
self.assertEqual(packet, CHACHA20_CLIENT_ENCRYPTED_PACKET)
def test_decrypt_short_server(self):
pair = CryptoPair()
pair.recv.setup(
INITIAL_CIPHER_SUITE,
binascii.unhexlify(
"310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
SHORT_SERVER_ENCRYPTED_PACKET, 9)
self.assertEqual(plain_header, SHORT_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, SHORT_SERVER_PLAIN_PAYLOAD)
self.assertEqual(packet_number, 3)
def test_decrypt_chacha20(self):
pair = CryptoPair()
pair.recv.setup(
CipherSuite.CHACHA20_POLY1305_SHA256,
binascii.unhexlify(
"fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
),
)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
CHACHA20_CLIENT_ENCRYPTED_PACKET, 34)
self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
self.assertEqual(packet_number, 2)
def create_crypto(self, is_client):
pair = CryptoPair()
pair.setup_initial(cid=binascii.unhexlify("8394c8f03e515708"),
is_client=is_client)
if is_client:
self.assertEqual(pair.send.iv,
binascii.unhexlify("19e94387805eb0b46c03a788"))
self.assertEqual(pair.recv.iv,
binascii.unhexlify("0a82086d32205ba22241d8dc"))
else:
self.assertEqual(pair.send.iv,
binascii.unhexlify("0a82086d32205ba22241d8dc"))
self.assertEqual(pair.recv.iv,
binascii.unhexlify("19e94387805eb0b46c03a788"))
return pair
def test_short_header_max_total_bytes_2(self):
"""
max_total_bytes allows a short packet.
"""
builder = create_builder()
builder.max_total_bytes = 800
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 773)
builder.buffer.push_bytes(bytes(builder.remaining_space))
self.assertTrue(builder.end_packet())
with self.assertRaises(QuicPacketBuilderStop):
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
def test_receive_datagram_wrong_version(self):
client = create_standalone_client(self)
builder = QuicPacketBuilder(
host_cid=client._peer_cid,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
crypto = CryptoPair()
crypto.setup_initial(client.host_cid, is_client=False)
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
builder.buffer.push_bytes(bytes(1200))
builder.end_packet()
for datagram in builder.flush()[0]:
client.receive_datagram(datagram, SERVER_ADDR, now=time.time())
self.assertEqual(drop(client), 0)
def test_datagram_received_wrong_version(self):
client, client_transport = create_standalone_client()
self.assertEqual(client_transport.sent, 1)
builder = QuicPacketBuilder(
host_cid=client.peer_cid,
peer_cid=client.host_cid,
version=0xFF000011, # DRAFT_16
)
crypto = CryptoPair()
crypto.setup_initial(client.host_cid, is_client=False)
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
push_bytes(builder.buffer, bytes(1200))
builder.end_packet()
for datagram in builder.flush()[0]:
client.datagram_received(datagram, SERVER_ADDR)
self.assertEqual(client_transport.sent, 1)
def test_long_header_empty(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
# nothing to write
self.assertFalse(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
self.assertEqual(builder.packet_number, 0)
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 0)
self.assertEqual(packets, [])
def test_long_header_then_long_header(self):
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
crypto = CryptoPair()
crypto.setup_initial(bytes(8), is_client=True)
# INITIAL
builder.start_packet(PACKET_TYPE_INITIAL, crypto)
self.assertEqual(builder.remaining_space, 1237)
builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(199))
self.assertEqual(builder.buffer.tell(), 227)
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 243)
# HANDSHAKE
builder.start_packet(PACKET_TYPE_HANDSHAKE, crypto)
self.assertEqual(builder.buffer.tell(), 269)
self.assertEqual(builder.remaining_space, 995)
builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(299))
self.assertEqual(builder.buffer.tell(), 569)
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 585)
# ONE_RTT
builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
self.assertEqual(builder.remaining_space, 668)
builder.start_frame(QuicFrameType.CRYPTO)
push_bytes(builder.buffer, bytes(299))
self.assertTrue(builder.end_packet())
self.assertEqual(builder.buffer.tell(), 0)
# check datagrams
datagrams, packets = builder.flush()
self.assertEqual(len(datagrams), 1)
self.assertEqual(len(datagrams[0]), 912)
self.assertEqual(
packets,
[
QuicSentPacket(
epoch=Epoch.INITIAL,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=0,
sent_bytes=243,
),
QuicSentPacket(
epoch=Epoch.HANDSHAKE,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=1,
sent_bytes=342,
),
QuicSentPacket(
epoch=Epoch.ONE_RTT,
is_ack_eliciting=True,
is_crypto_packet=True,
packet_number=2,
sent_bytes=327,
),
],
)
