path
stringlengths 9
117
| type
stringclasses 2
values | project
stringclasses 10
values | commit_hash
stringlengths 40
40
| commit_message
stringlengths 1
137
| ground_truth
stringlengths 0
2.74k
| main_code
stringlengths 102
3.37k
| context
stringlengths 0
14.7k
|
|---|---|---|---|---|---|---|---|
aioquic.tls/Context._server_handle_finished
|
Modified
|
aiortc~aioquic
|
bcd560325bc161ac22bcd4863c527911104f39c2
|
[tls] allow session ticket to use early data
|
<27>:<add> max_early_data_size=0xFFFFFFFF,
|
# module: aioquic.tls
class Context:
def _server_handle_finished(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> finished = pull_finished(input_buf)
<1>
<2> # check verify data
<3> expected_verify_data = self.key_schedule.finished_verify_data(self._dec_key)
<4> assert finished.verify_data == expected_verify_data
<5>
<6> # commit traffic key
<7> self._dec_key = self._next_dec_key
<8> self._next_dec_key = None
<9> self.update_traffic_key_cb(
<10> Direction.DECRYPT,
<11> Epoch.ONE_RTT,
<12> self.key_schedule.cipher_suite,
<13> self._dec_key,
<14> )
<15>
<16> self.key_schedule.update_hash(input_buf.data)
<17>
<18> self._set_state(State.SERVER_POST_HANDSHAKE)
<19>
<20> # create a new session ticket
<21> if self.new_session_ticket_cb is not None:
<22> new_session_ticket = NewSessionTicket(
<23> ticket_lifetime=86400,
<24> ticket_age_add=struct.unpack("I", os.urandom(4))[0],
<25> ticket_nonce=b"",
<26> ticket=os.urandom(64),
<27> )
<28>
<29> # notify application
<30> ticket = self._build_session_ticket(new_session_ticket)
<31> self.new_session_ticket_cb(ticket)
<32>
<33> # send messsage
<34> push_new_session_ticket(output_buf, new_session_ticket)
<35>
|
===========unchanged ref 0===========
at: _struct
unpack(format, buffer, /)
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
State()
NewSessionTicket(ticket_lifetime: int=0, ticket_age_add: int=0, ticket_nonce: bytes=b"", ticket: bytes=b"", max_early_data_size: Optional[int]=None)
pull_finished(buf: Buffer) -> Finished
at: aioquic.tls.Context
_build_session_ticket(new_session_ticket: NewSessionTicket) -> SessionTicket
_set_state(state: State) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, CipherSuite, bytes], None
] = lambda d, e, c, s: None
self._dec_key: Optional[bytes] = None
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
self._next_dec_key = self.key_schedule.derive_secret(b"c ap traffic")
at: aioquic.tls.Context._setup_traffic_protection
self._dec_key = key
at: aioquic.tls.Finished
verify_data: bytes = b""
at: aioquic.tls.KeySchedule
finished_verify_data(secret: bytes) -> bytes
update_hash(data: bytes) -> None
===========unchanged ref 1===========
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: aioquic.tls.NewSessionTicket
ticket_lifetime: int = 0
ticket_age_add: int = 0
ticket_nonce: bytes = b""
ticket: bytes = b""
max_early_data_size: Optional[int] = None
at: os
urandom(size: int, /) -> bytes
|
tests.test_tls/ContextTest._handshake
|
Modified
|
aiortc~aioquic
|
df6ba99214026ece8aa2577d9dc67670daf27bd9
|
[tls] fix broken tests
|
<33>:<add> self.assertEqual(len(client_input), 89)
<del> self.assertEqual(len(client_input), 81)
|
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server, create_ticket):
<0> # send client hello
<1> client_buf = create_buffers()
<2> client.handle_message(b"", client_buf)
<3> self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
<4> server_input = merge_buffers(client_buf)
<5> self.assertGreaterEqual(len(server_input), 219)
<6> self.assertLessEqual(len(server_input), 264)
<7> reset_buffers(client_buf)
<8>
<9> # handle client hello
<10> # send server hello, encrypted extensions, certificate, certificate verify, finished
<11> server_buf = create_buffers()
<12> server.handle_message(server_input, server_buf)
<13> self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
<14> client_input = merge_buffers(server_buf)
<15> self.assertGreaterEqual(len(client_input), 2194)
<16> self.assertLessEqual(len(client_input), 2239)
<17> reset_buffers(server_buf)
<18>
<19> # handle server hello, encrypted extensions, certificate, certificate verify, finished
<20> # send finished
<21> client.handle_message(client_input, client_buf)
<22> self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
<23> server_input = merge_buffers(client_buf)
<24> self.assertEqual(len(server_input), 52)
<25> reset_buffers(client_buf)
<26>
<27> # handle finished
<28> # send new_session_ticket
<29> server.handle_message(server_input, server_buf)
<30> self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
<31> client_input = merge_buffers(server_buf)
<32> if create_ticket:
<33> self.assertEqual(len(client_input), 81)
<34> reset_buffers(server_buf)
<35>
<36> </s>
|
===========below chunk 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def _handshake(self, client, server, create_ticket):
# offset: 1
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 0)
else:
self.assertEqual(len(client_input), 0)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check cipher suite
self.assertEqual(
client.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
self.assertEqual(
server.key_schedule.cipher_suite, tls.CipherSuite.AES_256_GCM_SHA384
)
===========unchanged ref 0===========
at: aioquic.tls
State()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._client_handle_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_finished
self._dec_key = self._next_dec_key
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.Context._set_state
self.state = state
at: aioquic.tls.Context._setup_traffic_protection
self._enc_key = key
self._dec_key = key
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: tests.test_tls
create_buffers()
merge_buffers(buffers)
reset_buffers(buffers)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
===========unchanged ref 1===========
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertGreaterEqual(a: Any, b: Any, msg: Any=...) -> None
assertLessEqual(a: Any, b: Any, msg: Any=...) -> None
|
tests.test_tls/ContextTest.test_session_ticket
|
Modified
|
aiortc~aioquic
|
df6ba99214026ece8aa2577d9dc67670daf27bd9
|
[tls] fix broken tests
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
<0> client_tickets = []
<1> server_tickets = []
<2>
<3> def client_new_ticket(ticket):
<4> client_tickets.append(ticket)
<5>
<6> def server_get_ticket(label):
<7> for t in server_tickets:
<8> if t.ticket == label:
<9> return t
<10> return None
<11>
<12> def server_new_ticket(ticket):
<13> server_tickets.append(ticket)
<14>
<15> def first_handshake():
<16> client = self.create_client()
<17> client.new_session_ticket_cb = client_new_ticket
<18>
<19> server = self.create_server()
<20> server.new_session_ticket_cb = server_new_ticket
<21>
<22> self._handshake(client, server, create_ticket=True)
<23>
<24> # check session resumption was not used
<25> self.assertFalse(client.session_resumed)
<26> self.assertFalse(server.session_resumed)
<27>
<28> # check tickets match
<29> self.assertEqual(len(client_tickets), 1)
<30> self.assertEqual(len(server_tickets), 1)
<31> self.assertEqual(client_tickets[0].ticket, server_tickets[0].ticket)
<32> self.assertEqual(
<33> client_tickets[0].resumption_secret, server_tickets[0].resumption_secret
<34> )
<35>
<36> def second_handshake():
<37> client = self.create_client()
<38> client.session_ticket = client_tickets[0]
<39>
<40> server = self.create_server()
<41> server.get_session_ticket_cb = server_get_ticket
<42>
<43> # send client hello with pre_shared_key
<44> client_buf = create_buffers()
<45> client.handle_message(b"", client_buf)
<46> self.assertEqual(client.state, State</s>
|
===========below chunk 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 1
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 379)
reset_buffers(client_buf)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create_buffers()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 303)
reset_buffers(server_buf)
# handle server hello, encrypted extensions, certificate, certificate verify, finished
# send finished
client.handle_message(client_input, client_buf)
self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 52)
reset_buffers(client_buf)
# handle finished
# send new_session_ticket
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_POST_HANDSHAKE)
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 0)
reset_buffers(server_buf)
# check keys match
self.assertEqual(client._dec_key, server._enc_key)
self.assertEqual(client._enc_key, server._dec_key)
# check session resumption was used
self.assertTrue(client.session_resumed)
self.assertTrue(server.session_resumed)
def second_handshake_bad_binder():
client = self.create_client()
client.session_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket</s>
===========below chunk 1===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 2
<s>_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket_cb = server_get_ticket
# send client hello with pre_shared_key
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 379)
reset_buffers(client_buf)
# tamper with binder
server_input = server_input[:-4] + bytes(4)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create_buffers()
with self.assertRaises(tls.AlertHandshakeFailure) as cm:
server.handle_message(server_input, server_buf)
self.assertEqual(str(cm.exception), "PSK validation failed")
def second_handshake_bad_pre_shared_key():
client = self.create_client()
client.session_ticket = client_tickets[0]
server = self.create_server()
server.get_session_ticket_cb = server_get_ticket
# send client hello with pre_shared_key
client_buf = create_buffers()
client.handle_message(b"", client_buf)
self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 379)
reset_buffers(client_buf)
# handle client hello
# send server hello, encrypted extensions, finished
server_buf = create</s>
===========below chunk 2===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_session_ticket(self):
# offset: 3
<s>()
server.handle_message(server_input, server_buf)
self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
# tamper with pre_share_key index
buf = server_buf[tls.Epoch.INITIAL]
buf._data[buf.tell() - 1] = 1
client_input = merge_buffers(server_buf)
self.assertEqual(len(client_input), 303)
reset_buffers(server_buf)
# handle server hello and bomb
with self.assertRaises(tls.AlertIllegalParameter):
client.handle_message(client_input, client_buf)
first_handshake()
second_handshake()
second_handshake_bad_binder()
second_handshake_bad_pre_shared_key()
===========unchanged ref 0===========
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.buffer.Buffer.__init__
self._data = bytearray(capacity)
self._data = bytearray(data)
at: aioquic.tls
AlertHandshakeFailure(*args: object)
AlertIllegalParameter(*args: object)
Epoch()
State()
at: aioquic.tls.Context.__init__
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
at: tests.test_tls
create_buffers()
merge_buffers(buffers)
reset_buffers(buffers)
at: tests.test_tls.ContextTest
create_client()
create_server()
_handshake(client, server, create_ticket)
_handshake(self, client, server, create_ticket)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
|
|
aioquic.tls/Context.__init__
|
Modified
|
aiortc~aioquic
|
45970cd26cb23a0c186c33fab746396298e27e47
|
[interop] test early data is accepted
|
<6>:<add> self.early_data_accepted = False
|
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
<0> self.alpn_negotiated: Optional[str] = None
<1> self.alpn_protocols: Optional[List[str]] = None
<2> self.certificate: Optional[x509.Certificate] = None
<3> self.certificate_private_key: Optional[
<4> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
<5> ] = None
<6> self.handshake_extensions: List[Extension] = []
<7> self.key_schedule: Optional[KeySchedule] = None
<8> self.received_extensions: Optional[List[Extension]] = None
<9> self.session_ticket: Optional[SessionTicket] = None
<10> self.server_name: Optional[str] = None
<11>
<12> # callbacks
<13> self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
<14> self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
<15> self.update_traffic_key_cb: Callable[
<16> [Direction, Epoch, CipherSuite, bytes], None
<17> ] = lambda d, e, c, s: None
<18>
<19> # supported parameters
<20> self._cipher_suites = [
<21> CipherSuite.AES_256_GCM_SHA384,
<22> CipherSuite.AES_128_GCM_SHA256,
<23> CipherSuite.CHACHA20_POLY1305_SHA256,
<24> ]
<25> self._compression_methods = [CompressionMethod.NULL]
<26> self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
<27> self._signature_algorithms = [
<28> SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
<29> SignatureAlgorithm.ECDSA_SECP256R1_SHA256,
<30> SignatureAlgorithm.RSA_PKCS1_SHA256,
<31> SignatureAlgorithm.RSA_PKCS1_SHA1</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
# offset: 1
]
self._supported_groups = [Group.SECP256R1]
self._supported_versions = [TLS_VERSION_1_3]
# state
self._key_schedule_psk: Optional[KeySchedule] = None
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._session_resumed = False
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
self._ec_private_key: Optional[ec.EllipticCurvePrivateKey] = None
self._x25519_private_key: Optional[x25519.X25519PrivateKey] = None
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
===========unchanged ref 0===========
at: aioquic.tls
TLS_VERSION_1_3 = 0x0304
Direction()
Epoch()
State()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
CompressionMethod(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
CompressionMethod(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
KeyExchangeMode(x: Union[str, bytes, bytearray], base: int)
KeyExchangeMode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
SignatureAlgorithm(x: Union[str, bytes, bytearray], base: int)
SignatureAlgorithm(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Extension = Tuple[int, bytes]
KeySchedule(cipher_suite: CipherSuite)
KeyScheduleProxy(cipher_suites: List[CipherSuite])
SessionTicket(age_add: int, cipher_suite: CipherSuite, not_valid_after: datetime.datetime, not_valid_before: datetime.datetime, resumption_secret: bytes, server_name: str, ticket: bytes, max_early_data_size: Optional[int]=None)
SessionTicketFetcher = Callable[[bytes], Optional[SessionTicket]]
SessionTicketHandler = Callable[[SessionTicket], None]
at: aioquic.tls.Context._client_handle_certificate
self._peer_certificate = x509.load_der_x509_certificate(
certificate.certificates[0][0], backend=default_backend()
)
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.alpn_negotiated = encrypted_extensions.alpn_protocol
===========unchanged ref 1===========
self.early_data_accepted = encrypted_extensions.early_data
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._client_handle_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
self._session_resumed = True
at: aioquic.tls.Context._client_send_hello
self._ec_private_key = ec.generate_private_key(
GROUP_TO_CURVE[Group.SECP256R1](), default_backend()
)
self._x25519_private_key = x25519.X25519PrivateKey.generate()
self._key_schedule_psk = KeySchedule(self.session_ticket.cipher_suite)
self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
at: aioquic.tls.Context._server_handle_finished
self._dec_key = self._next_dec_key
at: aioquic.tls.Context._server_handle_hello
self.alpn_negotiated = negotiate(
self.alpn_protocols,
peer_hello.alpn_protocols,
AlertHandshakeFailure("No common ALPN protocols"),
)
self.client_random = peer_hello.random
self.session_id = peer_hello.session_id
self.received_extensions = peer_hello.other_extensions
self.key_schedule = KeySchedule(cipher_suite)
self._session_resumed = True
self.early_data_accepted = True
self._x25519_private_key = x25519.X25519PrivateKey.generate()
===========unchanged ref 2===========
self._ec_private_key = ec.generate_private_key(
GROUP_TO_CURVE[key_share[0]](), default_backend()
)
at: aioquic.tls.Context._set_state
self.state = state
at: aioquic.tls.Context._setup_traffic_protection
self._enc_key = key
self._dec_key = key
at: aioquic.tls.Context.handle_message
self._receive_buffer += input_data
self._receive_buffer = self._receive_buffer[message_length:]
at: logging
Logger(name: str, level: _Level=...)
LoggerAdapter(logger: Logger, extra: Mapping[str, Any])
at: os
urandom(size: int, /) -> bytes
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.tls
@dataclass
class EncryptedExtensions:
alpn_protocol: Optional[str] = None
+ early_data: bool = False
- early_data: Optional[bool] = None
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
|
aioquic.tls/Context._client_handle_encrypted_extensions
|
Modified
|
aiortc~aioquic
|
45970cd26cb23a0c186c33fab746396298e27e47
|
[interop] test early data is accepted
|
<1>:<add>
<2>:<add> self.early_data_accepted = encrypted_extensions.early_data
|
# module: aioquic.tls
class Context:
def _client_handle_encrypted_extensions(self, input_buf: Buffer) -> None:
<0> encrypted_extensions = pull_encrypted_extensions(input_buf)
<1> self.alpn_negotiated = encrypted_extensions.alpn_protocol
<2> self.received_extensions = encrypted_extensions.other_extensions
<3>
<4> self._setup_traffic_protection(
<5> Direction.ENCRYPT, Epoch.HANDSHAKE, b"c hs traffic"
<6> )
<7> self.key_schedule.update_hash(input_buf.data)
<8>
<9> if self._key_schedule_psk is not None:
<10> self._set_state(State.CLIENT_EXPECT_FINISHED)
<11> else:
<12> self._set_state(State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE)
<13>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
at: aioquic.tls.Context.__init__
self.alpn_negotiated: Optional[str] = None
self.early_data_accepted = False
self.key_schedule: Optional[KeySchedule] = None
self.received_extensions: Optional[List[Extension]] = None
self._key_schedule_psk: Optional[KeySchedule] = None
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._client_send_hello
self._key_schedule_psk = KeySchedule(self.session_ticket.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.alpn_negotiated = negotiate(
self.alpn_protocols,
peer_hello.alpn_protocols,
AlertHandshakeFailure("No common ALPN protocols"),
)
self.received_extensions = peer_hello.other_extensions
self.key_schedule = KeySchedule(cipher_suite)
self.early_data_accepted = True
at: aioquic.tls.EncryptedExtensions
alpn_protocol: Optional[str] = None
early_data: bool = False
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
at: aioquic.tls.KeySchedule
update_hash(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.tls
@dataclass
class EncryptedExtensions:
alpn_protocol: Optional[str] = None
+ early_data: bool = False
- early_data: Optional[bool] = None
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 1===========
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
self.alpn_negotiated: Optional[str] = None
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
+ self.early_data_accepted = False
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.received_extensions: Optional[List[Extension]] = None
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
# callbacks
self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, CipherSuite, bytes], None
] = lambda d, e, c, s: None
# supported parameters
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [
SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
SignatureAlgorithm.ECDSA_SECP256R1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_groups = [Group.SECP256R</s>
===========changed ref 2===========
# module: aioquic.tls
class Context:
def __init__(
self,
is_client: bool,
logger: Optional[Union[logging.Logger, logging.LoggerAdapter]] = None,
):
# offset: 1
<s> SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_groups = [Group.SECP256R1]
self._supported_versions = [TLS_VERSION_1_3]
# state
self._key_schedule_psk: Optional[KeySchedule] = None
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._session_resumed = False
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
self._ec_private_key: Optional[ec.EllipticCurvePrivateKey] = None
self._x25519_private_key: Optional[x25519.X25519PrivateKey] = None
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.crypto/CryptoContext.decrypt_packet
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
<0> assert self.is_valid(), "Decryption key is not available"
<1>
<2> # header protection
<3> packet = bytearray(packet)
<4> sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
<5> sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
<6> mask = self.header_protection_mask(sample)
<7>
<8> if is_long_header(packet[0]):
<9> # long header
<10> packet[0] ^= mask[0] & 0x0F
<11> else:
<12> # short header
<13> packet[0] ^= mask[0] & 0x1F
<14>
<15> pn_length = (packet[0] & 0x03) + 1
<16> for i in range(pn_length):
<17> packet[encrypted_offset + i] ^= mask[1 + i]
<18> pn = packet[encrypted_offset : encrypted_offset + pn_length]
<19> plain_header = bytes(packet[: encrypted_offset + pn_length])
<20>
<21> # detect key phase change
<22> crypto = self
<23> if not is_long_header(packet[0]):
<24> key_phase = (packet[0] & 4) >> 2
<25> if key_phase != self.key_phase:
<26> crypto = self.next_key_phase()
<27>
<28> # payload protection
<29> nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
<30> for i in range(len(crypto.iv)):
<31> nonce[i] ^= crypto.iv[i]
<32> try:
<33> payload = crypto.aead.decrypt(
<34> nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
<35> )
<36> except InvalidTag:
<37> raise CryptoError("Payload</s>
|
===========below chunk 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
return plain_header, payload, packet_number, crypto != self
===========unchanged ref 0===========
at: aioquic.crypto
SAMPLE_SIZE = 16
CryptoError(*args: object)
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
is_valid() -> bool
next_key_phase() -> CryptoContext
at: aioquic.crypto.CryptoContext.__init__
self.iv: Optional[bytes]
self.key_phase = key_phase
at: aioquic.crypto.CryptoContext.apply_key_phase
self.iv = crypto.iv
self.key_phase = crypto.key_phase
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
at: aioquic.crypto.CryptoContext.teardown
self.iv = None
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
decode_packet_number(truncated: int, num_bits: int, expected: int) -> int
is_long_header(first_byte: int) -> bool
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 1===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_SPIN_BIT = 0x20
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
- PACKET_NUMBER_SEND_SIZE = 2
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
|
|
aioquic.crypto/CryptoPair.decrypt_packet
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<1>:<add> packet, encrypted_offset, expected_packet_number
<del> packet, encrypted_offset
|
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
<0> plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
<1> packet, encrypted_offset
<2> )
<3> if update_key:
<4> self._update_key()
<5> return plain_header, payload, packet_number
<6>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoContext(key_phase: int=0)
at: aioquic.crypto.CryptoContext
decrypt_packet(self, packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int, bool]
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int, bool]
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
at: aioquic.crypto.CryptoPair._update_key
self._update_key_requested = False
at: aioquic.crypto.CryptoPair.update_key
self._update_key_requested = True
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
assert self.is_valid(), "Decryption key is not available"
# header protection
packet = bytearray(packet)
sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
# detect key phase change
crypto = self
if not is_long_header(packet[0]):
key_phase = (packet[0] & 4) >> 2
if key_phase != self.key_phase:
crypto = self.next_key_phase()
# payload protection
nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
for i in range(len(crypto.iv)):
nonce[i] ^= crypto.iv[i]
try:
payload = crypto.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number <<</s>
===========changed ref 1===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
<s> number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
return plain_header, payload, packet_number, crypto != self
===========changed ref 2===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 3===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_SPIN_BIT = 0x20
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
- PACKET_NUMBER_SEND_SIZE = 2
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
|
aioquic.connection/QuicPacketSpace.__init__
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<2>:<add> self.expected_packet_number = 0
|
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
<0> self.ack_queue = RangeSet()
<1> self.ack_required = False
<2>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
remote_challenge: Optional[bytes] = None
===========changed ref 0===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 1===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
PACKET_MAX_SIZE = 1280
+ PACKET_NUMBER_SEND_SIZE = 2
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
===========changed ref 2===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset, expected_packet_number
- packet, encrypted_offset
)
if update_key:
self._update_key()
return plain_header, payload, packet_number
===========changed ref 3===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 4===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_SPIN_BIT = 0x20
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
- PACKET_NUMBER_SEND_SIZE = 2
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
===========changed ref 5===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
assert self.is_valid(), "Decryption key is not available"
# header protection
packet = bytearray(packet)
sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
# detect key phase change
crypto = self
if not is_long_header(packet[0]):
key_phase = (packet[0] & 4) >> 2
if key_phase != self.key_phase:
crypto = self.next_key_phase()
# payload protection
nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
for i in range(len(crypto.iv)):
nonce[i] ^= crypto.iv[i]
try:
payload = crypto.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number <<</s>
===========changed ref 6===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
# offset: 1
<s> number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number << 8) | pn[i]
+ packet_number = decode_packet_number(
+ packet_number, pn_length * 8, expected_packet_number
+ )
return plain_header, payload, packet_number, crypto != self
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<19>:<add> push_packet_number(buf, self.packet_number)
<del> push_uint16(buf, self.packet_number)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> crypto = self.cryptos[epoch]
<2> space = self.spaces[epoch]
<3> if not crypto.send.is_valid():
<4> return
<5>
<6> buf = Buffer(capacity=PACKET_MAX_SIZE)
<7> capacity = buf.capacity - crypto.aead_tag_size
<8>
<9> while True:
<10> # write header
<11> push_uint8(
<12> buf,
<13> PACKET_FIXED_BIT
<14> | (self._spin_bit << 5)
<15> | (crypto.key_phase << 2)
<16> | (PACKET_NUMBER_SEND_SIZE - 1),
<17> )
<18> push_bytes(buf, self.peer_cid)
<19> push_uint16(buf, self.packet_number)
<20> header_size = buf.tell()
<21>
<22> # ACK
<23> if space.ack_required and space.ack_queue:
<24> push_uint_var(buf, QuicFrameType.ACK)
<25> packet.push_ack_frame(buf, space.ack_queue, 0)
<26> space.ack_required = False
<27>
<28> # PATH CHALLENGE
<29> if (
<30> self.__epoch == tls.Epoch.ONE_RTT
<31> and not network_path.is_validated
<32> and network_path.local_challenge is None
<33> ):
<34> self._logger.info(
<35> "Network path %s sending challenge", network_path.addr
<36> )
<37> network_path.local_challenge = os.urandom(8)
<38> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<39> push_bytes(buf, network_path.local_challenge)
<40>
<41> # PATH RESPONSE
<42> if network_path.remote_challenge is not None:
<43> push_uint_var(</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
# offset: 1
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# PING
if self._ping_waiter is not None and self._ping_packet_number is None:
self._ping_packet_number = self.packet_number
self._logger.info("Sending PING in packet %d", self.packet_number)
push_uint_var(buf, QuicFrameType.PING)
# CLOSE
if self.__close and self.__epoch == epoch:
push_close(buf, **self.__close)
self.__close = None
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == tls.Epoch.ONE_RTT:
stream = self.streams[epoch]
frame_overhead = 3 + quic_uint_length(stream._send_start)
frame = stream.get_frame(capacity - buf.tell() - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream._send_start)
if stream._send_start
else 0
)
)
frame = stream.get_frame(
min(
capacity - buf.tell() - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
# offset: 2
<s> self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += len(frame.data)
packet_size = buf.tell()
if packet_size > header_size:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, bytes(padding_size))
packet_size += padding_size
# encrypt
data = buf.data
yield crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
else:
break
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
PACKET_NUMBER_SEND_SIZE = 2
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
push_packet_number(buf: Buffer, packet_number: int) -> None
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.secrets_log_file = secrets_log_file
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
===========unchanged ref 1===========
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_max_data = 0
self._remote_max_data_used = 0
self._spin_bit = False
at: aioquic.connection.QuicConnection._handle_ack_frame
self._ping_waiter = None
self._ping_packet_number = None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
self.packet_number += 1
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6> capacity = buf.capacity - crypto.aead_tag_size
<7>
<8> while True:
<9> if epoch == tls.Epoch.INITIAL:
<10> packet_type = PACKET_TYPE_INITIAL
<11> else:
<12> packet_type = PACKET_TYPE_HANDSHAKE
<13>
<14> # write header
<15> push_quic_header(
<16> buf,
<17> QuicHeader(
<18> version=self._version,
<19> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
<20> destination_cid=self.peer_cid,
<21> source_cid=self.host_cid,
<22> token=self.peer_token,
<23> ),
<24> )
<25> header_size = buf.tell()
<26>
<27> # ACK
<28> if space.ack_required and space.ack_queue:
<29> push_uint_var(buf, QuicFrameType.ACK)
<30> packet.push_ack_frame(buf, space.ack_queue, 0)
<31> space.ack_required = False
<32>
<33> # CLOSE
<34> if self.__close and self.__epoch == epoch:
<35> push_close(buf, **self.__close)
<36> self.__close = None
<37>
<38> # CRYPTO
<39> stream = self.streams[epoch]
<40> frame_overhead = 3 + quic_uint_length(stream._send_start)
<41> frame = stream.get_frame(capacity - buf.tell() - frame_overhead)
<42> if frame is not None:
<43> push_uint_var(buf, QuicFrameType.CRYPTO)
<44> with packet.push_crypto_frame</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
# offset: 1
push_bytes(buf, frame.data)
# PADDING
if epoch == tls.Epoch.INITIAL and self.is_client:
push_bytes(buf, bytes(capacity - buf.tell()))
packet_size = buf.tell()
if packet_size > header_size:
# finalize length
buf.seek(header_size - PACKET_NUMBER_SEND_SIZE - 2)
length = packet_size - header_size + 2 + crypto.aead_tag_size
push_uint16(buf, length | 0x4000)
push_uint16(buf, self.packet_number)
buf.seek(packet_size)
# encrypt
data = buf.data
yield crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
# discard initial keys
if self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
else:
break
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
PACKET_NUMBER_SEND_SIZE = 2
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_token = b""
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self.packet_number = 0
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._write_application
crypto = self.cryptos[epoch]
buf = Buffer(capacity=PACKET_MAX_SIZE)
header_size = buf.tell()
self.__close = None
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ header_size
- packet_size
)
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
===========unchanged ref 2===========
QuicHeader(version: Optional[int], packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
quic_uint_length(value: int) -> int
push_uint_var(buf: Buffer, value: int) -> None
push_quic_header(buf: Buffer, header: QuicHeader) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
push_crypto_frame(buf: Buffer, offset: int=0) -> Generator
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
at: aioquic.stream.QuicStream.__init__
self._send_start = 0
at: aioquic.stream.QuicStream.get_frame
self._send_start += size
at: aioquic.tls
Epoch()
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
===========changed ref 0===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 1===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
+ self.expected_packet_number = 0
|
|
tests.test_tls/TlsTest.test_pull_encrypted_extensions_with_alpn_and_early_data
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<5>:<del> print(binascii.hexlify(extensions.other_extensions[1][1]))
|
# module: tests.test_tls
class TlsTest(TestCase):
def test_pull_encrypted_extensions_with_alpn_and_early_data(self):
<0> buf = Buffer(data=load("tls_encrypted_extensions_with_alpn_and_early_data.bin"))
<1> extensions = pull_encrypted_extensions(buf)
<2> self.assertIsNotNone(extensions)
<3> self.assertTrue(buf.eof())
<4>
<5> print(binascii.hexlify(extensions.other_extensions[1][1]))
<6> self.assertEqual(
<7> extensions,
<8> EncryptedExtensions(
<9> alpn_protocol="hq-20",
<10> early_data=True,
<11> other_extensions=[
<12> (tls.ExtensionType.SERVER_NAME, b""),
<13> (
<14> tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
<15> SERVER_QUIC_TRANSPORT_PARAMETERS_3,
<16> ),
<17> ],
<18> ),
<19> )
<20>
<21> # serialize
<22> buf = Buffer(116)
<23> push_encrypted_extensions(buf, extensions)
<24> self.assertTrue(buf.eof())
<25>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
at: aioquic.tls
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
EncryptedExtensions(alpn_protocol: Optional[str]=None, early_data: bool=False, other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions
push_encrypted_extensions(buf: Buffer, extensions: EncryptedExtensions) -> None
at: aioquic.tls.EncryptedExtensions
alpn_protocol: Optional[str] = None
early_data: bool = False
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
at: tests.test_tls
SERVER_QUIC_TRANSPORT_PARAMETERS_3 = binascii.unhexlify(
b"0054000200100dcb50a442513295b4679baf04cb5effff8a0009c8afe72a6397"
b"255407000600048000ffff0008000106000400048005fffa000500048000ffff"
b"0003000247e4000a000103000100026710000b000119"
)
at: tests.utils
load(name)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertIsNotNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
+ self.expected_packet_number = 0
===========changed ref 1===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 2===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset, expected_packet_number
- packet, encrypted_offset
)
if update_key:
self._update_key()
return plain_header, payload, packet_number
===========changed ref 3===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 4===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
PACKET_MAX_SIZE = 1280
+ PACKET_NUMBER_SEND_SIZE = 2
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
===========changed ref 5===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_SPIN_BIT = 0x20
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
- PACKET_NUMBER_SEND_SIZE = 2
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
===========changed ref 6===========
# module: aioquic.crypto
class CryptoContext:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int, bool]:
assert self.is_valid(), "Decryption key is not available"
# header protection
packet = bytearray(packet)
sample_offset = encrypted_offset + PACKET_NUMBER_MAX_SIZE
sample = packet[sample_offset : sample_offset + SAMPLE_SIZE]
mask = self.header_protection_mask(sample)
if is_long_header(packet[0]):
# long header
packet[0] ^= mask[0] & 0x0F
else:
# short header
packet[0] ^= mask[0] & 0x1F
pn_length = (packet[0] & 0x03) + 1
for i in range(pn_length):
packet[encrypted_offset + i] ^= mask[1 + i]
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
# detect key phase change
crypto = self
if not is_long_header(packet[0]):
key_phase = (packet[0] & 4) >> 2
if key_phase != self.key_phase:
crypto = self.next_key_phase()
# payload protection
nonce = bytearray(len(crypto.iv) - pn_length) + bytearray(pn)
for i in range(len(crypto.iv)):
nonce[i] ^= crypto.iv[i]
try:
payload = crypto.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
except InvalidTag:
raise CryptoError("Payload decryption failed")
# packet number
packet_number = 0
for i in range(pn_length):
packet_number = (packet_number <<</s>
|
tests.test_crypto/CryptoTest.test_decrypt_chacha20
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<9>:<add> CHACHA20_CLIENT_ENCRYPTED_PACKET, 34, 0
<del> CHACHA20_CLIENT_ENCRYPTED_PACKET, 34
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_chacha20(self):
<0> pair = CryptoPair()
<1> pair.recv.setup(
<2> CipherSuite.CHACHA20_POLY1305_SHA256,
<3> binascii.unhexlify(
<4> "fcc211ac3ff1f3fe1b096a41e701e30033cbd899494ebabbbc009ee2626d987e"
<5> ),
<6> )
<7>
<8> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<9> CHACHA20_CLIENT_ENCRYPTED_PACKET, 34
<10> )
<11> self.assertEqual(plain_header, CHACHA20_CLIENT_PLAIN_HEADER)
<12> self.assertEqual(plain_payload, CHACHA20_CLIENT_PLAIN_PAYLOAD)
<13> self.assertEqual(packet_number, 2)
<14>
|
===========unchanged ref 0===========
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int]
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_crypto
CHACHA20_CLIENT_ENCRYPTED_PACKET = binascii.unhexlify(
"e7ff000014f5b06e20f064d8783dfab56c61e5e16e8024c0e1d6ddc2a43565a240175554"
"c9ead500f378c5b1dd3eebab26c089128698919bee"
)
CHACHA20_CLIENT_PLAIN_HEADER = binascii.unhexlify(
"e1ff000014f5b06e20f064d8783dfab56c61e5e16e8024c0e1d6ddc2a43565a240170002"
)
CHACHA20_CLIENT_PLAIN_PAYLOAD = binascii.unhexlify("0200000000")
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset, expected_packet_number
- packet, encrypted_offset
)
if update_key:
self._update_key()
return plain_header, payload, packet_number
===========changed ref 1===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
+ self.expected_packet_number = 0
===========changed ref 2===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 3===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 4===========
# module: tests.test_tls
class TlsTest(TestCase):
def test_pull_encrypted_extensions_with_alpn_and_early_data(self):
buf = Buffer(data=load("tls_encrypted_extensions_with_alpn_and_early_data.bin"))
extensions = pull_encrypted_extensions(buf)
self.assertIsNotNone(extensions)
self.assertTrue(buf.eof())
- print(binascii.hexlify(extensions.other_extensions[1][1]))
self.assertEqual(
extensions,
EncryptedExtensions(
alpn_protocol="hq-20",
early_data=True,
other_extensions=[
(tls.ExtensionType.SERVER_NAME, b""),
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
SERVER_QUIC_TRANSPORT_PARAMETERS_3,
),
],
),
)
# serialize
buf = Buffer(116)
push_encrypted_extensions(buf, extensions)
self.assertTrue(buf.eof())
===========changed ref 5===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
PACKET_MAX_SIZE = 1280
+ PACKET_NUMBER_SEND_SIZE = 2
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
===========changed ref 6===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_SPIN_BIT = 0x20
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
- PACKET_NUMBER_SEND_SIZE = 2
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
|
tests.test_crypto/CryptoTest.test_decrypt_long_client
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<3>:<add> LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
<del> LONG_CLIENT_ENCRYPTED_PACKET, 17
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
<0> pair = self.create_crypto(is_client=False)
<1>
<2> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<3> LONG_CLIENT_ENCRYPTED_PACKET, 17
<4> )
<5> self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
<6> self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
<7> self.assertEqual(packet_number, 2)
<8>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int]
at: tests.test_crypto
LONG_CLIENT_PLAIN_HEADER = binascii.unhexlify(
"c3ff000012508394c8f03e51570800449f00000002"
)
LONG_CLIENT_PLAIN_PAYLOAD = binascii.unhexlify(
"060040c4010000c003036660261ff947cea49cce6cfad687f457cf1b14531ba1"
"4131a0e8f309a1d0b9c4000006130113031302010000910000000b0009000006"
"736572766572ff01000100000a00140012001d00170018001901000101010201"
"03010400230000003300260024001d00204cfdfcd178b784bf328cae793b136f"
"2aedce005ff183d7bb1495207236647037002b0003020304000d0020001e0403"
"05030603020308040805080604010501060102010402050206020202002d0002"
"0101001c00024001"
) + bytes(963)
===========unchanged ref 1===========
LONG_CLIENT_ENCRYPTED_PACKET = binascii.unhexlify(
"c1ff000012508394c8f03e51570800449f0dbc195a0000f3a694c75775b4e546"
"172ce9e047cd0b5bee5181648c727adc87f7eae54473ec6cba6bdad4f5982317"
"4b769f12358abd292d4f3286934484fb8b239c38732e1f3bbbc6a003056487eb"
"8b5c88b9fd9279ffff3b0f4ecf95c4624db6d65d4113329ee9b0bf8cdd7c8a8d"
"72806d55df25ecb66488bc119d7c9a29abaf99bb33c56b08ad8c26995f838bb3"
"b7a3d5c1858b8ec06b839db2dcf918d5ea9317f1acd6b663cc8925868e2f6a1b"
"da546695f3c3f33175944db4a11a346afb07e78489e509b02add51b7b203eda5"
"c330b03641179a31fbba9b56ce00f3d5b5e3d7d9c5429aebb9576f2f7eacbe27"
"bc1b8082aaf68fb69c921aa5d33ec0c8510410865a178d86d7e54122d55ef2c2"
"bbc040be46d7fece73fe8a1b24495ec160df2da9b20a7ba2f26dfa2a44366dbc"
"63de5cd7d7c94c57172fe6d79c901f025c00</s>
===========unchanged ref 2===========
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset, expected_packet_number
- packet, encrypted_offset
)
if update_key:
self._update_key()
return plain_header, payload, packet_number
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
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, 0
- 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)
===========changed ref 2===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
+ self.expected_packet_number = 0
===========changed ref 3===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 4===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 5===========
# module: tests.test_tls
class TlsTest(TestCase):
def test_pull_encrypted_extensions_with_alpn_and_early_data(self):
buf = Buffer(data=load("tls_encrypted_extensions_with_alpn_and_early_data.bin"))
extensions = pull_encrypted_extensions(buf)
self.assertIsNotNone(extensions)
self.assertTrue(buf.eof())
- print(binascii.hexlify(extensions.other_extensions[1][1]))
self.assertEqual(
extensions,
EncryptedExtensions(
alpn_protocol="hq-20",
early_data=True,
other_extensions=[
(tls.ExtensionType.SERVER_NAME, b""),
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
SERVER_QUIC_TRANSPORT_PARAMETERS_3,
),
],
),
)
# serialize
buf = Buffer(116)
push_encrypted_extensions(buf, extensions)
self.assertTrue(buf.eof())
|
tests.test_crypto/CryptoTest.test_decrypt_long_server
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<3>:<add> LONG_SERVER_ENCRYPTED_PACKET, 17, 0
<del> LONG_SERVER_ENCRYPTED_PACKET, 17
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
<0> pair = self.create_crypto(is_client=True)
<1>
<2> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<3> LONG_SERVER_ENCRYPTED_PACKET, 17
<4> )
<5> self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
<6> self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
<7> self.assertEqual(packet_number, 1)
<8>
|
===========unchanged ref 0===========
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int]
at: tests.test_crypto
LONG_SERVER_PLAIN_HEADER = binascii.unhexlify("c1ff00001205f067a5502a4262b50040740001")
LONG_SERVER_PLAIN_PAYLOAD = binascii.unhexlify(
"0d0000000018410a020000560303eefce7f7b37ba1d1632e96677825ddf73988"
"cfc79825df566dc5430b9a045a1200130100002e00330024001d00209d3c940d"
"89690b84d08a60993c144eca684d1081287c834d5311bcf32bb9da1a002b0002"
"0304"
)
LONG_SERVER_ENCRYPTED_PACKET = binascii.unhexlify(
"c4ff00001205f067a5502a4262b5004074f7ed5f01c4c2a2303d297e3c519bf6"
"b22386e3d0bd6dfc66121677298031041bb9a79c9f0f9d4c5877270a660f5da3"
"6207d98b73839b2fdf2ef8e7df5a51b17b8c68d864fd3e708c6c1b71a98a3318"
"15599ef5014ea38c44bdfd387c03b5275c35e009b6238f831420047c7271281c"
"cb54df7884"
)
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
===========unchanged ref 1===========
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset, expected_packet_number
- packet, encrypted_offset
)
if update_key:
self._update_key()
return plain_header, payload, packet_number
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
+ LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
- LONG_CLIENT_ENCRYPTED_PACKET, 17
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
self.assertEqual(packet_number, 2)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
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, 0
- 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)
===========changed ref 3===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
+ self.expected_packet_number = 0
===========changed ref 4===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 5===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 6===========
# module: tests.test_tls
class TlsTest(TestCase):
def test_pull_encrypted_extensions_with_alpn_and_early_data(self):
buf = Buffer(data=load("tls_encrypted_extensions_with_alpn_and_early_data.bin"))
extensions = pull_encrypted_extensions(buf)
self.assertIsNotNone(extensions)
self.assertTrue(buf.eof())
- print(binascii.hexlify(extensions.other_extensions[1][1]))
self.assertEqual(
extensions,
EncryptedExtensions(
alpn_protocol="hq-20",
early_data=True,
other_extensions=[
(tls.ExtensionType.SERVER_NAME, b""),
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
SERVER_QUIC_TRANSPORT_PARAMETERS_3,
),
],
),
)
# serialize
buf = Buffer(116)
push_encrypted_extensions(buf, extensions)
self.assertTrue(buf.eof())
===========changed ref 7===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
PACKET_MAX_SIZE = 1280
+ PACKET_NUMBER_SEND_SIZE = 2
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
|
tests.test_crypto/CryptoTest.test_decrypt_short_server
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<9>:<add> SHORT_SERVER_ENCRYPTED_PACKET, 9, 0
<del> SHORT_SERVER_ENCRYPTED_PACKET, 9
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_short_server(self):
<0> pair = CryptoPair()
<1> pair.recv.setup(
<2> INITIAL_CIPHER_SUITE,
<3> binascii.unhexlify(
<4> "310281977cb8c1c1c1212d784b2d29e5a6489e23de848d370a5a2f9537f3a100"
<5> ),
<6> )
<7>
<8> plain_header, plain_payload, packet_number = pair.decrypt_packet(
<9> SHORT_SERVER_ENCRYPTED_PACKET, 9
<10> )
<11> self.assertEqual(plain_header, SHORT_SERVER_PLAIN_HEADER)
<12> self.assertEqual(plain_payload, SHORT_SERVER_PLAIN_PAYLOAD)
<13> self.assertEqual(packet_number, 3)
<14>
|
===========unchanged ref 0===========
at: aioquic.crypto
INITIAL_CIPHER_SUITE = CipherSuite.AES_128_GCM_SHA256
CryptoPair()
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int, expected_packet_number: int) -> Tuple[bytes, bytes, int]
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_crypto
SHORT_SERVER_PLAIN_HEADER = binascii.unhexlify("41b01fd24a586a9cf30003")
SHORT_SERVER_PLAIN_PAYLOAD = binascii.unhexlify(
"06003904000035000151805a4bebf5000020b098c8dc4183e4c182572e10ac3e"
"2b88897e0524c8461847548bd2dffa2c0ae60008002a0004ffffffff"
)
SHORT_SERVER_ENCRYPTED_PACKET = binascii.unhexlify(
"5db01fd24a586a9cf33dec094aaec6d6b4b7a5e15f5a3f05d06cf1ad0355c19d"
"cce0807eecf7bf1c844a66e1ecd1f74b2a2d69bfd25d217833edd973246597bd"
"5107ea15cb1e210045396afa602fe23432f4ab24ce251b"
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset, expected_packet_number
- packet, encrypted_offset
)
if update_key:
self._update_key()
return plain_header, payload, packet_number
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
+ LONG_SERVER_ENCRYPTED_PACKET, 17, 0
- LONG_SERVER_ENCRYPTED_PACKET, 17
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
self.assertEqual(packet_number, 1)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
+ LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
- LONG_CLIENT_ENCRYPTED_PACKET, 17
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
self.assertEqual(packet_number, 2)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
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, 0
- 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)
===========changed ref 4===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
+ self.expected_packet_number = 0
===========changed ref 5===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 6===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 7===========
# module: tests.test_tls
class TlsTest(TestCase):
def test_pull_encrypted_extensions_with_alpn_and_early_data(self):
buf = Buffer(data=load("tls_encrypted_extensions_with_alpn_and_early_data.bin"))
extensions = pull_encrypted_extensions(buf)
self.assertIsNotNone(extensions)
self.assertTrue(buf.eof())
- print(binascii.hexlify(extensions.other_extensions[1][1]))
self.assertEqual(
extensions,
EncryptedExtensions(
alpn_protocol="hq-20",
early_data=True,
other_extensions=[
(tls.ExtensionType.SERVER_NAME, b""),
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
SERVER_QUIC_TRANSPORT_PARAMETERS_3,
),
],
),
)
# serialize
buf = Buffer(116)
push_encrypted_extensions(buf, extensions)
self.assertTrue(buf.eof())
|
tests.test_crypto/CryptoTest.test_key_update
|
Modified
|
aiortc~aioquic
|
57b76a46c2f00d42aace70f96d8bdd58b0caca0a
|
[packet] fix packet number encoding / decoding
|
<14>:<add> encrypted, len(plain_header) - 2, 0
<del> encrypted, len(plain_header) - 2
|
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_key_update(self):
<0> pair1 = self.create_crypto(is_client=True)
<1> pair2 = self.create_crypto(is_client=False)
<2>
<3> def create_packet(key_phase, packet_number=0):
<4> buf = Buffer(capacity=100)
<5> push_uint8(buf, PACKET_FIXED_BIT | key_phase << 2 | 1)
<6> push_bytes(buf, binascii.unhexlify("8394c8f03e515708"))
<7> push_uint16(buf, packet_number)
<8> return buf.data, b"\x00\x01\x02\x03"
<9>
<10> def send(sender, receiver):
<11> plain_header, plain_payload = create_packet(key_phase=sender.key_phase)
<12> encrypted = sender.encrypt_packet(plain_header, plain_payload)
<13> recov_header, recov_payload, _ = receiver.decrypt_packet(
<14> encrypted, len(plain_header) - 2
<15> )
<16> self.assertEqual(recov_header, plain_header)
<17> self.assertEqual(recov_payload, plain_payload)
<18>
<19> # roundtrip
<20> send(pair1, pair2)
<21> send(pair2, pair1)
<22> self.assertEqual(pair1.key_phase, 0)
<23> self.assertEqual(pair2.key_phase, 0)
<24>
<25> # pair 1 key update
<26> pair1.update_key()
<27>
<28> # roundtrip
<29> send(pair1, pair2)
<30> send(pair2, pair1)
<31> self.assertEqual(pair1.key_phase, 1)
<32> self.assertEqual(pair2.key_phase, 1)
<33>
<34> # pair 2 key update
<35> pair2.update_key()
<36>
<37> # roundtrip
<38> send(pair2, pair1)
<39> send(pair1, pair2)
<40> </s>
|
===========below chunk 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_key_update(self):
# offset: 1
self.assertEqual(pair2.key_phase, 0)
# pair 1 key - update, but not next to send
pair1.update_key()
# roundtrip
send(pair2, pair1)
send(pair1, pair2)
self.assertEqual(pair1.key_phase, 1)
self.assertEqual(pair2.key_phase, 1)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_crypto.CryptoTest
create_crypto(is_client)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_server(self):
pair = self.create_crypto(is_client=True)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
+ LONG_SERVER_ENCRYPTED_PACKET, 17, 0
- LONG_SERVER_ENCRYPTED_PACKET, 17
)
self.assertEqual(plain_header, LONG_SERVER_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_SERVER_PLAIN_PAYLOAD)
self.assertEqual(packet_number, 1)
===========changed ref 1===========
# module: tests.test_crypto
class CryptoTest(TestCase):
def test_decrypt_long_client(self):
pair = self.create_crypto(is_client=False)
plain_header, plain_payload, packet_number = pair.decrypt_packet(
+ LONG_CLIENT_ENCRYPTED_PACKET, 17, 0
- LONG_CLIENT_ENCRYPTED_PACKET, 17
)
self.assertEqual(plain_header, LONG_CLIENT_PLAIN_HEADER)
self.assertEqual(plain_payload, LONG_CLIENT_PLAIN_PAYLOAD)
self.assertEqual(packet_number, 2)
===========changed ref 2===========
# module: tests.test_crypto
class CryptoTest(TestCase):
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, 0
- 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)
===========changed ref 3===========
# module: tests.test_crypto
class CryptoTest(TestCase):
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, 0
- 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)
===========changed ref 4===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
+ self.expected_packet_number = 0
===========changed ref 5===========
# module: aioquic.connection
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 6===========
# module: aioquic.crypto
class CryptoPair:
def decrypt_packet(
+ self, packet: bytes, encrypted_offset: int, expected_packet_number: int
- self, packet: bytes, encrypted_offset: int
) -> Tuple[bytes, bytes, int]:
plain_header, payload, packet_number, update_key = self.recv.decrypt_packet(
+ packet, encrypted_offset, expected_packet_number
- packet, encrypted_offset
)
if update_key:
self._update_key()
return plain_header, payload, packet_number
===========changed ref 7===========
# module: aioquic.packet
+ def decode_packet_number(truncated: int, num_bits: int, expected: int) -> int:
+ """
+ Recover a packet number from a truncated packet number.
+
+ See: Appendix A - Sample Packet Number Decoding Algorithm
+ """
+ window = 1 << num_bits
+ half_window = window // 2
+ candidate = (expected & ~(window - 1)) | truncated
+ if candidate <= expected - half_window:
+ return candidate + window
+ elif candidate > expected + half_window and candidate > window:
+ return candidate - window
+ else:
+ return candidate
+
===========changed ref 8===========
# module: tests.test_tls
class TlsTest(TestCase):
def test_pull_encrypted_extensions_with_alpn_and_early_data(self):
buf = Buffer(data=load("tls_encrypted_extensions_with_alpn_and_early_data.bin"))
extensions = pull_encrypted_extensions(buf)
self.assertIsNotNone(extensions)
self.assertTrue(buf.eof())
- print(binascii.hexlify(extensions.other_extensions[1][1]))
self.assertEqual(
extensions,
EncryptedExtensions(
alpn_protocol="hq-20",
early_data=True,
other_extensions=[
(tls.ExtensionType.SERVER_NAME, b""),
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
SERVER_QUIC_TRANSPORT_PARAMETERS_3,
),
],
),
)
# serialize
buf = Buffer(116)
push_encrypted_extensions(buf, extensions)
self.assertTrue(buf.eof())
|
aioquic.server/QuicServer.datagram_received
|
Modified
|
aiortc~aioquic
|
8812ffb959681d71f55ef3ee06df19e9c3d963c5
|
[server] also route packets based on their original CID
|
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
<0> data = cast(bytes, data)
<1> buf = Buffer(data=data)
<2> header = pull_quic_header(buf, host_cid_length=8)
<3>
<4> # version negotiation
<5> if (
<6> header.version is not None
<7> and header.version not in QuicConnection.supported_versions
<8> ):
<9> self._transport.sendto(
<10> encode_quic_version_negotiation(
<11> source_cid=header.destination_cid,
<12> destination_cid=header.source_cid,
<13> supported_versions=QuicConnection.supported_versions,
<14> ),
<15> addr,
<16> )
<17> return
<18>
<19> connection = self._connections.get(header.destination_cid, None)
<20> original_connection_id: Optional[bytes] = None
<21> if connection is None and header.packet_type == PACKET_TYPE_INITIAL:
<22> # stateless retry
<23> if self._retry_key is not None:
<24> if not header.token:
<25> retry_message = encode_address(addr) + b"|" + header.destination_cid
<26> retry_token = self._retry_key.public_key().encrypt(
<27> retry_message,
<28> padding.OAEP(
<29> mgf=padding.MGF1(hashes.SHA256()),
<30> algorithm=hashes.SHA256(),
<31> label=None,
<32> ),
<33> )
<34> self._transport.sendto(
<35> encode_quic_retry(
<36> version=header.version,
<37> source_cid=os.urandom(8),
<38> destination_cid=header.source_cid,
<39> original_destination_cid=header.destination_cid,
<40> retry_token=retry_token,
<41> ),
<42> addr,
<43> )
<44> return
<45> else:</s>
|
===========below chunk 0===========
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
retry_message = self._retry_key.decrypt(
header.token,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
encoded_addr, original_connection_id = retry_message.split(
b"|", maxsplit=1
)
if encoded_addr != encode_address(addr):
return
except ValueError:
return
# create new connection
connection = QuicConnection(
alpn_protocols=self._alpn_protocols,
certificate=self._certificate,
is_client=False,
original_connection_id=original_connection_id,
private_key=self._private_key,
secrets_log_file=self._secrets_log_file,
session_ticket_fetcher=self._session_ticket_fetcher,
session_ticket_handler=self._session_ticket_handler,
stream_handler=self._stream_handler,
)
connection.connection_made(self._transport)
self._connections[connection.host_cid] = connection
self._connection_handler(connection)
if connection is not None:
connection.datagram_received(data, addr)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
NetworkAddress = Any
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
connection_made(transport: asyncio.BaseTransport) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
encode_quic_retry(version: int, source_cid: bytes, destination_cid: bytes, original_destination_cid: bytes, retry_token: bytes) -> bytes
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
===========unchanged ref 1===========
at: aioquic.server
encode_address(addr: NetworkAddress) -> bytes
at: aioquic.server.QuicServer.__init__
self._alpn_protocols = alpn_protocols
self._certificate = certificate
self._connections: Dict[bytes, QuicConnection] = {}
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
self._connection_handler = connection_handler
self._connection_handler = lambda c: None
self._stream_handler = stream_handler
self._retry_key = None
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
at: aioquic.server.QuicServer.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
at: os
urandom(size: int, /) -> bytes
at: typing
cast(typ: Type[_T], val: Any) -> _T
cast(typ: str, val: Any) -> Any
cast(typ: object, val: Any) -> Any
Text = str
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
|
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
510f8e3b9547ec242d928eb729236a153a6bcbe8
|
[packet] add a QuicPacketBuilder class
|
<1>:<add>
<add> # build datagrams
<add> builder = QuicPacketBuilder(
<add> host_cid=self.host_cid,
<add> packet_number=self.packet_number,
<add> peer_cid=self.peer_cid,
<add> peer_token=self.peer_token,
<add> spin_bit=self._spin_bit,
<add> version=self._version,
<add> )
<add> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<add> self._write_handshake(builder, epoch)
<add> self._write_application(builder, network_path)
<add> self.packet_number = builder.packet_number
<add>
<add> # send datagrams
<add> for datagram in builder.flush():
<del> for datagram in self._pending_datagrams(network_path):
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1> for datagram in self._pending_datagrams(network_path):
<2> self._transport.sendto(datagram, network_path.addr)
<3> network_path.bytes_sent += len(datagram)
<4> self.__send_pending_task = None
<5>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self._loop = asyncio.get_event_loop()
self.__send_pending_task: Optional[asyncio.Handle] = None
at: aioquic.connection.QuicConnection._send_pending
self.__send_pending_task = None
at: aioquic.packet
pull_quic_transport_parameters(buf: Buffer) -> QuicTransportParameters
at: asyncio.events.AbstractEventLoop
call_soon(callback: Callable[..., Any], *args: Any) -> Handle
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
- def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application(network_path)
-
===========changed ref 1===========
+ # module: aioquic.packet_builder
+
+
===========changed ref 2===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ """
+ Helper for building QUIC packets.
+ """
+
===========changed ref 3===========
+ # module: aioquic.packet_builder
+ PACKET_MAX_SIZE = 1280
+ PACKET_NUMBER_SEND_SIZE = 2
+
===========changed ref 4===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ @property
+ def packet_number(self) -> int:
+ """
+ Returns the packet number for the next packet.
+ """
+ return self._packet_number
+
===========changed ref 5===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ def flush(self) -> List[bytes]:
+ """
+ Returns the assembled datagrams.
+ """
+ datagrams = self._datagrams
+ self._datagrams = []
+ return datagrams
+
===========changed ref 6===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ @property
+ def remaining_space(self) -> int:
+ """
+ Returns the remaining number of bytes which can be used in
+ the current packet.
+ """
+ return self.buffer.capacity - self.buffer.tell() - self._crypto.aead_tag_size
+
===========changed ref 7===========
+ # module: aioquic.packet_builder
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
===========changed ref 8===========
# module: aioquic.connection
- def push_packet_number(buf: Buffer, packet_number: int) -> None:
- """
- Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
-
- We choose to use 2 bytes which provides a good tradeoff between encoded
- size and the "window" of packets we can represent.
- """
- push_uint16(buf, packet_number & 0xFFFF)
-
===========changed ref 9===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ def __init__(
+ self,
+ host_cid: bytes,
+ packet_number: int,
+ peer_cid: bytes,
+ peer_token: bytes,
+ spin_bit: bool,
+ version: int,
+ ):
+ self._host_cid = host_cid
+ self._peer_cid = peer_cid
+ self._peer_token = peer_token
+ self._spin_bit = spin_bit
+ self._version = version
+
+ # assembled datagrams
+ self._datagrams: List[bytes] = []
+
+ # current packet
+ self._crypto: Optional[CryptoPair] = None
+ self._header_size = 0
+ self._packet_number = packet_number
+ self._packet_start = 0
+ self._packet_type = 0
+
+ self.buffer = Buffer(PACKET_MAX_SIZE)
+
===========changed ref 10===========
# module: aioquic.connection
logger = logging.getLogger("quic")
EPOCH_SHORTCUTS = {
"I": tls.Epoch.INITIAL,
"Z": tls.Epoch.ZERO_RTT,
"H": tls.Epoch.HANDSHAKE,
"O": tls.Epoch.ONE_RTT,
}
- PACKET_MAX_SIZE = 1280
- PACKET_NUMBER_SEND_SIZE = 2
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
STREAM_FLAGS = 0x07
NetworkAddress = Any
===========changed ref 11===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_SPIN_BIT = 0x20
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
+ PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
PACKET_TYPE_MASK = 0xF0
PACKET_NUMBER_MAX_SIZE = 4
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
510f8e3b9547ec242d928eb729236a153a6bcbe8
|
[packet] add a QuicPacketBuilder class
|
<6>:<del> buf = Buffer(capacity=PACKET_MAX_SIZE)
<7>:<del> capacity = buf.capacity - crypto.aead_tag_size
<8>:<add> buf = builder.buffer
<11>:<del> push_uint8(
<12>:<del> buf,
<13>:<del> PACKET_FIXED_BIT
<14>:<del> | (self._spin_bit << 5)
<15>:<del> | (crypto.key_phase << 2)
<16>:<del> | (PACKET_NUMBER_SEND_SIZE - 1),
<17>:<del> )
<18>:<del> push_bytes(buf, self.peer_cid)
<19>:<del> push_packet_number(buf, self.packet_number)
<20>:<del> header_size = buf.tell()
<21>:<add> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _write_application(
+ self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
+ ) -> None:
- def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> crypto = self.cryptos[epoch]
<2> space = self.spaces[epoch]
<3> if not crypto.send.is_valid():
<4> return
<5>
<6> buf = Buffer(capacity=PACKET_MAX_SIZE)
<7> capacity = buf.capacity - crypto.aead_tag_size
<8>
<9> while True:
<10> # write header
<11> push_uint8(
<12> buf,
<13> PACKET_FIXED_BIT
<14> | (self._spin_bit << 5)
<15> | (crypto.key_phase << 2)
<16> | (PACKET_NUMBER_SEND_SIZE - 1),
<17> )
<18> push_bytes(buf, self.peer_cid)
<19> push_packet_number(buf, self.packet_number)
<20> header_size = buf.tell()
<21>
<22> # ACK
<23> if space.ack_required and space.ack_queue:
<24> push_uint_var(buf, QuicFrameType.ACK)
<25> packet.push_ack_frame(buf, space.ack_queue, 0)
<26> space.ack_required = False
<27>
<28> # PATH CHALLENGE
<29> if (
<30> self.__epoch == tls.Epoch.ONE_RTT
<31> and not network_path.is_validated
<32> and network_path.local_challenge is None
<33> ):
<34> self._logger.info(
<35> "Network path %s sending challenge", network_path.addr
<36> )
<37> network_path.local_challenge = os.urandom(8)
<38> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<39> push_bytes(buf, network_</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _write_application(
+ self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
+ ) -> None:
- def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
# offset: 1
# PATH RESPONSE
if network_path.remote_challenge is not None:
push_uint_var(buf, QuicFrameType.PATH_RESPONSE)
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# PING
if self._ping_waiter is not None and self._ping_packet_number is None:
self._ping_packet_number = self.packet_number
self._logger.info("Sending PING in packet %d", self.packet_number)
push_uint_var(buf, QuicFrameType.PING)
# CLOSE
if self.__close and self.__epoch == epoch:
push_close(buf, **self.__close)
self.__close = None
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == tls.Epoch.ONE_RTT:
stream = self.streams[epoch]
frame_overhead = 3 + quic_uint_length(stream._send_start)
frame = stream.get_frame(capacity - buf.tell() - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream._send_start)
if</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _write_application(
+ self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
+ ) -> None:
- def _write_application(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
# offset: 2
<s>uint_length(stream_id)
+ (
quic_uint_length(stream._send_start)
if stream._send_start
else 0
)
)
frame = stream.get_frame(
min(
capacity - buf.tell() - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += len(frame.data)
packet_size = buf.tell()
if packet_size > header_size:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, bytes(padding_size))
packet_size += padding_size
# encrypt
data = buf.data
yield crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_max_data = 0
self._remote_max_data_used = 0
at: aioquic.connection.QuicConnection._handle_ack_frame
self._ping_waiter = None
self._ping_packet_number = None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._write_application
epoch = tls.Epoch.ONE_RTT
crypto = self.cryptos[epoch]
space = self.spaces[epoch]
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.ping
self._ping_packet_number = None
self._ping_waiter = self._loop.create_future()
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
quic_uint_length(value: int) -> int
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
510f8e3b9547ec242d928eb729236a153a6bcbe8
|
[packet] add a QuicPacketBuilder class
|
<5>:<del> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6>:<del> capacity = buf.capacity - crypto.aead_tag_size
<7>:<add> buf = builder.buffer
<13>:<del>
<14>:<del> # write header
<15>:<del> push_quic_header(
<16>:<del> buf,
<17>:<del> QuicHeader(
<18>:<del> version=self._version,
<19>:<del> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
<20>:<del> destination_cid=self.peer_cid,
<21>:<del> source_cid=self.host_cid,
<22>:<del> token=self.peer_token,
<23>:<del> ),
<24>:<del> )
<25>:<del> header_size = buf.tell()
<26>:<add> builder.start_packet(packet_type, crypto)
<41>:<add> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<del> frame = stream.get_frame(capacity - buf.tell() - frame_overhead)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
- def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6> capacity = buf.capacity - crypto.aead_tag_size
<7>
<8> while True:
<9> if epoch == tls.Epoch.INITIAL:
<10> packet_type = PACKET_TYPE_INITIAL
<11> else:
<12> packet_type = PACKET_TYPE_HANDSHAKE
<13>
<14> # write header
<15> push_quic_header(
<16> buf,
<17> QuicHeader(
<18> version=self._version,
<19> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
<20> destination_cid=self.peer_cid,
<21> source_cid=self.host_cid,
<22> token=self.peer_token,
<23> ),
<24> )
<25> header_size = buf.tell()
<26>
<27> # ACK
<28> if space.ack_required and space.ack_queue:
<29> push_uint_var(buf, QuicFrameType.ACK)
<30> packet.push_ack_frame(buf, space.ack_queue, 0)
<31> space.ack_required = False
<32>
<33> # CLOSE
<34> if self.__close and self.__epoch == epoch:
<35> push_close(buf, **self.__close)
<36> self.__close = None
<37>
<38> # CRYPTO
<39> stream = self.streams[epoch]
<40> frame_overhead = 3 + quic_uint_length(stream._send_start)
<41> frame = stream.get_frame(capacity - buf.tell() - frame_overhead)
<42> if frame is not None:
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
- def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
# offset: 1
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
# PADDING
if epoch == tls.Epoch.INITIAL and self.is_client:
push_bytes(buf, bytes(capacity - buf.tell()))
packet_size = buf.tell()
if packet_size > header_size:
# finalize length
buf.seek(header_size - PACKET_NUMBER_SEND_SIZE - 2)
length = packet_size - header_size + 2 + crypto.aead_tag_size
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self.packet_number)
buf.seek(packet_size)
# encrypt
data = buf.data
yield crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
buf.seek(0)
# discard initial keys
if self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
else:
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
at: aioquic.connection.QuicConnection._write_handshake
buf = builder.buffer
at: aioquic.crypto.CryptoPair
teardown() -> None
at: aioquic.packet_builder.QuicPacketBuilder
end_packet() -> bool
at: aioquic.tls
Epoch()
===========changed ref 0===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ @property
+ def remaining_space(self) -> int:
+ """
+ Returns the remaining number of bytes which can be used in
+ the current packet.
+ """
+ return self.buffer.capacity - self.buffer.tell() - self._crypto.aead_tag_size
+
===========changed ref 1===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ def end_packet(self) -> bool:
+ """
+ Ends the current packet.
+
+ Returns `True` if the packet contains data, `False` otherwise.
+ """
+ buf = self.buffer
+ empty = True
+ packet_size = buf.tell()
+ if packet_size > self._header_size:
+ empty = False
+
+ if is_long_header(self._packet_type):
+ # finalize length
+ buf.seek(self._header_size - PACKET_NUMBER_SEND_SIZE - 2)
+ length = (
+ packet_size - self._header_size + 2 + self._crypto.aead_tag_size
+ )
+ push_uint16(buf, length | 0x4000)
+ push_packet_number(buf, self._packet_number)
+ buf.seek(packet_size)
+ else:
+ # check whether we need padding
+ padding_size = (
+ PACKET_NUMBER_MAX_SIZE
+ - PACKET_NUMBER_SEND_SIZE
+ + self._header_size
+ - packet_size
+ )
+ if padding_size > 0:
+ push_bytes(buf, bytes(padding_size))
+ packet_size += padding_size
+
+ # encrypt
+ plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
+ packet = self._crypto.encrypt_packet(
+ plain[0 : self._header_size], plain[self._header_size : packet_size]
+ )
+
+ self._datagrams.append(packet)
+ self._packet_number += 1
+
+ self.buffer.seek(self._packet_start)
+ return not empty
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
- def _pending_datagrams(self, network_path: QuicNetworkPath) -> Iterator[bytes]:
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application(network_path)
-
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
+
+ # build datagrams
+ builder = QuicPacketBuilder(
+ host_cid=self.host_cid,
+ packet_number=self.packet_number,
+ peer_cid=self.peer_cid,
+ peer_token=self.peer_token,
+ spin_bit=self._spin_bit,
+ version=self._version,
+ )
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
+ self._write_handshake(builder, epoch)
+ self._write_application(builder, network_path)
+ self.packet_number = builder.packet_number
+
+ # send datagrams
+ for datagram in builder.flush():
- for datagram in self._pending_datagrams(network_path):
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
self.__send_pending_task = None
===========changed ref 4===========
+ # module: aioquic.packet_builder
+
+
===========changed ref 5===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ """
+ Helper for building QUIC packets.
+ """
+
===========changed ref 6===========
+ # module: aioquic.packet_builder
+ PACKET_MAX_SIZE = 1280
+ PACKET_NUMBER_SEND_SIZE = 2
+
===========changed ref 7===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ @property
+ def packet_number(self) -> int:
+ """
+ Returns the packet number for the next packet.
+ """
+ return self._packet_number
+
===========changed ref 8===========
+ # module: aioquic.packet_builder
+ class QuicPacketBuilder:
+ def flush(self) -> List[bytes]:
+ """
+ Returns the assembled datagrams.
+ """
+ datagrams = self._datagrams
+ self._datagrams = []
+ return datagrams
+
===========changed ref 9===========
+ # module: aioquic.packet_builder
+ def push_packet_number(buf: Buffer, packet_number: int) -> None:
+ """
+ Packet numbers are truncated and encoded using 1, 2 or 4 bytes.
+
+ We choose to use 2 bytes which provides a good tradeoff between encoded
+ size and the "window" of packets we can represent.
+ """
+ push_uint16(buf, packet_number & 0xFFFF)
+
|
aioquic.packet_builder/QuicPacketBuilder.flush
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<3>:<add> self._flush_current_datagram()
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
<0> """
<1> Returns the assembled datagrams.
<2> """
<3> datagrams = self._datagrams
<4> self._datagrams = []
<5> return datagrams
<6>
|
===========unchanged ref 0===========
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._datagrams: List[bytes] = []
at: typing
List = _alias(list, 1, inst=False, name='List')
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<3>:<add> # if there is too little space remaining, start a new datagram
<add> # FIXME: the limit is arbitrary!
<add> if self.buffer.capacity - self.buffer.tell() < 128:
<add> self._flush_current_datagram()
<add>
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> self._packet_start = self.buffer.tell()
<4>
<5> # write header
<6> if is_long_header(packet_type):
<7> push_quic_header(
<8> self.buffer,
<9> QuicHeader(
<10> version=self._version,
<11> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
<12> destination_cid=self._peer_cid,
<13> source_cid=self._host_cid,
<14> token=self._peer_token,
<15> ),
<16> )
<17> else:
<18> push_uint8(
<19> self.buffer,
<20> packet_type
<21> | (self._spin_bit << 5)
<22> | (crypto.key_phase << 2)
<23> | (PACKET_NUMBER_SEND_SIZE - 1),
<24> )
<25> push_bytes(self.buffer, self._peer_cid)
<26> push_packet_number(self.buffer, self._packet_number)
<27>
<28> self._crypto = crypto
<29> self._header_size = self.buffer.tell() - self._packet_start
<30> self._packet_type = packet_type
<31>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_uint8(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
QuicHeader(version: Optional[int], packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
is_long_header(first_byte: int) -> bool
push_quic_header(buf: Buffer, header: QuicHeader) -> None
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
self._packet_start = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
+ self._flush_current_datagram()
datagrams = self._datagrams
self._datagrams = []
return datagrams
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<7>:<add> packet_size = buf.tell() - self._packet_start
<del> packet_size = buf.tell()
<13>:<add> buf.seek(
<add> self._packet_start + self._header_size - PACKET_NUMBER_SEND_SIZE - 2
<del> buf.seek(self._header_size - PACKET_NUMBER_SEND_SIZE - 2)
<14>:<add> )
<32>:<add> # encrypt in place
<del> # encrypt
<34>:<add> self.buffer.seek(self._packet_start)
<add> push_bytes(
<add> self.buffer,
<add> self._crypto.encrypt_packet(
<del> packet = self._crypto.encrypt_packet(
<35>:<add> plain[0 : self._header_size], plain[self._header_size : packet_size]
<del> plain[0 : self._header_size], plain[self._header_size : packet_size]
<36>:<add> ),
<38>:<add> # short header packets cannot be coallesced, we need a new datagram
<add> if not is_long_header(self._packet_type):
<add> self._flush_current_datagram()
<add>
<del> self._datagrams.append(packet)
<40>:<add> else:
<add> # "cancel" the packet
<add> self.buffer.seek(self._packet_start
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell()
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> if is_long_header(self._packet_type):
<12> # finalize length
<13> buf.seek(self._header_size - PACKET_NUMBER_SEND_SIZE - 2)
<14> length = (
<15> packet_size - self._header_size + 2 + self._crypto.aead_tag_size
<16> )
<17> push_uint16(buf, length | 0x4000)
<18> push_packet_number(buf, self._packet_number)
<19> buf.seek(packet_size)
<20> else:
<21> # check whether we need padding
<22> padding_size = (
<23> PACKET_NUMBER_MAX_SIZE
<24> - PACKET_NUMBER_SEND_SIZE
<25> + self._header_size
<26> - packet_size
<27> )
<28> if padding_size > 0:
<29> push_bytes(buf, bytes(padding_size))
<30> packet_size += padding_size
<31>
<32> # encrypt
<33> plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
<34> packet = self._crypto.encrypt_packet(
<35> plain[0 : self._header_size], plain[self._header_size : packet_size]
<36> )
<37>
<38> self._datagrams.append(packet)
<39> self._packet_number += 1
<40>
<41> self.buffer.seek(self._packet_start)
<42> return not empty
<43>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._crypto = None
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet_start = self.buffer.tell()
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
+ self._flush_current_datagram()
datagrams = self._datagrams
self._datagrams = []
return datagrams
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ # if there is too little space remaining, start a new datagram
+ # FIXME: the limit is arbitrary!
+ if self.buffer.capacity - self.buffer.tell() < 128:
+ self._flush_current_datagram()
+
self._packet_start = self.buffer.tell()
# write header
if is_long_header(packet_type):
push_quic_header(
self.buffer,
QuicHeader(
version=self._version,
packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
destination_cid=self._peer_cid,
source_cid=self._host_cid,
token=self._peer_token,
),
)
else:
push_uint8(
self.buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(self.buffer, self._peer_cid)
push_packet_number(self.buffer, self._packet_number)
self._crypto = crypto
self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<12>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<13>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
<19>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 5)
<20>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 5)
<30>:<add> self.assertEqual(client_transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 6)
<31>:<add> self.assertEqual(server_transport.sent, 5)
<del> self.assertEqual(server_transport.sent, 6)
<39>:<add> self.assertEqual(client_transport.sent, 6)
<del> self.assertEqual(client_transport.sent, 7)
<40>:<add> self.assertEqual(server_transport.sent, 6)
<del> self.assertEqual(server_transport.sent, 7)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> client = QuicConnection(is_client=True)
<1> client.supported_versions = client_versions
<2>
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> )
<8> server.supported_versions = server_versions
<9>
<10> # perform handshake
<11> client_transport, server_transport = create_transport(client, server)
<12> self.assertEqual(client_transport.sent, 4)
<13> self.assertEqual(server_transport.sent, 4)
<14>
<15> # send data over stream
<16> client_reader, client_writer = run(client.create_stream())
<17> client_writer.write(b"ping")
<18> run(asyncio.sleep(0))
<19> self.assertEqual(client_transport.sent, 5)
<20> self.assertEqual(server_transport.sent, 5)
<21>
<22> # FIXME: needs an API
<23> server_reader, server_writer = (
<24> server.streams[0].reader,
<25> server.streams[0].writer,
<26> )
<27> self.assertEqual(run(server_reader.read(1024)), b"ping")
<28> server_writer.write(b"pong")
<29> run(asyncio.sleep(0))
<30> self.assertEqual(client_transport.sent, 6)
<31> self.assertEqual(server_transport.sent, 6)
<32>
<33> # client receives pong
<34> self.assertEqual(run(client_reader.read(1024)), b"pong")
<35>
<36> # client writes EOF
<37> client_writer.write_eof()
<38> run(asyncio.sleep(0))
<39> self.assertEqual(client_transport.sent, 7)
<40> self.assertEqual(server_transport.sent, 7)
<41>
<42> # server receives EOF
<43> </s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self.writer = None
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
write_eof() -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
===========unchanged ref 1===========
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def _flush_current_datagram(self) -> None:
+ if self.buffer.tell():
+ self._datagrams.append(self.buffer.data)
+ self.buffer.seek(0)
+
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
+ self._flush_current_datagram()
datagrams = self._datagrams
self._datagrams = []
return datagrams
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ # if there is too little space remaining, start a new datagram
+ # FIXME: the limit is arbitrary!
+ if self.buffer.capacity - self.buffer.tell() < 128:
+ self._flush_current_datagram()
+
self._packet_start = self.buffer.tell()
# write header
if is_long_header(packet_type):
push_quic_header(
self.buffer,
QuicHeader(
version=self._version,
packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
destination_cid=self._peer_cid,
source_cid=self._host_cid,
token=self._peer_token,
),
)
else:
push_uint8(
self.buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(self.buffer, self._peer_cid)
push_packet_number(self.buffer, self._packet_number)
self._crypto = crypto
self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
"""
Ends the current packet.
Returns `True` if the packet contains data, `False` otherwise.
"""
buf = self.buffer
empty = True
+ packet_size = buf.tell() - self._packet_start
- packet_size = buf.tell()
if packet_size > self._header_size:
empty = False
if is_long_header(self._packet_type):
# finalize length
+ buf.seek(
+ self._packet_start + self._header_size - PACKET_NUMBER_SEND_SIZE - 2
- buf.seek(self._header_size - PACKET_NUMBER_SEND_SIZE - 2)
+ )
length = (
packet_size - self._header_size + 2 + self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, bytes(padding_size))
packet_size += padding_size
+ # encrypt in place
- # encrypt
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
+ self.buffer.seek(self._packet_start)
+ push_bytes(
+ self.buffer,
+ self._crypto.encrypt_packet(
- packet = self._crypto.encrypt_packet(
+ plain[0 : self._header_size], plain[self._header_size : packet_size]
- plain[0 : self._header_size], plain[self._header_size : packet_size]
+ )</s>
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>]
- plain[0 : self._header_size], plain[self._header_size : packet_size]
+ ),
)
+ # short header packets cannot be coallesced, we need a new datagram
+ if not is_long_header(self._packet_type):
+ self._flush_current_datagram()
+
- self._datagrams.append(packet)
self._packet_number += 1
+ else:
+ # "cancel" the packet
+ self.buffer.seek(self._packet_start)
+ self._crypto = None
+
- self.buffer.seek(self._packet_start)
return not empty
|
tests.test_connection/QuicConnectionTest.test_connect_with_log
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<12>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<13>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
<0> client_log_file = io.StringIO()
<1> client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
<2> server_log_file = io.StringIO()
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> secrets_log_file=server_log_file,
<8> )
<9>
<10> # perform handshake
<11> client_transport, server_transport = create_transport(client, server)
<12> self.assertEqual(client_transport.sent, 4)
<13> self.assertEqual(server_transport.sent, 4)
<14>
<15> # check secrets were logged
<16> client_log = client_log_file.getvalue()
<17> server_log = server_log_file.getvalue()
<18> self.assertEqual(client_log, server_log)
<19> labels = []
<20> for line in client_log.splitlines():
<21> labels.append(line.split()[0])
<22> self.assertEqual(
<23> labels,
<24> [
<25> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<26> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
<27> "QUIC_SERVER_TRAFFIC_SECRET_0",
<28> "QUIC_CLIENT_TRAFFIC_SECRET_0",
<29> ],
<30> )
<31>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
client = QuicConnection(is_client=True)
client.supported_versions = client_versions
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# FIXME: needs an API
server_reader, server_writer = (
server.streams[0].reader,
server.streams[0].writer,
)
self.assertEqual(run(server_reader.read(1024)), b"ping")
server_writer.write(b"pong")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server_transport.sent, 5)
- self.assertEqual(server_transport.sent, 6)
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
</s>
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s> self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 6)
- self.assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 6)
- self.assertEqual(server_transport.sent, 7)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def _flush_current_datagram(self) -> None:
+ if self.buffer.tell():
+ self._datagrams.append(self.buffer.data)
+ self.buffer.seek(0)
+
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
+ self._flush_current_datagram()
datagrams = self._datagrams
self._datagrams = []
return datagrams
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ # if there is too little space remaining, start a new datagram
+ # FIXME: the limit is arbitrary!
+ if self.buffer.capacity - self.buffer.tell() < 128:
+ self._flush_current_datagram()
+
self._packet_start = self.buffer.tell()
# write header
if is_long_header(packet_type):
push_quic_header(
self.buffer,
QuicHeader(
version=self._version,
packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
destination_cid=self._peer_cid,
source_cid=self._host_cid,
token=self._peer_token,
),
)
else:
push_uint8(
self.buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(self.buffer, self._peer_cid)
push_packet_number(self.buffer, self._packet_number)
self._crypto = crypto
self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
|
tests.test_connection/QuicConnectionTest.test_connection_lost
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<9>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<10>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
<16>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 5)
<17>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 5)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 4)
<11>
<12> # send data over stream
<13> client_reader, client_writer = run(client.create_stream())
<14> client_writer.write(b"ping")
<15> run(asyncio.sleep(0))
<16> self.assertEqual(client_transport.sent, 5)
<17> self.assertEqual(server_transport.sent, 5)
<18>
<19> # break connection
<20> client.connection_lost(None)
<21> self.assertEqual(run(client_reader.read()), b"")
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
connection_lost(exc: Exception) -> None
at: asyncio.streams.StreamReader
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server)
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
secrets_log_file=server_log_file,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
client = QuicConnection(is_client=True)
client.supported_versions = client_versions
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# FIXME: needs an API
server_reader, server_writer = (
server.streams[0].reader,
server.streams[0].writer,
)
self.assertEqual(run(server_reader.read(1024)), b"ping")
server_writer.write(b"pong")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server_transport.sent, 5)
- self.assertEqual(server_transport.sent, 6)
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
</s>
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s> self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 6)
- self.assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 6)
- self.assertEqual(server_transport.sent, 7)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def _flush_current_datagram(self) -> None:
+ if self.buffer.tell():
+ self._datagrams.append(self.buffer.data)
+ self.buffer.seek(0)
+
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
+ self._flush_current_datagram()
datagrams = self._datagrams
self._datagrams = []
return datagrams
|
tests.test_connection/QuicConnectionTest.test_connection_lost_with_exception
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<9>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<10>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
<16>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 5)
<17>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 5)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 4)
<11>
<12> # send data over stream
<13> client_reader, client_writer = run(client.create_stream())
<14> client_writer.write(b"ping")
<15> run(asyncio.sleep(0))
<16> self.assertEqual(client_transport.sent, 5)
<17> self.assertEqual(server_transport.sent, 5)
<18>
<19> # break connection
<20> exc = Exception("some error")
<21> client.connection_lost(exc)
<22> with self.assertRaises(Exception) as cm:
<23> run(client_reader.read())
<24> self.assertEqual(cm.exception, exc)
<25>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
connection_lost(exc: Exception) -> None
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server)
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========unchanged ref 1===========
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
secrets_log_file=server_log_file,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
client = QuicConnection(is_client=True)
client.supported_versions = client_versions
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# FIXME: needs an API
server_reader, server_writer = (
server.streams[0].reader,
server.streams[0].writer,
)
self.assertEqual(run(server_reader.read(1024)), b"ping")
server_writer.write(b"pong")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server_transport.sent, 5)
- self.assertEqual(server_transport.sent, 6)
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
</s>
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s> self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 6)
- self.assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 6)
- self.assertEqual(server_transport.sent, 7)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
|
tests.test_connection/QuicConnectionTest.test_create_stream_over_max_streams
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<9>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<10>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
<15>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<16>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 4)
<11>
<12> # create streams
<13> for i in range(128):
<14> client_reader, client_writer = run(client.create_stream())
<15> self.assertEqual(client_transport.sent, 4)
<16> self.assertEqual(server_transport.sent, 4)
<17>
<18> # create one too many
<19> with self.assertRaises(ValueError) as cm:
<20> client_reader, client_writer = run(client.create_stream())
<21> self.assertEqual(str(cm.exception), "Too many streams open")
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: tests.test_connection
create_transport(client, server)
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
secrets_log_file=server_log_file,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<10>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<11>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
<20>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<21>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 5)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 4)
<11> self.assertEqual(server_transport.sent, 4)
<12>
<13> # mess with encryption key
<14> server.cryptos[tls.Epoch.ONE_RTT].send.setup(
<15> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<16> )
<17>
<18> # close
<19> server.close(error_code=QuicErrorCode.NO_ERROR)
<20> self.assertEqual(client_transport.sent, 4)
<21> self.assertEqual(server_transport.sent, 5)
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
create_transport(client, server)
===========unchanged ref 1===========
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
secrets_log_file=server_log_file,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<9>:<add> self.assertEqual(client_transport.sent, 3)
<del> self.assertEqual(client_transport.sent, 4)
<10>:<add> self.assertEqual(server_transport.sent, 3)
<del> self.assertEqual(server_transport.sent, 4)
<16>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 5)
<17>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 5)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 4)
<11>
<12> # close
<13> server.close(
<14> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<15> )
<16> self.assertEqual(client_transport.sent, 5)
<17> self.assertEqual(server_transport.sent, 5)
<18>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame_app
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<9>:<add> self.assertEqual(client_transport.sent, 3)
<add> self.assertEqual(server_transport.sent, 3)
<add>
<add> # close
<add> server.close(error_code=QuicErrorCode.NO_ERROR)
<12>:<del> # close
<13>:<del> server.close(error_code=QuicErrorCode.NO_ERROR)
<14>:<del> self.assertEqual(client_transport.sent, 5)
<15>:<del> self.assertEqual(server_transport.sent, 5)
<16>:<del>
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 4)
<10> self.assertEqual(server_transport.sent, 4)
<11>
<12> # close
<13> server.close(error_code=QuicErrorCode.NO_ERROR)
<14> self.assertEqual(client_transport.sent, 5)
<15> self.assertEqual(server_transport.sent, 5)
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# close
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
- self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
- self.assertEqual(server_transport.sent, 4)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 5)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
|
tests.test_packet_builder/QuicPacketBuilderTest.test_long_header_padding
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<11>:<add> # INITIAL, fully padded
<13>:<add> push_bytes(builder.buffer, bytes(builder.remaining_space))
<add> self.assertEqual(builder.remaining_space, 0)
<add> self.assertTrue(builder.end_packet())
<14>:<del> # padding only
<15>:<del> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16>:<del>
<17>:<del> self.assertTrue(builder.end_packet())
<18>:<add> # check builder state
<add> self.assertEqual(builder.buffer.tell(), 1280)
<del> self.assertEqual(builder.buffer.tell(), 0)
<21>:<add> # check datagrams
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_long_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> builder.start_packet(PACKET_TYPE_INITIAL, crypto)
<12> self.assertEqual(builder.remaining_space, 1237)
<13>
<14> # padding only
<15> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16>
<17> self.assertTrue(builder.end_packet())
<18> self.assertEqual(builder.buffer.tell(), 0)
<19> self.assertEqual(builder.packet_number, 1)
<20>
<21> datagrams = builder.flush()
<22> self.assertEqual(len(datagrams), 1)
<23> self.assertEqual(len(datagrams[0]), 1280)
<24>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet_builder
QuicPacketBuilder(host_cid: bytes, packet_number: int, peer_cid: bytes, peer_token: bytes, spin_bit: bool, version: int)
at: aioquic.packet_builder.QuicPacketBuilder
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ # if there is too little space remaining, start a new datagram
+ # FIXME: the limit is arbitrary!
+ if self.buffer.capacity - self.buffer.tell() < 128:
+ self._flush_current_datagram()
+
self._packet_start = self.buffer.tell()
# write header
if is_long_header(packet_type):
push_quic_header(
self.buffer,
QuicHeader(
version=self._version,
packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
destination_cid=self._peer_cid,
source_cid=self._host_cid,
token=self._peer_token,
),
)
else:
push_uint8(
self.buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(self.buffer, self._peer_cid)
push_packet_number(self.buffer, self._packet_number)
self._crypto = crypto
self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
"""
Ends the current packet.
Returns `True` if the packet contains data, `False` otherwise.
"""
buf = self.buffer
empty = True
+ packet_size = buf.tell() - self._packet_start
- packet_size = buf.tell()
if packet_size > self._header_size:
empty = False
if is_long_header(self._packet_type):
# finalize length
+ buf.seek(
+ self._packet_start + self._header_size - PACKET_NUMBER_SEND_SIZE - 2
- buf.seek(self._header_size - PACKET_NUMBER_SEND_SIZE - 2)
+ )
length = (
packet_size - self._header_size + 2 + self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, bytes(padding_size))
packet_size += padding_size
+ # encrypt in place
- # encrypt
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
+ self.buffer.seek(self._packet_start)
+ push_bytes(
+ self.buffer,
+ self._crypto.encrypt_packet(
- packet = self._crypto.encrypt_packet(
+ plain[0 : self._header_size], plain[self._header_size : packet_size]
- plain[0 : self._header_size], plain[self._header_size : packet_size]
+ )</s>
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>]
- plain[0 : self._header_size], plain[self._header_size : packet_size]
+ ),
)
+ # short header packets cannot be coallesced, we need a new datagram
+ if not is_long_header(self._packet_type):
+ self._flush_current_datagram()
+
- self._datagrams.append(packet)
self._packet_number += 1
+ else:
+ # "cancel" the packet
+ self.buffer.seek(self._packet_start)
+ self._crypto = None
+
- self.buffer.seek(self._packet_start)
return not empty
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
+ def _flush_current_datagram(self) -> None:
+ if self.buffer.tell():
+ self._datagrams.append(self.buffer.data)
+ self.buffer.seek(0)
+
===========changed ref 4===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
+ self._flush_current_datagram()
datagrams = self._datagrams
self._datagrams = []
return datagrams
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 3)
+ self.assertEqual(server_transport.sent, 3)
+
+ # close
+ server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
- # close
- server.close(error_code=QuicErrorCode.NO_ERROR)
- self.assertEqual(client_transport.sent, 5)
- self.assertEqual(server_transport.sent, 5)
-
|
tests.test_packet_builder/QuicPacketBuilderTest.test_short_header_padding
|
Modified
|
aiortc~aioquic
|
34e40ed0fd82b631633e9781b3e584c3a15322fa
|
[packet] coalesce packets!
|
<11>:<add> # ONE_RTT, fully padded
<13>:<add> push_bytes(builder.buffer, bytes(builder.remaining_space))
<add> self.assertTrue(builder.end_packet())
<14>:<del> # padding only
<15>:<del> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16>:<del>
<17>:<del> data = builder.end_packet()
<18>:<del> self.assertTrue(data)
<19>:<add> # check builder
<22>:<add> # check datagrams
|
# module: tests.test_packet_builder
class QuicPacketBuilderTest(TestCase):
def test_short_header_padding(self):
<0> builder = QuicPacketBuilder(
<1> host_cid=bytes(8),
<2> packet_number=0,
<3> peer_cid=bytes(8),
<4> peer_token=b"",
<5> spin_bit=False,
<6> version=QuicProtocolVersion.DRAFT_20,
<7> )
<8> crypto = CryptoPair()
<9> crypto.setup_initial(bytes(8), is_client=True)
<10>
<11> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<12> self.assertEqual(builder.remaining_space, 1253)
<13>
<14> # padding only
<15> push_bytes(builder.buffer, bytes(builder.remaining_space))
<16>
<17> data = builder.end_packet()
<18> self.assertTrue(data)
<19> self.assertEqual(builder.buffer.tell(), 0)
<20> self.assertEqual(builder.packet_number, 1)
<21>
<22> datagrams = builder.flush()
<23> self.assertEqual(len(datagrams), 1)
<24> self.assertEqual(len(datagrams[0]), 1280)
<25>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.packet_builder
QuicPacketBuilder(host_cid: bytes, packet_number: int, peer_cid: bytes, peer_token: bytes, spin_bit: bool, version: int)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> List[bytes]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_packet_builder.QuicPacketBuilderTest.test_long_header_then_short_header
builder = QuicPacketBuilder(
host_cid=bytes(8),
packet_number=0,
peer_cid=bytes(8),
peer_token=b"",
spin_bit=False,
version=QuicProtocolVersion.DRAFT_20,
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def flush(self) -> List[bytes]:
"""
Returns the assembled datagrams.
"""
+ self._flush_current_datagram()
datagrams = self._datagrams
self._datagrams = []
return datagrams
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ # if there is too little space remaining, start a new datagram
+ # FIXME: the limit is arbitrary!
+ if self.buffer.capacity - self.buffer.tell() < 128:
+ self._flush_current_datagram()
+
self._packet_start = self.buffer.tell()
# write header
if is_long_header(packet_type):
push_quic_header(
self.buffer,
QuicHeader(
version=self._version,
packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
destination_cid=self._peer_cid,
source_cid=self._host_cid,
token=self._peer_token,
),
)
else:
push_uint8(
self.buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(self.buffer, self._peer_cid)
push_packet_number(self.buffer, self._packet_number)
self._crypto = crypto
self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 2===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
"""
Ends the current packet.
Returns `True` if the packet contains data, `False` otherwise.
"""
buf = self.buffer
empty = True
+ packet_size = buf.tell() - self._packet_start
- packet_size = buf.tell()
if packet_size > self._header_size:
empty = False
if is_long_header(self._packet_type):
# finalize length
+ buf.seek(
+ self._packet_start + self._header_size - PACKET_NUMBER_SEND_SIZE - 2
- buf.seek(self._header_size - PACKET_NUMBER_SEND_SIZE - 2)
+ )
length = (
packet_size - self._header_size + 2 + self._crypto.aead_tag_size
)
push_uint16(buf, length | 0x4000)
push_packet_number(buf, self._packet_number)
buf.seek(packet_size)
else:
# check whether we need padding
padding_size = (
PACKET_NUMBER_MAX_SIZE
- PACKET_NUMBER_SEND_SIZE
+ self._header_size
- packet_size
)
if padding_size > 0:
push_bytes(buf, bytes(padding_size))
packet_size += padding_size
+ # encrypt in place
- # encrypt
plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
+ self.buffer.seek(self._packet_start)
+ push_bytes(
+ self.buffer,
+ self._crypto.encrypt_packet(
- packet = self._crypto.encrypt_packet(
+ plain[0 : self._header_size], plain[self._header_size : packet_size]
- plain[0 : self._header_size], plain[self._header_size : packet_size]
+ )</s>
===========changed ref 3===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
<s>]
- plain[0 : self._header_size], plain[self._header_size : packet_size]
+ ),
)
+ # short header packets cannot be coallesced, we need a new datagram
+ if not is_long_header(self._packet_type):
+ self._flush_current_datagram()
+
- self._datagrams.append(packet)
self._packet_number += 1
+ else:
+ # "cancel" the packet
+ self.buffer.seek(self._packet_start)
+ self._crypto = None
+
- self.buffer.seek(self._packet_start)
return not empty
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
73ddbe371c919e274ae0bb30f9621ebc79164026
|
[packet] get rid of push_quic_header
|
<11>:<add> buf = self.buffer
<12>:<del> push_quic_header(
<13>:<del> self.buffer,
<14>:<del> QuicHeader(
<15>:<del> version=self._version,
<16>:<add> push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<del> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
<17>:<del> destination_cid=self._peer_cid,
<18>:<del> source_cid=self._host_cid,
<19>:<del> token=self._peer_token,
<20>:<add> push_uint32(buf, self._version)
<add> push_uint8(
<add> buf,
<del> ),
<21>:<add> (encode_cid_length(len(self._peer_cid)) << 4)
<add> | encode_cid_length(len(self._host_cid)),
<22>:<add> push_bytes(buf, self._peer_cid)
<add> push_bytes(buf, self._host_cid)
<add> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<add> push_uint_var(buf, len(self._peer_token))
<add> push_bytes(buf, self._peer_token)
<add> push_uint16(buf, 0) # length
<add> push_packet_number(buf, 0) # packet number
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> # if there is too little space remaining, start a new datagram
<4> # FIXME: the limit is arbitrary!
<5> if self.buffer.capacity - self.buffer.tell() < 128:
<6> self._flush_current_datagram()
<7>
<8> self._packet_start = self.buffer.tell()
<9>
<10> # write header
<11> if is_long_header(packet_type):
<12> push_quic_header(
<13> self.buffer,
<14> QuicHeader(
<15> version=self._version,
<16> packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
<17> destination_cid=self._peer_cid,
<18> source_cid=self._host_cid,
<19> token=self._peer_token,
<20> ),
<21> )
<22> else:
<23> push_uint8(
<24> self.buffer,
<25> packet_type
<26> | (self._spin_bit << 5)
<27> | (crypto.key_phase << 2)
<28> | (PACKET_NUMBER_SEND_SIZE - 1),
<29> )
<30> push_bytes(self.buffer, self._peer_cid)
<31> push_packet_number(self.buffer, self._packet_number)
<32>
<33> self._crypto = crypto
<34> self._header_size = self.buffer.tell() - self._packet_start
<35> self._packet_type = packet_type
<36>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint32(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_MASK = 0xF0
encode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._version = version
self._datagrams: List[bytes] = []
self._packet_start = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
===========changed ref 0===========
# module: aioquic.packet
- def push_quic_header(buf: Buffer, header: QuicHeader) -> None:
- push_uint8(buf, header.packet_type)
- push_uint32(buf, header.version)
- push_uint8(
- buf,
- (encode_cid_length(len(header.destination_cid)) << 4)
- | encode_cid_length(len(header.source_cid)),
- )
- push_bytes(buf, header.destination_cid)
- push_bytes(buf, header.source_cid)
- if (header.packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
- push_uint_var(buf, len(header.token))
- push_bytes(buf, header.token)
- push_uint16(buf, 0) # length
- push_uint16(buf, 0) # pn
-
|
tests.test_connection/QuicConnectionTest.test_datagram_received_wrong_version
|
Modified
|
aiortc~aioquic
|
73ddbe371c919e274ae0bb30f9621ebc79164026
|
[packet] get rid of push_quic_header
|
<3>:<del> buf = Buffer(capacity=1300)
<4>:<del> push_quic_header(
<5>:<del> buf,
<6>:<del> QuicHeader(
<7>:<add> builder = QuicPacketBuilder(
<add> host_cid=client.peer_cid,
<add> peer_cid=client.host_cid,
<add> version=0xFF000011, # DRAFT_16
<del> version=0xFF000011, # DRAFT_16
<8>:<del> packet_type=PACKET_TYPE_INITIAL | (PACKET_NUMBER_SEND_SIZE - 1),
<9>:<del> destination_cid=client.host_cid,
<10>:<del> source_cid=client.peer_cid,
<11>:<del> ),
<13>:<add> crypto = CryptoPair()
<add> crypto.setup_initial(client.host_cid, is_client=False)
<add> builder.start_packet(PACKET_TYPE_INITIAL, crypto=crypto)
<add> push_bytes(builder.buffer, bytes(1200))
<add> builder.end_packet()
<add>
<add> for datagram in builder.flush():
<del> buf.seek(1300)
<14>:<add> client.datagram_received(datagram, SERVER_ADDR)
<del> client.datagram_received(buf.data, SERVER_ADDR)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_datagram_received_wrong_version(self):
<0> client, client_transport = create_standalone_client()
<1> self.assertEqual(client_transport.sent, 1)
<2>
<3> buf = Buffer(capacity=1300)
<4> push_quic_header(
<5> buf,
<6> QuicHeader(
<7> version=0xFF000011, # DRAFT_16
<8> packet_type=PACKET_TYPE_INITIAL | (PACKET_NUMBER_SEND_SIZE - 1),
<9> destination_cid=client.host_cid,
<10> source_cid=client.peer_cid,
<11> ),
<12> )
<13> buf.seek(1300)
<14> client.datagram_received(buf.data, SERVER_ADDR)
<15> self.assertEqual(client_transport.sent, 1)
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
flush() -> List[bytes]
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: tests.test_connection
SERVER_ADDR = ("2.3.4.5", 4433)
create_standalone_client()
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
if self.buffer.capacity - self.buffer.tell() < 128:
self._flush_current_datagram()
self._packet_start = self.buffer.tell()
# write header
+ buf = self.buffer
if is_long_header(packet_type):
- push_quic_header(
- self.buffer,
- QuicHeader(
- version=self._version,
+ push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
- packet_type=packet_type | (PACKET_NUMBER_SEND_SIZE - 1),
- destination_cid=self._peer_cid,
- source_cid=self._host_cid,
- token=self._peer_token,
+ push_uint32(buf, self._version)
+ push_uint8(
+ buf,
- ),
+ (encode_cid_length(len(self._peer_cid)) << 4)
+ | encode_cid_length(len(self._host_cid)),
)
+ push_bytes(buf, self._peer_cid)
+ push_bytes(buf, self._host_cid)
+ if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
+ push_uint_var(buf, len(self._peer_token))
+ push_bytes(buf, self._peer_token)
+ push_uint16(buf, 0) # length
+ push_packet_number(buf, 0) # packet number
else:
push_uint8(
self.buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
push_bytes(self.buffer, self._peer_cid)
push_packet_number(self.buffer, self._packet_number)
self._crypto = crypto
self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 2===========
# module: tests.test_packet
class PacketTest(TestCase):
- def test_push_initial(self):
- buf = Buffer(capacity=32)
- header = QuicHeader(
- version=QuicProtocolVersion.DRAFT_17,
- packet_type=PACKET_TYPE_INITIAL,
- destination_cid=binascii.unhexlify("90ed1e1c7b04b5d3"),
- source_cid=b"",
- )
- push_quic_header(buf, header)
- self.assertEqual(
- buf.data, binascii.unhexlify("c0ff0000115090ed1e1c7b04b5d30000000000")
- )
-
===========changed ref 3===========
# module: aioquic.packet
- def push_quic_header(buf: Buffer, header: QuicHeader) -> None:
- push_uint8(buf, header.packet_type)
- push_uint32(buf, header.version)
- push_uint8(
- buf,
- (encode_cid_length(len(header.destination_cid)) << 4)
- | encode_cid_length(len(header.source_cid)),
- )
- push_bytes(buf, header.destination_cid)
- push_bytes(buf, header.source_cid)
- if (header.packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
- push_uint_var(buf, len(header.token))
- push_bytes(buf, header.token)
- push_uint16(buf, 0) # length
- push_uint16(buf, 0) # pn
-
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
1c05bf0dcd62d3f646c255096bab87a04674ecd5
|
[packet] get rid of some magic numbers
|
<14>:<add> self._packet_start
<add> + self._header_size
<add> - PACKET_NUMBER_SEND_SIZE
<add> - PACKET_LENGTH_SEND_SIZE
<del> self._packet_start + self._header_size - PACKET_NUMBER_SEND_SIZE - 2
<17>:<add> packet_size
<add> - self._header_size
<add> + PACKET_NUMBER_SEND_SIZE
<add> + self._crypto.aead_tag_size
<del> packet_size - self._header_size + 2 + self._crypto.aead_tag_size
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell() - self._packet_start
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> if is_long_header(self._packet_type):
<12> # finalize length
<13> buf.seek(
<14> self._packet_start + self._header_size - PACKET_NUMBER_SEND_SIZE - 2
<15> )
<16> length = (
<17> packet_size - self._header_size + 2 + self._crypto.aead_tag_size
<18> )
<19> push_uint16(buf, length | 0x4000)
<20> push_packet_number(buf, self._packet_number)
<21> buf.seek(packet_size)
<22> else:
<23> # check whether we need padding
<24> padding_size = (
<25> PACKET_NUMBER_MAX_SIZE
<26> - PACKET_NUMBER_SEND_SIZE
<27> + self._header_size
<28> - packet_size
<29> )
<30> if padding_size > 0:
<31> push_bytes(buf, bytes(padding_size))
<32> packet_size += padding_size
<33>
<34> # encrypt in place
<35> plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
<36> self.buffer.seek(self._packet_start)
<37> push_bytes(
<38> self.buffer,
<39> self._crypto.encrypt_packet(
<40> plain[0 : self._header_size], plain[self._header_size : packet_size]
<41> ),
<42> )
<43>
<44> # short header packets cannot be coallesced, we need a new datagram
<45> if not is_long_header(self._packet_type):
<46> self</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
self._packet_number += 1
else:
# "cancel" the packet
self.buffer.seek(self._packet_start)
self._crypto = None
return not empty
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
PACKET_LENGTH_SEND_SIZE = 2
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._crypto = None
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet_start = self.buffer.tell()
self._crypto = crypto
self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 0===========
# module: aioquic.packet_builder
PACKET_MAX_SIZE = 1280
+ PACKET_LENGTH_SEND_SIZE = 2
PACKET_NUMBER_SEND_SIZE = 2
|
aioquic.packet_builder/QuicPacketBuilder.start_packet
|
Modified
|
aiortc~aioquic
|
f2df97385fa4a43c0ce8247b38a8d25560522c4a
|
[packet] harmonize code style
|
<3>:<add> buf = self.buffer
<add>
<5>:<add> if buf.capacity - buf.tell() < 128:
<del> if self.buffer.capacity - self.buffer.tell() < 128:
<8>:<add> self._packet_start = buf.tell()
<del> self._packet_start = self.buffer.tell()
<11>:<del> buf = self.buffer
<29>:<add> buf,
<del> self.buffer,
<35>:<add> push_bytes(buf, self._peer_cid)
<del> push_bytes(self.buffer, self._peer_cid)
<36>:<add> push_packet_number(buf, self._packet_number)
<del> push_packet_number(self.buffer, self._packet_number)
<39>:<add> self._header_size = buf.tell() - self._packet_start
<del> self._header_size = self.buffer
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
<0> """
<1> Starts a new packet.
<2> """
<3> # if there is too little space remaining, start a new datagram
<4> # FIXME: the limit is arbitrary!
<5> if self.buffer.capacity - self.buffer.tell() < 128:
<6> self._flush_current_datagram()
<7>
<8> self._packet_start = self.buffer.tell()
<9>
<10> # write header
<11> buf = self.buffer
<12> if is_long_header(packet_type):
<13> push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
<14> push_uint32(buf, self._version)
<15> push_uint8(
<16> buf,
<17> (encode_cid_length(len(self._peer_cid)) << 4)
<18> | encode_cid_length(len(self._host_cid)),
<19> )
<20> push_bytes(buf, self._peer_cid)
<21> push_bytes(buf, self._host_cid)
<22> if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<23> push_uint_var(buf, len(self._peer_token))
<24> push_bytes(buf, self._peer_token)
<25> push_uint16(buf, 0) # length
<26> push_packet_number(buf, 0) # packet number
<27> else:
<28> push_uint8(
<29> self.buffer,
<30> packet_type
<31> | (self._spin_bit << 5)
<32> | (crypto.key_phase << 2)
<33> | (PACKET_NUMBER_SEND_SIZE - 1),
<34> )
<35> push_bytes(self.buffer, self._peer_cid)
<36> push_packet_number(self.buffer, self._packet_number)
<37>
<38> self._crypto = crypto
<39> self._header_size = self.buffer</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
self._packet_type = packet_type
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
push_uint16(buf: Buffer, v: int) -> None
push_uint32(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.crypto
CryptoPair()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_MASK = 0xF0
encode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
push_uint_var(buf: Buffer, value: int) -> None
at: aioquic.packet_builder
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._host_cid = host_cid
self._peer_cid = peer_cid
self._peer_token = peer_token
self._spin_bit = spin_bit
self._version = version
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.end_packet
self._packet_number += 1
self._crypto = None
|
aioquic.packet_builder/QuicPacketBuilder.end_packet
|
Modified
|
aiortc~aioquic
|
f2df97385fa4a43c0ce8247b38a8d25560522c4a
|
[packet] harmonize code style
|
<42>:<add> buf.seek(self._packet_start)
<del> self.buffer.seek(self._packet_start)
<44>:<add> buf,
<del> self.buffer,
|
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
<0> """
<1> Ends the current packet.
<2>
<3> Returns `True` if the packet contains data, `False` otherwise.
<4> """
<5> buf = self.buffer
<6> empty = True
<7> packet_size = buf.tell() - self._packet_start
<8> if packet_size > self._header_size:
<9> empty = False
<10>
<11> if is_long_header(self._packet_type):
<12> # finalize length
<13> buf.seek(
<14> self._packet_start
<15> + self._header_size
<16> - PACKET_NUMBER_SEND_SIZE
<17> - PACKET_LENGTH_SEND_SIZE
<18> )
<19> length = (
<20> packet_size
<21> - self._header_size
<22> + PACKET_NUMBER_SEND_SIZE
<23> + self._crypto.aead_tag_size
<24> )
<25> push_uint16(buf, length | 0x4000)
<26> push_packet_number(buf, self._packet_number)
<27> buf.seek(packet_size)
<28> else:
<29> # check whether we need padding
<30> padding_size = (
<31> PACKET_NUMBER_MAX_SIZE
<32> - PACKET_NUMBER_SEND_SIZE
<33> + self._header_size
<34> - packet_size
<35> )
<36> if padding_size > 0:
<37> push_bytes(buf, bytes(padding_size))
<38> packet_size += padding_size
<39>
<40> # encrypt in place
<41> plain = buf.data_slice(self._packet_start, self._packet_start + packet_size)
<42> self.buffer.seek(self._packet_start)
<43> push_bytes(
<44> self.buffer,
<45> self._crypto.encrypt_packet(
<46> plain[0 : self._header_size], plain[self._header_size : packet_size]
<47> ),
<48> )
<49>
<50> # short header packets cannot be</s>
|
===========below chunk 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def end_packet(self) -> bool:
# offset: 1
if not is_long_header(self._packet_type):
self._flush_current_datagram()
self._packet_number += 1
else:
# "cancel" the packet
self.buffer.seek(self._packet_start)
self._crypto = None
return not empty
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
seek(pos: int) -> None
tell() -> int
at: aioquic.crypto.CryptoPair
encrypt_packet(plain_header: bytes, plain_payload: bytes) -> bytes
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
at: aioquic.packet
PACKET_NUMBER_MAX_SIZE = 4
is_long_header(first_byte: int) -> bool
at: aioquic.packet_builder
PACKET_LENGTH_SEND_SIZE = 2
PACKET_NUMBER_SEND_SIZE = 2
push_packet_number(buf: Buffer, packet_number: int) -> None
at: aioquic.packet_builder.QuicPacketBuilder
_flush_current_datagram() -> None
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self._crypto: Optional[CryptoPair] = None
self._header_size = 0
self._packet_number = packet_number
self._packet_start = 0
self._packet_type = 0
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.packet_builder.QuicPacketBuilder.start_packet
self._packet_start = buf.tell()
self._crypto = crypto
self._header_size = buf.tell() - self._packet_start
self._packet_type = packet_type
===========changed ref 0===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
"""
Starts a new packet.
"""
+ buf = self.buffer
+
# if there is too little space remaining, start a new datagram
# FIXME: the limit is arbitrary!
+ if buf.capacity - buf.tell() < 128:
- if self.buffer.capacity - self.buffer.tell() < 128:
self._flush_current_datagram()
+ self._packet_start = buf.tell()
- self._packet_start = self.buffer.tell()
# write header
- buf = self.buffer
if is_long_header(packet_type):
push_uint8(buf, packet_type | (PACKET_NUMBER_SEND_SIZE - 1))
push_uint32(buf, self._version)
push_uint8(
buf,
(encode_cid_length(len(self._peer_cid)) << 4)
| encode_cid_length(len(self._host_cid)),
)
push_bytes(buf, self._peer_cid)
push_bytes(buf, self._host_cid)
if (packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
push_uint_var(buf, len(self._peer_token))
push_bytes(buf, self._peer_token)
push_uint16(buf, 0) # length
push_packet_number(buf, 0) # packet number
else:
push_uint8(
+ buf,
- self.buffer,
packet_type
| (self._spin_bit << 5)
| (crypto.key_phase << 2)
| (PACKET_NUMBER_SEND_SIZE - 1),
)
+ push_bytes(buf, self._peer_cid)
- push_bytes(self.buffer, self._peer_cid)
+ push_packet_number(buf, self</s>
===========changed ref 1===========
# module: aioquic.packet_builder
class QuicPacketBuilder:
def start_packet(self, packet_type: int, crypto: CryptoPair) -> None:
# offset: 1
<s>)
- push_bytes(self.buffer, self._peer_cid)
+ push_packet_number(buf, self._packet_number)
- push_packet_number(self.buffer, self._packet_number)
self._crypto = crypto
+ self._header_size = buf.tell() - self._packet_start
- self._header_size = self.buffer.tell() - self._packet_start
self._packet_type = packet_type
|
aioquic.tls/Context._build_session_ticket
|
Modified
|
aiortc~aioquic
|
5312b199c8826cb635594dbc92510e9b444f2e95
|
[tls] save handshake extensions in SessionTicket, needed for 0-RTT
|
<17>:<add> other_extensions=self.handshake_extensions,
|
# module: aioquic.tls
class Context:
def _build_session_ticket(
self, new_session_ticket: NewSessionTicket
) -> SessionTicket:
<0> resumption_master_secret = self.key_schedule.derive_secret(b"res master")
<1> resumption_secret = hkdf_expand_label(
<2> algorithm=self.key_schedule.algorithm,
<3> secret=resumption_master_secret,
<4> label=b"resumption",
<5> hash_value=new_session_ticket.ticket_nonce,
<6> length=self.key_schedule.algorithm.digest_size,
<7> )
<8>
<9> timestamp = datetime.datetime.now()
<10> return SessionTicket(
<11> age_add=new_session_ticket.ticket_age_add,
<12> cipher_suite=self.key_schedule.cipher_suite,
<13> max_early_data_size=new_session_ticket.max_early_data_size,
<14> not_valid_after=timestamp
<15> + datetime.timedelta(seconds=new_session_ticket.ticket_lifetime),
<16> not_valid_before=timestamp,
<17> resumption_secret=resumption_secret,
<18> server_name=self.server_name,
<19> ticket=new_session_ticket.ticket,
<20> )
<21>
|
===========unchanged ref 0===========
at: aioquic.tls
hkdf_expand_label(algorithm: hashes.HashAlgorithm, secret: bytes, label: bytes, hash_value: bytes, length: int) -> bytes
NewSessionTicket(ticket_lifetime: int=0, ticket_age_add: int=0, ticket_nonce: bytes=b"", ticket: bytes=b"", max_early_data_size: Optional[int]=None)
SessionTicket(age_add: int, cipher_suite: CipherSuite, not_valid_after: datetime.datetime, not_valid_before: datetime.datetime, resumption_secret: bytes, server_name: str, ticket: bytes, max_early_data_size: Optional[int]=None, other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
at: aioquic.tls.Context.__init__
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.server_name: Optional[str] = None
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.KeySchedule
derive_secret(label: bytes) -> bytes
at: aioquic.tls.KeySchedule.__init__
self.algorithm = cipher_suite_hash(cipher_suite)
self.cipher_suite = cipher_suite
at: aioquic.tls.NewSessionTicket
ticket_lifetime: int = 0
ticket_age_add: int = 0
ticket_nonce: bytes = b""
ticket: bytes = b""
max_early_data_size: Optional[int] = None
at: aioquic.tls.SessionTicket
age_add: int
===========unchanged ref 1===========
cipher_suite: CipherSuite
not_valid_after: datetime.datetime
not_valid_before: datetime.datetime
resumption_secret: bytes
server_name: str
ticket: bytes
max_early_data_size: Optional[int] = None
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
at: datetime
timedelta(days: float=..., seconds: float=..., microseconds: float=..., milliseconds: float=..., minutes: float=..., hours: float=..., weeks: float=..., *, fold: int=...)
datetime()
at: datetime.datetime
__slots__ = date.__slots__ + time.__slots__
now(tz: Optional[_tzinfo]=...) -> _S
__radd__ = __add__
at: datetime.timedelta
__slots__ = '_days', '_seconds', '_microseconds', '_hashcode'
__radd__ = __add__
__rmul__ = __mul__
===========changed ref 0===========
# module: aioquic.tls
# callback types
@dataclass
class SessionTicket:
"""
A TLS session ticket for session resumption.
"""
age_add: int
cipher_suite: CipherSuite
not_valid_after: datetime.datetime
not_valid_before: datetime.datetime
resumption_secret: bytes
server_name: str
ticket: bytes
max_early_data_size: Optional[int] = None
+ other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
5312b199c8826cb635594dbc92510e9b444f2e95
|
[tls] save handshake extensions in SessionTicket, needed for 0-RTT
|
<12>:<add>
<add> # TLS session resumption
<add> if self._session_ticket is not None:
<add> self.tls.session_ticket = self._session_ticket
<del> self.tls.session_ticket = self._session_ticket
<13>:<add>
<add> # parse saved QUIC transport parameters - for 0-RTT
<add> for ext_type, ext_data in self._session_ticket.other_extensions:
<add> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<add> self._parse_transport_parameters(ext_data)
<add> break
<add>
<add> # TLS callbacks
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
<0> # TLS
<1> self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
<2> self.tls.alpn_protocols = self.alpn_protocols
<3> self.tls.certificate = self.certificate
<4> self.tls.certificate_private_key = self.private_key
<5> self.tls.handshake_extensions = [
<6> (
<7> tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
<8> self._serialize_transport_parameters(),
<9> )
<10> ]
<11> self.tls.server_name = self.server_name
<12> self.tls.session_ticket = self._session_ticket
<13> if self._session_ticket_fetcher is not None:
<14> self.tls.get_session_ticket_cb = self._session_ticket_fetcher
<15> if self._session_ticket_handler is not None:
<16> self.tls.new_session_ticket_cb = self._session_ticket_handler
<17> self.tls.update_traffic_key_cb = self._update_traffic_key
<18>
<19> # packet spaces
<20> self.cryptos = {
<21> tls.Epoch.INITIAL: CryptoPair(),
<22> tls.Epoch.ZERO_RTT: CryptoPair(),
<23> tls.Epoch.HANDSHAKE: CryptoPair(),
<24> tls.Epoch.ONE_RTT: CryptoPair(),
<25> }
<26> self.send_buffer = {
<27> tls.Epoch.INITIAL: Buffer(capacity=4096),
<28> tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
<29> tls.Epoch.ONE_RTT: Buffer(capacity=4096),
<30> }
<31> self.spaces = {
<32> tls.Epoch.INITIAL: QuicPacketSpace(),
<33> tls.Epoch.HANDSHAKE: QuicPacketSpace(),
<34> tls.Epoch.ONE_RTT: QuicPacketSpace(),
<35> }
<36> self.</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.cryptos[tls.Epoch.INITIAL].setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.packet_number = 0
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicPacketSpace()
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_parse_transport_parameters(data: bytes) -> None
_serialize_transport_parameters() -> bytes
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, cipher_suite: tls.CipherSuite, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.private_key = private_key
self.server_name = server_name
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._session_ticket = session_ticket
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
at: aioquic.crypto
CryptoPair()
at: aioquic.tls
Epoch()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Context(is_client: bool, logger: Optional[Union[logging.Logger, logging.LoggerAdapter]]=None)
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
===========unchanged ref 1===========
self.handshake_extensions: List[Extension] = []
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, CipherSuite, bytes], None
] = lambda d, e, c, s: None
===========changed ref 0===========
# module: aioquic.tls
# callback types
@dataclass
class SessionTicket:
"""
A TLS session ticket for session resumption.
"""
age_add: int
cipher_suite: CipherSuite
not_valid_after: datetime.datetime
not_valid_before: datetime.datetime
resumption_secret: bytes
server_name: str
ticket: bytes
max_early_data_size: Optional[int] = None
+ other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 1===========
# module: aioquic.tls
class Context:
def _build_session_ticket(
self, new_session_ticket: NewSessionTicket
) -> SessionTicket:
resumption_master_secret = self.key_schedule.derive_secret(b"res master")
resumption_secret = hkdf_expand_label(
algorithm=self.key_schedule.algorithm,
secret=resumption_master_secret,
label=b"resumption",
hash_value=new_session_ticket.ticket_nonce,
length=self.key_schedule.algorithm.digest_size,
)
timestamp = datetime.datetime.now()
return SessionTicket(
age_add=new_session_ticket.ticket_age_add,
cipher_suite=self.key_schedule.cipher_suite,
max_early_data_size=new_session_ticket.max_early_data_size,
not_valid_after=timestamp
+ datetime.timedelta(seconds=new_session_ticket.ticket_lifetime),
not_valid_before=timestamp,
+ other_extensions=self.handshake_extensions,
resumption_secret=resumption_secret,
server_name=self.server_name,
ticket=new_session_ticket.ticket,
)
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
5312b199c8826cb635594dbc92510e9b444f2e95
|
[tls] save handshake extensions in SessionTicket, needed for 0-RTT
|
<0>:<del> epoch = tls.Epoch.ONE_RTT
<1>:<add> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<del> crypto = self.cryptos[epoch]
<2>:<del> space = self.spaces[epoch]
<5>:<add> space = self.spaces[tls.Epoch.ONE_RTT]
<add> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<del>
<13>:<add> if is_one_rtt and space.ack_required and space.ack_queue:
<del> if space.ack_required and space.ack_queue:
<20>:<add> is_one_rtt
<del> self.__epoch == tls.Epoch.ONE_RTT
<32>:<add> if is_one_rtt and network_path.remote_challenge is not None:
<del> if network_path.remote_challenge is not None:
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> epoch = tls.Epoch.ONE_RTT
<1> crypto = self.cryptos[epoch]
<2> space = self.spaces[epoch]
<3> if not crypto.send.is_valid():
<4> return
<5>
<6> buf = builder.buffer
<7>
<8> while True:
<9> # write header
<10> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<11>
<12> # ACK
<13> if space.ack_required and space.ack_queue:
<14> push_uint_var(buf, QuicFrameType.ACK)
<15> packet.push_ack_frame(buf, space.ack_queue, 0)
<16> space.ack_required = False
<17>
<18> # PATH CHALLENGE
<19> if (
<20> self.__epoch == tls.Epoch.ONE_RTT
<21> and not network_path.is_validated
<22> and network_path.local_challenge is None
<23> ):
<24> self._logger.info(
<25> "Network path %s sending challenge", network_path.addr
<26> )
<27> network_path.local_challenge = os.urandom(8)
<28> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<29> push_bytes(buf, network_path.local_challenge)
<30>
<31> # PATH RESPONSE
<32> if network_path.remote_challenge is not None:
<33> push_uint_var(buf, QuicFrameType.PATH_RESPONSE)
<34> push_bytes(buf, network_path.remote_challenge)
<35> network_path.remote_challenge = None
<36>
<37> # PING
<38> if self._ping_waiter is not None and self._ping_packet_number is None:
<39> self._ping_packet_number = builder.packet_number
<40> self._logger.info("Sending PING in packet %d", builder</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
push_uint_var(buf, QuicFrameType.PING)
# CLOSE
if self.__close and self.__epoch == epoch:
push_close(buf, **self.__close)
self.__close = None
for stream_id, stream in self.streams.items():
# CRYPTO
if stream_id == tls.Epoch.ONE_RTT:
frame_overhead = 3 + quic_uint_length(stream._send_start)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream._send_start)
if stream._send_start
else 0
)
)
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s>
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += len(frame.data)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection.__init__
self.secrets_log_file = secrets_log_file
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_max_data = 0
self._remote_max_data_used = 0
at: aioquic.connection.QuicConnection._handle_ack_frame
self._ping_waiter = None
self._ping_packet_number = None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
===========unchanged ref 1===========
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._update_traffic_key
label = SECRETS_LABELS[label_row][epoch.value]
at: aioquic.connection.QuicConnection._write_application
self._remote_max_data_used += len(frame.data)
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.ping
self._ping_packet_number = None
self._ping_waiter = self._loop.create_future()
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.crypto.CryptoContext
is_valid() -> bool
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
self.send = CryptoContext()
|
aioquic.tls/Context._client_handle_hello
|
Modified
|
aiortc~aioquic
|
17568cc2fc1a99c222d9ca70342ad8e5a22336b9
|
[tls] fix client-side resumption logic
|
<18>:<add> self._key_schedule_psk = None
<add> self._key_schedule_proxy = None
|
# module: aioquic.tls
class Context:
def _client_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> peer_hello = pull_server_hello(input_buf)
<1>
<2> assert peer_hello.cipher_suite in self._cipher_suites
<3> assert peer_hello.compression_method in self._compression_methods
<4> assert peer_hello.supported_version in self._supported_versions
<5>
<6> # select key schedule
<7> if peer_hello.pre_shared_key is not None:
<8> if (
<9> self._key_schedule_psk is None
<10> or peer_hello.pre_shared_key != 0
<11> or peer_hello.cipher_suite != self._key_schedule_psk.cipher_suite
<12> ):
<13> raise AlertIllegalParameter
<14> self.key_schedule = self._key_schedule_psk
<15> self._session_resumed = True
<16> else:
<17> self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
<18>
<19> # perform key exchange
<20> peer_public_key = decode_public_key(peer_hello.key_share)
<21> shared_key: Optional[bytes] = None
<22> if (
<23> isinstance(peer_public_key, x25519.X25519PublicKey)
<24> and self._x25519_private_key is not None
<25> ):
<26> shared_key = self._x25519_private_key.exchange(peer_public_key)
<27> elif (
<28> isinstance(peer_public_key, ec.EllipticCurvePublicKey)
<29> and self._ec_private_key is not None
<30> and self._ec_private_key.public_key().curve.__class__
<31> == peer_public_key.curve.__class__
<32> ):
<33> shared_key = self._ec_private_key.exchange(ec.ECDH(), peer_public_key)
<34> assert shared_key is not None
<35>
<36> self.key_schedule.update_hash(input_buf</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def _client_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 1
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._set_state(State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertIllegalParameter(*args: object)
Direction()
Epoch()
pull_server_hello(buf: Buffer) -> ServerHello
decode_public_key(key_share: KeyShareEntry) -> Union[ec.EllipticCurvePublicKey, x25519.X25519PublicKey]
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_psk: Optional[KeySchedule] = None
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._session_resumed = False
self._ec_private_key: Optional[ec.EllipticCurvePrivateKey] = None
self._x25519_private_key: Optional[x25519.X25519PrivateKey] = None
at: aioquic.tls.Context._client_send_hello
self._ec_private_key = ec.generate_private_key(
GROUP_TO_CURVE[Group.SECP256R1](), default_backend()
)
self._x25519_private_key = x25519.X25519PrivateKey.generate()
self._key_schedule_psk = KeySchedule(self.session_ticket.cipher_suite)
self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
===========unchanged ref 1===========
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
self._session_resumed = True
self._x25519_private_key = x25519.X25519PrivateKey.generate()
self._ec_private_key = ec.generate_private_key(
GROUP_TO_CURVE[key_share[0]](), default_backend()
)
at: aioquic.tls.KeySchedule
extract(key_material: Optional[bytes]=None) -> None
update_hash(data: bytes) -> None
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: aioquic.tls.KeyScheduleProxy
select(cipher_suite: CipherSuite) -> KeySchedule
at: aioquic.tls.ServerHello
random: bytes
session_id: bytes
cipher_suite: CipherSuite
compression_method: CompressionMethod
key_share: Optional[KeyShareEntry] = None
pre_shared_key: Optional[int] = None
supported_version: Optional[int] = None
|
aioquic.tls/Context._client_handle_encrypted_extensions
|
Modified
|
aiortc~aioquic
|
17568cc2fc1a99c222d9ca70342ad8e5a22336b9
|
[tls] fix client-side resumption logic
|
<11>:<add> # if the server accepted our PSK we are done, other we want its certificate
<add> if self._session_resumed:
<del> if self._key_schedule_psk is not None:
|
# module: aioquic.tls
class Context:
def _client_handle_encrypted_extensions(self, input_buf: Buffer) -> None:
<0> encrypted_extensions = pull_encrypted_extensions(input_buf)
<1>
<2> self.alpn_negotiated = encrypted_extensions.alpn_protocol
<3> self.early_data_accepted = encrypted_extensions.early_data
<4> self.received_extensions = encrypted_extensions.other_extensions
<5>
<6> self._setup_traffic_protection(
<7> Direction.ENCRYPT, Epoch.HANDSHAKE, b"c hs traffic"
<8> )
<9> self.key_schedule.update_hash(input_buf.data)
<10>
<11> if self._key_schedule_psk is not None:
<12> self._set_state(State.CLIENT_EXPECT_FINISHED)
<13> else:
<14> self._set_state(State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE)
<15>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
State()
pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
_set_state(state: State) -> None
at: aioquic.tls.Context.__init__
self.alpn_negotiated: Optional[str] = None
self.early_data_accepted = False
self.key_schedule: Optional[KeySchedule] = None
self.received_extensions: Optional[List[Extension]] = None
self._session_resumed = False
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
self._session_resumed = True
at: aioquic.tls.Context._server_handle_hello
self.alpn_negotiated = negotiate(
self.alpn_protocols,
peer_hello.alpn_protocols,
AlertHandshakeFailure("No common ALPN protocols"),
)
self.received_extensions = peer_hello.other_extensions
self.key_schedule = KeySchedule(cipher_suite)
self._session_resumed = True
self.early_data_accepted = True
at: aioquic.tls.EncryptedExtensions
alpn_protocol: Optional[str] = None
early_data: bool = False
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
at: aioquic.tls.KeySchedule
update_hash(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.tls
class Context:
def _client_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
peer_hello = pull_server_hello(input_buf)
assert peer_hello.cipher_suite in self._cipher_suites
assert peer_hello.compression_method in self._compression_methods
assert peer_hello.supported_version in self._supported_versions
# select key schedule
if peer_hello.pre_shared_key is not None:
if (
self._key_schedule_psk is None
or peer_hello.pre_shared_key != 0
or peer_hello.cipher_suite != self._key_schedule_psk.cipher_suite
):
raise AlertIllegalParameter
self.key_schedule = self._key_schedule_psk
self._session_resumed = True
else:
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
+ self._key_schedule_psk = None
+ self._key_schedule_proxy = None
# perform key exchange
peer_public_key = decode_public_key(peer_hello.key_share)
shared_key: Optional[bytes] = None
if (
isinstance(peer_public_key, x25519.X25519PublicKey)
and self._x25519_private_key is not None
):
shared_key = self._x25519_private_key.exchange(peer_public_key)
elif (
isinstance(peer_public_key, ec.EllipticCurvePublicKey)
and self._ec_private_key is not None
and self._ec_private_key.public_key().curve.__class__
== peer_public_key.curve.__class__
):
shared_key = self._ec_private_key.exchange(ec.ECDH(), peer_public_key)
assert shared_key is not None
self.key_schedule.update_hash(input_buf.data)
self.key_schedule.extract</s>
===========changed ref 1===========
# module: aioquic.tls
class Context:
def _client_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 1
<s> not None
self.key_schedule.update_hash(input_buf.data)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._set_state(State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS)
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
14b28de341298ef9a5e465cd2d1307c84383c097
|
[connection] start wiring up client-side 0-RTT
|
<0>:<add> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<add> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<del> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<1>:<add> packet_type = PACKET_TYPE_ONE_RTT
<add> elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<add> crypto = self.cryptos[tls.Epoch.ZERO_RTT]
<add> packet_type = PACKET_TYPE_ZERO_RTT
<add> else:
<del> if not crypto.send.is_valid():
<5>:<add>
<6>:<del>
<9>:<add> builder.start_packet(packet_type, crypto)
<del> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<1> if not crypto.send.is_valid():
<2> return
<3> space = self.spaces[tls.Epoch.ONE_RTT]
<4> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<5> buf = builder.buffer
<6>
<7> while True:
<8> # write header
<9> builder.start_packet(PACKET_TYPE_ONE_RTT, crypto)
<10>
<11> # ACK
<12> if is_one_rtt and space.ack_required and space.ack_queue:
<13> push_uint_var(buf, QuicFrameType.ACK)
<14> packet.push_ack_frame(buf, space.ack_queue, 0)
<15> space.ack_required = False
<16>
<17> # PATH CHALLENGE
<18> if (
<19> is_one_rtt
<20> and not network_path.is_validated
<21> and network_path.local_challenge is None
<22> ):
<23> self._logger.info(
<24> "Network path %s sending challenge", network_path.addr
<25> )
<26> network_path.local_challenge = os.urandom(8)
<27> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<28> push_bytes(buf, network_path.local_challenge)
<29>
<30> # PATH RESPONSE
<31> if is_one_rtt and network_path.remote_challenge is not None:
<32> push_uint_var(buf, QuicFrameType.PATH_RESPONSE)
<33> push_bytes(buf, network_path.remote_challenge)
<34> network_path.remote_challenge = None
<35>
<36> # PING
<37> if self._ping_waiter is not None and self._ping_packet_number is None:
<38> self._</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
self._logger.info("Sending PING in packet %d", builder.packet_number)
push_uint_var(buf, QuicFrameType.PING)
# CLOSE
if is_one_rtt and self.__close:
push_close(buf, **self.__close)
self.__close = None
for stream_id, stream in self.streams.items():
# CRYPTO
if is_one_rtt and stream_id == tls.Epoch.ONE_RTT:
frame_overhead = 3 + quic_uint_length(stream._send_start)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream._send_start)
if stream._send_start
else 0
)
)
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s> flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += len(frame.data)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: str) -> None
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_max_data = 0
self._remote_max_data_used = 0
at: aioquic.connection.QuicConnection._handle_ack_frame
self._ping_waiter = None
self._ping_packet_number = None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._write_application
self._remote_max_data_used += len(frame.data)
at: aioquic.connection.QuicConnection._write_handshake
self.__close = None
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.ping
self._ping_packet_number = None
self._ping_waiter = self._loop.create_future()
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
61480494eaca7466734ea0311d84d9af4f5beb45
|
[connection] don't validate original_connection_id when loading ticket
|
<18>:<add> if self._session_ticket.max_early_data_size == 0xFFFFFFFF:
<add> for ext_type, ext_data in self._session_ticket.other_extensions:
<del> for ext_type, ext_data in self._session_ticket.other_extensions:
<19>:<add> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<del> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<20>:<add> self._parse_transport_parameters(
<del> self._parse_transport_parameters(ext_data)
<21>:<add> ext_data, from_session_ticket=True
<add> )
<add> break
<del> break
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
<0> # TLS
<1> self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
<2> self.tls.alpn_protocols = self.alpn_protocols
<3> self.tls.certificate = self.certificate
<4> self.tls.certificate_private_key = self.private_key
<5> self.tls.handshake_extensions = [
<6> (
<7> tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
<8> self._serialize_transport_parameters(),
<9> )
<10> ]
<11> self.tls.server_name = self.server_name
<12>
<13> # TLS session resumption
<14> if self._session_ticket is not None:
<15> self.tls.session_ticket = self._session_ticket
<16>
<17> # parse saved QUIC transport parameters - for 0-RTT
<18> for ext_type, ext_data in self._session_ticket.other_extensions:
<19> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<20> self._parse_transport_parameters(ext_data)
<21> break
<22>
<23> # TLS callbacks
<24> if self._session_ticket_fetcher is not None:
<25> self.tls.get_session_ticket_cb = self._session_ticket_fetcher
<26> if self._session_ticket_handler is not None:
<27> self.tls.new_session_ticket_cb = self._session_ticket_handler
<28> self.tls.update_traffic_key_cb = self._update_traffic_key
<29>
<30> # packet spaces
<31> self.cryptos = {
<32> tls.Epoch.INITIAL: CryptoPair(),
<33> tls.Epoch.ZERO_RTT: CryptoPair(),
<34> tls.Epoch.HANDSHAKE: CryptoPair(),
<35> tls.Epoch.ONE_RTT: CryptoPair(),
<36> }
<37> self.send_buffer = {
<38> tls.Epoch.INITIAL: Buffer(capacity=</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.cryptos[tls.Epoch.INITIAL].setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.packet_number = 0
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicPacketSpace()
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_parse_transport_parameters(self, data: bytes, from_session_ticket: bool=False) -> None
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
_serialize_transport_parameters() -> bytes
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, cipher_suite: tls.CipherSuite, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.private_key = private_key
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._session_ticket = session_ticket
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
at: aioquic.crypto
CryptoPair()
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.tls
Epoch()
===========unchanged ref 1===========
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Context(is_client: bool, logger: Optional[Union[logging.Logger, logging.LoggerAdapter]]=None)
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, CipherSuite, bytes], None
] = lambda d, e, c, s: None
at: aioquic.tls.SessionTicket
age_add: int
cipher_suite: CipherSuite
not_valid_after: datetime.datetime
not_valid_before: datetime.datetime
resumption_secret: bytes
server_name: str
ticket: bytes
max_early_data_size: Optional[int] = None
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
|
aioquic.connection/QuicConnection._parse_transport_parameters
|
Modified
|
aiortc~aioquic
|
61480494eaca7466734ea0311d84d9af4f5beb45
|
[connection] don't validate original_connection_id when loading ticket
|
<3>:<add> if (
<add> self.is_client
<del> if self.is_client and (
<4>:<add> and not from_session_ticket
<add> and (
<add> quic_transport_parameters.original_connection_id
<del> quic_transport_parameters.original_connection_id
<5>:<add> != self._original_connection_id
<del> != self._original_connection_id
<6>:<add> )
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _parse_transport_parameters(
+ self, data: bytes, from_session_ticket: bool = False
+ ) -> None:
- def _parse_transport_parameters(self, data: bytes) -> None:
<0> quic_transport_parameters = pull_quic_transport_parameters(Buffer(data=data))
<1>
<2> # validate remote parameters
<3> if self.is_client and (
<4> quic_transport_parameters.original_connection_id
<5> != self._original_connection_id
<6> ):
<7> raise QuicConnectionError(
<8> error_code=QuicErrorCode.TRANSPORT_PARAMETER_ERROR,
<9> frame_type=QuicFrameType.CRYPTO,
<10> reason_phrase="original_connection_id does not match",
<11> )
<12>
<13> # store remote parameters
<14> if quic_transport_parameters.idle_timeout is not None:
<15> self._remote_idle_timeout = quic_transport_parameters.idle_timeout
<16> for param in [
<17> "max_data",
<18> "max_stream_data_bidi_local",
<19> "max_stream_data_bidi_remote",
<20> "max_stream_data_uni",
<21> "max_streams_bidi",
<22> "max_streams_uni",
<23> ]:
<24> value = getattr(quic_transport_parameters, "initial_" + param)
<25> if value is not None:
<26> setattr(self, "_remote_" + param, value)
<27>
<28> self._logger.info("ALPN negotiated protocol %s", self.alpn_protocol)
<29>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection
_send_pending() -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self._loop = asyncio.get_event_loop()
self._original_connection_id = original_connection_id
self._remote_idle_timeout = 0 # milliseconds
self.__send_pending_task: Optional[asyncio.Handle] = None
at: aioquic.connection.QuicConnection._send_pending
self.__send_pending_task = None
at: aioquic.connection.QuicConnection.datagram_received
self._original_connection_id = self.peer_cid
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_transport_parameters(buf: Buffer) -> QuicTransportParameters
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
original_connection_id: Optional[bytes] = None
idle_timeout: Optional[int] = None
stateless_reset_token: Optional[bytes] = None
max_packet_size: Optional[int] = None
initial_max_data: Optional[int] = None
===========unchanged ref 1===========
initial_max_stream_data_bidi_local: Optional[int] = None
initial_max_stream_data_bidi_remote: Optional[int] = None
initial_max_stream_data_uni: Optional[int] = None
initial_max_streams_bidi: Optional[int] = None
initial_max_streams_uni: Optional[int] = None
ack_delay_exponent: Optional[int] = None
max_ack_delay: Optional[int] = None
disable_migration: Optional[bool] = False
preferred_address: Optional[bytes] = None
at: asyncio.events.AbstractEventLoop
call_soon(callback: Callable[..., Any], *args: Any) -> Handle
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# TLS
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.tls.alpn_protocols = self.alpn_protocols
self.tls.certificate = self.certificate
self.tls.certificate_private_key = self.private_key
self.tls.handshake_extensions = [
(
tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
self._serialize_transport_parameters(),
)
]
self.tls.server_name = self.server_name
# TLS session resumption
if self._session_ticket is not None:
self.tls.session_ticket = self._session_ticket
# parse saved QUIC transport parameters - for 0-RTT
+ if self._session_ticket.max_early_data_size == 0xFFFFFFFF:
+ for ext_type, ext_data in self._session_ticket.other_extensions:
- for ext_type, ext_data in self._session_ticket.other_extensions:
+ if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
- if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
+ self._parse_transport_parameters(
- self._parse_transport_parameters(ext_data)
+ ext_data, from_session_ticket=True
+ )
+ break
- break
# TLS callbacks
if self._session_ticket_fetcher is not None:
self.tls.get_session_ticket_cb = self._session_ticket_fetcher
if self._session_ticket_handler is not None:
self.tls.new_session_ticket_cb = self._session_ticket_handler
self.tls.update_traffic_key_cb = self._update_traffic_key
# packet spaces
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
</s>
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
<s>traffic_key
# packet spaces
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.cryptos[tls.Epoch.INITIAL].setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.packet_number = 0
|
aioquic.connection/QuicConnection._initialize
|
Modified
|
aiortc~aioquic
|
420cd90a14bcae4ee7d2ca82fb9fda190da3d294
|
[connection] don't use session ticket against different server_name
|
<14>:<add> if (
<add> self.is_client
<add> and self._session_ticket is not None
<del> if self._session_ticket is not None:
<15>:<add> and self._session_ticket.is_valid
<add> and self._session_ticket.server_name == self.server_name
<add> ):
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
<0> # TLS
<1> self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
<2> self.tls.alpn_protocols = self.alpn_protocols
<3> self.tls.certificate = self.certificate
<4> self.tls.certificate_private_key = self.private_key
<5> self.tls.handshake_extensions = [
<6> (
<7> tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS,
<8> self._serialize_transport_parameters(),
<9> )
<10> ]
<11> self.tls.server_name = self.server_name
<12>
<13> # TLS session resumption
<14> if self._session_ticket is not None:
<15> self.tls.session_ticket = self._session_ticket
<16>
<17> # parse saved QUIC transport parameters - for 0-RTT
<18> if self._session_ticket.max_early_data_size == 0xFFFFFFFF:
<19> for ext_type, ext_data in self._session_ticket.other_extensions:
<20> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<21> self._parse_transport_parameters(
<22> ext_data, from_session_ticket=True
<23> )
<24> break
<25>
<26> # TLS callbacks
<27> if self._session_ticket_fetcher is not None:
<28> self.tls.get_session_ticket_cb = self._session_ticket_fetcher
<29> if self._session_ticket_handler is not None:
<30> self.tls.new_session_ticket_cb = self._session_ticket_handler
<31> self.tls.update_traffic_key_cb = self._update_traffic_key
<32>
<33> # packet spaces
<34> self.cryptos = {
<35> tls.Epoch.INITIAL: CryptoPair(),
<36> tls.Epoch.ZERO_RTT: CryptoPair(),
<37> tls.Epoch.HANDSHAKE: CryptoPair(),
<38> tls.Epoch</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _initialize(self, peer_cid: bytes) -> None:
# offset: 1
}
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
self.streams[tls.Epoch.INITIAL] = QuicStream()
self.streams[tls.Epoch.HANDSHAKE] = QuicStream()
self.streams[tls.Epoch.ONE_RTT] = QuicStream()
self.cryptos[tls.Epoch.INITIAL].setup_initial(
cid=peer_cid, is_client=self.is_client
)
self.packet_number = 0
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicPacketSpace()
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
_parse_transport_parameters(data: bytes, from_session_ticket: bool=False) -> None
_serialize_transport_parameters() -> bytes
_update_traffic_key(direction: tls.Direction, epoch: tls.Epoch, cipher_suite: tls.CipherSuite, secret: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.private_key = private_key
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._session_ticket = session_ticket
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
at: aioquic.crypto
CryptoPair()
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.tls
Epoch()
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Context(is_client: bool, logger: Optional[Union[logging.Logger, logging.LoggerAdapter]]=None)
===========unchanged ref 1===========
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
self.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.session_ticket: Optional[SessionTicket] = None
self.server_name: Optional[str] = None
self.get_session_ticket_cb: Optional[SessionTicketFetcher] = None
self.new_session_ticket_cb: Optional[SessionTicketHandler] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, CipherSuite, bytes], None
] = lambda d, e, c, s: None
at: aioquic.tls.SessionTicket
age_add: int
cipher_suite: CipherSuite
not_valid_after: datetime.datetime
not_valid_before: datetime.datetime
resumption_secret: bytes
server_name: str
ticket: bytes
max_early_data_size: Optional[int] = None
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
|
tests.test_high_level/HighLevelTest.test_connect_and_serve_with_session_ticket
|
Modified
|
aiortc~aioquic
|
b5ad84204da515c5528c731cf251c77059bc462d
|
[tests] actually use saved session ticket!
|
<21>:<add> run_server(session_ticket_fetcher=store.pop),
<del> run_server(session_ticket_fetcher=store.pop), run_client("127.0.0.1")
<22>:<add> run_client("127.0.0.1", session_ticket=client_ticket),
|
# module: tests.test_high_level
class HighLevelTest(TestCase):
def test_connect_and_serve_with_session_ticket(self):
<0> client_ticket = None
<1> store = SessionTicketStore()
<2>
<3> def save_ticket(t):
<4> nonlocal client_ticket
<5> client_ticket = t
<6>
<7> # first request
<8> _, response = run(
<9> asyncio.gather(
<10> run_server(session_ticket_handler=store.add),
<11> run_client("127.0.0.1", session_ticket_handler=save_ticket),
<12> )
<13> )
<14> self.assertEqual(response, b"gnip")
<15>
<16> self.assertIsNotNone(client_ticket)
<17>
<18> # second request
<19> _, response = run(
<20> asyncio.gather(
<21> run_server(session_ticket_fetcher=store.pop), run_client("127.0.0.1")
<22> )
<23> )
<24> self.assertEqual(response, b"gnip")
<25>
|
===========unchanged ref 0===========
at: asyncio.tasks
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[
Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]]
]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2, _T3, _T4]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[Tuple[_T1, _T2]]
gather(coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop]=..., return_exceptions: bool=...) -> Future[List[Any]]
gather(coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop]=..., return_exceptions: Literal[False]=...) -> Future[</s>
===========unchanged ref 1===========
at: tests.test_high_level
SessionTicketStore()
run_client(host, *, alpn_protocols: Optional[List[str]]=None, secrets_log_file: Optional[TextIO]=None, stream_handler: Optional[QuicStreamHandler]=None)
run_server(*, alpn_protocols: Optional[List[str]]=None, connection_handler: QuicConnectionHandler=None, secrets_log_file: Optional[TextIO]=None)
at: tests.test_high_level.SessionTicketStore
add(ticket)
pop(label)
at: tests.utils
run(coro)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertIsNotNone(obj: Any, msg: Any=...) -> None
|
examples.interop/test_spin_bit
|
Modified
|
aiortc~aioquic
|
8eb888d6184331f5417615fbd93fed63e9092763
|
[interop] catch any Exception
|
<2>:<add> for i in range(5):
<del> for i in range(4):
|
# module: examples.interop
def test_spin_bit(config, **kwargs):
<0> async with aioquic.connect(config.host, config.port, **kwargs) as connection:
<1> spin_bits = set()
<2> for i in range(4):
<3> await connection.ping()
<4> spin_bits.add(connection._spin_bit_peer)
<5> if len(spin_bits) == 2:
<6> config.result |= Result.P
<7>
|
===========unchanged ref 0===========
at: aioquic.client
connect(host: str, port: int, *, alpn_protocols: Optional[List[str]]=None, protocol_version: Optional[int]=None, secrets_log_file: Optional[TextIO]=None, session_ticket: Optional[SessionTicket]=None, session_ticket_handler: Optional[SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None) -> AsyncGenerator[QuicConnection, None]
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
ping() -> None
at: aioquic.connection.QuicConnection.__init__
self._spin_bit_peer = False
at: aioquic.connection.QuicConnection.datagram_received
self._spin_bit_peer = get_spin_bit(plain_header[0])
at: examples.interop
Result()
|
examples.interop/run
|
Modified
|
aiortc~aioquic
|
8eb888d6184331f5417615fbd93fed63e9092763
|
[interop] catch any Exception
|
<9>:<add> except Exception:
<del> except asyncio.TimeoutError:
|
# module: examples.interop
def run(only=None, **kwargs):
<0> configs = list(filter(lambda x: not only or x.name == only, CONFIGS))
<1>
<2> for config in configs:
<3> for test_name, test_func in filter(
<4> lambda x: x[0].startswith("test_"), globals().items()
<5> ):
<6> print("\n=== %s %s ===\n" % (config.name, test_name))
<7> try:
<8> await asyncio.wait_for(test_func(config, **kwargs), timeout=5)
<9> except asyncio.TimeoutError:
<10> pass
<11> print("")
<12> print_result(config)
<13>
<14> # print summary
<15> if len(configs) > 1:
<16> print("SUMMARY")
<17> for config in configs:
<18> print_result(config)
<19>
|
===========unchanged ref 0===========
at: asyncio.tasks
wait_for(fut: _FutureT[_T], timeout: Optional[float], *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: examples.interop
CONFIGS = [
Config("aioquic", "quic.aiortc.org", 4434, "/"),
Config("ats", "quic.ogre.com", 4434, "/"),
Config("f5", "208.85.208.226", 4433, "/"),
Config("gquic", "quic.rocks", 4433, "/"),
Config("lsquic", "http3-test.litespeedtech.com", 4434, None),
Config("mvfst", "fb.mvfst.net", 4433, "/"),
Config("ngtcp2", "nghttp2.org", 4434, None),
Config("ngx_quic", "cloudflare-quic.com", 443, None),
Config("pandora", "pandora.cm.in.tum.de", 4433, "/"),
Config("picoquic", "test.privateoctopus.com", 4434, "/"),
Config("quant", "quant.eggert.org", 4434, "/"),
Config("quic-go", "quic.seemann.io", 443, "/"),
Config("quiche", "quic.tech", 4433, "/"),
Config("quicker", "quicker.edm.uhasselt.be", 4433, "/"),
Config("quicly", "kazuhooku.com", 4434, "/"),
Config("quinn", "ralith.com", 4433, "/"),
Config("winquic", "quic.westus.cloudapp.azure.com", 4434, "/"),
]
print_result(config)
at: examples.interop.Config
name: str
host: str
port: int
path: str
result: Result = field(default_factory=lambda: Result(0))
===========changed ref 0===========
# module: examples.interop
def test_spin_bit(config, **kwargs):
async with aioquic.connect(config.host, config.port, **kwargs) as connection:
spin_bits = set()
+ for i in range(5):
- for i in range(4):
await connection.ping()
spin_bits.add(connection._spin_bit_peer)
if len(spin_bits) == 2:
config.result |= Result.P
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
e1fa3a72284bbe7781e62a9fb43a58021e5f363c
|
[connection] when sending CLOSE, don't send anything else
|
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.host_cid = os.urandom(8)
<12> self.peer_cid = os.urandom(8)
<13> self.peer_cid_set = False
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._local_idle_timeout = 60000 # milliseconds
<29> self._local_max_data = 1048576
<30> self._local_max_data_used = 0
<31> self._local_max_stream_data</s>
|
===========below chunk 0===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[</s>
===========below chunk 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# callbacks
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame,</s>
===========below chunk 2===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>S("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self</s>
===========below chunk 3===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._send_pending
|
Modified
|
aiortc~aioquic
|
e1fa3a72284bbe7781e62a9fb43a58021e5f363c
|
[connection] when sending CLOSE, don't send anything else
|
<11>:<add>
<add> if self.__close:
<add> for epoch, packet_type in (
<add> (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
<add> (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
<add> (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
<add> ):
<add> crypto = self.cryptos[epoch]
<add> if crypto.send.is_valid():
<add> builder.start_packet(packet_type, crypto)
<add> push_close(builder.buffer, **self.__close)
<add> builder.end_packet()
<add> self.__close = None
<add> break
<add> else:
<add> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<del> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<12>:<add> self._write_handshake(builder, epoch)
<del> self._write_handshake(builder, epoch)
<13>:<add> self._write_application(builder, network_path)
<del> self._write_application(builder, network_path)
<14>:<add>
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
<0> network_path = self._network_paths[0]
<1>
<2> # build datagrams
<3> builder = QuicPacketBuilder(
<4> host_cid=self.host_cid,
<5> packet_number=self.packet_number,
<6> peer_cid=self.peer_cid,
<7> peer_token=self.peer_token,
<8> spin_bit=self._spin_bit,
<9> version=self._version,
<10> )
<11> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<12> self._write_handshake(builder, epoch)
<13> self._write_application(builder, network_path)
<14> self.packet_number = builder.packet_number
<15>
<16> # send datagrams
<17> for datagram in builder.flush():
<18> self._transport.sendto(datagram, network_path.addr)
<19> network_path.bytes_sent += len(datagram)
<20> self.__send_pending_task = None
<21>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_token = b""
self.__close: Optional[Dict] = None
self._network_paths: List[QuicNetworkPath] = []
self._spin_bit = False
self._version: Optional[int] = None
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._send_pending
self.__close = None
self.packet_number = builder.packet_number
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
at: aioquic.connection.QuicConnection.connect
self._network_paths = [QuicNetworkPath(addr, is_validated=True)]
self._version = max(self.supported_versions)
self._version = protocol_version
at: aioquic.connection.QuicConnection.datagram_received
self._version = QuicProtocolVersion(header.version)
self._version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self._network_paths = [network_path]
self._spin_bit = self._spin_bit_peer
self._spin_bit = not self._spin_bit_peer
at: aioquic.crypto.CryptoContext
is_valid() -> bool
===========unchanged ref 1===========
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.tls
Epoch()
===========changed ref 0===========
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
if is_client:
assert (
original_connection_id is None
), "Cannot set original_connection_id for a client"
else:
assert certificate is not None, "SSL certificate is required for a server"
assert private_key is not None, "SSL private key is required for a server"
self.alpn_protocols = alpn_protocols
self.certificate = certificate
self.is_client = is_client
self.host_cid = os.urandom(8)
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
self.peer_token = b""
self.private_key = private_key
self.secrets_log_file = secrets_log_file
self.server_name = server_name
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
# counters for debugging
self._stateless_retry_count = 0
self._version_negotiation_count = 0
self._loop = asyncio.get_event_loop()
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self</s>
===========changed ref 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
<s>i_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
+ self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_</s>
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
e1fa3a72284bbe7781e62a9fb43a58021e5f363c
|
[connection] when sending CLOSE, don't send anything else
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<1> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<2> packet_type = PACKET_TYPE_ONE_RTT
<3> elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<4> crypto = self.cryptos[tls.Epoch.ZERO_RTT]
<5> packet_type = PACKET_TYPE_ZERO_RTT
<6> else:
<7> return
<8> space = self.spaces[tls.Epoch.ONE_RTT]
<9> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<10>
<11> buf = builder.buffer
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> # ACK
<17> if is_one_rtt and space.ack_required and space.ack_queue:
<18> push_uint_var(buf, QuicFrameType.ACK)
<19> packet.push_ack_frame(buf, space.ack_queue, 0)
<20> space.ack_required = False
<21>
<22> # PATH CHALLENGE
<23> if (
<24> is_one_rtt
<25> and not network_path.is_validated
<26> and network_path.local_challenge is None
<27> ):
<28> self._logger.info(
<29> "Network path %s sending challenge", network_path.addr
<30> )
<31> network_path.local_challenge = os.urandom(8)
<32> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<33> push_bytes(buf, network_path.local_challenge)
<34>
<35> # PATH RESPONSE
<36> if is_one_rtt and network_path.remote_challenge is not None:
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# PING
if self._ping_waiter is not None and self._ping_packet_number is None:
self._ping_packet_number = builder.packet_number
self._logger.info("Sending PING in packet %d", builder.packet_number)
push_uint_var(buf, QuicFrameType.PING)
# CLOSE
if is_one_rtt and self.__close:
push_close(buf, **self.__close)
self.__close = None
for stream_id, stream in self.streams.items():
# CRYPTO
if is_one_rtt and stream_id == tls.Epoch.ONE_RTT:
frame_overhead = 3 + quic_uint_length(stream._send_start)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream._send_start)
if stream._send_start
else 0
)
)
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s>,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += len(frame.data)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.secrets_log_file = secrets_log_file
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._remote_max_data = 0
self._remote_max_data_used = 0
at: aioquic.connection.QuicConnection._handle_ack_frame
self._ping_waiter = None
self._ping_packet_number = None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._write_application
self._remote_max_data_used += len(frame.data)
at: aioquic.connection.QuicConnection.ping
self._ping_packet_number = None
self._ping_waiter = self._loop.create_future()
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.crypto.CryptoContext
is_valid() -> bool
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
|
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
e1fa3a72284bbe7781e62a9fb43a58021e5f363c
|
[connection] when sending CLOSE, don't send anything else
|
<19>:<del>
<20>:<del> # CLOSE
<21>:<del> if self.__close and self.__epoch == epoch:
<22>:<del> push_close(buf, **self.__close)
<23>:<del> self.__close = None
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_required and space.ack_queue:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> space.ack_required = False
<19>
<20> # CLOSE
<21> if self.__close and self.__epoch == epoch:
<22> push_close(buf, **self.__close)
<23> self.__close = None
<24>
<25> # CRYPTO
<26> stream = self.streams[epoch]
<27> frame_overhead = 3 + quic_uint_length(stream._send_start)
<28> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<29> if frame is not None:
<30> push_uint_var(buf, QuicFrameType.CRYPTO)
<31> with packet.push_crypto_frame(buf, frame.offset):
<32> push_bytes(buf, frame.data)
<33>
<34> # PADDING
<35> if epoch == tls.Epoch.INITIAL and self.is_client:
<36> push_bytes(buf, bytes(builder.remaining_space))
<37>
<38> if not builder.end_packet():
<39> break
<40>
<41> # discard initial keys
<42> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<43> self.cryptos[tls.Epoch.INITIAL].teardown()
</s>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._remote_max_data_used = 0
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._write_application
buf = builder.buffer
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_HANDSHAKE = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x20
quic_uint_length(value: int) -> int
push_uint_var(buf: Buffer, value: int) -> None
===========unchanged ref 1===========
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
push_ack_frame(buf: Buffer, rangeset: RangeSet, delay: int) -> None
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
push_crypto_frame(buf: Buffer, offset: int=0) -> Generator
push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator
at: aioquic.packet.QuicStreamFrame
fin: bool = False
offset: int = 0
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
start_packet(packet_type: int, crypto: CryptoPair) -> None
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
at: aioquic.stream.QuicStream.__init__
self._send_start = 0
at: aioquic.stream.QuicStream.get_frame
self._send_start += size
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _send_pending(self) -> None:
network_path = self._network_paths[0]
# build datagrams
builder = QuicPacketBuilder(
host_cid=self.host_cid,
packet_number=self.packet_number,
peer_cid=self.peer_cid,
peer_token=self.peer_token,
spin_bit=self._spin_bit,
version=self._version,
)
+
+ if self.__close:
+ for epoch, packet_type in (
+ (tls.Epoch.ONE_RTT, PACKET_TYPE_ONE_RTT),
+ (tls.Epoch.HANDSHAKE, PACKET_TYPE_HANDSHAKE),
+ (tls.Epoch.INITIAL, PACKET_TYPE_INITIAL),
+ ):
+ crypto = self.cryptos[epoch]
+ if crypto.send.is_valid():
+ builder.start_packet(packet_type, crypto)
+ push_close(builder.buffer, **self.__close)
+ builder.end_packet()
+ self.__close = None
+ break
+ else:
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
+ self._write_handshake(builder, epoch)
- self._write_handshake(builder, epoch)
+ self._write_application(builder, network_path)
- self._write_application(builder, network_path)
+
self.packet_number = builder.packet_number
# send datagrams
for datagram in builder.flush():
self._transport.sendto(datagram, network_path.addr)
network_path.bytes_sent += len(datagram)
self.__send_pending_task = None
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
crypto = self.cryptos[tls.Epoch.ONE_RTT]
packet_type = PACKET_TYPE_ONE_RTT
elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
crypto = self.cryptos[tls.Epoch.ZERO_RTT]
packet_type = PACKET_TYPE_ZERO_RTT
else:
return
space = self.spaces[tls.Epoch.ONE_RTT]
is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
buf = builder.buffer
while True:
# write header
builder.start_packet(packet_type, crypto)
# ACK
if is_one_rtt and space.ack_required and space.ack_queue:
push_uint_var(buf, QuicFrameType.ACK)
packet.push_ack_frame(buf, space.ack_queue, 0)
space.ack_required = False
# PATH CHALLENGE
if (
is_one_rtt
and not network_path.is_validated
and network_path.local_challenge is None
):
self._logger.info(
"Network path %s sending challenge", network_path.addr
)
network_path.local_challenge = os.urandom(8)
push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
push_bytes(buf, network_path.local_challenge)
# PATH RESPONSE
if is_one_rtt and network_path.remote_challenge is not None:
push_uint_var(buf, QuicFrameType.PATH_RESPONSE)
push_bytes(buf, network_path.remote_challenge)
network</s>
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<20>:<add> self._send_pending = RangeSet()
<21>:<add> self._send_end = 0
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
<0> self._connection = connection
<1> self.max_stream_data_local = max_stream_data_local
<2> self.max_stream_data_remote = max_stream_data_remote
<3>
<4> if stream_id is not None:
<5> self.reader = asyncio.StreamReader()
<6> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<7> else:
<8> self.reader = None
<9> self.writer = None
<10>
<11> self._recv_buffer = bytearray()
<12> self._recv_fin = False
<13> self._recv_highest = 0 # the highest offset ever seen
<14> self._recv_start = 0 # the offset for the start of the buffer
<15> self._recv_ranges = RangeSet()
<16>
<17> self._send_buffer = bytearray()
<18> self._send_complete = False
<19> self._send_eof = False
<20> self._send_start = 0
<21>
<22> self.__stream_id = stream_id
<23>
|
===========unchanged ref 0===========
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.stream.QuicStream.add_frame
self._recv_highest = frame_end
self._recv_buffer += bytearray(gap)
self._recv_fin = True
at: aioquic.stream.QuicStream.get_frame
self._send_complete = True
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: aioquic.stream.QuicStream.write
self._send_buffer += data
self._send_end += size
at: aioquic.stream.QuicStream.write_eof
self._send_eof = True
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: asyncio.transports.BaseTransport
__slots__ = ('_extra',)
__init__(self, extra: Optional[Mapping[Any, Any]]=...) -> None
|
aioquic.stream/QuicStream.get_frame
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<4>:<add> if self._send_complete or not (self._send_eof or bool(self._send_pending)):
<del> if self._send_complete or not self.has_data_to_send():
<7>:<add> if not self._send_pending:
<add> # FIN only
<add> self._send_complete = True
<add> return QuicStreamFrame(fin=True, offset=self._send_end)
<add>
<8>:<add> r = self._send_pending[0]
<add> size = min(size, r.stop - r.start)
<9>:<add> size = min(size, self.max_stream_data_remote - r.start)
<del> size = min(size, self.max_stream_data_remote - self._send_start)
<10>:<add> if size <= 0:
<del> if size < 0 or (size == 0 and self._send_buffer):
<14>:<add> send = range(r.start, r.start + size)
<add> frame = QuicStreamFrame(
<add> data=self._send_buffer[
<add> send.start - self._send_start : send.start + size - self._send_start
<add> ],
<add> offset=send.start,
<add> )
<add> self._send_pending.subtract(send.start, send.stop)
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
<0> """
<1> Get a frame of data to send.
<2> """
<3> # check there is something to send
<4> if self._send_complete or not self.has_data_to_send():
<5> return None
<6>
<7> # apply flow control
<8> if self.stream_id is not None:
<9> size = min(size, self.max_stream_data_remote - self._send_start)
<10> if size < 0 or (size == 0 and self._send_buffer):
<11> return None
<12>
<13> # create frame
<14> size = min(size, len(self._send_buffer))
<15> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
<16> self._send_buffer = self._send_buffer[size:]
<17> self._send_start += size
<18>
<19> # if the buffer is empty and EOF was written, set the FIN bit
<20> if self._send_eof and not self._send_buffer:
<21> frame.fin = True
<22> self._send_complete = True
<23>
<24> return frame
<25>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_remote = max_stream_data_remote
self.reader = asyncio.StreamReader()
self.reader = None
self._send_complete = False
self._send_eof = False
self._send_pending = RangeSet()
self._send_end = 0
at: aioquic.stream.QuicStream.write
self._send_end += size
at: aioquic.stream.QuicStream.write_eof
self._send_eof = True
at: asyncio.streams.StreamReader
_source_traceback = None
set_exception(exc: Exception) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_pending = RangeSet()
self._send_start = 0
+ self._send_end = 0
self.__stream_id = stream_id
|
aioquic.stream/QuicStream.is_blocked
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<5>:<add> bool(self._send_pending)
<add> and self._send_pending[0].start >= self.max_stream_data_remote
<del> bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def is_blocked(self) -> bool:
<0> """
<1> Returns True if there is data to send but the peer's MAX_STREAM_DATA
<2> prevents us from sending it.
<3> """
<4> return (
<5> bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
<6> )
<7>
|
===========unchanged ref 0===========
at: aioquic.packet.QuicStreamFrame
fin: bool = False
at: aioquic.stream.QuicStream.__init__
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_complete = False
at: aioquic.stream.QuicStream.get_frame
frame = QuicStreamFrame(
data=self._send_buffer[
send.start - self._send_start : send.start + size - self._send_start
],
offset=send.start,
)
at: aioquic.stream.QuicStream.pull_data
self._recv_start = r.stop
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def has_data_to_send(self) -> bool:
- return not self._send_complete and (self._send_eof or bool(self._send_buffer))
-
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_pending = RangeSet()
self._send_start = 0
+ self._send_end = 0
self.__stream_id = stream_id
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or bool(self._send_pending)):
- if self._send_complete or not self.has_data_to_send():
return None
+ if not self._send_pending:
+ # FIN only
+ self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_end)
+
# apply flow control
+ r = self._send_pending[0]
+ size = min(size, r.stop - r.start)
if self.stream_id is not None:
+ size = min(size, self.max_stream_data_remote - r.start)
- size = min(size, self.max_stream_data_remote - self._send_start)
+ if size <= 0:
- if size < 0 or (size == 0 and self._send_buffer):
return None
# create frame
+ send = range(r.start, r.start + size)
+ frame = QuicStreamFrame(
+ data=self._send_buffer[
+ send.start - self._send_start : send.start + size - self._send_start
+ ],
+ offset=send.start,
+ )
+ self._send_pending.subtract(send.start, send.stop)
- size = min(size, len(self._send_buffer))
- frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
- self._send_buffer = self._send_buffer[size:]
- self._send_start += size
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- </s>
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s> is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- if self._send_eof and not self._send_buffer:
frame.fin = True
self._send_complete = True
return frame
|
aioquic.stream/QuicStream.write
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<1>:<add> size = len(data)
<2>:<add> if size:
<del> if data:
<4>:<add> self._send_pending.add(self._send_end, self._send_end + size)
<add> self._send_end += size
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
<0> assert not self._send_complete, "cannot call write() after completion"
<1>
<2> if data:
<3> self._send_buffer += data
<4> if self._connection is not None:
<5> self._connection._send_soon()
<6>
|
===========unchanged ref 0===========
at: asyncio.transports.BaseTransport
get_extra_info(self, name: Any, default: Any=...) -> Any
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def has_data_to_send(self) -> bool:
- return not self._send_complete and (self._send_eof or bool(self._send_buffer))
-
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def is_blocked(self) -> bool:
"""
Returns True if there is data to send but the peer's MAX_STREAM_DATA
prevents us from sending it.
"""
return (
+ bool(self._send_pending)
+ and self._send_pending[0].start >= self.max_stream_data_remote
- bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
)
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_pending = RangeSet()
self._send_start = 0
+ self._send_end = 0
self.__stream_id = stream_id
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or bool(self._send_pending)):
- if self._send_complete or not self.has_data_to_send():
return None
+ if not self._send_pending:
+ # FIN only
+ self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_end)
+
# apply flow control
+ r = self._send_pending[0]
+ size = min(size, r.stop - r.start)
if self.stream_id is not None:
+ size = min(size, self.max_stream_data_remote - r.start)
- size = min(size, self.max_stream_data_remote - self._send_start)
+ if size <= 0:
- if size < 0 or (size == 0 and self._send_buffer):
return None
# create frame
+ send = range(r.start, r.start + size)
+ frame = QuicStreamFrame(
+ data=self._send_buffer[
+ send.start - self._send_start : send.start + size - self._send_start
+ ],
+ offset=send.start,
+ )
+ self._send_pending.subtract(send.start, send.stop)
- size = min(size, len(self._send_buffer))
- frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
- self._send_buffer = self._send_buffer[size:]
- self._send_start += size
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- </s>
===========changed ref 4===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s> is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- if self._send_eof and not self._send_buffer:
frame.fin = True
self._send_complete = True
return frame
|
tests.test_stream/QuicStreamTest.test_send_data
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<3>:<del> self.assertFalse(stream.has_data_to_send())
<10>:<add> self.assertEqual(list(stream._send_pending), [range(0, 16)])
<del> self.assertTrue(stream.has_data_to_send())
<16>:<add> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<18>:<del> self.assertTrue(stream.has_data_to_send())
<24>:<add> self.assertEqual(list(stream._send_pending), [])
<26>:<del> self.assertFalse(stream.has_data_to_send())
<30>:<add> self.assertEqual(list(stream._send_pending), [])
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.has_data_to_send())
<4> self.assertFalse(stream.is_blocked())
<5> frame = stream.get_frame(8)
<6> self.assertIsNone(frame)
<7>
<8> # write data, send a chunk
<9> stream.write(b"0123456789012345")
<10> self.assertTrue(stream.has_data_to_send())
<11> self.assertFalse(stream.is_blocked())
<12> frame = stream.get_frame(8)
<13> self.assertEqual(frame.data, b"01234567")
<14> self.assertFalse(frame.fin)
<15> self.assertEqual(frame.offset, 0)
<16>
<17> # send another chunk
<18> self.assertTrue(stream.has_data_to_send())
<19> self.assertFalse(stream.is_blocked())
<20> frame = stream.get_frame(8)
<21> self.assertEqual(frame.data, b"89012345")
<22> self.assertFalse(frame.fin)
<23> self.assertEqual(frame.offset, 8)
<24>
<25> # nothing more to send
<26> self.assertFalse(stream.has_data_to_send())
<27> self.assertFalse(stream.is_blocked())
<28> frame = stream.get_frame(8)
<29> self.assertIsNone(frame)
<30>
|
===========unchanged ref 0===========
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
is_blocked() -> bool
write(data: bytes) -> None
at: aioquic.stream.QuicStream.__init__
self._send_pending = RangeSet()
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def is_blocked(self) -> bool:
"""
Returns True if there is data to send but the peer's MAX_STREAM_DATA
prevents us from sending it.
"""
return (
+ bool(self._send_pending)
+ and self._send_pending[0].start >= self.max_stream_data_remote
- bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
)
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
assert not self._send_complete, "cannot call write() after completion"
+ size = len(data)
+ if size:
- if data:
self._send_buffer += data
+ self._send_pending.add(self._send_end, self._send_end + size)
+ self._send_end += size
if self._connection is not None:
self._connection._send_soon()
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or bool(self._send_pending)):
- if self._send_complete or not self.has_data_to_send():
return None
+ if not self._send_pending:
+ # FIN only
+ self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_end)
+
# apply flow control
+ r = self._send_pending[0]
+ size = min(size, r.stop - r.start)
if self.stream_id is not None:
+ size = min(size, self.max_stream_data_remote - r.start)
- size = min(size, self.max_stream_data_remote - self._send_start)
+ if size <= 0:
- if size < 0 or (size == 0 and self._send_buffer):
return None
# create frame
+ send = range(r.start, r.start + size)
+ frame = QuicStreamFrame(
+ data=self._send_buffer[
+ send.start - self._send_start : send.start + size - self._send_start
+ ],
+ offset=send.start,
+ )
+ self._send_pending.subtract(send.start, send.stop)
- size = min(size, len(self._send_buffer))
- frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
- self._send_buffer = self._send_buffer[size:]
- self._send_start += size
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- </s>
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s> is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- if self._send_eof and not self._send_buffer:
frame.fin = True
self._send_complete = True
return frame
===========changed ref 4===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def has_data_to_send(self) -> bool:
- return not self._send_complete and (self._send_eof or bool(self._send_buffer))
-
===========changed ref 5===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_pending = RangeSet()
self._send_start = 0
+ self._send_end = 0
self.__stream_id = stream_id
|
tests.test_stream/QuicStreamTest.test_send_data_and_fin
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<3>:<del> self.assertFalse(stream.has_data_to_send())
<11>:<del> self.assertTrue(stream.has_data_to_send())
<19>:<del> self.assertTrue(stream.has_data_to_send())
<27>:<del> self.assertFalse(stream.has_data_to_send())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.has_data_to_send())
<4> self.assertFalse(stream.is_blocked())
<5> frame = stream.get_frame(8)
<6> self.assertIsNone(frame)
<7>
<8> # write data and EOF, send a chunk
<9> stream.write(b"0123456789012345")
<10> stream.write_eof()
<11> self.assertTrue(stream.has_data_to_send())
<12> self.assertFalse(stream.is_blocked())
<13> frame = stream.get_frame(8)
<14> self.assertEqual(frame.data, b"01234567")
<15> self.assertFalse(frame.fin)
<16> self.assertEqual(frame.offset, 0)
<17>
<18> # send another chunk
<19> self.assertTrue(stream.has_data_to_send())
<20> self.assertFalse(stream.is_blocked())
<21> frame = stream.get_frame(8)
<22> self.assertEqual(frame.data, b"89012345")
<23> self.assertTrue(frame.fin)
<24> self.assertEqual(frame.offset, 8)
<25>
<26> # nothing more to send
<27> self.assertFalse(stream.has_data_to_send())
<28> self.assertFalse(stream.is_blocked())
<29> frame = stream.get_frame(8)
<30> self.assertIsNone(frame)
<31>
|
===========unchanged ref 0===========
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
is_blocked() -> bool
write(data: bytes) -> None
write_eof() -> None
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def is_blocked(self) -> bool:
"""
Returns True if there is data to send but the peer's MAX_STREAM_DATA
prevents us from sending it.
"""
return (
+ bool(self._send_pending)
+ and self._send_pending[0].start >= self.max_stream_data_remote
- bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
)
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
assert not self._send_complete, "cannot call write() after completion"
+ size = len(data)
+ if size:
- if data:
self._send_buffer += data
+ self._send_pending.add(self._send_end, self._send_end + size)
+ self._send_end += size
if self._connection is not None:
self._connection._send_soon()
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or bool(self._send_pending)):
- if self._send_complete or not self.has_data_to_send():
return None
+ if not self._send_pending:
+ # FIN only
+ self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_end)
+
# apply flow control
+ r = self._send_pending[0]
+ size = min(size, r.stop - r.start)
if self.stream_id is not None:
+ size = min(size, self.max_stream_data_remote - r.start)
- size = min(size, self.max_stream_data_remote - self._send_start)
+ if size <= 0:
- if size < 0 or (size == 0 and self._send_buffer):
return None
# create frame
+ send = range(r.start, r.start + size)
+ frame = QuicStreamFrame(
+ data=self._send_buffer[
+ send.start - self._send_start : send.start + size - self._send_start
+ ],
+ offset=send.start,
+ )
+ self._send_pending.subtract(send.start, send.stop)
- size = min(size, len(self._send_buffer))
- frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
- self._send_buffer = self._send_buffer[size:]
- self._send_start += size
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- </s>
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s> is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- if self._send_eof and not self._send_buffer:
frame.fin = True
self._send_complete = True
return frame
===========changed ref 4===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data, send a chunk
stream.write(b"0123456789012345")
+ self.assertEqual(list(stream._send_pending), [range(0, 16)])
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
+ self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 8)
+ self.assertEqual(list(stream._send_pending), [])
# nothing more to send
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
+ self.assertEqual(list(stream._send_pending), [])
===========changed ref 5===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
- def has_data_to_send(self) -> bool:
- return not self._send_complete and (self._send_eof or bool(self._send_buffer))
-
===========changed ref 6===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_pending = RangeSet()
self._send_start = 0
+ self._send_end = 0
self.__stream_id = stream_id
|
tests.test_stream/QuicStreamTest.test_send_blocked
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<3>:<del> self.assertFalse(stream.has_data_to_send())
<7>:<add> self.assertEqual(list(stream._send_pending), [])
<10>:<del> self.assertTrue(stream.has_data_to_send())
<16>:<add> self.assertEqual(list(stream._send_pending), [range(8, 16)])
<18>:<del> self.assertTrue(stream.has_data_to_send())
<24>:<add> self.assertEqual(list(stream._send_pending), [range(12, 16)])
<26>:<del> self.assertTrue(stream.has_data_to_send())
<30>:<add> self.assertEqual(list(stream._send_pending), [range(12, 16)])
<33>:<del> self.assertTrue(stream.has_data_to_send())
<37>:<add> self.assertEqual(list(stream._send_pending), [range(12, 24)])
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_blocked(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=12)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.has_data_to_send())
<4> self.assertFalse(stream.is_blocked())
<5> frame = stream.get_frame(8)
<6> self.assertIsNone(frame)
<7>
<8> # write data, send a chunk
<9> stream.write(b"0123456789012345")
<10> self.assertTrue(stream.has_data_to_send())
<11> self.assertFalse(stream.is_blocked())
<12> frame = stream.get_frame(8)
<13> self.assertEqual(frame.data, b"01234567")
<14> self.assertFalse(frame.fin)
<15> self.assertEqual(frame.offset, 0)
<16>
<17> # send is limited by peer
<18> self.assertTrue(stream.has_data_to_send())
<19> self.assertFalse(stream.is_blocked())
<20> frame = stream.get_frame(8)
<21> self.assertEqual(frame.data, b"8901")
<22> self.assertFalse(frame.fin)
<23> self.assertEqual(frame.offset, 8)
<24>
<25> # unable to send, blocked
<26> self.assertTrue(stream.has_data_to_send())
<27> self.assertTrue(stream.is_blocked())
<28> frame = stream.get_frame(8)
<29> self.assertIsNone(frame)
<30>
<31> # write more data, still blocked
<32> stream.write(b"abcdefgh")
<33> self.assertTrue(stream.has_data_to_send())
<34> self.assertTrue(stream.is_blocked())
<35> frame = stream.get_frame(8)
<36> self.assertIsNone(frame)
<37>
<38> # peer raises limit, send some data
<39> stream.max_stream_data_remote += 8
<40> frame</s>
|
===========below chunk 0===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_blocked(self):
# offset: 1
self.assertEqual(frame.data, b"2345abcd")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 12)
# peer raises limit again, send remaining data
stream.max_stream_data_remote += 8
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"efgh")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 20)
# nothing more to send
self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========unchanged ref 0===========
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
is_blocked() -> bool
write(data: bytes) -> None
at: aioquic.stream.QuicStream.__init__
self.max_stream_data_remote = max_stream_data_remote
self._send_pending = RangeSet()
at: tests.test_stream.QuicStreamTest.test_send_blocked
stream = QuicStream(stream_id=0, max_stream_data_remote=12)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def is_blocked(self) -> bool:
"""
Returns True if there is data to send but the peer's MAX_STREAM_DATA
prevents us from sending it.
"""
return (
+ bool(self._send_pending)
+ and self._send_pending[0].start >= self.max_stream_data_remote
- bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
)
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
assert not self._send_complete, "cannot call write() after completion"
+ size = len(data)
+ if size:
- if data:
self._send_buffer += data
+ self._send_pending.add(self._send_end, self._send_end + size)
+ self._send_end += size
if self._connection is not None:
self._connection._send_soon()
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or bool(self._send_pending)):
- if self._send_complete or not self.has_data_to_send():
return None
+ if not self._send_pending:
+ # FIN only
+ self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_end)
+
# apply flow control
+ r = self._send_pending[0]
+ size = min(size, r.stop - r.start)
if self.stream_id is not None:
+ size = min(size, self.max_stream_data_remote - r.start)
- size = min(size, self.max_stream_data_remote - self._send_start)
+ if size <= 0:
- if size < 0 or (size == 0 and self._send_buffer):
return None
# create frame
+ send = range(r.start, r.start + size)
+ frame = QuicStreamFrame(
+ data=self._send_buffer[
+ send.start - self._send_start : send.start + size - self._send_start
+ ],
+ offset=send.start,
+ )
+ self._send_pending.subtract(send.start, send.stop)
- size = min(size, len(self._send_buffer))
- frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
- self._send_buffer = self._send_buffer[size:]
- self._send_start += size
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- </s>
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s> is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- if self._send_eof and not self._send_buffer:
frame.fin = True
self._send_complete = True
return frame
===========changed ref 4===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
|
tests.test_stream/QuicStreamTest.test_send_fin_only
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<3>:<del> self.assertFalse(stream.has_data_to_send())
<10>:<del> self.assertTrue(stream.has_data_to_send())
<18>:<del> self.assertFalse(stream.has_data_to_send())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_fin_only(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=512)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.has_data_to_send())
<4> self.assertFalse(stream.is_blocked())
<5> frame = stream.get_frame(8)
<6> self.assertIsNone(frame)
<7>
<8> # write EOF
<9> stream.write_eof()
<10> self.assertTrue(stream.has_data_to_send())
<11> self.assertFalse(stream.is_blocked())
<12> frame = stream.get_frame(8)
<13> self.assertEqual(frame.data, b"")
<14> self.assertTrue(frame.fin)
<15> self.assertEqual(frame.offset, 0)
<16>
<17> # nothing more to send
<18> self.assertFalse(stream.has_data_to_send())
<19> self.assertFalse(stream.is_blocked())
<20> frame = stream.get_frame(8)
<21> self.assertIsNone(frame)
<22>
|
===========unchanged ref 0===========
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
is_blocked() -> bool
write_eof() -> None
at: tests.test_stream.QuicStreamTest.test_send_fin_only
stream = QuicStream(stream_id=0, max_stream_data_remote=512)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def is_blocked(self) -> bool:
"""
Returns True if there is data to send but the peer's MAX_STREAM_DATA
prevents us from sending it.
"""
return (
+ bool(self._send_pending)
+ and self._send_pending[0].start >= self.max_stream_data_remote
- bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
)
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or bool(self._send_pending)):
- if self._send_complete or not self.has_data_to_send():
return None
+ if not self._send_pending:
+ # FIN only
+ self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_end)
+
# apply flow control
+ r = self._send_pending[0]
+ size = min(size, r.stop - r.start)
if self.stream_id is not None:
+ size = min(size, self.max_stream_data_remote - r.start)
- size = min(size, self.max_stream_data_remote - self._send_start)
+ if size <= 0:
- if size < 0 or (size == 0 and self._send_buffer):
return None
# create frame
+ send = range(r.start, r.start + size)
+ frame = QuicStreamFrame(
+ data=self._send_buffer[
+ send.start - self._send_start : send.start + size - self._send_start
+ ],
+ offset=send.start,
+ )
+ self._send_pending.subtract(send.start, send.stop)
- size = min(size, len(self._send_buffer))
- frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
- self._send_buffer = self._send_buffer[size:]
- self._send_start += size
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- </s>
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s> is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- if self._send_eof and not self._send_buffer:
frame.fin = True
self._send_complete = True
return frame
===========changed ref 3===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========changed ref 4===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data(self):
stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data, send a chunk
stream.write(b"0123456789012345")
+ self.assertEqual(list(stream._send_pending), [range(0, 16)])
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
+ self.assertEqual(list(stream._send_pending), [range(8, 16)])
# send another chunk
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 8)
+ self.assertEqual(list(stream._send_pending), [])
# nothing more to send
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
+ self.assertEqual(list(stream._send_pending), [])
|
tests.test_stream/QuicStreamTest.test_send_fin_only_despite_blocked
|
Modified
|
aiortc~aioquic
|
2f46ee1d8b1bb13c8c9ecef0111614ccacb3a9fa
|
[stream] don't discard data when sending it
|
<3>:<del> self.assertFalse(stream.has_data_to_send())
<10>:<del> self.assertTrue(stream.has_data_to_send())
<18>:<del> self.assertFalse(stream.has_data_to_send())
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_fin_only_despite_blocked(self):
<0> stream = QuicStream(stream_id=0, max_stream_data_remote=0)
<1>
<2> # nothing to send yet
<3> self.assertFalse(stream.has_data_to_send())
<4> self.assertFalse(stream.is_blocked())
<5> frame = stream.get_frame(8)
<6> self.assertIsNone(frame)
<7>
<8> # write EOF
<9> stream.write_eof()
<10> self.assertTrue(stream.has_data_to_send())
<11> self.assertFalse(stream.is_blocked())
<12> frame = stream.get_frame(8)
<13> self.assertEqual(frame.data, b"")
<14> self.assertTrue(frame.fin)
<15> self.assertEqual(frame.offset, 0)
<16>
<17> # nothing more to send
<18> self.assertFalse(stream.has_data_to_send())
<19> self.assertFalse(stream.is_blocked())
<20> frame = stream.get_frame(8)
<21> self.assertIsNone(frame)
<22>
|
===========unchanged ref 0===========
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
is_blocked() -> bool
write_eof() -> None
at: tests.test_stream.QuicStreamTest.test_send_fin_only_despite_blocked
stream = QuicStream(stream_id=0, max_stream_data_remote=0)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertTrue(expr: Any, msg: Any=...) -> None
assertFalse(expr: Any, msg: Any=...) -> None
assertIsNone(obj: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def is_blocked(self) -> bool:
"""
Returns True if there is data to send but the peer's MAX_STREAM_DATA
prevents us from sending it.
"""
return (
+ bool(self._send_pending)
+ and self._send_pending[0].start >= self.max_stream_data_remote
- bool(self._send_buffer) and self._send_start >= self.max_stream_data_remote
)
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or bool(self._send_pending)):
- if self._send_complete or not self.has_data_to_send():
return None
+ if not self._send_pending:
+ # FIN only
+ self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_end)
+
# apply flow control
+ r = self._send_pending[0]
+ size = min(size, r.stop - r.start)
if self.stream_id is not None:
+ size = min(size, self.max_stream_data_remote - r.start)
- size = min(size, self.max_stream_data_remote - self._send_start)
+ if size <= 0:
- if size < 0 or (size == 0 and self._send_buffer):
return None
# create frame
+ send = range(r.start, r.start + size)
+ frame = QuicStreamFrame(
+ data=self._send_buffer[
+ send.start - self._send_start : send.start + size - self._send_start
+ ],
+ offset=send.start,
+ )
+ self._send_pending.subtract(send.start, send.stop)
- size = min(size, len(self._send_buffer))
- frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
- self._send_buffer = self._send_buffer[size:]
- self._send_start += size
# if the buffer is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- </s>
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
# offset: 1
<s> is empty and EOF was written, set the FIN bit
+ if self._send_eof and not self._send_pending:
- if self._send_eof and not self._send_buffer:
frame.fin = True
self._send_complete = True
return frame
===========changed ref 3===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_fin_only(self):
stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write EOF
stream.write_eof()
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 0)
# nothing more to send
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
===========changed ref 4===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_send_data_and_fin(self):
stream = QuicStream(stream_id=0, max_stream_data_remote=512)
# nothing to send yet
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
# write data and EOF, send a chunk
stream.write(b"0123456789012345")
stream.write_eof()
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"01234567")
self.assertFalse(frame.fin)
self.assertEqual(frame.offset, 0)
# send another chunk
- self.assertTrue(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertEqual(frame.data, b"89012345")
self.assertTrue(frame.fin)
self.assertEqual(frame.offset, 8)
# nothing more to send
- self.assertFalse(stream.has_data_to_send())
self.assertFalse(stream.is_blocked())
frame = stream.get_frame(8)
self.assertIsNone(frame)
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<17>:<add> self._send_acked = RangeSet()
<20>:<add> self._send_highest = 0
<21>:<add> self._send_buffer_start = 0 # the offset for the start of the buffer
<add> self._send_buffer_stop = 0 # the offset for the stop of the buffer
<del> self._send_start = 0
<22>:<del> self._send_end = 0
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
<0> self._connection = connection
<1> self.max_stream_data_local = max_stream_data_local
<2> self.max_stream_data_remote = max_stream_data_remote
<3>
<4> if stream_id is not None:
<5> self.reader = asyncio.StreamReader()
<6> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<7> else:
<8> self.reader = None
<9> self.writer = None
<10>
<11> self._recv_buffer = bytearray()
<12> self._recv_fin = False
<13> self._recv_highest = 0 # the highest offset ever seen
<14> self._recv_start = 0 # the offset for the start of the buffer
<15> self._recv_ranges = RangeSet()
<16>
<17> self._send_buffer = bytearray()
<18> self._send_complete = False
<19> self._send_eof = False
<20> self._send_pending = RangeSet()
<21> self._send_start = 0
<22> self._send_end = 0
<23>
<24> self.__stream_id = stream_id
<25>
|
===========unchanged ref 0===========
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.stream.QuicStream.add_frame
self._recv_highest = frame_end
self._recv_buffer += bytearray(gap)
self._recv_fin = True
at: aioquic.stream.QuicStream.get_frame
self._send_complete = True
self._send_highest = send.stop
at: aioquic.stream.QuicStream.on_data_delivery
self._send_buffer_start += size
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: aioquic.stream.QuicStream.write
self._send_buffer += data
self._send_buffer_stop += size
at: aioquic.stream.QuicStream.write_eof
self._send_eof = True
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: asyncio.transports.BaseTransport
__slots__ = ('_extra',)
__init__(self, extra: Optional[Mapping[Any, Any]]=...) -> None
|
aioquic.stream/QuicStream.get_frame
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<4>:<add> if self._send_complete or not (self._send_eof or self._send_pending):
<del> if self._send_complete or not (self._send_eof or bool(self._send_pending)):
<7>:<add> # FIN only
<8>:<del> # FIN only
<10>:<add> return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
<del> return QuicStreamFrame(fin=True, offset=self._send_end)
<24>:<add> send.start
<add> - self._send_buffer_start : send.start
<add> + size
<add> - self._send_buffer_start
<del> send.start - self._send_start : send.start + size - self._send_start
<29>:<add>
<add> # track the highest offset ever sent
<add> if send.stop > self._send_highest:
<add> self._send_highest = send.stop
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
<0> """
<1> Get a frame of data to send.
<2> """
<3> # check there is something to send
<4> if self._send_complete or not (self._send_eof or bool(self._send_pending)):
<5> return None
<6>
<7> if not self._send_pending:
<8> # FIN only
<9> self._send_complete = True
<10> return QuicStreamFrame(fin=True, offset=self._send_end)
<11>
<12> # apply flow control
<13> r = self._send_pending[0]
<14> size = min(size, r.stop - r.start)
<15> if self.stream_id is not None:
<16> size = min(size, self.max_stream_data_remote - r.start)
<17> if size <= 0:
<18> return None
<19>
<20> # create frame
<21> send = range(r.start, r.start + size)
<22> frame = QuicStreamFrame(
<23> data=self._send_buffer[
<24> send.start - self._send_start : send.start + size - self._send_start
<25> ],
<26> offset=send.start,
<27> )
<28> self._send_pending.subtract(send.start, send.stop)
<29>
<30> # if the buffer is empty and EOF was written, set the FIN bit
<31> if self._send_eof and not self._send_pending:
<32> frame.fin = True
<33> self._send_complete = True
<34>
<35> return frame
<36>
|
===========unchanged ref 0===========
at: aioquic.rangeset.RangeSet
shift() -> range
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
self._send_pending = RangeSet()
self._send_buffer_stop = 0 # the offset for the stop of the buffer
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
self._recv_fin = True
at: aioquic.stream.QuicStream.write
self._send_buffer_stop += size
at: asyncio.streams.StreamReader
_source_traceback = None
feed_eof() -> None
feed_data(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
+ self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_buffer_start = 0 # the offset for the start of the buffer
+ self._send_buffer_stop = 0 # the offset for the stop of the buffer
- self._send_start = 0
- self._send_end = 0
self.__stream_id = stream_id
|
aioquic.stream/QuicStream.write
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<4>:<add> self._send_pending.add(
<add> self._send_buffer_stop, self._send_buffer_stop + size
<add> )
<5>:<del> self._send_pending.add(self._send_end, self._send_end + size)
<6>:<add> self._send_buffer_stop += size
<del> self._send_end += size
|
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
<0> assert not self._send_complete, "cannot call write() after completion"
<1> size = len(data)
<2>
<3> if size:
<4> self._send_buffer += data
<5> self._send_pending.add(self._send_end, self._send_end + size)
<6> self._send_end += size
<7> if self._connection is not None:
<8> self._connection._send_soon()
<9>
|
===========unchanged ref 0===========
at: aioquic.stream.QuicStream.__init__
self._send_complete = False
at: aioquic.stream.QuicStream.get_frame
frame = QuicStreamFrame(
data=self._send_buffer[
send.start
- self._send_buffer_start : send.start
+ size
- self._send_buffer_start
],
offset=send.start,
)
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ # writer
+
+ @property
+ def next_send_offset(self) -> int:
+ """
+ The offset for the next frame to send.
+
+ This is used to determine the space needed for the frame's `offset` field.
+ """
+ try:
+ return self._send_pending[0].start
+ except IndexError:
+ return self._send_buffer_stop
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
+ self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_buffer_start = 0 # the offset for the start of the buffer
+ self._send_buffer_stop = 0 # the offset for the stop of the buffer
- self._send_start = 0
- self._send_end = 0
self.__stream_id = stream_id
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or self._send_pending):
- if self._send_complete or not (self._send_eof or bool(self._send_pending)):
return None
+ # FIN only
if not self._send_pending:
- # FIN only
self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
- return QuicStreamFrame(fin=True, offset=self._send_end)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
+ send.start
+ - self._send_buffer_start : send.start
+ + size
+ - self._send_buffer_start
- send.start - self._send_start : send.start + size - self._send_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
+
+ # track the highest offset ever sent
+ if send.stop > self._send_highest:
+ self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
if self._send_eof and not self._send_pending:
frame.fin = True
self._send_complete = True
return frame
|
aioquic.connection/QuicPacketSpace.__init__
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<3>:<add> self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
|
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
<0> self.ack_queue = RangeSet()
<1> self.ack_required = False
<2> self.expected_packet_number = 0
<3>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
bytes_received: int = 0
bytes_sent: int = 0
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ # writer
+
+ @property
+ def next_send_offset(self) -> int:
+ """
+ The offset for the next frame to send.
+
+ This is used to determine the space needed for the frame's `offset` field.
+ """
+ try:
+ return self._send_pending[0].start
+ except IndexError:
+ return self._send_buffer_stop
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def on_data_delivery(self, start: int, stop: int) -> None:
+ """
+ Callback when sent data is ACK'd.
+ """
+ if stop - start:
+ self._send_acked.add(start, stop)
+ first_range = self._send_acked[0]
+ if first_range.start == self._send_buffer_start:
+ size = first_range.stop - first_range.start
+ self._send_acked.shift()
+ self._send_buffer_start += size
+ del self._send_buffer[:size]
+
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
assert not self._send_complete, "cannot call write() after completion"
size = len(data)
if size:
+ self._send_pending.add(
+ self._send_buffer_stop, self._send_buffer_stop + size
+ )
self._send_buffer += data
- self._send_pending.add(self._send_end, self._send_end + size)
+ self._send_buffer_stop += size
- self._send_end += size
if self._connection is not None:
self._connection._send_soon()
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
+ self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_buffer_start = 0 # the offset for the start of the buffer
+ self._send_buffer_stop = 0 # the offset for the stop of the buffer
- self._send_start = 0
- self._send_end = 0
self.__stream_id = stream_id
===========changed ref 4===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or self._send_pending):
- if self._send_complete or not (self._send_eof or bool(self._send_pending)):
return None
+ # FIN only
if not self._send_pending:
- # FIN only
self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
- return QuicStreamFrame(fin=True, offset=self._send_end)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
+ send.start
+ - self._send_buffer_start : send.start
+ + size
+ - self._send_buffer_start
- send.start - self._send_start : send.start + size - self._send_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
+
+ # track the highest offset ever sent
+ if send.stop > self._send_highest:
+ self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
if self._send_eof and not self._send_pending:
frame.fin = True
self._send_complete = True
return frame
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.host_cid = os.urandom(8)
<12> self.peer_cid = os.urandom(8)
<13> self.peer_cid_set = False
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._local_idle_timeout = 60000 # milliseconds
<29> self._local_max_data = 1048576
<30> self._local_max_data_used = 0
<31> self._local_max_stream_data</s>
|
===========below chunk 0===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_packet_number: Optional[int] = None
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = Quic</s>
===========below chunk 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# callbacks
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("Z</s>
===========below chunk 2===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_</s>
===========below chunk 3===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s> EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection.ping
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<4>:<add> self._ping_pending = True
<del> self._ping_packet_number = None
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def ping(self) -> None:
<0> """
<1> Pings the remote host and waits for the response.
<2> """
<3> assert self._ping_waiter is None
<4> self._ping_packet_number = None
<5> self._ping_waiter = self._loop.create_future()
<6> self._send_soon()
<7> await asyncio.shield(self._ping_waiter)
<8>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.connection.QuicConnection.create_stream
stream_id += 4
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
max_stream_data_local = 0
max_stream_data_local = self._local_max_stream_data_bidi_local
max_stream_data_remote = self._remote_max_stream_data_bidi_remote
max_stream_data_remote = self._remote_max_stream_data_uni
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
===========changed ref 0===========
# module: aioquic.connection
+ QuicDeliveryHandler = Callable[..., None]
+
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 1===========
# module: aioquic.connection
class QuicPacketSpace:
+ def expect_ack(
+ self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
+ ) -> None:
+ if packet_number not in self.delivery_handlers:
+ self.delivery_handlers[packet_number] = []
+ self.delivery_handlers[packet_number].append((handler, args))
+
===========changed ref 2===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
+ self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
===========changed ref 3===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ # writer
+
+ @property
+ def next_send_offset(self) -> int:
+ """
+ The offset for the next frame to send.
+
+ This is used to determine the space needed for the frame's `offset` field.
+ """
+ try:
+ return self._send_pending[0].start
+ except IndexError:
+ return self._send_buffer_stop
+
===========changed ref 4===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def on_data_delivery(self, start: int, stop: int) -> None:
+ """
+ Callback when sent data is ACK'd.
+ """
+ if stop - start:
+ self._send_acked.add(start, stop)
+ first_range = self._send_acked[0]
+ if first_range.start == self._send_buffer_start:
+ size = first_range.stop - first_range.start
+ self._send_acked.shift()
+ self._send_buffer_start += size
+ del self._send_buffer[:size]
+
===========changed ref 5===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
assert not self._send_complete, "cannot call write() after completion"
size = len(data)
if size:
+ self._send_pending.add(
+ self._send_buffer_stop, self._send_buffer_stop + size
+ )
self._send_buffer += data
- self._send_pending.add(self._send_end, self._send_end + size)
+ self._send_buffer_stop += size
- self._send_end += size
if self._connection is not None:
self._connection._send_soon()
===========changed ref 6===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
+ self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_buffer_start = 0 # the offset for the start of the buffer
+ self._send_buffer_stop = 0 # the offset for the stop of the buffer
- self._send_start = 0
- self._send_end = 0
self.__stream_id = stream_id
===========changed ref 7===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or self._send_pending):
- if self._send_complete or not (self._send_eof or bool(self._send_pending)):
return None
+ # FIN only
if not self._send_pending:
- # FIN only
self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
- return QuicStreamFrame(fin=True, offset=self._send_end)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
+ send.start
+ - self._send_buffer_start : send.start
+ + size
+ - self._send_buffer_start
- send.start - self._send_start : send.start + size - self._send_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
+
+ # track the highest offset ever sent
+ if send.stop > self._send_highest:
+ self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
if self._send_eof and not self._send_pending:
frame.fin = True
self._send_complete = True
return frame
|
aioquic.connection/QuicConnection._handle_ack_frame
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<4>:<del>
<5>:<del> # handle PING response
<6>:<del> if (
<7>:<del> self._ping_packet_number is not None
<8>:<del> and self._ping_packet_number in rangeset
<9>:<del> ):
<10>:<del> waiter = self._ping_waiter
<11>:<del> self._ping_waiter = None
<12>:<del> self._ping_packet_number = None
<13>:<del> self._logger.info("Received PING response")
<14>:<del> waiter.set_result(None)
<15>:<del>
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_ack_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle an ACK frame.
<2> """
<3> rangeset, _ = packet.pull_ack_frame(buf)
<4>
<5> # handle PING response
<6> if (
<7> self._ping_packet_number is not None
<8> and self._ping_packet_number in rangeset
<9> ):
<10> waiter = self._ping_waiter
<11> self._ping_waiter = None
<12> self._ping_packet_number = None
<13> self._logger.info("Received PING response")
<14> waiter.set_result(None)
<15>
<16> if frame_type == QuicFrameType.ACK_ECN:
<17> pull_uint_var(buf)
<18> pull_uint_var(buf)
<19> pull_uint_var(buf)
<20>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicPacketSpace()
QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
at: aioquic.connection.QuicConnection._send_pending
self.packet_number = builder.packet_number
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None, max_stream_data_local: int=0, max_stream_data_remote: int=0)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def ping(self) -> None:
"""
Pings the remote host and waits for the response.
"""
assert self._ping_waiter is None
+ self._ping_pending = True
- self._ping_packet_number = None
self._ping_waiter = self._loop.create_future()
self._send_soon()
await asyncio.shield(self._ping_waiter)
===========changed ref 1===========
# module: aioquic.connection
+ QuicDeliveryHandler = Callable[..., None]
+
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 2===========
# module: aioquic.connection
class QuicPacketSpace:
+ def expect_ack(
+ self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
+ ) -> None:
+ if packet_number not in self.delivery_handlers:
+ self.delivery_handlers[packet_number] = []
+ self.delivery_handlers[packet_number].append((handler, args))
+
===========changed ref 3===========
# module: aioquic.connection
class QuicPacketSpace:
def __init__(self) -> None:
self.ack_queue = RangeSet()
self.ack_required = False
self.expected_packet_number = 0
+ self.delivery_handlers: Dict[int, List[Tuple[QuicDeliveryHandler, Any]]] = {}
===========changed ref 4===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ # writer
+
+ @property
+ def next_send_offset(self) -> int:
+ """
+ The offset for the next frame to send.
+
+ This is used to determine the space needed for the frame's `offset` field.
+ """
+ try:
+ return self._send_pending[0].start
+ except IndexError:
+ return self._send_buffer_stop
+
===========changed ref 5===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def on_data_delivery(self, start: int, stop: int) -> None:
+ """
+ Callback when sent data is ACK'd.
+ """
+ if stop - start:
+ self._send_acked.add(start, stop)
+ first_range = self._send_acked[0]
+ if first_range.start == self._send_buffer_start:
+ size = first_range.stop - first_range.start
+ self._send_acked.shift()
+ self._send_buffer_start += size
+ del self._send_buffer[:size]
+
===========changed ref 6===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def write(self, data: bytes) -> None:
assert not self._send_complete, "cannot call write() after completion"
size = len(data)
if size:
+ self._send_pending.add(
+ self._send_buffer_stop, self._send_buffer_stop + size
+ )
self._send_buffer += data
- self._send_pending.add(self._send_end, self._send_end + size)
+ self._send_buffer_stop += size
- self._send_end += size
if self._connection is not None:
self._connection._send_soon()
===========changed ref 7===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def __init__(
self,
stream_id: Optional[int] = None,
connection: Optional[Any] = None,
max_stream_data_local: int = 0,
max_stream_data_remote: int = 0,
) -> None:
self._connection = connection
self.max_stream_data_local = max_stream_data_local
self.max_stream_data_remote = max_stream_data_remote
if stream_id is not None:
self.reader = asyncio.StreamReader()
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
else:
self.reader = None
self.writer = None
self._recv_buffer = bytearray()
self._recv_fin = False
self._recv_highest = 0 # the highest offset ever seen
self._recv_start = 0 # the offset for the start of the buffer
self._recv_ranges = RangeSet()
+ self._send_acked = RangeSet()
self._send_buffer = bytearray()
self._send_complete = False
self._send_eof = False
+ self._send_highest = 0
self._send_pending = RangeSet()
+ self._send_buffer_start = 0 # the offset for the start of the buffer
+ self._send_buffer_stop = 0 # the offset for the stop of the buffer
- self._send_start = 0
- self._send_end = 0
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<1> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<2> packet_type = PACKET_TYPE_ONE_RTT
<3> elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<4> crypto = self.cryptos[tls.Epoch.ZERO_RTT]
<5> packet_type = PACKET_TYPE_ZERO_RTT
<6> else:
<7> return
<8> space = self.spaces[tls.Epoch.ONE_RTT]
<9> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<10>
<11> buf = builder.buffer
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> # ACK
<17> if is_one_rtt and space.ack_required and space.ack_queue:
<18> push_uint_var(buf, QuicFrameType.ACK)
<19> packet.push_ack_frame(buf, space.ack_queue, 0)
<20> space.ack_required = False
<21>
<22> # PATH CHALLENGE
<23> if (
<24> is_one_rtt
<25> and not network_path.is_validated
<26> and network_path.local_challenge is None
<27> ):
<28> self._logger.info(
<29> "Network path %s sending challenge", network_path.addr
<30> )
<31> network_path.local_challenge = os.urandom(8)
<32> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<33> push_bytes(buf, network_path.local_challenge)
<34>
<35> # PATH RESPONSE
<36> if is_one_rtt and network_path.remote_challenge is not None:
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# PING
if self._ping_waiter is not None and self._ping_packet_number is None:
self._ping_packet_number = builder.packet_number
self._logger.info("Sending PING in packet %d", builder.packet_number)
push_uint_var(buf, QuicFrameType.PING)
for stream_id, stream in self.streams.items():
# CRYPTO
if is_one_rtt and stream_id == tls.Epoch.ONE_RTT:
frame_overhead = 3 + quic_uint_length(stream._send_start)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream._send_start)
if stream._send_start
else 0
)
)
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s> = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += len(frame.data)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
_on_ping_delivery() -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.secrets_log_file = secrets_log_file
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_pending = False
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
===========unchanged ref 1===========
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection.ping
self._ping_pending = True
at: aioquic.connection.QuicNetworkPath
addr: NetworkAddress
is_validated: bool = False
local_challenge: Optional[bytes] = None
remote_challenge: Optional[bytes] = None
at: aioquic.connection.QuicPacketSpace
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
at: aioquic.connection.QuicPacketSpace.__init__
self.ack_queue = RangeSet()
self.ack_required = False
at: aioquic.crypto.CryptoContext
is_valid() -> bool
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.recv = CryptoContext()
self.send = CryptoContext()
at: aioquic.packet
PACKET_TYPE_ZERO_RTT = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x10
PACKET_TYPE_ONE_RTT = PACKET_FIXED_BIT
quic_uint_length(value: int) -> int
push_uint_var(buf: Buffer, value: int) -> None
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
|
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
47971d7d0bdfba8141cd12e5ec11a62c914771cf
|
[connection] start adding packet delivery handlers
|
<22>:<add> frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
<del> frame_overhead = 3 + quic_uint_length(stream._send_start)
<28>:<add> space.expect_ack(
<add> builder.packet_number,
<add> stream.on_data_delivery,
<add> (frame.offset, frame.offset + len(frame.data)),
<add> )
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_handshake(self, builder: QuicPacketBuilder, epoch: tls.Epoch) -> None:
<0> crypto = self.cryptos[epoch]
<1> space = self.spaces[epoch]
<2> if not crypto.send.is_valid():
<3> return
<4>
<5> buf = builder.buffer
<6>
<7> while True:
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12> builder.start_packet(packet_type, crypto)
<13>
<14> # ACK
<15> if space.ack_required and space.ack_queue:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, space.ack_queue, 0)
<18> space.ack_required = False
<19>
<20> # CRYPTO
<21> stream = self.streams[epoch]
<22> frame_overhead = 3 + quic_uint_length(stream._send_start)
<23> frame = stream.get_frame(builder.remaining_space - frame_overhead)
<24> if frame is not None:
<25> push_uint_var(buf, QuicFrameType.CRYPTO)
<26> with packet.push_crypto_frame(buf, frame.offset):
<27> push_bytes(buf, frame.data)
<28>
<29> # PADDING
<30> if epoch == tls.Epoch.INITIAL and self.is_client:
<31> push_bytes(buf, bytes(builder.remaining_space))
<32>
<33> if not builder.end_packet():
<34> break
<35>
<36> # discard initial keys
<37> if self.is_client and epoch == tls.Epoch.HANDSHAKE:
<38> self.cryptos[tls.Epoch.INITIAL].teardown()
<39>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection.QuicConnection.__init__
self._remote_max_data = 0
self._remote_max_data_used = 0
at: aioquic.connection.QuicConnection._handle_max_data_frame
self._remote_max_data = max_data
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._write_application
space = self.spaces[tls.Epoch.ONE_RTT]
buf = builder.buffer
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream.next_send_offset)
if stream.next_send_offset
else 0
)
)
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
at: aioquic.connection.QuicPacketSpace
expect_ack(packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any]=[]) -> None
at: aioquic.crypto.CryptoContext
is_valid() -> bool
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
push_uint_var(buf: Buffer, value: int) -> None
===========unchanged ref 1===========
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator
at: aioquic.packet.QuicStreamFrame
offset: int = 0
at: aioquic.packet_builder
QuicPacketBuilder(*, host_cid: bytes, peer_cid: bytes, version: int, packet_number: int=0, peer_token: bytes=b"", spin_bit: bool=False)
at: aioquic.packet_builder.QuicPacketBuilder
end_packet() -> bool
at: aioquic.packet_builder.QuicPacketBuilder.__init__
self.buffer = Buffer(PACKET_MAX_SIZE)
at: aioquic.stream.QuicStream
get_frame(size: int) -> Optional[QuicStreamFrame]
on_data_delivery(start: int, stop: int) -> None
at: aioquic.stream.QuicStream.__init__
self._send_highest = 0
at: aioquic.stream.QuicStream.get_frame
self._send_highest = send.stop
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
class QuicPacketSpace:
+ def expect_ack(
+ self, packet_number: int, handler: QuicDeliveryHandler, args: Sequence[Any] = []
+ ) -> None:
+ if packet_number not in self.delivery_handlers:
+ self.delivery_handlers[packet_number] = []
+ self.delivery_handlers[packet_number].append((handler, args))
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
+ def on_data_delivery(self, start: int, stop: int) -> None:
+ """
+ Callback when sent data is ACK'd.
+ """
+ if stop - start:
+ self._send_acked.add(start, stop)
+ first_range = self._send_acked[0]
+ if first_range.start == self._send_buffer_start:
+ size = first_range.stop - first_range.start
+ self._send_acked.shift()
+ self._send_buffer_start += size
+ del self._send_buffer[:size]
+
===========changed ref 2===========
# module: aioquic.stream
class QuicStream(asyncio.BaseTransport):
def get_frame(self, size: int) -> Optional[QuicStreamFrame]:
"""
Get a frame of data to send.
"""
# check there is something to send
+ if self._send_complete or not (self._send_eof or self._send_pending):
- if self._send_complete or not (self._send_eof or bool(self._send_pending)):
return None
+ # FIN only
if not self._send_pending:
- # FIN only
self._send_complete = True
+ return QuicStreamFrame(fin=True, offset=self._send_buffer_stop)
- return QuicStreamFrame(fin=True, offset=self._send_end)
# apply flow control
r = self._send_pending[0]
size = min(size, r.stop - r.start)
if self.stream_id is not None:
size = min(size, self.max_stream_data_remote - r.start)
if size <= 0:
return None
# create frame
send = range(r.start, r.start + size)
frame = QuicStreamFrame(
data=self._send_buffer[
+ send.start
+ - self._send_buffer_start : send.start
+ + size
+ - self._send_buffer_start
- send.start - self._send_start : send.start + size - self._send_start
],
offset=send.start,
)
self._send_pending.subtract(send.start, send.stop)
+
+ # track the highest offset ever sent
+ if send.stop > self._send_highest:
+ self._send_highest = send.stop
# if the buffer is empty and EOF was written, set the FIN bit
if self._send_eof and not self._send_pending:
frame.fin = True
self._send_complete = True
return frame
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _on_ping_delivery(self) -> None:
+ """
+ Callback when a PING is ACK'd.
+ """
+ self._logger.info("Received PING response")
+ waiter = self._ping_waiter
+ self._ping_waiter = None
+ waiter.set_result(None)
+
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
e34fa15f9c647d974e660bb04c584f07dcde04bd
|
[connection] improve logging, store received connection IDs
|
<12>:<add> self.host_cids = [QuicConnectionId(cid=self.host_cid, sequence_number=0)]
<14>:<add> self.peer_cids: List[QuicConnectionId] = []
|
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.host_cid = os.urandom(8)
<12> self.peer_cid = os.urandom(8)
<13> self.peer_cid_set = False
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._local_idle_timeout = 60000 # milliseconds
<29> self._local_max_data = 1048576
<30> self._local_max_data_used = 0
<31> self._local_max_stream_data</s>
|
===========below chunk 0===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
</s>
===========below chunk 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# callbacks
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self</s>
===========below chunk 2===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("Z</s>
===========below chunk 3===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
aioquic.connection/QuicConnection._handle_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
e34fa15f9c647d974e660bb04c584f07dcde04bd
|
[connection] improve logging, store received connection IDs
|
<3>:<add> sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
<add> buf
<add> )
<add> self._logger.info(
<add> "New connection ID received %d %s",
<add> sequence_number,
<add> binascii.hexlify(cid).decode("ascii"),
<add> )
<add> self.peer_cids.append(
<add> QuicConnectionId(
<add> cid=cid,
<add> sequence_number=sequence_number,
<add> stateless_reset_token=stateless_reset_token,
<add> )
<add> )
<del> packet.pull_new_connection_id_frame(buf)
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a NEW_CONNECTION_ID frame.
<2> """
<3> packet.pull_new_connection_id_frame(buf)
<4>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)
===========changed ref 0===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
+ def __str__(self) -> str:
+ return self.epoch.name
+
===========changed ref 1===========
# module: aioquic.connection
+ @dataclass
+ class QuicConnectionId:
+ cid: bytes
+ sequence_number: int
+ stateless_reset_token: bytes = b""
+
===========changed ref 2===========
# module: aioquic.connection
+ def frame_type_name(frame_type: int) -> str:
+ if (
+ frame_type >= QuicFrameType.STREAM_BASE
+ and frame_type < QuicFrameType.STREAM_BASE + 16
+ ):
+ return "STREAM"
+ else:
+ return QuicFrameType(frame_type).name
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
if self.is_client and header.destination_cid != self.host_cid:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
and not self._stateless_retry_count
):
self._original_connection_id = self.peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self</s>
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
<s>peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self._stateless_retry_count += 1
self._logger.info("Performing stateless retry")
self._connect()
return
network_path = self._find_network_path(addr)
# server initialization
if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:
assert (
header.packet_type == PACKET_TYPE_INITIAL
), "first packet must be INITIAL"
self._network_paths = [network_path]
self._version = QuicProtocolVersion(header.version)
self._initialize(header.destination_cid)
# determine crypto and packet space
epoch = get_epoch(header.packet_type)
crypto = self.cryptos[epoch]
if epoch == tls.Epoch.ZERO_RTT:
space = self.spaces[tls.Epoch.ONE_RTT]
else:
space = self.spaces[epoch]
# decrypt packet
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not crypto.recv.is_valid():
continue
try:
plain_header, plain_payload, packet_number = crypto.decrypt_packet(
data[start_off:end_off], encrypted_off, space.expected_packet_number
)
except CryptoError as exc:
self._logger.warning(exc)
continue
if packet_number > space.expected_packet_number:
space.expected_packet_number = packet_number + 1
</s>
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 2
<s> # discard initial keys
if not self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
# update state
if not self.peer_cid_set:
self.peer_cid = header.source_cid
+ self.peer_cids = [
+ QuicConnectionId(cid=header.source_cid, sequence_number=0)
+ ]
self.peer_cid_set = True
if self.__state == QuicConnectionState.FIRSTFLIGHT:
self._set_state(QuicConnectionState.CONNECTED)
# update spin bit
if (
not is_long_header(plain_header[0])
and packet_number > self._spin_highest_pn
):
self._spin_bit_peer = get_spin_bit(plain_header[0])
if self.is_client:
self._spin_bit = not self._spin_bit_peer
else:
self._spin_bit = self._spin_bit_peer
self._spin_highest_pn = packet_number
# handle payload
context = QuicReceiveContext(epoch=epoch, network_path=network_path)
+ self._logger.debug("[%s] handling packet %d", context, packet_number)
- self._logger.debug("[%s] handling packet %d", context.epoch, packet_number)
try:
is_ack_only, is_probing = self._payload_received(context, plain_payload)
except QuicConnectionError as exc:
self._logger.warning(exc)
self.close(
error_code=exc.error_code,
frame_type=exc.</s>
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
e34fa15f9c647d974e660bb04c584f07dcde04bd
|
[connection] improve logging, store received connection IDs
|
<31>:<add> "[%s] handling frame %s", context, frame_type_name(frame_type)
<del> "[%s] handling frame type %s", context.epoch, frame_type
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
<0> """
<1> Handle a QUIC packet payload.
<2> """
<3> buf = Buffer(data=plain)
<4>
<5> is_ack_only = True
<6> is_probing = None
<7> while not buf.eof():
<8> frame_type = pull_uint_var(buf)
<9>
<10> # check frame type is known
<11> try:
<12> frame_handler, frame_epochs = self.__frame_handlers[frame_type]
<13> except IndexError:
<14> raise QuicConnectionError(
<15> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<16> frame_type=frame_type,
<17> reason_phrase="Unknown frame type",
<18> )
<19>
<20> # check frame is allowed for the epoch
<21> if context.epoch not in frame_epochs:
<22> raise QuicConnectionError(
<23> error_code=QuicErrorCode.PROTOCOL_VIOLATION,
<24> frame_type=frame_type,
<25> reason_phrase="Unexpected frame type",
<26> )
<27>
<28> # handle the frame
<29> if frame_type != QuicFrameType.PADDING:
<30> self._logger.debug(
<31> "[%s] handling frame type %s", context.epoch, frame_type
<32> )
<33> try:
<34> frame_handler(context, frame_type, buf)
<35> except BufferReadError:
<36> raise QuicConnectionError(
<37> error_code=QuicErrorCode.FRAME_ENCODING_ERROR,
<38> frame_type=frame_type,
<39> reason_phrase="Failed to parse frame",
<40> )
<41>
<42> # update ACK only / probing flags
<43> if frame_type not in [
<44> QuicFrameType.ACK,
<45> QuicFrameType.ACK_ECN,
<46> QuicFrameType.PADDING,
<47> ]:
<48> is_ack_only = False
<49>
<50> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _payload_received(
self, context: QuicReceiveContext, plain: bytes
) -> Tuple[bool, bool]:
# offset: 1
QuicFrameType.PATH_CHALLENGE,
QuicFrameType.PATH_RESPONSE,
QuicFrameType.PADDING,
QuicFrameType.NEW_CONNECTION_ID,
]:
is_probing = False
elif is_probing is None:
is_probing = True
self._push_crypto_data()
return is_ack_only, bool(is_probing)
===========unchanged ref 0===========
at: _asyncio.Future
set_result(result, /)
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicReceiveContext(epoch: tls.Epoch, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection
_assert_stream_can_receive(frame_type: int, stream_id: int) -> None
_get_or_create_stream(frame_type: int, stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection.__init__
self._local_max_data_used = 0
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_waiter: Optional[asyncio.Future[None]] = None
===========unchanged ref 1===========
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame,</s>
===========unchanged ref 2===========
at: aioquic.connection.QuicConnection._handle_stream_frame
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
stream = self._get_or_create_stream(frame_type, stream_id)
newly_received = max(0, offset + length - stream._recv_highest)
at: aioquic.connection.QuicConnection.ping
self._ping_waiter = self._loop.create_future()
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
network_path: QuicNetworkPath
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_uint_var(buf: Buffer) -> int
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
at: asyncio.futures.Future
_state = _PENDING
_result = None
_exception = None
_loop = None
_source_traceback = None
_cancel_message = None
_cancelled_exc = None
_asyncio_future_blocking = False
__log_traceback = False
__class_getitem__ = classmethod(GenericAlias)
set_result(result: _T, /) -> None
__iter__ = __await__ # make compatible with 'yield from'.
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_CONNECTION_ID frame.
"""
+ sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
+ buf
+ )
+ self._logger.info(
+ "New connection ID received %d %s",
+ sequence_number,
+ binascii.hexlify(cid).decode("ascii"),
+ )
+ self.peer_cids.append(
+ QuicConnectionId(
+ cid=cid,
+ sequence_number=sequence_number,
+ stateless_reset_token=stateless_reset_token,
+ )
+ )
- packet.pull_new_connection_id_frame(buf)
===========changed ref 1===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
+ def __str__(self) -> str:
+ return self.epoch.name
+
===========changed ref 2===========
# module: aioquic.connection
+ @dataclass
+ class QuicConnectionId:
+ cid: bytes
+ sequence_number: int
+ stateless_reset_token: bytes = b""
+
===========changed ref 3===========
# module: aioquic.connection
+ def frame_type_name(frame_type: int) -> str:
+ if (
+ frame_type >= QuicFrameType.STREAM_BASE
+ and frame_type < QuicFrameType.STREAM_BASE + 16
+ ):
+ return "STREAM"
+ else:
+ return QuicFrameType(frame_type).name
+
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<11>:<del> self.host_cid = os.urandom(8)
<12>:<del> self.host_cids = [QuicConnectionId(cid=self.host_cid, sequence_number=0)]
<30>:<add> self._host_cids = [
<add> QuicConnectionId(
<add> cid=os.urandom(8),
<add> sequence_number=0,
<add> stateless_reset_token=os.urandom(16),
<add> was_sent=True,
<add> )
<add> ]
<add> self.host_cid = self._host_cids[0].cid
<add> self._host_cid_seq = 1
|
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.host_cid = os.urandom(8)
<12> self.host_cids = [QuicConnectionId(cid=self.host_cid, sequence_number=0)]
<13> self.peer_cid = os.urandom(8)
<14> self.peer_cid_set = False
<15> self.peer_cids: List[QuicConnectionId] = []
<16> self.peer_token = b""
<17> self.private_key = private_key
<18> self.secrets_log_file = secrets_log_file
<19> self.server_name = server_name
<20> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<21>
<22> # counters for debugging
<23> self._stateless_retry_count = 0
<24> self._version_negotiation_count = 0
<25>
<26> self._loop = asyncio.get_event_loop()
<27> self.__close: Optional[Dict] = None
<28> self.__connected = asyncio.Event()
<29> self.__epoch = tls.Epoch.INITIAL
<30> self._local_</s>
|
===========below chunk 0===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False</s>
===========below chunk 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s> self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# callbacks
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS</s>
===========below chunk 2===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS</s>
===========below chunk 3===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s>O")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
aioquic.connection/QuicConnection._handle_crypto_frame
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<33>:<add> self._replenish_connection_ids()
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a CRYPTO frame.
<2> """
<3> stream = self.streams[context.epoch]
<4> stream.add_frame(packet.pull_crypto_frame(buf))
<5> data = stream.pull_data()
<6> if data:
<7> # pass data to TLS layer
<8> try:
<9> self.tls.handle_message(data, self.send_buffer)
<10> except tls.Alert as exc:
<11> raise QuicConnectionError(
<12> error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<13> frame_type=QuicFrameType.CRYPTO,
<14> reason_phrase=str(exc),
<15> )
<16>
<17> # parse transport parameters
<18> if (
<19> not self._parameters_received
<20> and self.tls.received_extensions is not None
<21> ):
<22> for ext_type, ext_data in self.tls.received_extensions:
<23> if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
<24> self._parse_transport_parameters(ext_data)
<25> break
<26> self._parameters_received = True
<27>
<28> # update current epoch
<29> if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
<30> tls.State.CLIENT_POST_HANDSHAKE,
<31> tls.State.SERVER_POST_HANDSHAKE,
<32> ]:
<33> self.__epoch = tls.Epoch.ONE_RTT
<34> # wakeup waiter
<35> if not self.__connected.is_set():
<36> self.__connected.set()
<37> elif self.__epoch == tls.Epoch.INITIAL:
<38> self.__epoch = tls.Epoch.HANDSHAKE
<39>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnectionState()
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
maybe_connection_error(error_code: int, frame_type: Optional[int], reason_phrase: str) -> Optional[QuicConnectionError]
at: aioquic.connection.QuicConnection
connection_lost(exc: Exception) -> None
_set_state(self, state: QuicConnectionState) -> None
_set_state(state: QuicConnectionState) -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._parameters_received = False
at: aioquic.connection.QuicConnection._handle_crypto_frame
self._parameters_received = True
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.send_buffer = {
tls.Epoch.INITIAL: Buffer(capacity=4096),
tls.Epoch.HANDSHAKE: Buffer(capacity=4096),
tls.Epoch.ONE_RTT: Buffer(capacity=4096),
}
at: aioquic.connection.QuicReceiveContext
epoch: tls.Epoch
host_cid: bytes
network_path: QuicNetworkPath
===========unchanged ref 1===========
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_application_close_frame(buf: Buffer) -> Tuple[int, str]
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.received_extensions: Optional[List[Extension]] = None
at: aioquic.tls.Context._client_handle_encrypted_extensions
self.received_extensions = encrypted_extensions.other_extensions
at: aioquic.tls.Context._server_handle_hello
self.received_extensions = peer_hello.other_extensions
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
epoch: tls.Epoch
+ host_cid: bytes
network_path: QuicNetworkPath
===========changed ref 1===========
# module: aioquic.connection
+ QuicConnectionIdHandler = Callable[[bytes], None]
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 2===========
# module: aioquic.connection
@dataclass
class QuicConnectionId:
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
+ was_sent: bool = False
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
if self.is_client and header.destination_cid != self.host_cid:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
and not self._stateless_retry_count
):
self._original_connection_id = self.peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self</s>
|
aioquic.connection/QuicConnection._handle_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<3>:<add> sequence_number = pull_uint_var(buf)
<del> pull_uint_var(buf) # sequence number
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a RETIRE_CONNECTION_ID frame.
<2> """
<3> pull_uint_var(buf) # sequence number
<4>
|
===========unchanged ref 0===========
at: aioquic.buffer
pull_uint16(buf: Buffer) -> int
at: aioquic.connection.QuicConnection
_assert_stream_can_receive(frame_type: int, stream_id: int) -> None
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
break
self._parameters_received = True
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
+ self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========changed ref 1===========
# module: aioquic.connection
+ QuicConnectionIdHandler = Callable[[bytes], None]
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 2===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
epoch: tls.Epoch
+ host_cid: bytes
network_path: QuicNetworkPath
===========changed ref 3===========
# module: aioquic.connection
@dataclass
class QuicConnectionId:
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
+ was_sent: bool = False
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
if self.is_client and header.destination_cid != self.host_cid:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
and not self._stateless_retry_count
):
self._original_connection_id = self.peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self</s>
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
<s>peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self._stateless_retry_count += 1
self._logger.info("Performing stateless retry")
self._connect()
return
network_path = self._find_network_path(addr)
# server initialization
if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:
assert (
header.packet_type == PACKET_TYPE_INITIAL
), "first packet must be INITIAL"
self._network_paths = [network_path]
self._version = QuicProtocolVersion(header.version)
self._initialize(header.destination_cid)
# determine crypto and packet space
epoch = get_epoch(header.packet_type)
crypto = self.cryptos[epoch]
if epoch == tls.Epoch.ZERO_RTT:
space = self.spaces[tls.Epoch.ONE_RTT]
else:
space = self.spaces[epoch]
# decrypt packet
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not crypto.recv.is_valid():
continue
try:
plain_header, plain_payload, packet_number = crypto.decrypt_packet(
data[start_off:end_off], encrypted_off, space.expected_packet_number
)
except CryptoError as exc:
self._logger.warning(exc)
continue
if packet_number > space.expected_packet_number:
space.expected_packet_number = packet_number + 1
</s>
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<16>:<add> if is_one_rtt:
<add> # ACK
<del> # ACK
<17>:<add> if space.ack_required and space.ack_queue:
<del> if is_one_rtt and space.ack_required and space.ack_queue:
<18>:<add> push_uint_var(buf, QuicFrameType.ACK)
<del> push_uint_var(buf, QuicFrameType.ACK)
<19>:<add> packet.push_ack_frame(buf, space.ack_queue, 0)
<del> packet.push_ack_frame(buf, space.ack_queue, 0)
<20>:<add> space.ack_required = False
<del> space.ack_required = False
<22>:<add> # PATH CHALLENGE
<del> # PATH CHALLENGE
<23>:<add> if (
<del> if (
<24>:<del> is_one_rtt
<25>:<add> not network_path.is_validated
<del> and not network_path.is_validated
<26>:<add> and network_path.local_challenge is None
<del> and network_path.local_challenge is None
<27>:<add> ):
<del> ):
<28>:<add> self._logger.info(
<del> self._logger.info(
<29>:<add> "Network path %s sending challenge", network_path.addr
<del> "Network path %s sending challenge", network_path.addr
<30>:<add> )
<del> )
<31>:<add> network_path.local_challenge = os.urandom(8)
<del> network_path.local_challenge = os.urandom(8)
<32>:<add> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<del> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<33>:<add> push_bytes(buf, network_path
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<1> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<2> packet_type = PACKET_TYPE_ONE_RTT
<3> elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<4> crypto = self.cryptos[tls.Epoch.ZERO_RTT]
<5> packet_type = PACKET_TYPE_ZERO_RTT
<6> else:
<7> return
<8> space = self.spaces[tls.Epoch.ONE_RTT]
<9> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<10>
<11> buf = builder.buffer
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> # ACK
<17> if is_one_rtt and space.ack_required and space.ack_queue:
<18> push_uint_var(buf, QuicFrameType.ACK)
<19> packet.push_ack_frame(buf, space.ack_queue, 0)
<20> space.ack_required = False
<21>
<22> # PATH CHALLENGE
<23> if (
<24> is_one_rtt
<25> and not network_path.is_validated
<26> and network_path.local_challenge is None
<27> ):
<28> self._logger.info(
<29> "Network path %s sending challenge", network_path.addr
<30> )
<31> network_path.local_challenge = os.urandom(8)
<32> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<33> push_bytes(buf, network_path.local_challenge)
<34>
<35> # PATH RESPONSE
<36> if is_one_rtt and network_path.remote_challenge is not None:
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
push_uint_var(buf, QuicFrameType.PING)
space.expect_ack(builder.packet_number, self._on_ping_delivery)
self._ping_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if is_one_rtt and stream_id == tls.Epoch.ONE_RTT:
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream.next_send_offset)
if stream.next_send_offset
else 0
)
)
previous_send_highest = stream._send_highest
frame = stream.get_frame(
min(
builder.remaining_space - frame_over</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s>._send_highest
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += (
stream._send_highest - previous_send_highest
)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
stream_is_client_initiated(stream_id: int) -> bool
stream_is_unidirectional(stream_id: int) -> bool
QuicConnectionState()
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.secrets_log_file = secrets_log_file
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._original_connection_id = original_connection_id
self._ping_pending = False
self.__state = QuicConnectionState.FIRSTFLIGHT
===========unchanged ref 1===========
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
at: aioquic.connection.QuicConnection._handle_crypto_frame
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self._logger)
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
self.spaces = {
tls.Epoch.INITIAL: QuicPacketSpace(),
tls.Epoch.HANDSHAKE: QuicPacketSpace(),
tls.Epoch.ONE_RTT: QuicPacketSpace(),
}
at: aioquic.connection.QuicConnection._serialize_transport_parameters
quic_transport_parameters = QuicTransportParameters(
idle_timeout=self._local_idle_timeout,
initial_max_data=self._local_max_data,
initial_max_stream_data_bidi_local=self._local_max_stream_data_bidi_local,
initial_max_stream_data_bidi_remote=self._local_max_stream_data_bidi_remote,
initial_max_stream_data_uni=self._local_max_stream_data_uni,
initial_max_streams_bidi=self._local_max_streams_bidi,
initial_max_streams_uni=self._local_max_streams_uni,
ack_delay_exponent=10,
)
at: aioquic.connection.QuicConnection._write_application
self._ping_pending = False
at: aioquic.connection.QuicConnection.datagram_received
self._original_connection_id = self.peer_cid
|
aioquic.server/QuicServer.datagram_received
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
<0> data = cast(bytes, data)
<1> buf = Buffer(data=data)
<2> header = pull_quic_header(buf, host_cid_length=8)
<3>
<4> # version negotiation
<5> if (
<6> header.version is not None
<7> and header.version not in QuicConnection.supported_versions
<8> ):
<9> self._transport.sendto(
<10> encode_quic_version_negotiation(
<11> source_cid=header.destination_cid,
<12> destination_cid=header.source_cid,
<13> supported_versions=QuicConnection.supported_versions,
<14> ),
<15> addr,
<16> )
<17> return
<18>
<19> connection = self._connections.get(header.destination_cid, None)
<20> original_connection_id: Optional[bytes] = None
<21> if connection is None and header.packet_type == PACKET_TYPE_INITIAL:
<22> # stateless retry
<23> if self._retry_key is not None:
<24> if not header.token:
<25> retry_message = encode_address(addr) + b"|" + header.destination_cid
<26> retry_token = self._retry_key.public_key().encrypt(
<27> retry_message,
<28> padding.OAEP(
<29> mgf=padding.MGF1(hashes.SHA256()),
<30> algorithm=hashes.SHA256(),
<31> label=None,
<32> ),
<33> )
<34> self._transport.sendto(
<35> encode_quic_retry(
<36> version=header.version,
<37> source_cid=os.urandom(8),
<38> destination_cid=header.source_cid,
<39> original_destination_cid=header.destination_cid,
<40> retry_token=retry_token,
<41> ),
<42> addr,
<43> )
<44> return
<45> else:</s>
|
===========below chunk 0===========
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
retry_message = self._retry_key.decrypt(
header.token,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
encoded_addr, original_connection_id = retry_message.split(
b"|", maxsplit=1
)
if encoded_addr != encode_address(addr):
return
except ValueError:
return
# create new connection
connection = QuicConnection(
alpn_protocols=self._alpn_protocols,
certificate=self._certificate,
is_client=False,
original_connection_id=original_connection_id,
private_key=self._private_key,
secrets_log_file=self._secrets_log_file,
session_ticket_fetcher=self._session_ticket_fetcher,
session_ticket_handler=self._session_ticket_handler,
stream_handler=self._stream_handler,
)
connection.connection_made(self._transport)
self._connections[connection.host_cid] = connection
self._connections[header.destination_cid] = connection
self._connection_handler(connection)
if connection is not None:
connection.datagram_received(data, addr)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
NetworkAddress = Any
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
at: aioquic.packet
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
encode_quic_retry(version: int, source_cid: bytes, destination_cid: bytes, original_destination_cid: bytes, retry_token: bytes) -> bytes
encode_quic_version_negotiation(source_cid: bytes, destination_cid: bytes, supported_versions: List[QuicProtocolVersion]) -> bytes
at: aioquic.packet.QuicHeader
version: Optional[int]
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: aioquic.server
encode_address(addr: NetworkAddress) -> bytes
at: aioquic.server.QuicServer.__init__
self._alpn_protocols = alpn_protocols
self._certificate = certificate
===========unchanged ref 1===========
self._connections: Dict[bytes, QuicConnection] = {}
self._private_key = private_key
self._secrets_log_file = secrets_log_file
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
self._transport: Optional[asyncio.DatagramTransport] = None
self._stream_handler = stream_handler
self._retry_key = None
self._retry_key = rsa.generate_private_key(
public_exponent=65537, key_size=1024, backend=default_backend()
)
at: aioquic.server.QuicServer.connection_made
self._transport = cast(asyncio.DatagramTransport, transport)
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: asyncio.transports.DatagramTransport
__slots__ = ()
sendto(data: Any, addr: Optional[_Address]=...) -> None
at: os
urandom(size: int, /) -> bytes
at: typing
cast(typ: Type[_T], val: Any) -> _T
cast(typ: str, val: Any) -> Any
cast(typ: object, val: Any) -> Any
Text = str
at: typing.Mapping
get(key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]
get(key: _KT) -> Optional[_VT_co]
===========changed ref 0===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
epoch: tls.Epoch
+ host_cid: bytes
network_path: QuicNetworkPath
===========changed ref 1===========
# module: aioquic.connection
+ QuicConnectionIdHandler = Callable[[bytes], None]
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 2===========
# module: aioquic.connection
@dataclass
class QuicConnectionId:
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
+ was_sent: bool = False
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RETIRE_CONNECTION_ID frame.
"""
+ sequence_number = pull_uint_var(buf)
- pull_uint_var(buf) # sequence number
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _replenish_connection_ids(self) -> None:
+ """
+ Generate new connection IDs.
+ """
+ while len(self._host_cids) < 8:
+ self._host_cids.append(
+ QuicConnectionId(
+ cid=os.urandom(8),
+ sequence_number=self._host_cid_seq,
+ stateless_reset_token=os.urandom(16),
+ )
+ )
+ self._host_cid_seq += 1
+
|
|
tests.test_connection/client_receive_context
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<0>:<add> return QuicReceiveContext(
<add> epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
<add> )
<del> return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
|
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
<0> return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
<1>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
epoch: tls.Epoch
+ host_cid: bytes
network_path: QuicNetworkPath
===========changed ref 1===========
# module: aioquic.connection
+ QuicConnectionIdHandler = Callable[[bytes], None]
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 2===========
# module: aioquic.connection
@dataclass
class QuicConnectionId:
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
+ was_sent: bool = False
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RETIRE_CONNECTION_ID frame.
"""
+ sequence_number = pull_uint_var(buf)
- pull_uint_var(buf) # sequence number
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _replenish_connection_ids(self) -> None:
+ """
+ Generate new connection IDs.
+ """
+ while len(self._host_cids) < 8:
+ self._host_cids.append(
+ QuicConnectionId(
+ cid=os.urandom(8),
+ sequence_number=self._host_cid_seq,
+ stateless_reset_token=os.urandom(16),
+ )
+ )
+ self._host_cid_seq += 1
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
break
self._parameters_received = True
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
+ self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
===========changed ref 6===========
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
data = cast(bytes, data)
buf = Buffer(data=data)
header = pull_quic_header(buf, host_cid_length=8)
# version negotiation
if (
header.version is not None
and header.version not in QuicConnection.supported_versions
):
self._transport.sendto(
encode_quic_version_negotiation(
source_cid=header.destination_cid,
destination_cid=header.source_cid,
supported_versions=QuicConnection.supported_versions,
),
addr,
)
return
connection = self._connections.get(header.destination_cid, None)
original_connection_id: Optional[bytes] = None
if connection is None and header.packet_type == PACKET_TYPE_INITIAL:
# stateless retry
if self._retry_key is not None:
if not header.token:
retry_message = encode_address(addr) + b"|" + header.destination_cid
retry_token = self._retry_key.public_key().encrypt(
retry_message,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
self._transport.sendto(
encode_quic_retry(
version=header.version,
source_cid=os.urandom(8),
destination_cid=header.source_cid,
original_destination_cid=header.destination_cid,
retry_token=retry_token,
),
addr,
)
return
else:
try:
retry_message = self._retry_key.decrypt(
header.token,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA</s>
===========changed ref 7===========
# module: aioquic.server
class QuicServer(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
<s>decrypt(
header.token,
padding.OAEP(
mgf=padding.MGF1(hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
encoded_addr, original_connection_id = retry_message.split(
b"|", maxsplit=1
)
if encoded_addr != encode_address(addr):
return
except ValueError:
return
# create new connection
connection = QuicConnection(
alpn_protocols=self._alpn_protocols,
certificate=self._certificate,
is_client=False,
original_connection_id=original_connection_id,
private_key=self._private_key,
secrets_log_file=self._secrets_log_file,
session_ticket_fetcher=self._session_ticket_fetcher,
session_ticket_handler=self._session_ticket_handler,
stream_handler=self._stream_handler,
)
+ self._connections[header.destination_cid] = connection
+
+ def connection_id_issued(cid: bytes) -> None:
+ self._connections[cid] = connection
+
+ def connection_id_retired(cid: bytes) -> None:
+ del self._connections[cid]
+
+ connection._connection_id_issued_handler = connection_id_issued
+ connection._connection_id_retired_handler = connection_id_retired
connection.connection_made(self._transport)
+
self._connections[connection.host_cid] = connection
- self._connections[header.destination_cid] = connection
self._connection_handler(connection)
if connection is not
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<12>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
<19>:<add> self.assertEqual(client_transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 4)
<30>:<add> self.assertEqual(client_transport.sent, 6)
<del> self.assertEqual(client_transport.sent, 5)
<39>:<add> self.assertEqual(client_transport.sent, 7)
<del> self.assertEqual(client_transport.sent, 6)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> client = QuicConnection(is_client=True)
<1> client.supported_versions = client_versions
<2>
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> )
<8> server.supported_versions = server_versions
<9>
<10> # perform handshake
<11> client_transport, server_transport = create_transport(client, server)
<12> self.assertEqual(client_transport.sent, 3)
<13> self.assertEqual(server_transport.sent, 3)
<14>
<15> # send data over stream
<16> client_reader, client_writer = run(client.create_stream())
<17> client_writer.write(b"ping")
<18> run(asyncio.sleep(0))
<19> self.assertEqual(client_transport.sent, 4)
<20> self.assertEqual(server_transport.sent, 4)
<21>
<22> # FIXME: needs an API
<23> server_reader, server_writer = (
<24> server.streams[0].reader,
<25> server.streams[0].writer,
<26> )
<27> self.assertEqual(run(server_reader.read(1024)), b"ping")
<28> server_writer.write(b"pong")
<29> run(asyncio.sleep(0))
<30> self.assertEqual(client_transport.sent, 5)
<31> self.assertEqual(server_transport.sent, 5)
<32>
<33> # client receives pong
<34> self.assertEqual(run(client_reader.read(1024)), b"pong")
<35>
<36> # client writes EOF
<37> client_writer.write_eof()
<38> run(asyncio.sleep(0))
<39> self.assertEqual(client_transport.sent, 6)
<40> self.assertEqual(server_transport.sent, 6)
<41>
<42> # server receives EOF
<43> </s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self.writer = None
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
write_eof() -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
===========unchanged ref 1===========
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 1===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
epoch: tls.Epoch
+ host_cid: bytes
network_path: QuicNetworkPath
===========changed ref 2===========
# module: aioquic.connection
+ QuicConnectionIdHandler = Callable[[bytes], None]
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 3===========
# module: aioquic.connection
@dataclass
class QuicConnectionId:
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
+ was_sent: bool = False
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RETIRE_CONNECTION_ID frame.
"""
+ sequence_number = pull_uint_var(buf)
- pull_uint_var(buf) # sequence number
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _replenish_connection_ids(self) -> None:
+ """
+ Generate new connection IDs.
+ """
+ while len(self._host_cids) < 8:
+ self._host_cids.append(
+ QuicConnectionId(
+ cid=os.urandom(8),
+ sequence_number=self._host_cid_seq,
+ stateless_reset_token=os.urandom(16),
+ )
+ )
+ self._host_cid_seq += 1
+
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
break
self._parameters_received = True
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
+ self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
|
tests.test_connection/QuicConnectionTest.test_connect_with_log
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<12>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
<0> client_log_file = io.StringIO()
<1> client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
<2> server_log_file = io.StringIO()
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> secrets_log_file=server_log_file,
<8> )
<9>
<10> # perform handshake
<11> client_transport, server_transport = create_transport(client, server)
<12> self.assertEqual(client_transport.sent, 3)
<13> self.assertEqual(server_transport.sent, 3)
<14>
<15> # check secrets were logged
<16> client_log = client_log_file.getvalue()
<17> server_log = server_log_file.getvalue()
<18> self.assertEqual(client_log, server_log)
<19> labels = []
<20> for line in client_log.splitlines():
<21> labels.append(line.split()[0])
<22> self.assertEqual(
<23> labels,
<24> [
<25> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<26> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
<27> "QUIC_SERVER_TRAFFIC_SECRET_0",
<28> "QUIC_CLIENT_TRAFFIC_SECRET_0",
<29> ],
<30> )
<31>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
client = QuicConnection(is_client=True)
client.supported_versions = client_versions
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# FIXME: needs an API
server_reader, server_writer = (
server.streams[0].reader,
server.streams[0].writer,
)
self.assertEqual(run(server_reader.read(1024)), b"ping")
server_writer.write(b"pong")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 6)
- self.assertEqual(client_transport.sent, 5)
self.assertEqual(server_transport.sent, 5)
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 7)
- self.assertEqual(client_transport.sent, 6</s>
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s> <add> self.assertEqual(client_transport.sent, 7)
- self.assertEqual(client_transport.sent, 6)
self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
===========changed ref 3===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
epoch: tls.Epoch
+ host_cid: bytes
network_path: QuicNetworkPath
===========changed ref 4===========
# module: aioquic.connection
+ QuicConnectionIdHandler = Callable[[bytes], None]
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 5===========
# module: aioquic.connection
@dataclass
class QuicConnectionId:
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
+ was_sent: bool = False
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RETIRE_CONNECTION_ID frame.
"""
+ sequence_number = pull_uint_var(buf)
- pull_uint_var(buf) # sequence number
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _replenish_connection_ids(self) -> None:
+ """
+ Generate new connection IDs.
+ """
+ while len(self._host_cids) < 8:
+ self._host_cids.append(
+ QuicConnectionId(
+ cid=os.urandom(8),
+ sequence_number=self._host_cid_seq,
+ stateless_reset_token=os.urandom(16),
+ )
+ )
+ self._host_cid_seq += 1
+
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_crypto_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a CRYPTO frame.
"""
stream = self.streams[context.epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
# pass data to TLS layer
try:
self.tls.handle_message(data, self.send_buffer)
except tls.Alert as exc:
raise QuicConnectionError(
error_code=QuicErrorCode.CRYPTO_ERROR + int(exc.description),
frame_type=QuicFrameType.CRYPTO,
reason_phrase=str(exc),
)
# parse transport parameters
if (
not self._parameters_received
and self.tls.received_extensions is not None
):
for ext_type, ext_data in self.tls.received_extensions:
if ext_type == tls.ExtensionType.QUIC_TRANSPORT_PARAMETERS:
self._parse_transport_parameters(ext_data)
break
self._parameters_received = True
# update current epoch
if self.__epoch == tls.Epoch.HANDSHAKE and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
+ self._replenish_connection_ids()
self.__epoch = tls.Epoch.ONE_RTT
# wakeup waiter
if not self.__connected.is_set():
self.__connected.set()
elif self.__epoch == tls.Epoch.INITIAL:
self.__epoch = tls.Epoch.HANDSHAKE
|
tests.test_connection/QuicConnectionTest.test_connection_lost
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<9>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
<16>:<add> self.assertEqual(client_transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 3)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # send data over stream
<13> client_reader, client_writer = run(client.create_stream())
<14> client_writer.write(b"ping")
<15> run(asyncio.sleep(0))
<16> self.assertEqual(client_transport.sent, 4)
<17> self.assertEqual(server_transport.sent, 4)
<18>
<19> # break connection
<20> client.connection_lost(None)
<21> self.assertEqual(run(client_reader.read()), b"")
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server)
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
secrets_log_file=server_log_file,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
client = QuicConnection(is_client=True)
client.supported_versions = client_versions
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# FIXME: needs an API
server_reader, server_writer = (
server.streams[0].reader,
server.streams[0].writer,
)
self.assertEqual(run(server_reader.read(1024)), b"ping")
server_writer.write(b"pong")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 6)
- self.assertEqual(client_transport.sent, 5)
self.assertEqual(server_transport.sent, 5)
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 7)
- self.assertEqual(client_transport.sent, 6</s>
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s> <add> self.assertEqual(client_transport.sent, 7)
- self.assertEqual(client_transport.sent, 6)
self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
===========changed ref 4===========
# module: aioquic.connection
@dataclass
class QuicReceiveContext:
epoch: tls.Epoch
+ host_cid: bytes
network_path: QuicNetworkPath
===========changed ref 5===========
# module: aioquic.connection
+ QuicConnectionIdHandler = Callable[[bytes], None]
QuicStreamHandler = Callable[[asyncio.StreamReader, asyncio.StreamWriter], None]
===========changed ref 6===========
# module: aioquic.connection
@dataclass
class QuicConnectionId:
cid: bytes
sequence_number: int
stateless_reset_token: bytes = b""
+ was_sent: bool = False
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_retire_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a RETIRE_CONNECTION_ID frame.
"""
+ sequence_number = pull_uint_var(buf)
- pull_uint_var(buf) # sequence number
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _replenish_connection_ids(self) -> None:
+ """
+ Generate new connection IDs.
+ """
+ while len(self._host_cids) < 8:
+ self._host_cids.append(
+ QuicConnectionId(
+ cid=os.urandom(8),
+ sequence_number=self._host_cid_seq,
+ stateless_reset_token=os.urandom(16),
+ )
+ )
+ self._host_cid_seq += 1
+
|
tests.test_connection/QuicConnectionTest.test_connection_lost_with_exception
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<9>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
<16>:<add> self.assertEqual(client_transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 3)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # send data over stream
<13> client_reader, client_writer = run(client.create_stream())
<14> client_writer.write(b"ping")
<15> run(asyncio.sleep(0))
<16> self.assertEqual(client_transport.sent, 4)
<17> self.assertEqual(server_transport.sent, 4)
<18>
<19> # break connection
<20> exc = Exception("some error")
<21> client.connection_lost(exc)
<22> with self.assertRaises(Exception) as cm:
<23> run(client_reader.read())
<24> self.assertEqual(cm.exception, exc)
<25>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
connection_lost(exc: Exception) -> None
at: asyncio.streams.StreamReader
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_connection_lost
client_reader, client_writer = run(client.create_stream())
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========unchanged ref 1===========
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
secrets_log_file=server_log_file,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
client = QuicConnection(is_client=True)
client.supported_versions = client_versions
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# FIXME: needs an API
server_reader, server_writer = (
server.streams[0].reader,
server.streams[0].writer,
)
self.assertEqual(run(server_reader.read(1024)), b"ping")
server_writer.write(b"pong")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 6)
- self.assertEqual(client_transport.sent, 5)
self.assertEqual(server_transport.sent, 5)
# client receives pong
self.assertEqual(run(client_reader.read(1024)), b"pong")
# client writes EOF
client_writer.write_eof()
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 7)
- self.assertEqual(client_transport.sent, 6</s>
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s> <add> self.assertEqual(client_transport.sent, 7)
- self.assertEqual(client_transport.sent, 6)
self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
|
tests.test_connection/QuicConnectionTest.test_create_stream_over_max_streams
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<9>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
<15>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 3)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # create streams
<13> for i in range(128):
<14> client_reader, client_writer = run(client.create_stream())
<15> self.assertEqual(client_transport.sent, 3)
<16> self.assertEqual(server_transport.sent, 3)
<17>
<18> # create one too many
<19> with self.assertRaises(ValueError) as cm:
<20> client_reader, client_writer = run(client.create_stream())
<21> self.assertEqual(str(cm.exception), "Too many streams open")
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: tests.test_connection
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_create_stream
reader, writer = run(server.create_stream(is_unidirectional=True))
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connect_with_log(self):
client_log_file = io.StringIO()
client = QuicConnection(is_client=True, secrets_log_file=client_log_file)
server_log_file = io.StringIO()
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
secrets_log_file=server_log_file,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# check secrets were logged
client_log = client_log_file.getvalue()
server_log = server_log_file.getvalue()
self.assertEqual(client_log, server_log)
labels = []
for line in client_log.splitlines():
labels.append(line.split()[0])
self.assertEqual(
labels,
[
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
)
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<10>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
<20>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> server = QuicConnection(
<3> is_client=False,
<4> certificate=SERVER_CERTIFICATE,
<5> private_key=SERVER_PRIVATE_KEY,
<6> )
<7>
<8> # perform handshake
<9> client_transport, server_transport = create_transport(client, server)
<10> self.assertEqual(client_transport.sent, 3)
<11> self.assertEqual(server_transport.sent, 3)
<12>
<13> # mess with encryption key
<14> server.cryptos[tls.Epoch.ONE_RTT].send.setup(
<15> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<16> )
<17>
<18> # close
<19> server.close(error_code=QuicErrorCode.NO_ERROR)
<20> self.assertEqual(client_transport.sent, 3)
<21> self.assertEqual(server_transport.sent, 4)
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: aioquic.connection.QuicConnection._initialize
self.cryptos = {
tls.Epoch.INITIAL: CryptoPair(),
tls.Epoch.ZERO_RTT: CryptoPair(),
tls.Epoch.HANDSHAKE: CryptoPair(),
tls.Epoch.ONE_RTT: CryptoPair(),
}
at: aioquic.crypto.CryptoContext
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.send = CryptoContext()
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls
Epoch()
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
create_transport(client, server)
===========unchanged ref 1===========
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 1===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<9>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
<16>:<add> self.assertEqual(client_transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 3)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # close
<13> server.close(
<14> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<15> )
<16> self.assertEqual(client_transport.sent, 4)
<17> self.assertEqual(server_transport.sent, 4)
<18>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 4)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 2===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
|
tests.test_connection/QuicConnectionTest.test_handle_connection_close_frame_app
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<9>:<add> self.assertEqual(client_transport.sent, 4)
<del> self.assertEqual(client_transport.sent, 3)
<14>:<add> self.assertEqual(client_transport.sent, 5)
<del> self.assertEqual(client_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(client_transport.sent, 3)
<10> self.assertEqual(server_transport.sent, 3)
<11>
<12> # close
<13> server.close(error_code=QuicErrorCode.NO_ERROR)
<14> self.assertEqual(client_transport.sent, 4)
<15> self.assertEqual(server_transport.sent, 4)
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
close(error_code: int=QuicErrorCode.NO_ERROR, frame_type: Optional[int]=None, reason_phrase: str="") -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_connection_close_frame
client_transport, server_transport = create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# close
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 4)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 3===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
client.connection_lost(None)
self.assertEqual(run(client_reader.read()), b"")
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
eafdefab792cc284f76f250f5863990e027bda97
|
[connection] provide peer with spare connection IDs
|
<9>:<add> self.assertEqual(
<add> list(map(lambda x: x.sequence_number, client._host_cids)),
<add> [0, 1, 2, 3, 4, 5, 6, 7],
<add> )
<16>:<add> self.assertEqual(
<add> list(map(lambda x: x.sequence_number, client._host_cids)),
<add> [0, 1, 3, 4, 5, 6, 7, 8],
<add> )
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives RETIRE_CONNECTION_ID
<11> client._handle_retire_connection_id_frame(
<12> client_receive_context(client),
<13> QuicFrameType.RETIRE_CONNECTION_ID,
<14> Buffer(data=b"\x02"),
<15> )
<16>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection.__init__
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
at: tests.test_connection
create_transport(client, server)
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame_app(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_connection_close_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# close
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_decryption_error(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# mess with encryption key
server.cryptos[tls.Epoch.ONE_RTT].send.setup(
tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 4)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream_over_max_streams(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create streams
for i in range(128):
client_reader, client_writer = run(client.create_stream())
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# create one too many
with self.assertRaises(ValueError) as cm:
client_reader, client_writer = run(client.create_stream())
self.assertEqual(str(cm.exception), "Too many streams open")
===========changed ref 4===========
# module: tests.test_connection
def client_receive_context(client, epoch=tls.Epoch.ONE_RTT):
+ return QuicReceiveContext(
+ epoch=epoch, host_cid=client.host_cid, network_path=client._network_paths[0]
+ )
- return QuicReceiveContext(epoch=epoch, network_path=client._network_paths[0])
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_connection_lost_with_exception(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
- self.assertEqual(client_transport.sent, 3)
self.assertEqual(server_transport.sent, 3)
# send data over stream
client_reader, client_writer = run(client.create_stream())
client_writer.write(b"ping")
run(asyncio.sleep(0))
+ self.assertEqual(client_transport.sent, 5)
- self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 4)
# break connection
exc = Exception("some error")
client.connection_lost(exc)
with self.assertRaises(Exception) as cm:
run(client_reader.read())
self.assertEqual(cm.exception, exc)
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
186954e18b52ba274b4dfe8e91923793218f1e17
|
[connection] clarify handling of peer's connection IDs
|
<12>:<add> self._peer_cid_seq: Optional[int] = None
<del> self.peer_cid_set = False
<13>:<add> self._peer_cid_available: List[QuicConnectionId] = []
<del> self.peer_cids: List[QuicConnectionId] = []
|
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self.peer_cid_set = False
<13> self.peer_cids: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset_token=os.ur</s>
|
===========below chunk 0===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
</s>
===========below chunk 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_padding_frame, EPOCHS("ZO")),
(self._handle_ack_frame, E</s>
===========below chunk 2===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),
(self._handle_max_streams_uni_frame, EPOCHS("ZO")),</s>
===========below chunk 3===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s> (self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
aioquic.connection/QuicConnection._handle_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
186954e18b52ba274b4dfe8e91923793218f1e17
|
[connection] clarify handling of peer's connection IDs
|
<11>:<add> self._peer_cid_available.append(
<del> self.peer_cids.append(
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a NEW_CONNECTION_ID frame.
<2> """
<3> sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
<4> buf
<5> )
<6> self._logger.info(
<7> "New connection ID received %d %s",
<8> sequence_number,
<9> binascii.hexlify(cid).decode("ascii"),
<10> )
<11> self.peer_cids.append(
<12> QuicConnectionId(
<13> cid=cid,
<14> sequence_number=sequence_number,
<15> stateless_reset_token=stateless_reset_token,
<16> )
<17> )
<18>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._remote_max_streams_uni = 0
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _consume_connection_id(self) -> None:
+ """
+ Switch to the next available connection ID and retire
+ the previous one.
+ """
+ if self._peer_cid_available:
+ # retire previous CID
+ self._retire_connection_ids.append(self._peer_cid_seq)
+
+ # assign new CID
+ connection_id = self._peer_cid_available.pop(0)
+ self._peer_cid_seq = connection_id.sequence_number
+ self.peer_cid = connection_id.cid
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
if self.is_client and header.destination_cid != self.host_cid:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
and not self._stateless_retry_count
):
self._original_connection_id = self.peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
<s>peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self._stateless_retry_count += 1
self._logger.info("Performing stateless retry")
self._connect()
return
network_path = self._find_network_path(addr)
# server initialization
if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:
assert (
header.packet_type == PACKET_TYPE_INITIAL
), "first packet must be INITIAL"
self._network_paths = [network_path]
self._version = QuicProtocolVersion(header.version)
self._initialize(header.destination_cid)
# determine crypto and packet space
epoch = get_epoch(header.packet_type)
crypto = self.cryptos[epoch]
if epoch == tls.Epoch.ZERO_RTT:
space = self.spaces[tls.Epoch.ONE_RTT]
else:
space = self.spaces[epoch]
# decrypt packet
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not crypto.recv.is_valid():
continue
try:
plain_header, plain_payload, packet_number = crypto.decrypt_packet(
data[start_off:end_off], encrypted_off, space.expected_packet_number
)
except CryptoError as exc:
self._logger.warning(exc)
continue
if packet_number > space.expected_packet_number:
space.expected_packet_number = packet_number + 1
</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 2
<s> # discard initial keys
if not self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
# update state
+ if self._peer_cid_seq is None:
- if not self.peer_cid_set:
self.peer_cid = header.source_cid
+ self._peer_cid_seq = 0
- self.peer_cids = [
- QuicConnectionId(cid=header.source_cid, sequence_number=0)
- ]
- self.peer_cid_set = True
if self.__state == QuicConnectionState.FIRSTFLIGHT:
self._set_state(QuicConnectionState.CONNECTED)
# update spin bit
if (
not is_long_header(plain_header[0])
and packet_number > self._spin_highest_pn
):
self._spin_bit_peer = get_spin_bit(plain_header[0])
if self.is_client:
self._spin_bit = not self._spin_bit_peer
else:
self._spin_bit = self._spin_bit_peer
self._spin_highest_pn = packet_number
# handle payload
context = QuicReceiveContext(
epoch=epoch, host_cid=header.destination_cid, network_path=network_path
)
self._logger.debug("[%s] handling packet %d", context, packet_number)
try:
is_ack_only, is_probing = self._payload_received(context, plain_payload)
except QuicConnectionError as exc:
self._logger.warning(exc)
self.close(
error_</s>
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
186954e18b52ba274b4dfe8e91923793218f1e17
|
[connection] clarify handling of peer's connection IDs
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
<0> if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
<1> crypto = self.cryptos[tls.Epoch.ONE_RTT]
<2> packet_type = PACKET_TYPE_ONE_RTT
<3> elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
<4> crypto = self.cryptos[tls.Epoch.ZERO_RTT]
<5> packet_type = PACKET_TYPE_ZERO_RTT
<6> else:
<7> return
<8> space = self.spaces[tls.Epoch.ONE_RTT]
<9> is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
<10>
<11> buf = builder.buffer
<12> while True:
<13> # write header
<14> builder.start_packet(packet_type, crypto)
<15>
<16> if is_one_rtt:
<17> # ACK
<18> if space.ack_required and space.ack_queue:
<19> push_uint_var(buf, QuicFrameType.ACK)
<20> packet.push_ack_frame(buf, space.ack_queue, 0)
<21> space.ack_required = False
<22>
<23> # PATH CHALLENGE
<24> if (
<25> not network_path.is_validated
<26> and network_path.local_challenge is None
<27> ):
<28> self._logger.info(
<29> "Network path %s sending challenge", network_path.addr
<30> )
<31> network_path.local_challenge = os.urandom(8)
<32> push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
<33> push_bytes(buf, network_path.local_challenge)
<34>
<35> # PATH RESPONSE
<36> if network_path.remote_challenge is not None:
<37> push_uint_var(buf, QuicFrame</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 1
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# NEW_CONNECTION_ID
for connection_id in self._host_cids:
if not connection_id.was_sent:
push_uint_var(buf, QuicFrameType.NEW_CONNECTION_ID)
packet.push_new_connection_id_frame(
buf,
connection_id.sequence_number,
connection_id.cid,
connection_id.stateless_reset_token,
)
connection_id.was_sent = True
space.expect_ack(builder.packet_number, lambda: None)
self._connection_id_issued_handler(connection_id.cid)
# PING
if self._ping_pending:
self._logger.info("Sending PING in packet %d", builder.packet_number)
push_uint_var(buf, QuicFrameType.PING)
space.expect_ack(builder.packet_number, self._on_ping_delivery)
self._ping_pending = False
for stream_id, stream in self.streams.items():
# CRYPTO
if is_one_rtt and stream_id == tls.Epoch.ONE_RTT:
frame_overhead = 3 + quic_uint_length(stream.next_send_offset)
frame = stream.get_frame(builder.remaining_space - frame_overhead)
if frame is not None:
push_uint_var(buf, QuicFrameType.CRYPTO)
with packet.push_crypto_frame(buf, frame.offset):
push_bytes(buf, frame.data)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
# offset: 2
<s> builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
# STREAM
elif isinstance(stream_id, int):
# the frame data size is constrained by our peer's MAX_DATA and
# the space available in the current packet
frame_overhead = (
3
+ quic_uint_length(stream_id)
+ (
quic_uint_length(stream.next_send_offset)
if stream.next_send_offset
else 0
)
)
previous_send_highest = stream._send_highest
frame = stream.get_frame(
min(
builder.remaining_space - frame_overhead,
self._remote_max_data - self._remote_max_data_used,
)
)
if frame is not None:
flags = QuicStreamFlag.LEN
if frame.offset:
flags |= QuicStreamFlag.OFF
if frame.fin:
flags |= QuicStreamFlag.FIN
push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
with push_stream_frame(buf, stream_id, frame.offset):
push_bytes(buf, frame.data)
self._remote_max_data_used += (
stream._send_highest - previous_send_highest
)
space.expect_ack(
builder.packet_number,
stream.on_data_delivery,
(frame.offset, frame.offset + len(frame.data)),
)
if not builder.end_packet():
break
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.connection
SECRETS_LABELS = [
[
None,
"QUIC_CLIENT_EARLY_TRAFFIC_SECRET",
"QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_CLIENT_TRAFFIC_SECRET_0",
],
[
None,
None,
"QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
"QUIC_SERVER_TRAFFIC_SECRET_0",
],
]
QuicNetworkPath(addr: NetworkAddress, bytes_received: int=0, bytes_sent: int=0, is_validated: bool=False, local_challenge: Optional[bytes]=None, remote_challenge: Optional[bytes]=None)
at: aioquic.connection.QuicConnection
_on_ping_delivery() -> None
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.secrets_log_file = secrets_log_file
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__epoch = tls.Epoch.INITIAL
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._ping_pending = False
self._remote_max_data = 0
self._remote_max_data_used = 0
self._retire_connection_ids: List[int] = []
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
|
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
186954e18b52ba274b4dfe8e91923793218f1e17
|
[connection] clarify handling of peer's connection IDs
|
<14>:<add>
<add> # check each endpoint has available connection IDs for the peer
<add> self.assertEqual(
<add> sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<add> )
<add> self.assertEqual(
<add> sequence_numbers(server._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
<add> )
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
<0> client = QuicConnection(is_client=True)
<1> client.supported_versions = client_versions
<2>
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> )
<8> server.supported_versions = server_versions
<9>
<10> # perform handshake
<11> client_transport, server_transport = create_transport(client, server)
<12> self.assertEqual(client_transport.sent, 4)
<13> self.assertEqual(server_transport.sent, 3)
<14>
<15> # send data over stream
<16> client_reader, client_writer = run(client.create_stream())
<17> client_writer.write(b"ping")
<18> run(asyncio.sleep(0))
<19> self.assertEqual(client_transport.sent, 5)
<20> self.assertEqual(server_transport.sent, 4)
<21>
<22> # FIXME: needs an API
<23> server_reader, server_writer = (
<24> server.streams[0].reader,
<25> server.streams[0].writer,
<26> )
<27> self.assertEqual(run(server_reader.read(1024)), b"ping")
<28> server_writer.write(b"pong")
<29> run(asyncio.sleep(0))
<30> self.assertEqual(client_transport.sent, 6)
<31> self.assertEqual(server_transport.sent, 5)
<32>
<33> # client receives pong
<34> self.assertEqual(run(client_reader.read(1024)), b"pong")
<35>
<36> # client writes EOF
<37> client_writer.write_eof()
<38> run(asyncio.sleep(0))
<39> self.assertEqual(client_transport.sent, 7)
<40> self.assertEqual(server_transport.sent, 6)
<41>
<42> # server receives EOF
<43> </s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
supported_versions = [QuicProtocolVersion.DRAFT_19, QuicProtocolVersion.DRAFT_20]
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.connection.QuicConnection.__init__
self._peer_cid_available: List[QuicConnectionId] = []
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self.writer = None
self.writer = asyncio.StreamWriter(self, None, self.reader, None)
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
at: asyncio.tasks
sleep(delay: float, result: _T=..., *, loop: Optional[AbstractEventLoop]=...) -> Future[_T]
at: tests.test_connection
create_transport(client, server)
sequence_numbers(connection_ids)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.utils
run(coro)
===========unchanged ref 1===========
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case
TestCase(methodName: str=...)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
+ def sequence_numbers(connection_ids):
+ return list(map(lambda x: x.sequence_number, connection_ids))
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _consume_connection_id(self) -> None:
+ """
+ Switch to the next available connection ID and retire
+ the previous one.
+ """
+ if self._peer_cid_available:
+ # retire previous CID
+ self._retire_connection_ids.append(self._peer_cid_seq)
+
+ # assign new CID
+ connection_id = self._peer_cid_available.pop(0)
+ self._peer_cid_seq = connection_id.sequence_number
+ self.peer_cid = connection_id.cid
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
"""
Handle a NEW_CONNECTION_ID frame.
"""
sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
buf
)
self._logger.info(
"New connection ID received %d %s",
sequence_number,
binascii.hexlify(cid).decode("ascii"),
)
+ self._peer_cid_available.append(
- self.peer_cids.append(
QuicConnectionId(
cid=cid,
sequence_number=sequence_number,
stateless_reset_token=stateless_reset_token,
)
)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _write_application(
self, builder: QuicPacketBuilder, network_path: QuicNetworkPath
) -> None:
if self.cryptos[tls.Epoch.ONE_RTT].send.is_valid():
crypto = self.cryptos[tls.Epoch.ONE_RTT]
packet_type = PACKET_TYPE_ONE_RTT
elif self.cryptos[tls.Epoch.ZERO_RTT].send.is_valid():
crypto = self.cryptos[tls.Epoch.ZERO_RTT]
packet_type = PACKET_TYPE_ZERO_RTT
else:
return
space = self.spaces[tls.Epoch.ONE_RTT]
is_one_rtt = self.__epoch == tls.Epoch.ONE_RTT
buf = builder.buffer
while True:
# write header
builder.start_packet(packet_type, crypto)
if is_one_rtt:
# ACK
if space.ack_required and space.ack_queue:
push_uint_var(buf, QuicFrameType.ACK)
packet.push_ack_frame(buf, space.ack_queue, 0)
space.ack_required = False
# PATH CHALLENGE
if (
not network_path.is_validated
and network_path.local_challenge is None
):
self._logger.info(
"Network path %s sending challenge", network_path.addr
)
network_path.local_challenge = os.urandom(8)
push_uint_var(buf, QuicFrameType.PATH_CHALLENGE)
push_bytes(buf, network_path.local_challenge)
# PATH RESPONSE
if network_path.remote_challenge is not None:
push_uint_var(buf, QuicFrameType.PATH_RESPONSE)
push_bytes(buf, network_path.remote_challenge)
network_path.remote_challenge = None
# NEW</s>
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame
|
Modified
|
aiortc~aioquic
|
186954e18b52ba274b4dfe8e91923793218f1e17
|
[connection] clarify handling of peer's connection IDs
|
<9>:<del> self.assertEqual(
<10>:<del> list(map(lambda x: x.sequence_number, client._host_cids)),
<11>:<del> [0, 1, 2, 3, 4, 5, 6, 7],
<12>:<del> )
<13>:<add> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7])
<20>:<del> self.assertEqual(
<21>:<del> list(map(lambda x: x.sequence_number, client._host_cids)),
<22>:<del> [0, 1, 3, 4, 5, 6, 7, 8],
<23>:<del> )
<24>:<add> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8])
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9> self.assertEqual(
<10> list(map(lambda x: x.sequence_number, client._host_cids)),
<11> [0, 1, 2, 3, 4, 5, 6, 7],
<12> )
<13>
<14> # client receives RETIRE_CONNECTION_ID
<15> client._handle_retire_connection_id_frame(
<16> client_receive_context(client),
<17> QuicFrameType.RETIRE_CONNECTION_ID,
<18> Buffer(data=b"\x02"),
<19> )
<20> self.assertEqual(
<21> list(map(lambda x: x.sequence_number, client._host_cids)),
<22> [0, 1, 3, 4, 5, 6, 7, 8],
<23> )
<24>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
_handle_reset_stream_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
create_transport(client, server)
at: tests.test_connection.QuicConnectionTest.test_handle_reset_stream_frame_send_only
client = QuicConnection(is_client=True)
===========unchanged ref 1===========
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
at: tests.utils
run(coro)
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
at: unittest.case._AssertRaisesContext.__exit__
self.exception = exc_value.with_traceback(None)
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_handle_new_connection_id_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_CONNECTION_ID
- client._handle_new_connection_id_frame(
- client_receive_context(client),
- QuicFrameType.NEW_CONNECTION_ID,
- Buffer(
- data=binascii.unhexlify(
- "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
- )
- ),
- )
-
===========changed ref 1===========
# module: tests.test_connection
+ def sequence_numbers(connection_ids):
+ return list(map(lambda x: x.sequence_number, connection_ids))
+
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_consume_connection_id(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
+
+ # change connection ID
+ client._consume_connection_id()
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
+ )
+
+ # the server provides a new connection ID
+ client._send_pending()
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
+ )
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _consume_connection_id(self) -> None:
+ """
+ Switch to the next available connection ID and retire
+ the previous one.
+ """
+ if self._peer_cid_available:
+ # retire previous CID
+ self._retire_connection_ids.append(self._peer_cid_seq)
+
+ # assign new CID
+ connection_id = self._peer_cid_available.pop(0)
+ self._peer_cid_seq = connection_id.sequence_number
+ self.peer_cid = connection_id.cid
+
|
tests.test_connection/QuicConnectionTest.test_handle_retire_connection_id_frame_current_cid
|
Modified
|
aiortc~aioquic
|
186954e18b52ba274b4dfe8e91923793218f1e17
|
[connection] clarify handling of peer's connection IDs
|
<22>:<add> self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7])
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame_current_cid(self):
<0> client = QuicConnection(is_client=True)
<1> server = QuicConnection(
<2> is_client=False,
<3> certificate=SERVER_CERTIFICATE,
<4> private_key=SERVER_PRIVATE_KEY,
<5> )
<6>
<7> # perform handshake
<8> client_transport, server_transport = create_transport(client, server)
<9>
<10> # client receives RETIRE_CONNECTION_ID for the current CID
<11> with self.assertRaises(QuicConnectionError) as cm:
<12> client._handle_retire_connection_id_frame(
<13> client_receive_context(client),
<14> QuicFrameType.RETIRE_CONNECTION_ID,
<15> Buffer(data=b"\x00"),
<16> )
<17> self.assertEqual(cm.exception.error_code, QuicErrorCode.PROTOCOL_VIOLATION)
<18> self.assertEqual(cm.exception.frame_type, QuicFrameType.RETIRE_CONNECTION_ID)
<19> self.assertEqual(
<20> cm.exception.reason_phrase, "Cannot retire current connection ID"
<21> )
<22>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
QuicConnection(*, is_client: bool=True, certificate: Any=None, private_key: Any=None, alpn_protocols: Optional[List[str]]=None, original_connection_id: Optional[bytes]=None, secrets_log_file: TextIO=None, server_name: Optional[str]=None, session_ticket: Optional[tls.SessionTicket]=None, session_ticket_fetcher: Optional[tls.SessionTicketFetcher]=None, session_ticket_handler: Optional[tls.SessionTicketHandler]=None, stream_handler: Optional[QuicStreamHandler]=None)
at: aioquic.connection.QuicConnection
_handle_retire_connection_id_frame(context: QuicReceiveContext, frame_type: int, buf: Buffer) -> None
at: aioquic.connection.QuicConnection.__init__
self._host_cids = [
QuicConnectionId(
cid=os.urandom(8),
sequence_number=0,
stateless_reset_token=os.urandom(16),
was_sent=True,
)
]
at: aioquic.packet
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
at: tests.test_connection
client_receive_context(client, epoch=tls.Epoch.ONE_RTT)
create_transport(client, server)
sequence_numbers(connection_ids)
at: tests.test_connection.QuicConnectionTest.test_handle_retire_connection_id_frame
client = QuicConnection(is_client=True)
===========unchanged ref 1===========
at: tests.utils
SERVER_CERTIFICATE = x509.load_pem_x509_certificate(
load("ssl_cert.pem"), backend=default_backend()
)
SERVER_PRIVATE_KEY = serialization.load_pem_private_key(
load("ssl_key.pem"), password=None, backend=default_backend()
)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
assertRaises(expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any=...) -> _AssertRaisesContext[_E]
assertRaises(expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None
===========changed ref 0===========
# module: tests.test_connection
+ def sequence_numbers(connection_ids):
+ return list(map(lambda x: x.sequence_number, connection_ids))
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_handle_retire_connection_id_frame(self):
client = QuicConnection(is_client=True)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
# perform handshake
client_transport, server_transport = create_transport(client, server)
- self.assertEqual(
- list(map(lambda x: x.sequence_number, client._host_cids)),
- [0, 1, 2, 3, 4, 5, 6, 7],
- )
+ self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 2, 3, 4, 5, 6, 7])
# client receives RETIRE_CONNECTION_ID
client._handle_retire_connection_id_frame(
client_receive_context(client),
QuicFrameType.RETIRE_CONNECTION_ID,
Buffer(data=b"\x02"),
)
- self.assertEqual(
- list(map(lambda x: x.sequence_number, client._host_cids)),
- [0, 1, 3, 4, 5, 6, 7, 8],
- )
+ self.assertEqual(sequence_numbers(client._host_cids), [0, 1, 3, 4, 5, 6, 7, 8])
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
- def test_handle_new_connection_id_frame(self):
- client = QuicConnection(is_client=True)
- server = QuicConnection(
- is_client=False,
- certificate=SERVER_CERTIFICATE,
- private_key=SERVER_PRIVATE_KEY,
- )
-
- # perform handshake
- client_transport, server_transport = create_transport(client, server)
-
- # client receives NEW_CONNECTION_ID
- client._handle_new_connection_id_frame(
- client_receive_context(client),
- QuicFrameType.NEW_CONNECTION_ID,
- Buffer(
- data=binascii.unhexlify(
- "02117813f3d9e45e0cacbb491b4b66b039f20406f68fede38ec4c31aba8ab1245244e8"
- )
- ),
- )
-
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_consume_connection_id(self):
+ client = QuicConnection(is_client=True)
+ server = QuicConnection(
+ is_client=False,
+ certificate=SERVER_CERTIFICATE,
+ private_key=SERVER_PRIVATE_KEY,
+ )
+
+ # perform handshake
+ client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [1, 2, 3, 4, 5, 6, 7]
+ )
+
+ # change connection ID
+ client._consume_connection_id()
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7]
+ )
+
+ # the server provides a new connection ID
+ client._send_pending()
+ self.assertEqual(
+ sequence_numbers(client._peer_cid_available), [2, 3, 4, 5, 6, 7, 8]
+ )
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
+ def _consume_connection_id(self) -> None:
+ """
+ Switch to the next available connection ID and retire
+ the previous one.
+ """
+ if self._peer_cid_available:
+ # retire previous CID
+ self._retire_connection_ids.append(self._peer_cid_seq)
+
+ # assign new CID
+ connection_id = self._peer_cid_available.pop(0)
+ self._peer_cid_seq = connection_id.sequence_number
+ self.peer_cid = connection_id.cid
+
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
8b8858627fa14ee0dd39bd66d37c62052ab40e43
|
[connection] respond to peer migrations
|
<s>[List[str]] = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
<0> if is_client:
<1> assert (
<2> original_connection_id is None
<3> ), "Cannot set original_connection_id for a client"
<4> else:
<5> assert certificate is not None, "SSL certificate is required for a server"
<6> assert private_key is not None, "SSL private key is required for a server"
<7>
<8> self.alpn_protocols = alpn_protocols
<9> self.certificate = certificate
<10> self.is_client = is_client
<11> self.peer_cid = os.urandom(8)
<12> self._peer_cid_seq: Optional[int] = None
<13> self._peer_cid_available: List[QuicConnectionId] = []
<14> self.peer_token = b""
<15> self.private_key = private_key
<16> self.secrets_log_file = secrets_log_file
<17> self.server_name = server_name
<18> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<19>
<20> # counters for debugging
<21> self._stateless_retry_count = 0
<22> self._version_negotiation_count = 0
<23>
<24> self._loop = asyncio.get_event_loop()
<25> self.__close: Optional[Dict] = None
<26> self.__connected = asyncio.Event()
<27> self.__epoch = tls.Epoch.INITIAL
<28> self._host_cids = [
<29> QuicConnectionId(
<30> cid=os.urandom(8),
<31> sequence_number=0,
<32> stateless_reset</s>
|
===========below chunk 0===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 1
was_sent=True,
)
]
self.host_cid = self._host_cids[0].cid
self._host_cid_seq = 1
self._local_idle_timeout = 60000 # milliseconds
self._local_max_data = 1048576
self._local_max_data_used = 0
self._local_max_stream_data_bidi_local = 1048576
self._local_max_stream_data_bidi_remote = 1048576
self._local_max_stream_data_uni = 1048576
self._local_max_streams_bidi = 128
self._local_max_streams_uni = 128
self._logger = QuicConnectionAdapter(
logger, {"host_cid": binascii.hexlify(self.host_cid).decode("ascii")}
)
self._network_paths: List[QuicNetworkPath] = []
self._original_connection_id = original_connection_id
self._parameters_received = False
self._ping_pending = False
self._ping_waiter: Optional[asyncio.Future[None]] = None
self._probe_timeout = 0.1 # seconds
self._remote_idle_timeout = 0 # milliseconds
self._remote_max_data = 0
self._remote_max_data_used = 0
self._remote_max_stream_data_bidi_local = 0
self._remote_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
</s>
===========below chunk 1===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 2
<s>_max_stream_data_bidi_remote = 0
self._remote_max_stream_data_uni = 0
self._remote_max_streams_bidi = 0
self._remote_max_streams_uni = 0
self._session_ticket = session_ticket
self._spin_bit = False
self._spin_bit_peer = False
self._spin_highest_pn = 0
self.__send_pending_task: Optional[asyncio.Handle] = None
self.__state = QuicConnectionState.FIRSTFLIGHT
self._transport: Optional[asyncio.DatagramTransport] = None
self._version: Optional[int] = None
# things to send
self._retire_connection_ids: List[int] = []
# callbacks
self._connection_id_issued_handler: QuicConnectionIdHandler = lambda c: None
self._connection_id_retired_handler: QuicConnectionIdHandler = lambda c: None
self._session_ticket_fetcher = session_ticket_fetcher
self._session_ticket_handler = session_ticket_handler
if stream_handler is not None:
self._stream_handler = stream_handler
else:
self._stream_handler = lambda r, w: None
# frame handlers
self.__frame_handlers = [
(self._handle_padding_frame, EPOCHS("IZHO")),
(self._handle_</s>
===========below chunk 2===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 3
<s>frame, EPOCHS("ZO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_ack_frame, EPOCHS("IHO")),
(self._handle_reset_stream_frame, EPOCHS("ZO")),
(self._handle_stop_sending_frame, EPOCHS("ZO")),
(self._handle_crypto_frame, EPOCHS("IHO")),
(self._handle_new_token_frame, EPOCHS("O")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_stream_frame, EPOCHS("ZO")),
(self._handle_max_data_frame, EPOCHS("ZO")),
(self._handle_max_stream_data_frame, EPOCHS("ZO")),
(self._handle_max_streams_bidi_frame, EPOCHS("ZO")),</s>
===========below chunk 3===========
<s> = None,
original_connection_id: Optional[bytes] = None,
secrets_log_file: TextIO = None,
server_name: Optional[str] = None,
session_ticket: Optional[tls.SessionTicket] = None,
session_ticket_fetcher: Optional[tls.SessionTicketFetcher] = None,
session_ticket_handler: Optional[tls.SessionTicketHandler] = None,
stream_handler: Optional[QuicStreamHandler] = None,
) -> None:
# offset: 4
<s> (self._handle_max_streams_uni_frame, EPOCHS("ZO")),
(self._handle_data_blocked_frame, EPOCHS("ZO")),
(self._handle_stream_data_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_streams_blocked_frame, EPOCHS("ZO")),
(self._handle_new_connection_id_frame, EPOCHS("ZO")),
(self._handle_retire_connection_id_frame, EPOCHS("O")),
(self._handle_path_challenge_frame, EPOCHS("ZO")),
(self._handle_path_response_frame, EPOCHS("O")),
(self._handle_connection_close_frame, EPOCHS("IZHO")),
(self._handle_connection_close_frame, EPOCHS("ZO")),
]
|
|
aioquic.connection/QuicConnection._consume_connection_id
|
Modified
|
aiortc~aioquic
|
8b8858627fa14ee0dd39bd66d37c62052ab40e43
|
[connection] respond to peer migrations
|
<12>:<add> self._logger.info(
<add> "Migrating to %s (%d)", dump_cid(self.peer_cid), self._peer_cid_seq
<add> )
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _consume_connection_id(self) -> None:
<0> """
<1> Switch to the next available connection ID and retire
<2> the previous one.
<3> """
<4> if self._peer_cid_available:
<5> # retire previous CID
<6> self._retire_connection_ids.append(self._peer_cid_seq)
<7>
<8> # assign new CID
<9> connection_id = self._peer_cid_available.pop(0)
<10> self._peer_cid_seq = connection_id.sequence_number
<11> self.peer_cid = connection_id.cid
<12>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnectionError(error_code: int, frame_type: int, reason_phrase: str)
at: aioquic.connection.QuicConnection
_stream_can_send(stream_id: int) -> bool
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.connection
+ def dump_cid(cid: bytes) -> str:
+ return binascii.hexlify(cid).decode("ascii")
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
+ destination_cid_seq: Optional[int] = None
+ for connection_id in self._host_cids:
+ if header.destination_cid == connection_id.cid:
+ destination_cid_seq = connection_id.sequence_number
+ break
+ if self.is_client and destination_cid_seq is None:
- if self.is_client and header.destination_cid != self.host_cid:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
<s>.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
and not self._stateless_retry_count
):
self._original_connection_id = self.peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self._stateless_retry_count += 1
self._logger.info("Performing stateless retry")
self._connect()
return
network_path = self._find_network_path(addr)
# server initialization
if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:
assert (
header.packet_type == PACKET_TYPE_INITIAL
), "first packet must be INITIAL"
self._network_paths = [network_path]
self._version = QuicProtocolVersion(header.version)
self._initialize(header.destination_cid)
# determine crypto and packet space
epoch = get_epoch(header.packet_type)
crypto = self.cryptos[epoch]
if epoch == tls.Epoch.ZERO_RTT:
space = self.spaces[tls.Epoch.ONE_RTT]
else:
space = self.spaces[epoch]
# decrypt packet
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not crypto.recv.is_valid():
continue
try:
plain_header, plain_payload, packet_number</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 2
<s>.decrypt_packet(
data[start_off:end_off], encrypted_off, space.expected_packet_number
)
except CryptoError as exc:
self._logger.warning(exc)
continue
if packet_number > space.expected_packet_number:
space.expected_packet_number = packet_number + 1
# discard initial keys
if not self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
# update state
if self._peer_cid_seq is None:
self.peer_cid = header.source_cid
self._peer_cid_seq = 0
if self.__state == QuicConnectionState.FIRSTFLIGHT:
self._set_state(QuicConnectionState.CONNECTED)
# update spin bit
if (
not is_long_header(plain_header[0])
and packet_number > self._spin_highest_pn
):
self._spin_bit_peer = get_spin_bit(plain_header[0])
if self.is_client:
self._spin_bit = not self._spin_bit_peer
else:
self._spin_bit = self._spin_bit_peer
self._spin_highest_pn = packet_number
# handle payload
context = QuicReceiveContext(
epoch=epoch, host_cid=header.destination_cid, network_path=network_path
)
self._logger.debug("[%s] handling packet %d", context, packet_number)
try:
is_ack_only, is_probing = self._payload_received(context, plain_payload)
except QuicConnectionError as exc</s>
|
aioquic.connection/QuicConnection._handle_new_connection_id_frame
|
Modified
|
aiortc~aioquic
|
8b8858627fa14ee0dd39bd66d37c62052ab40e43
|
[connection] respond to peer migrations
|
<7>:<add> "New connection ID received %d %s", sequence_number, dump_cid(cid)
<del> "New connection ID received %d %s",
<8>:<del> sequence_number,
<9>:<del> binascii.hexlify(cid).decode("ascii"),
|
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _handle_new_connection_id_frame(
self, context: QuicReceiveContext, frame_type: int, buf: Buffer
) -> None:
<0> """
<1> Handle a NEW_CONNECTION_ID frame.
<2> """
<3> sequence_number, cid, stateless_reset_token = packet.pull_new_connection_id_frame(
<4> buf
<5> )
<6> self._logger.info(
<7> "New connection ID received %d %s",
<8> sequence_number,
<9> binascii.hexlify(cid).decode("ascii"),
<10> )
<11> self._peer_cid_available.append(
<12> QuicConnectionId(
<13> cid=cid,
<14> sequence_number=sequence_number,
<15> stateless_reset_token=stateless_reset_token,
<16> )
<17> )
<18>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicReceiveContext(epoch: tls.Epoch, host_cid: bytes, network_path: QuicNetworkPath)
at: aioquic.connection.QuicConnection.__init__
self._logger = QuicConnectionAdapter(
logger, {"host_cid": dump_cid(self.host_cid)}
)
self._remote_max_streams_bidi = 0
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
at: logging.LoggerAdapter
logger: Logger
extra: Mapping[str, Any]
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def _consume_connection_id(self) -> None:
"""
Switch to the next available connection ID and retire
the previous one.
"""
if self._peer_cid_available:
# retire previous CID
self._retire_connection_ids.append(self._peer_cid_seq)
# assign new CID
connection_id = self._peer_cid_available.pop(0)
self._peer_cid_seq = connection_id.sequence_number
self.peer_cid = connection_id.cid
+ self._logger.info(
+ "Migrating to %s (%d)", dump_cid(self.peer_cid), self._peer_cid_seq
+ )
===========changed ref 1===========
# module: aioquic.connection
+ def dump_cid(cid: bytes) -> str:
+ return binascii.hexlify(cid).decode("ascii")
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
"""
Handle an incoming datagram.
"""
# stop handling packets when closing
if self.__state in [QuicConnectionState.CLOSING, QuicConnectionState.DRAINING]:
return
data = cast(bytes, data)
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
# check destination CID matches
+ destination_cid_seq: Optional[int] = None
+ for connection_id in self._host_cids:
+ if header.destination_cid == connection_id.cid:
+ destination_cid_seq = connection_id.sequence_number
+ break
+ if self.is_client and destination_cid_seq is None:
- if self.is_client and header.destination_cid != self.host_cid:
return
# check protocol version
if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
versions = []
while not buf.eof():
versions.append(pull_uint32(buf))
common = set(self.supported_versions).intersection(versions)
if not common:
self._logger.error("Could not find a common protocol version")
return
self._version = QuicProtocolVersion(max(common))
self._version_negotiation_count += 1
self._logger.info("Retrying with %s", self._version)
self._connect()
return
elif (
header.version is not None
and header.version not in self.supported_versions
):
# unsupported version
return
if self.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 1
<s>.is_client and header.packet_type == PACKET_TYPE_RETRY:
# stateless retry
if (
header.destination_cid == self.host_cid
and header.original_destination_cid == self.peer_cid
and not self._stateless_retry_count
):
self._original_connection_id = self.peer_cid
self.peer_cid = header.source_cid
self.peer_token = header.token
self._stateless_retry_count += 1
self._logger.info("Performing stateless retry")
self._connect()
return
network_path = self._find_network_path(addr)
# server initialization
if not self.is_client and self.__state == QuicConnectionState.FIRSTFLIGHT:
assert (
header.packet_type == PACKET_TYPE_INITIAL
), "first packet must be INITIAL"
self._network_paths = [network_path]
self._version = QuicProtocolVersion(header.version)
self._initialize(header.destination_cid)
# determine crypto and packet space
epoch = get_epoch(header.packet_type)
crypto = self.cryptos[epoch]
if epoch == tls.Epoch.ZERO_RTT:
space = self.spaces[tls.Epoch.ONE_RTT]
else:
space = self.spaces[epoch]
# decrypt packet
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not crypto.recv.is_valid():
continue
try:
plain_header, plain_payload, packet_number</s>
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection(asyncio.DatagramProtocol):
def datagram_received(self, data: Union[bytes, Text], addr: NetworkAddress) -> None:
# offset: 2
<s>.decrypt_packet(
data[start_off:end_off], encrypted_off, space.expected_packet_number
)
except CryptoError as exc:
self._logger.warning(exc)
continue
if packet_number > space.expected_packet_number:
space.expected_packet_number = packet_number + 1
# discard initial keys
if not self.is_client and epoch == tls.Epoch.HANDSHAKE:
self.cryptos[tls.Epoch.INITIAL].teardown()
# update state
if self._peer_cid_seq is None:
self.peer_cid = header.source_cid
self._peer_cid_seq = 0
if self.__state == QuicConnectionState.FIRSTFLIGHT:
self._set_state(QuicConnectionState.CONNECTED)
# update spin bit
if (
not is_long_header(plain_header[0])
and packet_number > self._spin_highest_pn
):
self._spin_bit_peer = get_spin_bit(plain_header[0])
if self.is_client:
self._spin_bit = not self._spin_bit_peer
else:
self._spin_bit = self._spin_bit_peer
self._spin_highest_pn = packet_number
# handle payload
context = QuicReceiveContext(
epoch=epoch, host_cid=header.destination_cid, network_path=network_path
)
self._logger.debug("[%s] handling packet %d", context, packet_number)
try:
is_ack_only, is_probing = self._payload_received(context, plain_payload)
except QuicConnectionError as exc</s>
|
aioquic.tls/Context._client_handle_certificate_verify
|
Modified
|
aiortc~aioquic
|
677b31fdb890dc9de8bfe4114e262a24d788913f
|
[tls] raise AlertDecryptError where appropriate
|
<5>:<add> try:
<add> self._peer_certificate.public_key().verify(
<del> self._peer_certificate.public_key().verify(
<6>:<add> verify.signature,
<del> verify.signature,
<7>:<add> self.key_schedule.certificate_verify_data(
<del> self.key_schedule.certificate_verify_data(
<8>:<add> b"TLS 1.3, server CertificateVerify"
<del> b"TLS 1.3, server CertificateVerify"
<9>:<add> ),
<del> ),
<10>:<add> *signature_algorithm_params(verify.algorithm),
<del> *signature_algorithm_params(verify.algorithm),
<11>:<add> )
<del> )
<12>:<add> except InvalidSignature:
<add> raise AlertDecryptError
|
# module: aioquic.tls
class Context:
def _client_handle_certificate_verify(self, input_buf: Buffer) -> None:
<0> verify = pull_certificate_verify(input_buf)
<1>
<2> assert verify.algorithm in self._signature_algorithms
<3>
<4> # check signature
<5> self._peer_certificate.public_key().verify(
<6> verify.signature,
<7> self.key_schedule.certificate_verify_data(
<8> b"TLS 1.3, server CertificateVerify"
<9> ),
<10> *signature_algorithm_params(verify.algorithm),
<11> )
<12>
<13> self.key_schedule.update_hash(input_buf.data)
<14>
<15> self._set_state(State.CLIENT_EXPECT_FINISHED)
<16>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
State()
pull_certificate_verify(buf: Buffer) -> CertificateVerify
at: aioquic.tls.CertificateVerify
algorithm: SignatureAlgorithm
signature: bytes
at: aioquic.tls.Context
_set_state(state: State) -> None
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self._signature_algorithms = [
SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
SignatureAlgorithm.ECDSA_SECP256R1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._peer_certificate: Optional[x509.Certificate] = None
at: aioquic.tls.Context._client_handle_certificate
self._peer_certificate = x509.load_der_x509_certificate(
certificate.certificates[0][0], backend=default_backend()
)
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_psk
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.KeySchedule
certificate_verify_data(context_string: bytes) -> bytes
update_hash(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.tls
+ class AlertDecryptError(Alert):
+ description = AlertDescription.decrypt_error
+
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.