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.stream/QuicStream.push_data
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<5>:<add> if self._connection is not None:
<add> self._connection._send_pending()
|
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
<0> """
<1> Push data to send.
<2> """
<3> if data:
<4> self._send_buffer += data
<5>
|
===========unchanged ref 0===========
at: aioquic.stream.QuicStream.__init__
self._recv_buffer = bytearray()
self._recv_start = 0
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
at: aioquic.stream.QuicStream.pull_data
r = self._recv_ranges.shift()
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<36>:<add> self.__connected = asyncio.Event()
<38>:<add> self.__transport = None
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client=True,
certificate=None,
private_key=None,
secrets_log_file=None,
alpn_protocols=None,
server_name=None,
):
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams = {}
<15>
<16> # protocol versions
<17> self.supported_versions = [
<18> QuicProtocolVersion.DRAFT_17,
<19> QuicProtocolVersion.DRAFT_18,
<20> QuicProtocolVersion.DRAFT_19,
<21> QuicProtocolVersion.DRAFT_20,
<22> ]
<23> self.version = QuicProtocolVersion.DRAFT_20
<24>
<25> self.quic_transport_parameters = QuicTransportParameters(
<26> idle_timeout=600,
<27> initial_max_data=16777216,
<28> initial_max_stream_data_bidi_local=1048576,
<29> initial_max_stream_data_bidi_remote=1048576,
<30> initial_max_stream_data_uni=1048576,
<31> initial_max_streams_bidi=100,
<32> ack_delay_exponent=10,
<33> )
<34>
<35> self.__close = None
<36> self.__initialized = False
<37> self.__logger = logger
<38>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicTransportParameters(initial_version: int=None, negotiated_version: int=None, supported_versions: List[int]=field(default_factory=list), original_connection_id: bytes=None, idle_timeout: int=None, stateless_reset_token: bytes=None, max_packet_size: int=None, initial_max_data: int=None, initial_max_stream_data_bidi_local: int=None, initial_max_stream_data_bidi_remote: int=None, initial_max_stream_data_uni: int=None, initial_max_streams_bidi: int=None, initial_max_streams_uni: int=None, ack_delay_exponent: int=None, max_ack_delay: int=None, disable_migration: bool=False, preferred_address: bytes=None)
at: aioquic.packet.QuicTransportParameters
initial_version: int = None
negotiated_version: int = None
supported_versions: List[int] = field(default_factory=list)
original_connection_id: bytes = None
idle_timeout: int = None
stateless_reset_token: bytes = None
max_packet_size: int = None
initial_max_data: int = None
initial_max_stream_data_bidi_local: int = None
initial_max_stream_data_bidi_remote: int = None
initial_max_stream_data_uni: int = None
initial_max_streams_bidi: int = None
===========unchanged ref 1===========
initial_max_streams_uni: int = None
ack_delay_exponent: int = None
max_ack_delay: int = None
disable_migration: bool = False
preferred_address: bytes = None
at: os
urandom(size: int, /) -> bytes
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection.close
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<0>:<add> """
<add> Close the connection.
<add> """
<5>:<add> self._send_pending()
|
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
<0> self.__close = {
<1> "error_code": error_code,
<2> "frame_type": frame_type,
<3> "reason_phrase": reason_phrase,
<4> }
<5>
|
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client=True,
certificate=None,
private_key=None,
secrets_log_file=None,
alpn_protocols=None,
server_name=None,
):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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 = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
self.__close = None
+ self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport = None
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection.connection_made
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<1>:<add> Inform the connection of the transport used to send data. This object
<add> must have a ``sendto`` method which accepts a datagram to send.
<add>
<add> Calling :meth:`connection_made` on a client starts the TLS handshake.
<del> At startup the client initiates the crypto handshake.
<3>:<add> self.__transport = transport
<8>:<add> self._send_pending()
|
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
<0> """
<1> At startup the client initiates the crypto handshake.
<2> """
<3> if self.is_client:
<4> self._initialize(self.peer_cid)
<5>
<6> self.tls.handle_message(b"", self.send_buffer)
<7> self._push_crypto_data()
<8>
|
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._pending_datagrams
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.connection_made
self.__transport = transport
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client=True,
certificate=None,
private_key=None,
secrets_log_file=None,
alpn_protocols=None,
server_name=None,
):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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 = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
self.__close = None
+ self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport = None
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection.create_stream
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<1>:<add> Create a :class:`QuicStream` and return it.
<del> Create a stream and return it.
<6>:<del> self.streams[stream_id] = QuicStream(stream_id=stream_id)
<7>:<add> return self._get_or_create_stream(stream_id)
<del> return self.streams[stream_id]
|
# module: aioquic.connection
class QuicConnection:
def create_stream(self, is_unidirectional=False):
<0> """
<1> Create a stream and return it.
<2> """
<3> stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
<4> while stream_id in self.streams:
<5> stream_id += 4
<6> self.streams[stream_id] = QuicStream(stream_id=stream_id)
<7> return self.streams[stream_id]
<8>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_send_pending()
at: aioquic.connection.QuicConnection.__init__
self.__close = None
at: aioquic.connection.QuicConnection._pending_datagrams
self.__close = None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client=True,
certificate=None,
private_key=None,
secrets_log_file=None,
alpn_protocols=None,
server_name=None,
):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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 = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
self.__close = None
+ self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport = None
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection.datagram_received
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<20>:<add> self.connection_made(self.__transport)
<del> self.connection_made()
<31>:<add> self.connection_made(self.__transport)
<del> self.connection_made()
|
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
<0> """
<1> Handle an incoming datagram.
<2> """
<3> buf = Buffer(data=data)
<4>
<5> while not buf.eof():
<6> start_off = buf.tell()
<7> header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
<8>
<9> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
<10> # version negotiation
<11> versions = []
<12> while not buf.eof():
<13> versions.append(pull_uint32(buf))
<14> common = set(self.supported_versions).intersection(versions)
<15> if not common:
<16> self.__logger.error("Could not find a common protocol version")
<17> return
<18> self.version = QuicProtocolVersion(max(common))
<19> self.__logger.info("Retrying with %s" % self.version)
<20> self.connection_made()
<21> return
<22> elif self.is_client and header.packet_type == PACKET_TYPE_RETRY:
<23> # stateless retry
<24> if (
<25> header.destination_cid == self.host_cid
<26> and header.original_destination_cid == self.peer_cid
<27> ):
<28> self.__logger.info("Performing stateless retry")
<29> self.peer_cid = header.source_cid
<30> self.peer_token = header.token
<31> self.connection_made()
<32> return
<33>
<34> encrypted_off = buf.tell() - start_off
<35> end_off = buf.tell() + header.rest_length
<36> pull_bytes(buf, header.rest_length)
<37>
<38> if not self.is_client and not self.__initialized:
<39> self._initialize(header.destination_cid)
<40>
<41> epoch = get_epoch(header.packet_type)
<42> space</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
# offset: 1
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
is_ack_only = self._payload_received(epoch, plain_payload)
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_get_or_create_stream(stream_id)
_initialize(peer_cid)
_push_crypto_data()
_send_pending()
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 = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__connected = asyncio.Event()
self.__logger = logger
self.__transport = None
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.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: aioquic.tls.Context
handle_message(input_data, output_buf)
at: asyncio.locks.Event
wait() -> bool
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self):
+ """
+ Wait for the TLS handshake to complete.
+ """
+ return await self.__connected.wait()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def create_stream(self, is_unidirectional=False):
"""
+ Create a :class:`QuicStream` and return it.
- Create a stream and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
+ return self._get_or_create_stream(stream_id)
- return self.streams[stream_id]
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client=True,
certificate=None,
private_key=None,
secrets_log_file=None,
alpn_protocols=None,
server_name=None,
):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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 = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
self.__close = None
+ self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport = None
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
aioquic.connection/QuicConnection._get_or_create_stream
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<1>:<add> self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
<del> self.streams[stream_id] = QuicStream(stream_id=stream_id)
|
# module: aioquic.connection
class QuicConnection:
def _get_or_create_stream(self, stream_id):
<0> if stream_id not in self.streams:
<1> self.streams[stream_id] = QuicStream(stream_id=stream_id)
<2> return self.streams[stream_id]
<3>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.peer_cid_set = False
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid_set = True
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self):
+ """
+ Wait for the TLS handshake to complete.
+ """
+ return await self.__connected.wait()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
- def pending_datagrams(self):
- """
- Retrieve outgoing datagrams.
- """
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application()
-
- if self.__close is not None:
- yield from self._write_close(tls.Epoch.ONE_RTT, **self.__close)
- self.__close = None
-
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def create_stream(self, is_unidirectional=False):
"""
+ Create a :class:`QuicStream` and return it.
- Create a stream and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
+ return self._get_or_create_stream(stream_id)
- return self.streams[stream_id]
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client=True,
certificate=None,
private_key=None,
secrets_log_file=None,
alpn_protocols=None,
server_name=None,
):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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 = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
self.__close = None
+ self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport = None
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
"""
Handle an incoming datagram.
"""
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
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.__logger.info("Retrying with %s" % self.version)
+ self.connection_made(self.__transport)
- self.connection_made()
return
elif 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
):
self.__logger.info("Performing stateless retry")
self.peer_cid = header.source_cid
self.peer_token = header.token
+ self.connection_made(self.__transport)
- self.connection_made()
return
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not self.is_client and not self.__initialized:
self._initialize(header.destination_cid)
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
</s>
===========changed ref 7===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
# offset: 1
<s>
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
is_ack_only = self._payload_received(epoch, plain_payload)
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<18>:<add> if not self.__connected.is_set() and self.tls.state in [
<add> tls.State.CLIENT_POST_HANDSHAKE,
<add> tls.State.SERVER_POST_HANDSHAKE,
<add> ]:
<add> self.__connected.set()
<add>
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> self.tls.handle_message(data, self.send_buffer)
<18> elif frame_type == QuicFrameType.NEW_TOKEN:
<19> packet.pull_new_token_frame(buf)
<20> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<21> flags = frame_type & STREAM_FLAGS
<22> stream_id = pull_uint_var(buf)
<23> if flags & STREAM_FLAG_OFF:
<24> offset = pull_uint_var(buf)
<25> else:
<26> offset = 0
<27> if flags & STREAM_FLAG_LEN:
<28> length = pull_uint_var(buf)
<29> else:
<30> length = buf.capacity - buf.tell()
<31> frame = QuicStreamFrame(offset=offset, data=pull_bytes(buf, length))
<32> stream = self._get_or_create_stream(stream_id)
<33> stream.add_frame(frame)
<34> elif frame_type == QuicFrameType.MAX_DATA:
<35> pull_uint_var(buf)
<36> elif frame_type in [
<37> QuicFrameType.MAX_STREAMS_BIDI,
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
# offset: 1
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams = {}
self.__connected = asyncio.Event()
self.__initialized = False
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.tls.Context
handle_message(input_data, output_buf)
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _get_or_create_stream(self, stream_id):
if stream_id not in self.streams:
+ self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
return self.streams[stream_id]
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self):
+ """
+ Wait for the TLS handshake to complete.
+ """
+ return await self.__connected.wait()
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
- def pending_datagrams(self):
- """
- Retrieve outgoing datagrams.
- """
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application()
-
- if self.__close is not None:
- yield from self._write_close(tls.Epoch.ONE_RTT, **self.__close)
- self.__close = None
-
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def create_stream(self, is_unidirectional=False):
"""
+ Create a :class:`QuicStream` and return it.
- Create a stream and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
+ return self._get_or_create_stream(stream_id)
- return self.streams[stream_id]
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client=True,
certificate=None,
private_key=None,
secrets_log_file=None,
alpn_protocols=None,
server_name=None,
):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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 = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
self.__close = None
+ self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport = None
|
examples.client/run
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<7>:<add> lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port)
<del> lambda: QuicProtocol(**kwargs), remote_addr=(host, port)
<9>:<add> await protocol.connect()
<10>:<add> stream = protocol.create_stream()
<del> stream = protocol._connection.create_stream()
<12>:<del> protocol._send_pending()
|
# module: examples.client
def run(host, port, **kwargs):
<0> # if host is not an IP address, pass it to enable SNI
<1> try:
<2> ipaddress.ip_address(host)
<3> except ValueError:
<4> kwargs["server_name"] = host
<5>
<6> _, protocol = await loop.create_datagram_endpoint(
<7> lambda: QuicProtocol(**kwargs), remote_addr=(host, port)
<8> )
<9>
<10> stream = protocol._connection.create_stream()
<11> stream.push_data(b"GET /\r\n")
<12> protocol._send_pending()
<13>
<14> await asyncio.sleep(1)
<15>
<16> print(stream.pull_data())
<17>
|
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: argparse
ArgumentParser(prog: Optional[str]=..., usage: Optional[str]=..., description: Optional[str]=..., epilog: Optional[str]=..., parents: Sequence[ArgumentParser]=..., formatter_class: _FormatterClass=..., prefix_chars: str=..., fromfile_prefix_chars: Optional[str]=..., argument_default: Any=..., conflict_handler: str=..., add_help: bool=..., allow_abbrev: bool=...)
at: argparse.ArgumentParser
parse_args(args: Optional[Sequence[Text]], namespace: None) -> Namespace
parse_args(args: Optional[Sequence[Text]]=...) -> Namespace
parse_args(*, namespace: None) -> Namespace
parse_args(args: Optional[Sequence[Text]], namespace: _N) -> _N
parse_args(*, namespace: _N) -> _N
at: argparse._ActionsContainer
add_argument(*name_or_flags: Text, action: Union[Text, Type[Action]]=..., nargs: Union[int, Text]=..., const: Any=..., default: Any=..., type: Union[Callable[[Text], _T], Callable[[str], _T], FileType]=..., choices: Iterable[_T]=..., required: bool=..., help: Optional[Text]=..., metavar: Optional[Union[Text, Tuple[Text, ...]]]=..., dest: Optional[Text]=..., version: Text=..., **kwargs: Any) -> Action
at: asyncio.events
get_event_loop() -> AbstractEventLoop
at: asyncio.events.AbstractEventLoop
run_until_complete(future: Generator[Any, None, _T]) -> _T
run_until_complete(future: Awaitable[_T]) -> _T
at: examples.client
run(host, port, *, certificate=None, private_key=None, server_name=None)
at: logging
INFO = 20
===========unchanged ref 1===========
basicConfig(*, filename: Optional[StrPath]=..., filemode: str=..., format: str=..., datefmt: Optional[str]=..., style: str=..., level: Optional[_Level]=..., stream: Optional[IO[str]]=..., handlers: Optional[Iterable[Handler]]=...) -> None
===========changed ref 0===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def datagram_received(self, datagram, addr):
- self._connection.datagram_received(datagram)
- self._send_pending()
-
===========changed ref 1===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def _send_pending(self):
- for datagram in self._connection.pending_datagrams():
- self._transport.sendto(datagram)
-
===========changed ref 2===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def __init__(self, **kwargs):
- self._connection = QuicConnection(**kwargs)
- self._transport = None
-
===========changed ref 3===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
- self._connection.connection_made()
- self._send_pending()
-
===========changed ref 4===========
# module: tests.utils
+ def run(coro):
+ return asyncio.get_event_loop().run_until_complete(coro)
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
+ def _send_pending(self):
+ for datagram in self._pending_datagrams():
+ self.__transport.sendto(datagram)
+
===========changed ref 6===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self):
+ """
+ Wait for the TLS handshake to complete.
+ """
+ return await self.__connected.wait()
+
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 9===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 10===========
# module: aioquic.connection
class QuicConnection:
def _get_or_create_stream(self, stream_id):
if stream_id not in self.streams:
+ self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
return self.streams[stream_id]
===========changed ref 11===========
# module: aioquic.connection
class QuicConnection:
+ def _pending_datagrams(self):
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
+ yield from self._write_handshake(epoch)
+
+ yield from self._write_application()
+
+ if self.__close is not None:
+ close = self.__close
+ self.__close = None
+ yield from self._write_close(tls.Epoch.ONE_RTT, **close)
+
===========changed ref 12===========
# module: aioquic.connection
class QuicConnection:
- def pending_datagrams(self):
- """
- Retrieve outgoing datagrams.
- """
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application()
-
- if self.__close is not None:
- yield from self._write_close(tls.Epoch.ONE_RTT, **self.__close)
- self.__close = None
-
===========changed ref 13===========
# module: aioquic.connection
class QuicConnection:
def create_stream(self, is_unidirectional=False):
"""
+ Create a :class:`QuicStream` and return it.
- Create a stream and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
+ return self._get_or_create_stream(stream_id)
- return self.streams[stream_id]
===========changed ref 14===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
|
examples.server/run
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<7>:<add> lambda: QuicServerProtocol(**kwargs), local_addr=(host, port)
<del> lambda: QuicProtocol(**kwargs), local_addr=(host, port)
|
# module: examples.server
def run(host, port, **kwargs):
<0> # if host is not an IP address, pass it to enable SNI
<1> try:
<2> ipaddress.ip_address(host)
<3> except ValueError:
<4> kwargs["server_name"] = host
<5>
<6> _, protocol = await loop.create_datagram_endpoint(
<7> lambda: QuicProtocol(**kwargs), local_addr=(host, port)
<8> )
<9> return protocol
<10>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
connection_made(transport)
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
at: examples.server
QuicConnectionTransport(protocol, addr)
at: examples.server.QuicServerProtocol.__init__
self._connections = {}
self._kwargs = kwargs
at: ipaddress
ip_address(address: object) -> Any
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 1===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def connection_made(self, transport):
+ self._transport = transport
+
===========changed ref 2===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
-
===========changed ref 3===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def __init__(self, **kwargs):
+ self._connections = {}
+ self._kwargs = kwargs
+ self._transport = None
+
===========changed ref 4===========
# module: examples.server
+ class QuicConnectionTransport:
+ def __init__(self, protocol, addr):
+ self.__addr = addr
+ self.__protocol = protocol
+
===========changed ref 5===========
# module: examples.server
+ class QuicConnectionTransport:
+ def sendto(self, datagram):
+ self.__protocol._transport.sendto(datagram, self.__addr)
+
===========changed ref 6===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def __init__(self, **kwargs):
- self._connections = {}
- self._kwargs = kwargs
- self._kwargs["is_client"] = False
- self._transport = None
-
===========changed ref 7===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def datagram_received(self, datagram, addr):
+ buf = Buffer(data=datagram)
+ header = pull_quic_header(buf, host_cid_length=8)
+ connection = self._connections.get(header.destination_cid, None)
+ if connection is None:
+ connection = QuicConnection(is_client=False, **self._kwargs)
+ connection.connection_made(QuicConnectionTransport(self, addr))
+ self._connections[connection.host_cid] = connection
+ connection.datagram_received(datagram)
+
===========changed ref 8===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def datagram_received(self, datagram, addr):
- buf = Buffer(data=datagram)
- header = pull_quic_header(buf, host_cid_length=8)
- connection = self._connections.get(header.destination_cid, None)
- if connection is None:
- connection = QuicConnection(**self._kwargs)
- self._connections[connection.host_cid] = connection
- connection.datagram_received(datagram)
- for datagram in connection.pending_datagrams():
- self._transport.sendto(datagram, addr)
-
===========changed ref 9===========
# module: tests.utils
+ def run(coro):
+ return asyncio.get_event_loop().run_until_complete(coro)
+
===========changed ref 10===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def __init__(self, **kwargs):
- self._connection = QuicConnection(**kwargs)
- self._transport = None
-
===========changed ref 11===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def datagram_received(self, datagram, addr):
- self._connection.datagram_received(datagram)
- self._send_pending()
-
===========changed ref 12===========
# module: aioquic.connection
class QuicConnection:
+ def _send_pending(self):
+ for datagram in self._pending_datagrams():
+ self.__transport.sendto(datagram)
+
===========changed ref 13===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self):
+ """
+ Wait for the TLS handshake to complete.
+ """
+ return await self.__connected.wait()
+
===========changed ref 14===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
- self._connection.connection_made()
- self._send_pending()
-
===========changed ref 15===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def _send_pending(self):
- for datagram in self._connection.pending_datagrams():
- self._transport.sendto(datagram)
-
===========changed ref 16===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 17===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 18===========
# module: aioquic.stream
class QuicStream:
+ def __init__(self, stream_id=None, connection=None):
- def __init__(self, stream_id=None):
+ self._connection = connection
+
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 19===========
# module: aioquic.connection
class QuicConnection:
def _get_or_create_stream(self, stream_id):
if stream_id not in self.streams:
+ self.streams[stream_id] = QuicStream(connection=self, stream_id=stream_id)
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
return self.streams[stream_id]
===========changed ref 20===========
# module: aioquic.connection
class QuicConnection:
+ def _pending_datagrams(self):
+ for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
+ yield from self._write_handshake(epoch)
+
+ yield from self._write_application()
+
+ if self.__close is not None:
+ close = self.__close
+ self.__close = None
+ yield from self._write_close(tls.Epoch.ONE_RTT, **close)
+
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<13>:<add> client_transport, server_transport = create_transport(client, server)
<add> self.assertEqual(client_transport.sent, 4)
<add> self.assertEqual(server_transport.sent, 3)
<add> run(client.connect())
<del> client.connection_made()
<14>:<del> self.assertEqual(exchange_data(client, server), 2)
<19>:<add> self.assertEqual(client_transport.sent, 5)
<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(exchange_data(client, server), 1)
|
# 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> client.version = max(client_versions)
<3>
<4> server = QuicConnection(
<5> is_client=False,
<6> certificate=SERVER_CERTIFICATE,
<7> private_key=SERVER_PRIVATE_KEY,
<8> )
<9> server.supported_versions = server_versions
<10> server.version = max(server_versions)
<11>
<12> # perform handshake
<13> client.connection_made()
<14> self.assertEqual(exchange_data(client, server), 2)
<15>
<16> # send data over stream
<17> client_stream = client.create_stream()
<18> client_stream.push_data(b"ping")
<19> self.assertEqual(exchange_data(client, server), 1)
<20>
<21> server_stream = server.streams[0]
<22> self.assertEqual(server_stream.pull_data(), b"ping")
<23>
<24> return client, server
<25>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
connection_made()
create_stream(is_unidirectional=False)
at: aioquic.connection.QuicConnection.__init__
self.streams = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: tests.test_connection
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()
)
exchange_data(client, server)
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 exchange_data(client, server):
- rounds = 0
-
- while True:
- client_sent = False
- for datagram in client.pending_datagrams():
- server.datagram_received(datagram)
- client_sent = True
-
- server_sent = False
- for datagram in server.pending_datagrams():
- client.datagram_received(datagram)
- server_sent = True
-
- if client_sent or server_sent:
- rounds += 1
- else:
- break
-
- return rounds
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def create_stream(self, is_unidirectional=False):
"""
+ Create a :class:`QuicStream` and return it.
- Create a stream and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
- self.streams[stream_id] = QuicStream(stream_id=stream_id)
+ return self._get_or_create_stream(stream_id)
- return self.streams[stream_id]
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 3===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 4===========
# module: tests.test_connection
+ class FakeTransport:
+ def sendto(self, data):
+ self.sent += 1
+ if self.target is not None:
+ self.target.datagram_received(data)
+
===========changed ref 5===========
# module: tests.test_connection
+ def create_transport(client, server):
+ client_transport = FakeTransport()
+ client_transport.target = server
+
+ server_transport = FakeTransport()
+ server_transport.target = client
+
+ server.connection_made(server_transport)
+ client.connection_made(client_transport)
+
+ return client_transport, server_transport
+
===========changed ref 6===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def connection_made(self, transport):
+ self._transport = transport
+
===========changed ref 7===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
-
===========changed ref 8===========
# module: examples.server
+ class QuicConnectionTransport:
+ def __init__(self, protocol, addr):
+ self.__addr = addr
+ self.__protocol = protocol
+
===========changed ref 9===========
# module: examples.server
+ class QuicConnectionTransport:
+ def sendto(self, datagram):
+ self.__protocol._transport.sendto(datagram, self.__addr)
+
===========changed ref 10===========
# module: tests.utils
+ def run(coro):
+ return asyncio.get_event_loop().run_until_complete(coro)
+
===========changed ref 11===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def __init__(self, **kwargs):
+ self._connections = {}
+ self._kwargs = kwargs
+ self._transport = None
+
===========changed ref 12===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def __init__(self, **kwargs):
- self._connection = QuicConnection(**kwargs)
- self._transport = None
-
===========changed ref 13===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def datagram_received(self, datagram, addr):
- self._connection.datagram_received(datagram)
- self._send_pending()
-
===========changed ref 14===========
# module: aioquic.connection
class QuicConnection:
+ def _send_pending(self):
+ for datagram in self._pending_datagrams():
+ self.__transport.sendto(datagram)
+
===========changed ref 15===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self):
+ """
+ Wait for the TLS handshake to complete.
+ """
+ return await self.__connected.wait()
+
===========changed ref 16===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
- self._connection.connection_made()
- self._send_pending()
-
===========changed ref 17===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def _send_pending(self):
- for datagram in self._connection.pending_datagrams():
- self._transport.sendto(datagram)
-
===========changed ref 18===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def __init__(self, **kwargs):
- self._connections = {}
- self._kwargs = kwargs
- self._kwargs["is_client"] = False
- self._transport = None
-
===========changed ref 19===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
===========changed ref 20===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
|
tests.test_connection/QuicConnectionTest.test_connect_with_log
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<11>:<add> client_transport, server_transport = create_transport(client, server)
<add> self.assertEqual(client_transport.sent, 4)
<add> self.assertEqual(server_transport.sent, 3)
<del> client.connection_made()
<12>:<del> self.assertEqual(exchange_data(client, server), 2)
|
# 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.connection_made()
<12> self.assertEqual(exchange_data(client, server), 2)
<13>
<14> # check secrets were logged
<15> client_log = client_log_file.getvalue()
<16> server_log = server_log_file.getvalue()
<17> self.assertEqual(client_log, server_log)
<18> labels = []
<19> for line in client_log.splitlines():
<20> labels.append(line.split()[0])
<21> self.assertEqual(
<22> labels,
<23> [
<24> "QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET",
<25> "QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET",
<26> "QUIC_SERVER_TRAFFIC_SECRET_0",
<27> "QUIC_CLIENT_TRAFFIC_SECRET_0",
<28> ],
<29> )
<30>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
connection_made()
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
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()
)
exchange_data(client, server)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
- def exchange_data(client, server):
- rounds = 0
-
- while True:
- client_sent = False
- for datagram in client.pending_datagrams():
- server.datagram_received(datagram)
- client_sent = True
-
- server_sent = False
- for datagram in server.pending_datagrams():
- client.datagram_received(datagram)
- server_sent = True
-
- if client_sent or server_sent:
- rounds += 1
- else:
- break
-
- return rounds
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 2===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 3===========
# module: tests.test_connection
+ class FakeTransport:
+ def sendto(self, data):
+ self.sent += 1
+ if self.target is not None:
+ self.target.datagram_received(data)
+
===========changed ref 4===========
# module: tests.test_connection
+ def create_transport(client, server):
+ client_transport = FakeTransport()
+ client_transport.target = server
+
+ server_transport = FakeTransport()
+ server_transport.target = client
+
+ server.connection_made(server_transport)
+ client.connection_made(client_transport)
+
+ return client_transport, server_transport
+
===========changed ref 5===========
# 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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
+ client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
+ run(client.connect())
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# send data over stream
client_stream = client.create_stream()
client_stream.push_data(b"ping")
+ self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 1)
server_stream = server.streams[0]
self.assertEqual(server_stream.pull_data(), b"ping")
return client, server
===========changed ref 6===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def connection_made(self, transport):
+ self._transport = transport
+
===========changed ref 7===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
-
===========changed ref 8===========
# module: examples.server
+ class QuicConnectionTransport:
+ def __init__(self, protocol, addr):
+ self.__addr = addr
+ self.__protocol = protocol
+
===========changed ref 9===========
# module: examples.server
+ class QuicConnectionTransport:
+ def sendto(self, datagram):
+ self.__protocol._transport.sendto(datagram, self.__addr)
+
===========changed ref 10===========
# module: tests.utils
+ def run(coro):
+ return asyncio.get_event_loop().run_until_complete(coro)
+
===========changed ref 11===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def __init__(self, **kwargs):
+ self._connections = {}
+ self._kwargs = kwargs
+ self._transport = None
+
===========changed ref 12===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def __init__(self, **kwargs):
- self._connection = QuicConnection(**kwargs)
- self._transport = None
-
===========changed ref 13===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def datagram_received(self, datagram, addr):
- self._connection.datagram_received(datagram)
- self._send_pending()
-
===========changed ref 14===========
# module: aioquic.connection
class QuicConnection:
+ def _send_pending(self):
+ for datagram in self._pending_datagrams():
+ self.__transport.sendto(datagram)
+
===========changed ref 15===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self):
+ """
+ Wait for the TLS handshake to complete.
+ """
+ return await self.__connected.wait()
+
===========changed ref 16===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
- self._connection.connection_made()
- self._send_pending()
-
===========changed ref 17===========
# module: examples.client
- class QuicProtocol(asyncio.DatagramProtocol):
- def _send_pending(self):
- for datagram in self._connection.pending_datagrams():
- self._transport.sendto(datagram)
-
===========changed ref 18===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def __init__(self, **kwargs):
- self._connections = {}
- self._kwargs = kwargs
- self._kwargs["is_client"] = False
- self._transport = None
-
===========changed ref 19===========
# module: aioquic.stream
class QuicStream:
def push_data(self, data):
"""
Push data to send.
"""
if data:
self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<9>:<add> client_transport, server_transport = create_transport(client, server)
<add> self.assertEqual(client_transport.sent, 4)
<add> self.assertEqual(server_transport.sent, 3)
<del> client.connection_made()
<10>:<del> self.assertEqual(exchange_data(client, server), 2)
<19>:<add> self.assertEqual(client_transport.sent, 4)
<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(exchange_data(client, server), 1)
|
# 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.connection_made()
<10> self.assertEqual(exchange_data(client, server), 2)
<11>
<12> # mess with encryption key
<13> server.spaces[tls.Epoch.ONE_RTT].crypto.send.setup(
<14> tls.CipherSuite.AES_128_GCM_SHA256, bytes(48)
<15> )
<16>
<17> # close
<18> server.close(error_code=QuicErrorCode.NO_ERROR)
<19> self.assertEqual(exchange_data(client, server), 1)
<20>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
close(error_code, frame_type=None, reason_phrase=b"")
connection_made()
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
at: aioquic.crypto.CryptoContext
setup(cipher_suite, secret)
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
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()
)
exchange_data(client, server)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
- def exchange_data(client, server):
- rounds = 0
-
- while True:
- client_sent = False
- for datagram in client.pending_datagrams():
- server.datagram_received(datagram)
- client_sent = True
-
- server_sent = False
- for datagram in server.pending_datagrams():
- client.datagram_received(datagram)
- server_sent = True
-
- if client_sent or server_sent:
- rounds += 1
- else:
- break
-
- return rounds
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 3===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 4===========
# module: tests.test_connection
+ class FakeTransport:
+ def sendto(self, data):
+ self.sent += 1
+ if self.target is not None:
+ self.target.datagram_received(data)
+
===========changed ref 5===========
# module: tests.test_connection
+ def create_transport(client, server):
+ client_transport = FakeTransport()
+ client_transport.target = server
+
+ server_transport = FakeTransport()
+ server_transport.target = client
+
+ server.connection_made(server_transport)
+ client.connection_made(client_transport)
+
+ return client_transport, server_transport
+
===========changed ref 6===========
# 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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# 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 7===========
# 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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
+ client_transport, server_transport = create_transport(client, server)
+ self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 3)
+ run(client.connect())
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# send data over stream
client_stream = client.create_stream()
client_stream.push_data(b"ping")
+ self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 1)
server_stream = server.streams[0]
self.assertEqual(server_stream.pull_data(), b"ping")
return client, server
===========changed ref 8===========
# module: examples.server
+ class QuicServerProtocol(asyncio.DatagramProtocol):
+ def connection_made(self, transport):
+ self._transport = transport
+
===========changed ref 9===========
# module: examples.server
- class QuicProtocol(asyncio.DatagramProtocol):
- def connection_made(self, transport):
- self._transport = transport
-
|
tests.test_connection/QuicConnectionTest.test_retry
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<4>:<add> client_transport = FakeTransport()
<del> datagrams = 0
<5>:<add> client.connection_made(client_transport)
<del> client.connection_made()
<6>:<del> for datagram in client.pending_datagrams():
<7>:<del> datagrams += 1
<8>:<add> self.assertEqual(client_transport.sent, 1)
<del> self.assertEqual(datagrams, 1)
<11>:<del> for datagram in client.pending_datagrams():
<12>:<del> datagrams += 1
<13>:<add> self.assertEqual(client_transport.sent, 2)
<del> self.assertEqual(datagrams, 2)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_retry(self):
<0> client = QuicConnection(is_client=True)
<1> client.host_cid = binascii.unhexlify("c98343fe8f5f0ff4")
<2> client.peer_cid = binascii.unhexlify("85abb547bf28be97")
<3>
<4> datagrams = 0
<5> client.connection_made()
<6> for datagram in client.pending_datagrams():
<7> datagrams += 1
<8> self.assertEqual(datagrams, 1)
<9>
<10> client.datagram_received(load("retry.bin"))
<11> for datagram in client.pending_datagrams():
<12> datagrams += 1
<13> self.assertEqual(datagrams, 2)
<14>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
connection_made()
datagram_received(data: bytes)
pending_datagrams()
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: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.utils
load(name)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
- def pending_datagrams(self):
- """
- Retrieve outgoing datagrams.
- """
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application()
-
- if self.__close is not None:
- yield from self._write_close(tls.Epoch.ONE_RTT, **self.__close)
- self.__close = None
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
"""
Handle an incoming datagram.
"""
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
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.__logger.info("Retrying with %s" % self.version)
+ self.connection_made(self.__transport)
- self.connection_made()
return
elif 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
):
self.__logger.info("Performing stateless retry")
self.peer_cid = header.source_cid
self.peer_token = header.token
+ self.connection_made(self.__transport)
- self.connection_made()
return
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not self.is_client and not self.__initialized:
self._initialize(header.destination_cid)
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
# offset: 1
<s>
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
is_ack_only = self._payload_received(epoch, plain_payload)
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
===========changed ref 4===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 5===========
# module: tests.test_connection
+ class FakeTransport:
+ def sendto(self, data):
+ self.sent += 1
+ if self.target is not None:
+ self.target.datagram_received(data)
+
===========changed ref 6===========
# module: tests.test_connection
+ def create_transport(client, server):
+ client_transport = FakeTransport()
+ client_transport.target = server
+
+ server_transport = FakeTransport()
+ server_transport.target = client
+
+ server.connection_made(server_transport)
+ client.connection_made(client_transport)
+
+ return client_transport, server_transport
+
===========changed ref 7===========
# 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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# mess with encryption key
server.spaces[tls.Epoch.ONE_RTT].crypto.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(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 1)
===========changed ref 8===========
# module: tests.test_connection
- def exchange_data(client, server):
- rounds = 0
-
- while True:
- client_sent = False
- for datagram in client.pending_datagrams():
- server.datagram_received(datagram)
- client_sent = True
-
- server_sent = False
- for datagram in server.pending_datagrams():
- client.datagram_received(datagram)
- server_sent = True
-
- if client_sent or server_sent:
- rounds += 1
- else:
- break
-
- return rounds
-
|
tests.test_connection/QuicConnectionTest.test_application_close
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<9>:<add> client_transport, server_transport = create_transport(client, server)
<add> self.assertEqual(client_transport.sent, 4)
<add> self.assertEqual(server_transport.sent, 3)
<del> client.connection_made()
<10>:<del> self.assertEqual(exchange_data(client, server), 2)
<14>:<add> self.assertEqual(client_transport.sent, 5)
<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(exchange_data(client, server), 2)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_application_close(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.connection_made()
<10> self.assertEqual(exchange_data(client, server), 2)
<11>
<12> # close
<13> server.close(error_code=QuicErrorCode.NO_ERROR)
<14> self.assertEqual(exchange_data(client, server), 2)
<15>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
close(error_code, frame_type=None, reason_phrase=b"")
connection_made()
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
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()
)
exchange_data(client, server)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
- def exchange_data(client, server):
- rounds = 0
-
- while True:
- client_sent = False
- for datagram in client.pending_datagrams():
- server.datagram_received(datagram)
- client_sent = True
-
- server_sent = False
- for datagram in server.pending_datagrams():
- client.datagram_received(datagram)
- server_sent = True
-
- if client_sent or server_sent:
- rounds += 1
- else:
- break
-
- return rounds
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 3===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 4===========
# module: tests.test_connection
+ class FakeTransport:
+ def sendto(self, data):
+ self.sent += 1
+ if self.target is not None:
+ self.target.datagram_received(data)
+
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_retry(self):
client = QuicConnection(is_client=True)
client.host_cid = binascii.unhexlify("c98343fe8f5f0ff4")
client.peer_cid = binascii.unhexlify("85abb547bf28be97")
+ client_transport = FakeTransport()
- datagrams = 0
+ client.connection_made(client_transport)
- client.connection_made()
- for datagram in client.pending_datagrams():
- datagrams += 1
+ self.assertEqual(client_transport.sent, 1)
- self.assertEqual(datagrams, 1)
client.datagram_received(load("retry.bin"))
- for datagram in client.pending_datagrams():
- datagrams += 1
+ self.assertEqual(client_transport.sent, 2)
- self.assertEqual(datagrams, 2)
===========changed ref 6===========
# module: tests.test_connection
+ def create_transport(client, server):
+ client_transport = FakeTransport()
+ client_transport.target = server
+
+ server_transport = FakeTransport()
+ server_transport.target = client
+
+ server.connection_made(server_transport)
+ client.connection_made(client_transport)
+
+ return client_transport, server_transport
+
===========changed ref 7===========
# 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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# mess with encryption key
server.spaces[tls.Epoch.ONE_RTT].crypto.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(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 1)
===========changed ref 8===========
# 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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# 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_transport_close
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<9>:<add> client_transport, server_transport = create_transport(client, server)
<add> self.assertEqual(client_transport.sent, 4)
<add> self.assertEqual(server_transport.sent, 3)
<del> client.connection_made()
<10>:<del> self.assertEqual(exchange_data(client, server), 2)
<16>:<add> self.assertEqual(client_transport.sent, 5)
<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(exchange_data(client, server), 2)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_transport_close(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.connection_made()
<10> self.assertEqual(exchange_data(client, server), 2)
<11>
<12> # close
<13> server.close(
<14> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<15> )
<16> self.assertEqual(exchange_data(client, server), 2)
<17>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
close(error_code, frame_type=None, reason_phrase=b"")
connection_made()
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
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()
)
exchange_data(client, server)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
- def exchange_data(client, server):
- rounds = 0
-
- while True:
- client_sent = False
- for datagram in client.pending_datagrams():
- server.datagram_received(datagram)
- client_sent = True
-
- server_sent = False
- for datagram in server.pending_datagrams():
- client.datagram_received(datagram)
- server_sent = True
-
- if client_sent or server_sent:
- rounds += 1
- else:
- break
-
- return rounds
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def close(self, error_code, frame_type=None, reason_phrase=b""):
+ """
+ Close the connection.
+ """
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 3===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_application_close(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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 2)
===========changed ref 5===========
# module: tests.test_connection
+ class FakeTransport:
+ def sendto(self, data):
+ self.sent += 1
+ if self.target is not None:
+ self.target.datagram_received(data)
+
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_retry(self):
client = QuicConnection(is_client=True)
client.host_cid = binascii.unhexlify("c98343fe8f5f0ff4")
client.peer_cid = binascii.unhexlify("85abb547bf28be97")
+ client_transport = FakeTransport()
- datagrams = 0
+ client.connection_made(client_transport)
- client.connection_made()
- for datagram in client.pending_datagrams():
- datagrams += 1
+ self.assertEqual(client_transport.sent, 1)
- self.assertEqual(datagrams, 1)
client.datagram_received(load("retry.bin"))
- for datagram in client.pending_datagrams():
- datagrams += 1
+ self.assertEqual(client_transport.sent, 2)
- self.assertEqual(datagrams, 2)
===========changed ref 7===========
# module: tests.test_connection
+ def create_transport(client, server):
+ client_transport = FakeTransport()
+ client_transport.target = server
+
+ server_transport = FakeTransport()
+ server_transport.target = client
+
+ server.connection_made(server_transport)
+ client.connection_made(client_transport)
+
+ return client_transport, server_transport
+
===========changed ref 8===========
# 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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# mess with encryption key
server.spaces[tls.Epoch.ONE_RTT].crypto.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(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 1)
|
tests.test_connection/QuicConnectionTest.test_version_negotiation_fail
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<3>:<add> client_transport = FakeTransport()
<del> datagrams = 0
<4>:<add> client.connection_made(client_transport)
<del> client.connection_made()
<5>:<del> for datagram in client.pending_datagrams():
<6>:<del> datagrams += 1
<7>:<add> self.assertEqual(client_transport.sent, 1)
<del> self.assertEqual(datagrams, 1)
<11>:<del> for datagram in client.pending_datagrams():
<12>:<del> datagrams += 1
<13>:<add> self.assertEqual(client_transport.sent, 1)
<del> self.assertEqual(datagrams, 1)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_fail(self):
<0> client = QuicConnection(is_client=True)
<1> client.supported_versions = [QuicProtocolVersion.DRAFT_19]
<2>
<3> datagrams = 0
<4> client.connection_made()
<5> for datagram in client.pending_datagrams():
<6> datagrams += 1
<7> self.assertEqual(datagrams, 1)
<8>
<9> # no common version, no retry
<10> client.datagram_received(load("version_negotiation.bin"))
<11> for datagram in client.pending_datagrams():
<12> datagrams += 1
<13> self.assertEqual(datagrams, 1)
<14>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
connection_made()
datagram_received(data: bytes)
pending_datagrams()
at: aioquic.connection.QuicConnection.__init__
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.utils
load(name)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
- def pending_datagrams(self):
- """
- Retrieve outgoing datagrams.
- """
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application()
-
- if self.__close is not None:
- yield from self._write_close(tls.Epoch.ONE_RTT, **self.__close)
- self.__close = None
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
"""
Handle an incoming datagram.
"""
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
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.__logger.info("Retrying with %s" % self.version)
+ self.connection_made(self.__transport)
- self.connection_made()
return
elif 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
):
self.__logger.info("Performing stateless retry")
self.peer_cid = header.source_cid
self.peer_token = header.token
+ self.connection_made(self.__transport)
- self.connection_made()
return
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not self.is_client and not self.__initialized:
self._initialize(header.destination_cid)
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
# offset: 1
<s>
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
is_ack_only = self._payload_received(epoch, plain_payload)
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_transport_close(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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# close
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
+ self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 2)
===========changed ref 5===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 6===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_application_close(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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 2)
===========changed ref 7===========
# module: tests.test_connection
+ class FakeTransport:
+ def sendto(self, data):
+ self.sent += 1
+ if self.target is not None:
+ self.target.datagram_received(data)
+
|
tests.test_connection/QuicConnectionTest.test_version_negotiation_ok
|
Modified
|
aiortc~aioquic
|
1e067acdbcfb6ae91769aad7c6ae8ad067ec86e3
|
[connection] Add connect() coroutine, rework transmission
|
<2>:<add> client_transport = FakeTransport()
<del> datagrams = 0
<3>:<add> client.connection_made(client_transport)
<del> client.connection_made()
<4>:<del> for datagram in client.pending_datagrams():
<5>:<del> datagrams += 1
<6>:<add> self.assertEqual(client_transport.sent, 1)
<del> self.assertEqual(datagrams, 1)
<10>:<del> for datagram in client.pending_datagrams():
<11>:<del> datagrams += 1
<12>:<add> self.assertEqual(client_transport.sent, 2)
<del> self.assertEqual(datagrams, 2)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_ok(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> datagrams = 0
<3> client.connection_made()
<4> for datagram in client.pending_datagrams():
<5> datagrams += 1
<6> self.assertEqual(datagrams, 1)
<7>
<8> # found a common version, retry
<9> client.datagram_received(load("version_negotiation.bin"))
<10> for datagram in client.pending_datagrams():
<11> datagrams += 1
<12> self.assertEqual(datagrams, 2)
<13>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
connection_made()
datagram_received(data: bytes)
pending_datagrams()
at: tests.utils
load(name)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
- def pending_datagrams(self):
- """
- Retrieve outgoing datagrams.
- """
- for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
- yield from self._write_handshake(epoch)
-
- yield from self._write_application()
-
- if self.__close is not None:
- yield from self._write_close(tls.Epoch.ONE_RTT, **self.__close)
- self.__close = None
-
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connection_made(self, transport):
- def connection_made(self):
"""
+ Inform the connection of the transport used to send data. This object
+ must have a ``sendto`` method which accepts a datagram to send.
+
+ Calling :meth:`connection_made` on a client starts the TLS handshake.
- At startup the client initiates the crypto handshake.
"""
+ self.__transport = transport
if self.is_client:
self._initialize(self.peer_cid)
self.tls.handle_message(b"", self.send_buffer)
self._push_crypto_data()
+ self._send_pending()
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
"""
Handle an incoming datagram.
"""
buf = Buffer(data=data)
while not buf.eof():
start_off = buf.tell()
header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
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.__logger.info("Retrying with %s" % self.version)
+ self.connection_made(self.__transport)
- self.connection_made()
return
elif 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
):
self.__logger.info("Performing stateless retry")
self.peer_cid = header.source_cid
self.peer_token = header.token
+ self.connection_made(self.__transport)
- self.connection_made()
return
encrypted_off = buf.tell() - start_off
end_off = buf.tell() + header.rest_length
pull_bytes(buf, header.rest_length)
if not self.is_client and not self.__initialized:
self._initialize(header.destination_cid)
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
</s>
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
+ def datagram_received(self, data: bytes, *args):
- def datagram_received(self, data: bytes):
# offset: 1
<s>
epoch = get_epoch(header.packet_type)
space = self.spaces[epoch]
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
is_ack_only = self._payload_received(epoch, plain_payload)
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_fail(self):
client = QuicConnection(is_client=True)
client.supported_versions = [QuicProtocolVersion.DRAFT_19]
+ client_transport = FakeTransport()
- datagrams = 0
+ client.connection_made(client_transport)
- client.connection_made()
- for datagram in client.pending_datagrams():
- datagrams += 1
+ self.assertEqual(client_transport.sent, 1)
- self.assertEqual(datagrams, 1)
# no common version, no retry
client.datagram_received(load("version_negotiation.bin"))
- for datagram in client.pending_datagrams():
- datagrams += 1
+ self.assertEqual(client_transport.sent, 1)
- self.assertEqual(datagrams, 1)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_transport_close(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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# close
server.close(
error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
)
+ self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 2)
===========changed ref 6===========
# module: tests.test_connection
+ class FakeTransport:
+ sent = 0
+ target = None
+
===========changed ref 7===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_application_close(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(server_transport.sent, 3)
- client.connection_made()
- self.assertEqual(exchange_data(client, server), 2)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
+ self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(exchange_data(client, server), 2)
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
94bf0a95efe1a85f6675d338b7506ee42cbf4d71
|
[streams] add QuicStream.read() and QuicStream.write()
|
<1>:<add> self._eof = False
<add> self._loop = asyncio.get_event_loop()
<5>:<add> self._recv_waiter = None
|
# module: aioquic.stream
class QuicStream:
def __init__(self, stream_id=None, connection=None):
<0> self._connection = connection
<1>
<2> self._recv_buffer = bytearray()
<3> self._recv_start = 0
<4> self._recv_ranges = RangeSet()
<5>
<6> self._send_buffer = bytearray()
<7> self._send_start = 0
<8>
<9> self.__stream_id = stream_id
<10>
|
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
at: aioquic.stream.QuicStream.feed_eof
self._eof = True
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: asyncio.events
get_event_loop() -> AbstractEventLoop
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
94bf0a95efe1a85f6675d338b7506ee42cbf4d71
|
[streams] add QuicStream.read() and QuicStream.write()
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> self.tls.handle_message(data, self.send_buffer)
<18> if not self.__connected.is_set() and self.tls.state in [
<19> tls.State.CLIENT_POST_HANDSHAKE,
<20> tls.State.SERVER_POST_HANDSHAKE,
<21> ]:
<22> self.__connected.set()
<23>
<24> elif frame_type == QuicFrameType.NEW_TOKEN:
<25> packet.pull_new_token_frame(buf)
<26> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<27> flags = frame_type & STREAM_FLAGS
<28> stream_id = pull_uint_var(buf)
<29> if flags & STREAM_FLAG_OFF:
<30> offset = pull_uint_var(buf)
<31> else:
<32> offset = 0
<33> if flags & STREAM_FLAG_LEN:
<34> length = pull_uint_var(buf)
<35> else:
<36> length = buf.capacity - buf.tell()
<37> frame = QuicStreamFrame(offset=offset, data=pull_bytes(buf, length))
<38> stream = self._get_or_create_stream(stream_</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
# offset: 1
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type in [
QuicFrameType.MAX_STREAMS_BIDI,
QuicFrameType.MAX_STREAMS_UNI,
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity=None, data=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof()
tell()
at: aioquic.connection
STREAM_FLAGS = 0x07
STREAM_FLAG_LEN = 2
STREAM_FLAG_OFF = 4
at: aioquic.connection.QuicConnection
_get_or_create_stream(stream_id)
at: aioquic.connection.QuicConnection.__init__
self.streams = {}
self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
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),
}
self.__initialized = True
self.packet_number = 0
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_close
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.packet
pull_uint_var(buf)
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf)
QuicStreamFrame(data: bytes=b"", offset: int=0)
pull_crypto_frame(buf)
pull_new_token_frame(buf)
===========unchanged ref 1===========
pull_new_connection_id_frame(buf)
pull_transport_close_frame(buf)
pull_application_close_frame(buf)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
offset: int = 0
at: aioquic.tls
State()
at: aioquic.tls.Context
handle_message(input_data, output_buf)
at: aioquic.tls.Context.__init__
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.Logger
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:
+ def connection_lost(self, exc):
+ for stream in self.streams.values():
+ stream.feed_eof()
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
+ def feed_eof(self):
+ self._eof = True
+ self._wakeup_waiter()
+
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
- def push_data(self, data):
- """
- Push data to send.
- """
- if data:
- self._send_buffer += data
- if self._connection is not None:
- self._connection._send_pending()
-
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
+ def _wakeup_waiter(self):
+ """
+ Wakeup read() function.
+ """
+ waiter = self._recv_waiter
+ if waiter is not None:
+ self._recv_waiter = None
+ if not waiter.cancelled():
+ waiter.set_result(None)
+
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
+ def write(self, data: bytes):
+ """
+ Write some `data` bytes to the stream.
+
+ This method does not block; it buffers the data and arranges for it to
+ be sent out asynchronously.
+ """
+ if data:
+ self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
+
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
def __init__(self, stream_id=None, connection=None):
self._connection = connection
+ self._eof = False
+ self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
+ self._recv_waiter = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
+ def read(self):
+ """
+ Read data from the stream.
+ """
+ if (
+ not self._recv_ranges
+ or self._recv_ranges[0].start != self._recv_start
+ and not self._eof
+ ):
+ assert self._recv_waiter is None
+ self._recv_waiter = self._loop.create_future()
+ try:
+ await self._recv_waiter
+ finally:
+ self._recv_waiter = None
+
+ return self.pull_data()
+
|
|
aioquic.connection/QuicConnection._push_crypto_data
|
Modified
|
aiortc~aioquic
|
94bf0a95efe1a85f6675d338b7506ee42cbf4d71
|
[streams] add QuicStream.read() and QuicStream.write()
|
<1>:<add> self.streams[epoch].write(buf.data)
<del> self.streams[epoch].push_data(buf.data)
|
# module: aioquic.connection
class QuicConnection:
def _push_crypto_data(self):
<0> for epoch, buf in self.send_buffer.items():
<1> self.streams[epoch].push_data(buf.data)
<2> buf.seek(0)
<3>
|
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def connection_lost(self, exc):
+ for stream in self.streams.values():
+ stream.feed_eof()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
buf = Buffer(data=plain)
is_ack_only = True
while not buf.eof():
frame_type = pull_uint_var(buf)
if frame_type != QuicFrameType.ACK:
is_ack_only = False
if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
pass
elif frame_type == QuicFrameType.ACK:
packet.pull_ack_frame(buf)
elif frame_type == QuicFrameType.CRYPTO:
stream = self.streams[epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
self.tls.handle_message(data, self.send_buffer)
if not self.__connected.is_set() and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self.__connected.set()
elif frame_type == QuicFrameType.NEW_TOKEN:
packet.pull_new_token_frame(buf)
elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & STREAM_FLAG_OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & STREAM_FLAG_LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(offset=offset, data=pull_bytes(buf, length))
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
# offset: 1
<s>(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type in [
QuicFrameType.MAX_STREAMS_BIDI,
QuicFrameType.MAX_STREAMS_UNI,
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
+ self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
+ self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
+ def feed_eof(self):
+ self._eof = True
+ self._wakeup_waiter()
+
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
- def push_data(self, data):
- """
- Push data to send.
- """
- if data:
- self._send_buffer += data
- if self._connection is not None:
- self._connection._send_pending()
-
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
+ def _wakeup_waiter(self):
+ """
+ Wakeup read() function.
+ """
+ waiter = self._recv_waiter
+ if waiter is not None:
+ self._recv_waiter = None
+ if not waiter.cancelled():
+ waiter.set_result(None)
+
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
+ def write(self, data: bytes):
+ """
+ Write some `data` bytes to the stream.
+
+ This method does not block; it buffers the data and arranges for it to
+ be sent out asynchronously.
+ """
+ if data:
+ self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
+
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
def __init__(self, stream_id=None, connection=None):
self._connection = connection
+ self._eof = False
+ self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
+ self._recv_waiter = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 8===========
# module: aioquic.stream
class QuicStream:
+ def read(self):
+ """
+ Read data from the stream.
+ """
+ if (
+ not self._recv_ranges
+ or self._recv_ranges[0].start != self._recv_start
+ and not self._eof
+ ):
+ assert self._recv_waiter is None
+ self._recv_waiter = self._loop.create_future()
+ try:
+ await self._recv_waiter
+ finally:
+ self._recv_waiter = None
+
+ return self.pull_data()
+
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
94bf0a95efe1a85f6675d338b7506ee42cbf4d71
|
[streams] add QuicStream.read() and QuicStream.write()
|
<20>:<add> client_stream.write(b"ping")
<del> client_stream.push_data(b"ping")
<25>:<add> self.assertEqual(run(server_stream.read()), b"ping")
<del> self.assertEqual(server_stream.pull_data(), b"ping")
<26>:<add> server_stream.write(b"pong")
<add>
<add> self.assertEqual(run(client_stream.read()), b"pong")
|
# 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> client.version = max(client_versions)
<3>
<4> server = QuicConnection(
<5> is_client=False,
<6> certificate=SERVER_CERTIFICATE,
<7> private_key=SERVER_PRIVATE_KEY,
<8> )
<9> server.supported_versions = server_versions
<10> server.version = max(server_versions)
<11>
<12> # perform handshake
<13> client_transport, server_transport = create_transport(client, server)
<14> self.assertEqual(client_transport.sent, 4)
<15> self.assertEqual(server_transport.sent, 3)
<16> run(client.connect())
<17>
<18> # send data over stream
<19> client_stream = client.create_stream()
<20> client_stream.push_data(b"ping")
<21> self.assertEqual(client_transport.sent, 5)
<22> self.assertEqual(server_transport.sent, 4)
<23>
<24> server_stream = server.streams[0]
<25> self.assertEqual(server_stream.pull_data(), b"ping")
<26>
<27> return client, server
<28>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: aioquic.connection.QuicConnection
connect()
create_stream(is_unidirectional=False)
at: aioquic.connection.QuicConnection.__init__
self.streams = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: tests.test_connection
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()
)
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
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
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
+ def feed_eof(self):
+ self._eof = True
+ self._wakeup_waiter()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connection_lost(self, exc):
+ for stream in self.streams.values():
+ stream.feed_eof()
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _push_crypto_data(self):
for epoch, buf in self.send_buffer.items():
+ self.streams[epoch].write(buf.data)
- self.streams[epoch].push_data(buf.data)
buf.seek(0)
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
- def push_data(self, data):
- """
- Push data to send.
- """
- if data:
- self._send_buffer += data
- if self._connection is not None:
- self._connection._send_pending()
-
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
+ def _wakeup_waiter(self):
+ """
+ Wakeup read() function.
+ """
+ waiter = self._recv_waiter
+ if waiter is not None:
+ self._recv_waiter = None
+ if not waiter.cancelled():
+ waiter.set_result(None)
+
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
+ def write(self, data: bytes):
+ """
+ Write some `data` bytes to the stream.
+
+ This method does not block; it buffers the data and arranges for it to
+ be sent out asynchronously.
+ """
+ if data:
+ self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
+
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
def __init__(self, stream_id=None, connection=None):
self._connection = connection
+ self._eof = False
+ self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
+ self._recv_waiter = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
+ def read(self):
+ """
+ Read data from the stream.
+ """
+ if (
+ not self._recv_ranges
+ or self._recv_ranges[0].start != self._recv_start
+ and not self._eof
+ ):
+ assert self._recv_waiter is None
+ self._recv_waiter = self._loop.create_future()
+ try:
+ await self._recv_waiter
+ finally:
+ self._recv_waiter = None
+
+ return self.pull_data()
+
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
buf = Buffer(data=plain)
is_ack_only = True
while not buf.eof():
frame_type = pull_uint_var(buf)
if frame_type != QuicFrameType.ACK:
is_ack_only = False
if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
pass
elif frame_type == QuicFrameType.ACK:
packet.pull_ack_frame(buf)
elif frame_type == QuicFrameType.CRYPTO:
stream = self.streams[epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
self.tls.handle_message(data, self.send_buffer)
if not self.__connected.is_set() and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self.__connected.set()
elif frame_type == QuicFrameType.NEW_TOKEN:
packet.pull_new_token_frame(buf)
elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & STREAM_FLAG_OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & STREAM_FLAG_LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(offset=offset, data=pull_bytes(buf, length))
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
</s>
|
examples.client/run
|
Modified
|
aiortc~aioquic
|
94bf0a95efe1a85f6675d338b7506ee42cbf4d71
|
[streams] add QuicStream.read() and QuicStream.write()
|
<11>:<add> # perform HTTP/0.9 request
<12>:<add> stream.write(b"GET /\r\n")
<del> stream.push_data(b"GET /\r\n")
<13>:<add> print(await stream.read())
<14>:<del> await asyncio.sleep(1)
<15>:<del>
<16>:<del> print(stream.pull_data())
<17>:<del>
|
# module: examples.client
def run(host, port, **kwargs):
<0> # if host is not an IP address, pass it to enable SNI
<1> try:
<2> ipaddress.ip_address(host)
<3> except ValueError:
<4> kwargs["server_name"] = host
<5>
<6> _, protocol = await loop.create_datagram_endpoint(
<7> lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port)
<8> )
<9> await protocol.connect()
<10>
<11> stream = protocol.create_stream()
<12> stream.push_data(b"GET /\r\n")
<13>
<14> await asyncio.sleep(1)
<15>
<16> print(stream.pull_data())
<17>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client=True, certificate=None, private_key=None, secrets_log_file=None, alpn_protocols=None, server_name=None)
at: asyncio.events.AbstractEventLoop
create_datagram_endpoint(protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]]=..., remote_addr: Optional[Tuple[str, int]]=..., *, family: int=..., proto: int=..., flags: int=..., reuse_address: Optional[bool]=..., reuse_port: Optional[bool]=..., allow_broadcast: Optional[bool]=..., sock: Optional[socket]=...) -> _TransProtPair
at: examples.client
loop = asyncio.get_event_loop()
at: ipaddress
ip_address(address: object) -> Any
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
+ def feed_eof(self):
+ self._eof = True
+ self._wakeup_waiter()
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connection_lost(self, exc):
+ for stream in self.streams.values():
+ stream.feed_eof()
+
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def _push_crypto_data(self):
for epoch, buf in self.send_buffer.items():
+ self.streams[epoch].write(buf.data)
- self.streams[epoch].push_data(buf.data)
buf.seek(0)
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
- def push_data(self, data):
- """
- Push data to send.
- """
- if data:
- self._send_buffer += data
- if self._connection is not None:
- self._connection._send_pending()
-
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
+ def _wakeup_waiter(self):
+ """
+ Wakeup read() function.
+ """
+ waiter = self._recv_waiter
+ if waiter is not None:
+ self._recv_waiter = None
+ if not waiter.cancelled():
+ waiter.set_result(None)
+
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
+ def write(self, data: bytes):
+ """
+ Write some `data` bytes to the stream.
+
+ This method does not block; it buffers the data and arranges for it to
+ be sent out asynchronously.
+ """
+ if data:
+ self._send_buffer += data
+ if self._connection is not None:
+ self._connection._send_pending()
+
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
def __init__(self, stream_id=None, connection=None):
self._connection = connection
+ self._eof = False
+ self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
+ self._recv_waiter = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
+ def read(self):
+ """
+ Read data from the stream.
+ """
+ if (
+ not self._recv_ranges
+ or self._recv_ranges[0].start != self._recv_start
+ and not self._eof
+ ):
+ assert self._recv_waiter is None
+ self._recv_waiter = self._loop.create_future()
+ try:
+ await self._recv_waiter
+ finally:
+ self._recv_waiter = None
+
+ return self.pull_data()
+
===========changed ref 8===========
# 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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
client_transport, server_transport = create_transport(client, server)
self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 3)
run(client.connect())
# send data over stream
client_stream = client.create_stream()
+ client_stream.write(b"ping")
- client_stream.push_data(b"ping")
self.assertEqual(client_transport.sent, 5)
self.assertEqual(server_transport.sent, 4)
server_stream = server.streams[0]
+ self.assertEqual(run(server_stream.read()), b"ping")
- self.assertEqual(server_stream.pull_data(), b"ping")
+ server_stream.write(b"pong")
+
+ self.assertEqual(run(client_stream.read()), b"pong")
return client, server
===========changed ref 9===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch, plain):
buf = Buffer(data=plain)
is_ack_only = True
while not buf.eof():
frame_type = pull_uint_var(buf)
if frame_type != QuicFrameType.ACK:
is_ack_only = False
if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
pass
elif frame_type == QuicFrameType.ACK:
packet.pull_ack_frame(buf)
elif frame_type == QuicFrameType.CRYPTO:
stream = self.streams[epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
self.tls.handle_message(data, self.send_buffer)
if not self.__connected.is_set() and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self.__connected.set()
elif frame_type == QuicFrameType.NEW_TOKEN:
packet.pull_new_token_frame(buf)
elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
if flags & STREAM_FLAG_OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & STREAM_FLAG_LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(offset=offset, data=pull_bytes(buf, length))
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
</s>
|
aioquic.buffer/Buffer.__init__
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<1>:<add> self._data = bytearray(data)
<del> self._data = data
|
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
<0> if data is not None:
<1> self._data = data
<2> self._length = len(data)
<3> else:
<4> self._data = bytearray(capacity)
<5> self._length = capacity
<6> self._pos = 0
<7>
| |
aioquic.buffer/pull_bytes
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<7>:<add> return bytes(v)
<del> return v
|
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
<0> """
<1> Pull bytes.
<2> """
<3> if buf._pos + length > buf._length:
<4> raise BufferReadError
<5> v = buf._data[buf._pos : buf._pos + length]
<6> buf._pos += length
<7> return v
<8>
|
===========unchanged ref 0===========
at: aioquic.buffer
BufferReadError(*args: object)
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer.__init__
self._data = bytearray(capacity)
self._data = bytearray(data)
self._length = len(data)
self._length = capacity
self._pos = 0
at: aioquic.buffer.Buffer.seek
self._pos = pos
===========changed ref 0===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
|
aioquic.tls/pull_key_share
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<0>:<add> group = pull_group(buf)
<del> group = pull_uint16(buf)
|
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
<0> group = pull_uint16(buf)
<1> data_length = pull_uint16(buf)
<2> data = pull_bytes(buf, data_length)
<3> return (group, data)
<4>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
at: typing
Generator = _alias(collections.abc.Generator, 3)
===========changed ref 0===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 1===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 2===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 6===========
# module: aioquic.tls
TLS_VERSION_1_2 = 0x0303
TLS_VERSION_1_3 = 0x0304
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
TLS_VERSION_1_3_DRAFT_27 = 0x7F1B
TLS_VERSION_1_3_DRAFT_26 = 0x7F1A
+ T = TypeVar("T")
+
+ push_cipher_suite = push_uint16
+ push_compression_method = push_uint8
+ push_group = push_uint16
+ push_key_exchange_mode = push_uint8
+ push_signature_algorithm = push_uint16
+
+ # KeyShareEntry
+
+
+ KeyShareEntry = Tuple[Group, bytes]
+
+ # MESSAGES
+
+ Extension = Tuple[int, bytes]
+
+ CertificateEntry = Tuple[bytes, bytes]
+
===========changed ref 7===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
|
aioquic.tls/push_key_share
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<0>:<add> push_group(buf, value[0])
<del> push_uint16(buf, value[0])
|
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
<0> push_uint16(buf, value[0])
<1> with push_block(buf, 2):
<2> push_bytes(buf, value[1])
<3>
|
===========unchanged ref 0===========
at: aioquic.buffer.Buffer.__init__
self._pos = 0
at: aioquic.buffer.Buffer.seek
self._pos = pos
at: aioquic.tls.pull_block
end = buf._pos + length
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
===========changed ref 0===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 1===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 2===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 6===========
# module: aioquic.tls
TLS_VERSION_1_2 = 0x0303
TLS_VERSION_1_3 = 0x0304
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
TLS_VERSION_1_3_DRAFT_27 = 0x7F1B
TLS_VERSION_1_3_DRAFT_26 = 0x7F1A
+ T = TypeVar("T")
+
+ push_cipher_suite = push_uint16
+ push_compression_method = push_uint8
+ push_group = push_uint16
+ push_key_exchange_mode = push_uint8
+ push_signature_algorithm = push_uint16
+
+ # KeyShareEntry
+
+
+ KeyShareEntry = Tuple[Group, bytes]
+
+ # MESSAGES
+
+ Extension = Tuple[int, bytes]
+
+ CertificateEntry = Tuple[bytes, bytes]
+
===========changed ref 7===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
===========changed ref 8===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
|
aioquic.tls/pull_client_hello
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<0>:<del> hello = ClientHello()
<1>:<del>
<5>:<add> client_random = pull_bytes(buf, 32)
<del> hello.random = pull_bytes(buf, 32)
<6>:<add> session_id_length = pull_uint8(buf)
<7>:<add> hello = ClientHello(
<add> random=client_random,
<del> session_id_length = pull_uint8(buf)
<8>:<add> session_id=pull_bytes(buf, session_id_length),
<del> hello.session_id = pull_bytes(buf, session_id_length)
<9>:<del>
<10>:<add> cipher_suites=pull_list(buf, 2, pull_cipher_suite),
<del> hello.cipher_suites = pull_list(buf, 2, pull_uint16)
<11>:<add> compression_methods=pull_list(buf, 1, pull_compression_method),
<del> hello.compression_methods = pull_list(buf, 1, pull_uint8)
<12>:<add> )
<14>:<add> def pull_extension(buf: Buffer) -> None:
<del> def pull_extension(buf):
<22>:<add> hello.signature_algorithms = pull_list(buf, 2, pull_signature_algorithm)
<del> hello.signature_algorithms = pull_list(buf, 2, pull_uint16)
<24>:<add> hello.supported_groups = pull_list(buf, 2, pull_group)
<del> hello.supported_groups = pull_list(buf, 2, pull_uint16)
<26>:<add> hello.key_exchange_modes = pull_list(buf, 1, pull_key_exchange_mode)
<del> hello.key_exchange_modes = pull_list(buf, 1, pull_uint8)
|
# module: aioquic.tls
+ def pull_client_hello(buf: Buffer) -> ClientHello:
- def pull_client_hello(buf: Buffer):
<0> hello = ClientHello()
<1>
<2> assert pull_uint8(buf) == HandshakeType.CLIENT_HELLO
<3> with pull_block(buf, 3):
<4> assert pull_uint16(buf) == TLS_VERSION_1_2
<5> hello.random = pull_bytes(buf, 32)
<6>
<7> session_id_length = pull_uint8(buf)
<8> hello.session_id = pull_bytes(buf, session_id_length)
<9>
<10> hello.cipher_suites = pull_list(buf, 2, pull_uint16)
<11> hello.compression_methods = pull_list(buf, 1, pull_uint8)
<12>
<13> # extensions
<14> def pull_extension(buf):
<15> extension_type = pull_uint16(buf)
<16> extension_length = pull_uint16(buf)
<17> if extension_type == ExtensionType.KEY_SHARE:
<18> hello.key_share = pull_list(buf, 2, pull_key_share)
<19> elif extension_type == ExtensionType.SUPPORTED_VERSIONS:
<20> hello.supported_versions = pull_list(buf, 1, pull_uint16)
<21> elif extension_type == ExtensionType.SIGNATURE_ALGORITHMS:
<22> hello.signature_algorithms = pull_list(buf, 2, pull_uint16)
<23> elif extension_type == ExtensionType.SUPPORTED_GROUPS:
<24> hello.supported_groups = pull_list(buf, 2, pull_uint16)
<25> elif extension_type == ExtensionType.PSK_KEY_EXCHANGE_MODES:
<26> hello.key_exchange_modes = pull_list(buf, 1, pull_uint8)
<27> elif extension_type == ExtensionType.SERVER_NAME:
<28> with pull_block(buf, 2):
<29> assert pull_uint8(buf) == 0
<30> with pull_block(buf, 2) as length:
<31> hello.server_name = pull_bytes</s>
|
===========below chunk 0===========
# module: aioquic.tls
+ def pull_client_hello(buf: Buffer) -> ClientHello:
- def pull_client_hello(buf: Buffer):
# offset: 1
elif extension_type == ExtensionType.ALPN:
hello.alpn_protocols = pull_list(buf, 2, pull_alpn_protocol)
else:
hello.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return hello
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
push_bytes(buf: Buffer, v: bytes) -> None
pull_uint8(buf: Buffer) -> int
push_uint8(buf: Buffer, v: int) -> None
pull_uint16(buf: Buffer) -> int
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.tls
pull_group(buf: Buffer) -> Group
push_group = push_uint16
push_block(buf: Buffer, capacity: int) -> Generator
KeyShareEntry = Tuple[Group, bytes]
at: aioquic.tls.ClientHello
session_id: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
alpn_protocols: Optional[List[str]] = None
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
key_share: Optional[List[KeyShareEntry]] = None
server_name: Optional[str] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_groups: Optional[List[Group]] = None
supported_versions: Optional[List[int]] = None
other_extensions: List[Extension] = field(default_factory=list)
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
at: dataclasses
dataclass(*, init: bool=..., repr: bool=..., eq: bool=..., order: bool=..., unsafe_hash: bool=..., frozen: bool=...) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: None) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: Type[_T]) -> Type[_T]
===========unchanged ref 1===========
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
Generator = _alias(collections.abc.Generator, 3)
===========changed ref 0===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 1===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 2===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 5===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 7===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 8===========
# module: aioquic.tls
- # MESSAGES
-
-
@dataclass
class ClientHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suites: List[CipherSuite]
- cipher_suites: List[int] = None
+ compression_methods: List[CompressionMethod]
- compression_methods: List[int] = None
# extensions
+ alpn_protocols: Optional[List[str]] = None
- alpn_protocols: List[str] = None
+ key_exchange_modes: Optional[List[KeyExchangeMode]] = None
+ key_share: Optional[List[KeyShareEntry]] = None
- key_exchange_modes: List[int] = None
- key_share: List[Tuple[int, bytes]] = None
+ server_name: Optional[str] = None
- server_name: str = None
+ signature_algorithms: Optional[List[SignatureAlgorithm]] = None
- signature_algorithms: List[int] = None
+ supported_groups: Optional[List[Group]] = None
- supported_groups: List[int] = None
+ supported_versions: Optional[List[int]] = None
- supported_versions: List[int] = None
+ other_extensions: List[Extension] = field(default_factory=list)
- other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 9===========
# module: aioquic.tls
TLS_VERSION_1_2 = 0x0303
TLS_VERSION_1_3 = 0x0304
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
TLS_VERSION_1_3_DRAFT_27 = 0x7F1B
TLS_VERSION_1_3_DRAFT_26 = 0x7F1A
+ T = TypeVar("T")
+
+ push_cipher_suite = push_uint16
+ push_compression_method = push_uint8
+ push_group = push_uint16
+ push_key_exchange_mode = push_uint8
+ push_signature_algorithm = push_uint16
+
+ # KeyShareEntry
+
+
+ KeyShareEntry = Tuple[Group, bytes]
+
+ # MESSAGES
+
+ Extension = Tuple[int, bytes]
+
+ CertificateEntry = Tuple[bytes, bytes]
+
===========changed ref 10===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
|
aioquic.tls/push_client_hello
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<6>:<add> push_list(buf, 2, push_cipher_suite, hello.cipher_suites)
<del> push_list(buf, 2, push_uint16, hello.cipher_suites)
<7>:<add> push_list(buf, 1, push_compression_method, hello.compression_methods)
<del> push_list(buf, 1, push_uint8, hello.compression_methods)
<18>:<add> push_list(buf, 2, push_signature_algorithm, hello.signature_algorithms)
<del> push_list(buf, 2, push_uint16, hello.signature_algorithms)
<21>:<add> push_list(buf, 2, push_group, hello.supported_groups)
<del> push_list(buf, 2, push_uint16, hello.supported_groups)
<24>:<add> push_list(buf, 1, push_key_exchange_mode, hello.key_exchange_modes)
<del> push_list(buf, 1, push_uint8, hello.key_exchange_modes)
|
# module: aioquic.tls
+ def push_client_hello(buf: Buffer, hello: ClientHello) -> None:
- def push_client_hello(buf: Buffer, hello: ClientHello):
<0> push_uint8(buf, HandshakeType.CLIENT_HELLO)
<1> with push_block(buf, 3):
<2> push_uint16(buf, TLS_VERSION_1_2)
<3> push_bytes(buf, hello.random)
<4> with push_block(buf, 1):
<5> push_bytes(buf, hello.session_id)
<6> push_list(buf, 2, push_uint16, hello.cipher_suites)
<7> push_list(buf, 1, push_uint8, hello.compression_methods)
<8>
<9> # extensions
<10> with push_block(buf, 2):
<11> with push_extension(buf, ExtensionType.KEY_SHARE):
<12> push_list(buf, 2, push_key_share, hello.key_share)
<13>
<14> with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
<15> push_list(buf, 1, push_uint16, hello.supported_versions)
<16>
<17> with push_extension(buf, ExtensionType.SIGNATURE_ALGORITHMS):
<18> push_list(buf, 2, push_uint16, hello.signature_algorithms)
<19>
<20> with push_extension(buf, ExtensionType.SUPPORTED_GROUPS):
<21> push_list(buf, 2, push_uint16, hello.supported_groups)
<22>
<23> with push_extension(buf, ExtensionType.PSK_KEY_EXCHANGE_MODES):
<24> push_list(buf, 1, push_uint8, hello.key_exchange_modes)
<25>
<26> if hello.server_name is not None:
<27> with push_extension(buf, ExtensionType.SERVER_NAME):
<28> with push_block(buf, 2):
<29> push_uint8(buf, 0)
<30> with push_block(buf, 2):
<31> push_bytes(buf, hello.server_name.encode("ascii"))
<32>
<33> if</s>
|
===========below chunk 0===========
# module: aioquic.tls
+ def push_client_hello(buf: Buffer, hello: ClientHello) -> None:
- def push_client_hello(buf: Buffer, hello: ClientHello):
# offset: 1
with push_extension(buf, ExtensionType.ALPN):
push_list(buf, 2, push_alpn_protocol, hello.alpn_protocols)
for extension_type, extension_value in hello.other_extensions:
with push_extension(buf, extension_type):
push_bytes(buf, extension_value)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint8(buf: Buffer) -> int
pull_uint16(buf: Buffer) -> int
at: aioquic.tls
TLS_VERSION_1_2 = 0x0303
CompressionMethod(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
CompressionMethod(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Group(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, bytearray], base: int)
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]=...)
pull_cipher_suite(buf: Buffer) -> CipherSuite
pull_compression_method(buf: Buffer) -> CompressionMethod
pull_group(buf: Buffer) -> Group
pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm
pull_block(buf: Buffer, capacity: int) -> Generator
pull_list(buf: Buffer, capacity: int, func: Callable[[Buffer], T]) -> List[T]
KeyShareEntry = Tuple[Group, bytes]
pull_key_share(buf: Buffer) -> KeyShareEntry
===========unchanged ref 1===========
Extension = Tuple[int, bytes]
ClientHello(random: bytes, session_id: bytes, cipher_suites: List[CipherSuite], compression_methods: List[CompressionMethod], alpn_protocols: Optional[List[str]]=None, key_exchange_modes: Optional[List[KeyExchangeMode]]=None, key_share: Optional[List[KeyShareEntry]]=None, server_name: Optional[str]=None, signature_algorithms: Optional[List[SignatureAlgorithm]]=None, supported_groups: Optional[List[Group]]=None, supported_versions: Optional[List[int]]=None, other_extensions: List[Extension]=field(default_factory=list))
at: dataclasses
field(*, default_factory: Callable[[], _T], init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> _T
field(*, init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> Any
field(*, default: _T, init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> _T
at: typing
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 1===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 2===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 5===========
# module: aioquic.tls
- # MESSAGES
-
-
@dataclass
class ClientHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suites: List[CipherSuite]
- cipher_suites: List[int] = None
+ compression_methods: List[CompressionMethod]
- compression_methods: List[int] = None
# extensions
+ alpn_protocols: Optional[List[str]] = None
- alpn_protocols: List[str] = None
+ key_exchange_modes: Optional[List[KeyExchangeMode]] = None
+ key_share: Optional[List[KeyShareEntry]] = None
- key_exchange_modes: List[int] = None
- key_share: List[Tuple[int, bytes]] = None
+ server_name: Optional[str] = None
- server_name: str = None
+ signature_algorithms: Optional[List[SignatureAlgorithm]] = None
- signature_algorithms: List[int] = None
+ supported_groups: Optional[List[Group]] = None
- supported_groups: List[int] = None
+ supported_versions: Optional[List[int]] = None
- supported_versions: List[int] = None
+ other_extensions: List[Extension] = field(default_factory=list)
- other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 6===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 7===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 8===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
|
aioquic.tls/pull_server_hello
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<0>:<del> hello = ServerHello()
<1>:<del>
<5>:<add> server_random = pull_bytes(buf, 32)
<del> hello.random = pull_bytes(buf, 32)
<7>:<add>
<add> hello = ServerHello(
<add> random=server_random,
<add> session_id=pull_bytes(buf, session_id_length),
<del> hello.session_id = pull_bytes(buf, session_id_length)
<8>:<add> cipher_suite=pull_cipher_suite(buf),
<add> compression_method=pull_compression_method(buf),
<add> )
<del> hello.cipher_suite = pull_uint16(buf)
<9>:<del> hello.compression_method = pull_uint8(buf)
<12>:<add> def pull_extension(buf: Buffer) -> None:
<del> def pull_extension(buf):
|
# module: aioquic.tls
def pull_server_hello(buf: Buffer) -> ServerHello:
<0> hello = ServerHello()
<1>
<2> assert pull_uint8(buf) == HandshakeType.SERVER_HELLO
<3> with pull_block(buf, 3):
<4> assert pull_uint16(buf) == TLS_VERSION_1_2
<5> hello.random = pull_bytes(buf, 32)
<6> session_id_length = pull_uint8(buf)
<7> hello.session_id = pull_bytes(buf, session_id_length)
<8> hello.cipher_suite = pull_uint16(buf)
<9> hello.compression_method = pull_uint8(buf)
<10>
<11> # extensions
<12> def pull_extension(buf):
<13> extension_type = pull_uint16(buf)
<14> extension_length = pull_uint16(buf)
<15> if extension_type == ExtensionType.SUPPORTED_VERSIONS:
<16> hello.supported_version = pull_uint16(buf)
<17> elif extension_type == ExtensionType.KEY_SHARE:
<18> hello.key_share = pull_key_share(buf)
<19> else:
<20> pull_bytes(buf, extension_length)
<21>
<22> pull_list(buf, 2, pull_extension)
<23>
<24> return hello
<25>
|
===========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.tls
TLS_VERSION_1_2 = 0x0303
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, bytearray], base: int)
push_cipher_suite = push_uint16
push_compression_method = push_uint8
push_signature_algorithm = push_uint16
push_block(buf: Buffer, capacity: int) -> Generator
push_list(buf: Buffer, capacity: int, func: Callable[[Buffer, T], None], values: Sequence[T]) -> None
push_key_share(buf: Buffer, value: KeyShareEntry) -> None
push_extension(buf: Buffer, extension_type: int) -> Generator
ClientHello(random: bytes, session_id: bytes, cipher_suites: List[CipherSuite], compression_methods: List[CompressionMethod], alpn_protocols: Optional[List[str]]=None, key_exchange_modes: Optional[List[KeyExchangeMode]]=None, key_share: Optional[List[KeyShareEntry]]=None, server_name: Optional[str]=None, signature_algorithms: Optional[List[SignatureAlgorithm]]=None, supported_groups: Optional[List[Group]]=None, supported_versions: Optional[List[int]]=None, other_extensions: List[Extension]=field(default_factory=list))
at: aioquic.tls.ClientHello
random: bytes
session_id: bytes
===========unchanged ref 1===========
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
key_share: Optional[List[KeyShareEntry]] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_versions: Optional[List[int]] = None
at: aioquic.tls.pull_client_hello
hello = ClientHello(
random=client_random,
session_id=pull_bytes(buf, session_id_length),
cipher_suites=pull_list(buf, 2, pull_cipher_suite),
compression_methods=pull_list(buf, 1, pull_compression_method),
)
===========changed ref 0===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 1===========
# module: aioquic.tls
- # MESSAGES
-
-
@dataclass
class ClientHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suites: List[CipherSuite]
- cipher_suites: List[int] = None
+ compression_methods: List[CompressionMethod]
- compression_methods: List[int] = None
# extensions
+ alpn_protocols: Optional[List[str]] = None
- alpn_protocols: List[str] = None
+ key_exchange_modes: Optional[List[KeyExchangeMode]] = None
+ key_share: Optional[List[KeyShareEntry]] = None
- key_exchange_modes: List[int] = None
- key_share: List[Tuple[int, bytes]] = None
+ server_name: Optional[str] = None
- server_name: str = None
+ signature_algorithms: Optional[List[SignatureAlgorithm]] = None
- signature_algorithms: List[int] = None
+ supported_groups: Optional[List[Group]] = None
- supported_groups: List[int] = None
+ supported_versions: Optional[List[int]] = None
- supported_versions: List[int] = None
+ other_extensions: List[Extension] = field(default_factory=list)
- other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 2===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 3===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 8===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 9===========
# module: aioquic.tls
TLS_VERSION_1_2 = 0x0303
TLS_VERSION_1_3 = 0x0304
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
TLS_VERSION_1_3_DRAFT_27 = 0x7F1B
TLS_VERSION_1_3_DRAFT_26 = 0x7F1A
+ T = TypeVar("T")
+
+ push_cipher_suite = push_uint16
+ push_compression_method = push_uint8
+ push_group = push_uint16
+ push_key_exchange_mode = push_uint8
+ push_signature_algorithm = push_uint16
+
+ # KeyShareEntry
+
+
+ KeyShareEntry = Tuple[Group, bytes]
+
+ # MESSAGES
+
+ Extension = Tuple[int, bytes]
+
+ CertificateEntry = Tuple[bytes, bytes]
+
|
aioquic.tls/push_server_hello
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<8>:<add> push_cipher_suite(buf, hello.cipher_suite)
<del> push_uint16(buf, hello.cipher_suite)
<9>:<add> push_compression_method(buf, hello.compression_method)
<del> push_uint8(buf, hello.compression_method)
<13>:<add> if hello.supported_version is not None:
<add> with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
<del> with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
<14>:<add> push_uint16(buf, hello.supported_version)
<del> push_uint16(buf, hello.supported_version)
<16>:<add> if hello.key_share is not None:
<add> with push_extension(buf, ExtensionType.KEY_SHARE):
<del> with push_extension(buf, ExtensionType.KEY_SHARE):
<17>:<add> push_key_share(buf, hello.key_share)
<del> push_key_share(buf, hello.key_share)
|
# module: aioquic.tls
+ def push_server_hello(buf: Buffer, hello: ServerHello) -> None:
- def push_server_hello(buf: Buffer, hello: ServerHello):
<0> push_uint8(buf, HandshakeType.SERVER_HELLO)
<1> with push_block(buf, 3):
<2> push_uint16(buf, TLS_VERSION_1_2)
<3> push_bytes(buf, hello.random)
<4>
<5> with push_block(buf, 1):
<6> push_bytes(buf, hello.session_id)
<7>
<8> push_uint16(buf, hello.cipher_suite)
<9> push_uint8(buf, hello.compression_method)
<10>
<11> # extensions
<12> with push_block(buf, 2):
<13> with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
<14> push_uint16(buf, hello.supported_version)
<15>
<16> with push_extension(buf, ExtensionType.KEY_SHARE):
<17> push_key_share(buf, hello.key_share)
<18>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
push_uint8(buf: Buffer, v: int) -> None
at: aioquic.tls
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
push_key_exchange_mode = push_uint8
push_block(buf: Buffer, capacity: int) -> Generator
push_list(buf: Buffer, capacity: int, func: Callable[[Buffer, T], None], values: Sequence[T]) -> None
push_extension(buf: Buffer, extension_type: int) -> Generator
push_alpn_protocol(buf: Buffer, protocol: str) -> None
at: aioquic.tls.ClientHello
alpn_protocols: Optional[List[str]] = None
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
server_name: Optional[str] = None
other_extensions: List[Extension] = field(default_factory=list)
===========changed ref 0===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 1===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 2===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 5===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 7===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 8===========
# module: aioquic.tls
def pull_server_hello(buf: Buffer) -> ServerHello:
- hello = ServerHello()
-
assert pull_uint8(buf) == HandshakeType.SERVER_HELLO
with pull_block(buf, 3):
assert pull_uint16(buf) == TLS_VERSION_1_2
+ server_random = pull_bytes(buf, 32)
- hello.random = pull_bytes(buf, 32)
session_id_length = pull_uint8(buf)
+
+ hello = ServerHello(
+ random=server_random,
+ session_id=pull_bytes(buf, session_id_length),
- hello.session_id = pull_bytes(buf, session_id_length)
+ cipher_suite=pull_cipher_suite(buf),
+ compression_method=pull_compression_method(buf),
+ )
- hello.cipher_suite = pull_uint16(buf)
- hello.compression_method = pull_uint8(buf)
# extensions
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
if extension_type == ExtensionType.SUPPORTED_VERSIONS:
hello.supported_version = pull_uint16(buf)
elif extension_type == ExtensionType.KEY_SHARE:
hello.key_share = pull_key_share(buf)
else:
pull_bytes(buf, extension_length)
pull_list(buf, 2, pull_extension)
return hello
===========changed ref 9===========
# module: aioquic.tls
- # MESSAGES
-
-
@dataclass
class ClientHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suites: List[CipherSuite]
- cipher_suites: List[int] = None
+ compression_methods: List[CompressionMethod]
- compression_methods: List[int] = None
# extensions
+ alpn_protocols: Optional[List[str]] = None
- alpn_protocols: List[str] = None
+ key_exchange_modes: Optional[List[KeyExchangeMode]] = None
+ key_share: Optional[List[KeyShareEntry]] = None
- key_exchange_modes: List[int] = None
- key_share: List[Tuple[int, bytes]] = None
+ server_name: Optional[str] = None
- server_name: str = None
+ signature_algorithms: Optional[List[SignatureAlgorithm]] = None
- signature_algorithms: List[int] = None
+ supported_groups: Optional[List[Group]] = None
- supported_groups: List[int] = None
+ supported_versions: Optional[List[int]] = None
- supported_versions: List[int] = None
+ other_extensions: List[Extension] = field(default_factory=list)
- other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
===========changed ref 10===========
# module: aioquic.tls
TLS_VERSION_1_2 = 0x0303
TLS_VERSION_1_3 = 0x0304
TLS_VERSION_1_3_DRAFT_28 = 0x7F1C
TLS_VERSION_1_3_DRAFT_27 = 0x7F1B
TLS_VERSION_1_3_DRAFT_26 = 0x7F1A
+ T = TypeVar("T")
+
+ push_cipher_suite = push_uint16
+ push_compression_method = push_uint8
+ push_group = push_uint16
+ push_key_exchange_mode = push_uint8
+ push_signature_algorithm = push_uint16
+
+ # KeyShareEntry
+
+
+ KeyShareEntry = Tuple[Group, bytes]
+
+ # MESSAGES
+
+ Extension = Tuple[int, bytes]
+
+ CertificateEntry = Tuple[bytes, bytes]
+
|
aioquic.tls/pull_encrypted_extensions
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<5>:<add> def pull_extension(buf: Buffer) -> None:
<del> def pull_extension(buf):
|
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
<0> extensions = EncryptedExtensions()
<1>
<2> assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
<3> with pull_block(buf, 3):
<4>
<5> def pull_extension(buf):
<6> extension_type = pull_uint16(buf)
<7> extension_length = pull_uint16(buf)
<8> extensions.other_extensions.append(
<9> (extension_type, pull_bytes(buf, extension_length))
<10> )
<11>
<12> pull_list(buf, 2, pull_extension)
<13>
<14> return extensions
<15>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint16(buf: Buffer) -> int
at: aioquic.tls
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_list(buf: Buffer, capacity: int, func: Callable[[Buffer], T]) -> List[T]
pull_key_share(buf: Buffer) -> KeyShareEntry
at: aioquic.tls.ServerHello
random: bytes
session_id: bytes
cipher_suite: CipherSuite
compression_method: CompressionMethod
key_share: Optional[KeyShareEntry] = None
supported_version: Optional[int] = None
at: aioquic.tls.pull_server_hello
hello = ServerHello(
random=server_random,
session_id=pull_bytes(buf, session_id_length),
cipher_suite=pull_cipher_suite(buf),
compression_method=pull_compression_method(buf),
)
===========changed ref 0===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 1===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 2===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 3===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 7===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 8===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 9===========
# module: aioquic.tls
+ def push_server_hello(buf: Buffer, hello: ServerHello) -> None:
- def push_server_hello(buf: Buffer, hello: ServerHello):
push_uint8(buf, HandshakeType.SERVER_HELLO)
with push_block(buf, 3):
push_uint16(buf, TLS_VERSION_1_2)
push_bytes(buf, hello.random)
with push_block(buf, 1):
push_bytes(buf, hello.session_id)
+ push_cipher_suite(buf, hello.cipher_suite)
- push_uint16(buf, hello.cipher_suite)
+ push_compression_method(buf, hello.compression_method)
- push_uint8(buf, hello.compression_method)
# extensions
with push_block(buf, 2):
+ if hello.supported_version is not None:
+ with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
- with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
+ push_uint16(buf, hello.supported_version)
- push_uint16(buf, hello.supported_version)
+ if hello.key_share is not None:
+ with push_extension(buf, ExtensionType.KEY_SHARE):
- with push_extension(buf, ExtensionType.KEY_SHARE):
+ push_key_share(buf, hello.key_share)
- push_key_share(buf, hello.key_share)
===========changed ref 10===========
# module: aioquic.tls
def pull_server_hello(buf: Buffer) -> ServerHello:
- hello = ServerHello()
-
assert pull_uint8(buf) == HandshakeType.SERVER_HELLO
with pull_block(buf, 3):
assert pull_uint16(buf) == TLS_VERSION_1_2
+ server_random = pull_bytes(buf, 32)
- hello.random = pull_bytes(buf, 32)
session_id_length = pull_uint8(buf)
+
+ hello = ServerHello(
+ random=server_random,
+ session_id=pull_bytes(buf, session_id_length),
- hello.session_id = pull_bytes(buf, session_id_length)
+ cipher_suite=pull_cipher_suite(buf),
+ compression_method=pull_compression_method(buf),
+ )
- hello.cipher_suite = pull_uint16(buf)
- hello.compression_method = pull_uint8(buf)
# extensions
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
if extension_type == ExtensionType.SUPPORTED_VERSIONS:
hello.supported_version = pull_uint16(buf)
elif extension_type == ExtensionType.KEY_SHARE:
hello.key_share = pull_key_share(buf)
else:
pull_bytes(buf, extension_length)
pull_list(buf, 2, pull_extension)
return hello
|
aioquic.tls/pull_certificate
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<7>:<add> def pull_certificate_entry(buf: Buffer) -> CertificateEntry:
<del> def pull_certificate_entry(buf):
|
# module: aioquic.tls
def pull_certificate(buf: Buffer) -> Certificate:
<0> certificate = Certificate()
<1>
<2> assert pull_uint8(buf) == HandshakeType.CERTIFICATE
<3> with pull_block(buf, 3):
<4> with pull_block(buf, 1) as length:
<5> certificate.request_context = pull_bytes(buf, length)
<6>
<7> def pull_certificate_entry(buf):
<8> with pull_block(buf, 3) as length:
<9> data = pull_bytes(buf, length)
<10> with pull_block(buf, 2) as length:
<11> extensions = pull_bytes(buf, length)
<12> return (data, extensions)
<13>
<14> certificate.certificates = pull_list(buf, 3, pull_certificate_entry)
<15>
<16> return certificate
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_uint8(buf: Buffer) -> int
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.tls
ExtensionType(x: Union[str, bytes, bytearray], base: int)
ExtensionType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, bytearray], base: int)
push_key_share(buf: Buffer, value: KeyShareEntry) -> None
push_extension(buf: Buffer, extension_type: int) -> Generator
at: aioquic.tls.ServerHello
key_share: Optional[KeyShareEntry] = None
supported_version: Optional[int] = None
at: dataclasses
dataclass(*, init: bool=..., repr: bool=..., eq: bool=..., order: bool=..., unsafe_hash: bool=..., frozen: bool=...) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: None) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: Type[_T]) -> Type[_T]
===========changed ref 0===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 1===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 2===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 3===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 4===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 8===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 9===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 10===========
# module: aioquic.tls
+ def push_server_hello(buf: Buffer, hello: ServerHello) -> None:
- def push_server_hello(buf: Buffer, hello: ServerHello):
push_uint8(buf, HandshakeType.SERVER_HELLO)
with push_block(buf, 3):
push_uint16(buf, TLS_VERSION_1_2)
push_bytes(buf, hello.random)
with push_block(buf, 1):
push_bytes(buf, hello.session_id)
+ push_cipher_suite(buf, hello.cipher_suite)
- push_uint16(buf, hello.cipher_suite)
+ push_compression_method(buf, hello.compression_method)
- push_uint8(buf, hello.compression_method)
# extensions
with push_block(buf, 2):
+ if hello.supported_version is not None:
+ with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
- with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
+ push_uint16(buf, hello.supported_version)
- push_uint16(buf, hello.supported_version)
+ if hello.key_share is not None:
+ with push_extension(buf, ExtensionType.KEY_SHARE):
- with push_extension(buf, ExtensionType.KEY_SHARE):
+ push_key_share(buf, hello.key_share)
- push_key_share(buf, hello.key_share)
===========changed ref 11===========
# module: aioquic.tls
def pull_server_hello(buf: Buffer) -> ServerHello:
- hello = ServerHello()
-
assert pull_uint8(buf) == HandshakeType.SERVER_HELLO
with pull_block(buf, 3):
assert pull_uint16(buf) == TLS_VERSION_1_2
+ server_random = pull_bytes(buf, 32)
- hello.random = pull_bytes(buf, 32)
session_id_length = pull_uint8(buf)
+
+ hello = ServerHello(
+ random=server_random,
+ session_id=pull_bytes(buf, session_id_length),
- hello.session_id = pull_bytes(buf, session_id_length)
+ cipher_suite=pull_cipher_suite(buf),
+ compression_method=pull_compression_method(buf),
+ )
- hello.cipher_suite = pull_uint16(buf)
- hello.compression_method = pull_uint8(buf)
# extensions
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
if extension_type == ExtensionType.SUPPORTED_VERSIONS:
hello.supported_version = pull_uint16(buf)
elif extension_type == ExtensionType.KEY_SHARE:
hello.key_share = pull_key_share(buf)
else:
pull_bytes(buf, extension_length)
pull_list(buf, 2, pull_extension)
return hello
|
aioquic.tls/push_certificate
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<5>:<add> def push_certificate_entry(buf: Buffer, entry: CertificateEntry) -> None:
<del> def push_certificate_entry(buf, entry):
|
# module: aioquic.tls
+ def push_certificate(buf: Buffer, certificate: Certificate) -> None:
- def push_certificate(buf: Buffer, certificate: Certificate):
<0> push_uint8(buf, HandshakeType.CERTIFICATE)
<1> with push_block(buf, 3):
<2> with push_block(buf, 1):
<3> push_bytes(buf, certificate.request_context)
<4>
<5> def push_certificate_entry(buf, entry):
<6> with push_block(buf, 3):
<7> push_bytes(buf, entry[0])
<8> with push_block(buf, 2):
<9> push_bytes(buf, entry[1])
<10>
<11> push_list(buf, 3, push_certificate_entry, certificate.certificates)
<12>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.tls.NewSessionTicket
ticket: bytes = b""
at: aioquic.tls.pull_new_session_ticket
new_session_ticket = NewSessionTicket()
at: dataclasses
field(*, default_factory: Callable[[], _T], init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> _T
field(*, init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> Any
field(*, default: _T, init: bool=..., repr: bool=..., hash: Optional[bool]=..., compare: bool=..., metadata: Optional[Mapping[str, Any]]=...) -> _T
dataclass(*, init: bool=..., repr: bool=..., eq: bool=..., order: bool=..., unsafe_hash: bool=..., frozen: bool=...) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: None) -> Callable[[Type[_T]], Type[_T]]
dataclass(_cls: Type[_T]) -> Type[_T]
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
List = _alias(list, 1, inst=False, name='List')
===========changed ref 0===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 1===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 2===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 3===========
# module: aioquic.tls
def pull_certificate(buf: Buffer) -> Certificate:
certificate = Certificate()
assert pull_uint8(buf) == HandshakeType.CERTIFICATE
with pull_block(buf, 3):
with pull_block(buf, 1) as length:
certificate.request_context = pull_bytes(buf, length)
+ def pull_certificate_entry(buf: Buffer) -> CertificateEntry:
- def pull_certificate_entry(buf):
with pull_block(buf, 3) as length:
data = pull_bytes(buf, length)
with pull_block(buf, 2) as length:
extensions = pull_bytes(buf, length)
return (data, extensions)
certificate.certificates = pull_list(buf, 3, pull_certificate_entry)
return certificate
===========changed ref 4===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 5===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 8===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 9===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 10===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 11===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 12===========
# module: aioquic.tls
+ def push_server_hello(buf: Buffer, hello: ServerHello) -> None:
- def push_server_hello(buf: Buffer, hello: ServerHello):
push_uint8(buf, HandshakeType.SERVER_HELLO)
with push_block(buf, 3):
push_uint16(buf, TLS_VERSION_1_2)
push_bytes(buf, hello.random)
with push_block(buf, 1):
push_bytes(buf, hello.session_id)
+ push_cipher_suite(buf, hello.cipher_suite)
- push_uint16(buf, hello.cipher_suite)
+ push_compression_method(buf, hello.compression_method)
- push_uint8(buf, hello.compression_method)
# extensions
with push_block(buf, 2):
+ if hello.supported_version is not None:
+ with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
- with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
+ push_uint16(buf, hello.supported_version)
- push_uint16(buf, hello.supported_version)
+ if hello.key_share is not None:
+ with push_extension(buf, ExtensionType.KEY_SHARE):
- with push_extension(buf, ExtensionType.KEY_SHARE):
+ push_key_share(buf, hello.key_share)
- push_key_share(buf, hello.key_share)
|
aioquic.tls/pull_certificate_verify
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<0>:<del> verify = CertificateVerify()
<1>:<del>
<4>:<add> algorithm = pull_signature_algorithm(buf)
<del> verify.algorithm = pull_uint16(buf)
<6>:<add> signature = pull_bytes(buf, length)
<del> verify.signature = pull_bytes(buf, length)
<8>:<add> return CertificateVerify(algorithm=algorithm, signature=signature)
<del> return verify
|
# module: aioquic.tls
def pull_certificate_verify(buf: Buffer) -> CertificateVerify:
<0> verify = CertificateVerify()
<1>
<2> assert pull_uint8(buf) == HandshakeType.CERTIFICATE_VERIFY
<3> with pull_block(buf, 3):
<4> verify.algorithm = pull_uint16(buf)
<5> with pull_block(buf, 2) as length:
<6> verify.signature = pull_bytes(buf, length)
<7>
<8> return verify
<9>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_uint8(buf: Buffer, v: int) -> None
at: aioquic.tls
HandshakeType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, bytearray], base: int)
push_block(buf: Buffer, capacity: int) -> Generator
pull_list(buf: Buffer, capacity: int, func: Callable[[Buffer], T]) -> List[T]
EncryptedExtensions(other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
at: aioquic.tls.pull_encrypted_extensions
extensions = EncryptedExtensions()
pull_extension(buf: Buffer) -> None
===========changed ref 0===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 1===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 2===========
# module: aioquic.tls
+ def push_certificate(buf: Buffer, certificate: Certificate) -> None:
- def push_certificate(buf: Buffer, certificate: Certificate):
push_uint8(buf, HandshakeType.CERTIFICATE)
with push_block(buf, 3):
with push_block(buf, 1):
push_bytes(buf, certificate.request_context)
+ def push_certificate_entry(buf: Buffer, entry: CertificateEntry) -> None:
- def push_certificate_entry(buf, entry):
with push_block(buf, 3):
push_bytes(buf, entry[0])
with push_block(buf, 2):
push_bytes(buf, entry[1])
push_list(buf, 3, push_certificate_entry, certificate.certificates)
===========changed ref 3===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 4===========
# module: aioquic.tls
def pull_certificate(buf: Buffer) -> Certificate:
certificate = Certificate()
assert pull_uint8(buf) == HandshakeType.CERTIFICATE
with pull_block(buf, 3):
with pull_block(buf, 1) as length:
certificate.request_context = pull_bytes(buf, length)
+ def pull_certificate_entry(buf: Buffer) -> CertificateEntry:
- def pull_certificate_entry(buf):
with pull_block(buf, 3) as length:
data = pull_bytes(buf, length)
with pull_block(buf, 2) as length:
extensions = pull_bytes(buf, length)
return (data, extensions)
certificate.certificates = pull_list(buf, 3, pull_certificate_entry)
return certificate
===========changed ref 5===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 6===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 8===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 9===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 10===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 11===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 12===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 13===========
# module: aioquic.tls
+ def push_server_hello(buf: Buffer, hello: ServerHello) -> None:
- def push_server_hello(buf: Buffer, hello: ServerHello):
push_uint8(buf, HandshakeType.SERVER_HELLO)
with push_block(buf, 3):
push_uint16(buf, TLS_VERSION_1_2)
push_bytes(buf, hello.random)
with push_block(buf, 1):
push_bytes(buf, hello.session_id)
+ push_cipher_suite(buf, hello.cipher_suite)
- push_uint16(buf, hello.cipher_suite)
+ push_compression_method(buf, hello.compression_method)
- push_uint8(buf, hello.compression_method)
# extensions
with push_block(buf, 2):
+ if hello.supported_version is not None:
+ with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
- with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
+ push_uint16(buf, hello.supported_version)
- push_uint16(buf, hello.supported_version)
+ if hello.key_share is not None:
+ with push_extension(buf, ExtensionType.KEY_SHARE):
- with push_extension(buf, ExtensionType.KEY_SHARE):
+ push_key_share(buf, hello.key_share)
- push_key_share(buf, hello.key_share)
|
aioquic.tls/push_certificate_verify
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<2>:<add> push_signature_algorithm(buf, verify.algorithm)
<del> push_uint16(buf, verify.algorithm)
|
# module: aioquic.tls
+ def push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None:
- def push_certificate_verify(buf: Buffer, verify: CertificateVerify):
<0> push_uint8(buf, HandshakeType.CERTIFICATE_VERIFY)
<1> with push_block(buf, 3):
<2> push_uint16(buf, verify.algorithm)
<3> with push_block(buf, 2):
<4> push_bytes(buf, verify.signature)
<5>
|
===========unchanged ref 0===========
at: aioquic.buffer
push_bytes(buf: Buffer, v: bytes) -> None
at: aioquic.tls
push_extension(buf: Buffer, extension_type: int) -> Generator
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 1===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 2===========
# module: aioquic.tls
def pull_certificate_verify(buf: Buffer) -> CertificateVerify:
- verify = CertificateVerify()
-
assert pull_uint8(buf) == HandshakeType.CERTIFICATE_VERIFY
with pull_block(buf, 3):
+ algorithm = pull_signature_algorithm(buf)
- verify.algorithm = pull_uint16(buf)
with pull_block(buf, 2) as length:
+ signature = pull_bytes(buf, length)
- verify.signature = pull_bytes(buf, length)
+ return CertificateVerify(algorithm=algorithm, signature=signature)
- return verify
===========changed ref 3===========
# module: aioquic.tls
+ def push_certificate(buf: Buffer, certificate: Certificate) -> None:
- def push_certificate(buf: Buffer, certificate: Certificate):
push_uint8(buf, HandshakeType.CERTIFICATE)
with push_block(buf, 3):
with push_block(buf, 1):
push_bytes(buf, certificate.request_context)
+ def push_certificate_entry(buf: Buffer, entry: CertificateEntry) -> None:
- def push_certificate_entry(buf, entry):
with push_block(buf, 3):
push_bytes(buf, entry[0])
with push_block(buf, 2):
push_bytes(buf, entry[1])
push_list(buf, 3, push_certificate_entry, certificate.certificates)
===========changed ref 4===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 5===========
# module: aioquic.tls
def pull_certificate(buf: Buffer) -> Certificate:
certificate = Certificate()
assert pull_uint8(buf) == HandshakeType.CERTIFICATE
with pull_block(buf, 3):
with pull_block(buf, 1) as length:
certificate.request_context = pull_bytes(buf, length)
+ def pull_certificate_entry(buf: Buffer) -> CertificateEntry:
- def pull_certificate_entry(buf):
with pull_block(buf, 3) as length:
data = pull_bytes(buf, length)
with pull_block(buf, 2) as length:
extensions = pull_bytes(buf, length)
return (data, extensions)
certificate.certificates = pull_list(buf, 3, pull_certificate_entry)
return certificate
===========changed ref 6===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 7===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 8===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 9===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 10===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 11===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 12===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 13===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 14===========
# module: aioquic.tls
+ def push_server_hello(buf: Buffer, hello: ServerHello) -> None:
- def push_server_hello(buf: Buffer, hello: ServerHello):
push_uint8(buf, HandshakeType.SERVER_HELLO)
with push_block(buf, 3):
push_uint16(buf, TLS_VERSION_1_2)
push_bytes(buf, hello.random)
with push_block(buf, 1):
push_bytes(buf, hello.session_id)
+ push_cipher_suite(buf, hello.cipher_suite)
- push_uint16(buf, hello.cipher_suite)
+ push_compression_method(buf, hello.compression_method)
- push_uint8(buf, hello.compression_method)
# extensions
with push_block(buf, 2):
+ if hello.supported_version is not None:
+ with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
- with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
+ push_uint16(buf, hello.supported_version)
- push_uint16(buf, hello.supported_version)
+ if hello.key_share is not None:
+ with push_extension(buf, ExtensionType.KEY_SHARE):
- with push_extension(buf, ExtensionType.KEY_SHARE):
+ push_key_share(buf, hello.key_share)
- push_key_share(buf, hello.key_share)
|
aioquic.tls/KeyScheduleProxy.select
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<3>:<add> raise KeyError
|
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
<0> for k in self.__items:
<1> if k.cipher_suite == cipher_suite:
<2> return k
<3>
|
===========unchanged ref 0===========
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
cipher_suite_hash(cipher_suite: CipherSuite) -> hashes.HashAlgorithm
===========changed ref 0===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 1===========
# module: aioquic.tls
+ def push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None:
- def push_certificate_verify(buf: Buffer, verify: CertificateVerify):
push_uint8(buf, HandshakeType.CERTIFICATE_VERIFY)
with push_block(buf, 3):
+ push_signature_algorithm(buf, verify.algorithm)
- push_uint16(buf, verify.algorithm)
with push_block(buf, 2):
push_bytes(buf, verify.signature)
===========changed ref 2===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 3===========
# module: aioquic.tls
def pull_certificate_verify(buf: Buffer) -> CertificateVerify:
- verify = CertificateVerify()
-
assert pull_uint8(buf) == HandshakeType.CERTIFICATE_VERIFY
with pull_block(buf, 3):
+ algorithm = pull_signature_algorithm(buf)
- verify.algorithm = pull_uint16(buf)
with pull_block(buf, 2) as length:
+ signature = pull_bytes(buf, length)
- verify.signature = pull_bytes(buf, length)
+ return CertificateVerify(algorithm=algorithm, signature=signature)
- return verify
===========changed ref 4===========
# module: aioquic.tls
+ def push_certificate(buf: Buffer, certificate: Certificate) -> None:
- def push_certificate(buf: Buffer, certificate: Certificate):
push_uint8(buf, HandshakeType.CERTIFICATE)
with push_block(buf, 3):
with push_block(buf, 1):
push_bytes(buf, certificate.request_context)
+ def push_certificate_entry(buf: Buffer, entry: CertificateEntry) -> None:
- def push_certificate_entry(buf, entry):
with push_block(buf, 3):
push_bytes(buf, entry[0])
with push_block(buf, 2):
push_bytes(buf, entry[1])
push_list(buf, 3, push_certificate_entry, certificate.certificates)
===========changed ref 5===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 6===========
# module: aioquic.tls
def pull_certificate(buf: Buffer) -> Certificate:
certificate = Certificate()
assert pull_uint8(buf) == HandshakeType.CERTIFICATE
with pull_block(buf, 3):
with pull_block(buf, 1) as length:
certificate.request_context = pull_bytes(buf, length)
+ def pull_certificate_entry(buf: Buffer) -> CertificateEntry:
- def pull_certificate_entry(buf):
with pull_block(buf, 3) as length:
data = pull_bytes(buf, length)
with pull_block(buf, 2) as length:
extensions = pull_bytes(buf, length)
return (data, extensions)
certificate.certificates = pull_list(buf, 3, pull_certificate_entry)
return certificate
===========changed ref 7===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 8===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 9===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 10===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 11===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 12===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 13===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 14===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 15===========
# module: aioquic.tls
+ def push_server_hello(buf: Buffer, hello: ServerHello) -> None:
- def push_server_hello(buf: Buffer, hello: ServerHello):
push_uint8(buf, HandshakeType.SERVER_HELLO)
with push_block(buf, 3):
push_uint16(buf, TLS_VERSION_1_2)
push_bytes(buf, hello.random)
with push_block(buf, 1):
push_bytes(buf, hello.session_id)
+ push_cipher_suite(buf, hello.cipher_suite)
- push_uint16(buf, hello.cipher_suite)
+ push_compression_method(buf, hello.compression_method)
- push_uint8(buf, hello.compression_method)
# extensions
with push_block(buf, 2):
+ if hello.supported_version is not None:
+ with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
- with push_extension(buf, ExtensionType.SUPPORTED_VERSIONS):
+ push_uint16(buf, hello.supported_version)
- push_uint16(buf, hello.supported_version)
+ if hello.key_share is not None:
+ with push_extension(buf, ExtensionType.KEY_SHARE):
- with push_extension(buf, ExtensionType.KEY_SHARE):
+ push_key_share(buf, hello.key_share)
- push_key_share(buf, hello.key_share)
|
aioquic.tls/Context.__init__
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<0>:<add> self.alpn_protocols: Optional[List[str]] = None
<del> self.alpn_protocols = None
<1>:<add> self.certificate: Optional[x509.Certificate] = None
<del> self.certificate = None
<2>:<add> self.certificate_private_key: Optional[
<del> self.certificate_private_key = None
<3>:<add> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
<add> ] = None
<add> self.handshake_extensions: List[Extension] = []
<del> self.handshake_extensions = []
<5>:<add> self.key_schedule: KeySchedule
<add> self.server_name: Optional[str] = None
<del> self.server_name = None
<17>:<add> self._peer_certificate: Optional[x509.Certificate] = None
<del> self._peer_certificate = None
<19>:<add> self._enc_key: Optional[bytes] = None
<del> self._enc_key = None
<20>:<add> self._dec_key: Optional[bytes] = None
<del> self._dec_key = None
|
# module: aioquic.tls
class Context:
+ def __init__(self, is_client: bool, logger: logging.Logger = None):
- def __init__(self, is_client, logger=None):
<0> self.alpn_protocols = None
<1> self.certificate = None
<2> self.certificate_private_key = None
<3> self.handshake_extensions = []
<4> self.is_client = is_client
<5> self.server_name = None
<6> self.update_traffic_key_cb = lambda d, e, s: None
<7>
<8> self._cipher_suites = [
<9> CipherSuite.AES_256_GCM_SHA384,
<10> CipherSuite.AES_128_GCM_SHA256,
<11> CipherSuite.CHACHA20_POLY1305_SHA256,
<12> ]
<13> self._compression_methods = [CompressionMethod.NULL]
<14> self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
<15> self._supported_versions = [TLS_VERSION_1_3]
<16>
<17> self._peer_certificate = None
<18> self._receive_buffer = b""
<19> self._enc_key = None
<20> self._dec_key = None
<21> self.__logger = logger
<22>
<23> if is_client:
<24> self.client_random = os.urandom(32)
<25> self.session_id = os.urandom(32)
<26> self.private_key = ec.generate_private_key(
<27> ec.SECP256R1(), default_backend()
<28> )
<29> self.state = State.CLIENT_HANDSHAKE_START
<30> else:
<31> self.client_random = None
<32> self.session_id = None
<33> self.private_key = None
<34> self.state = State.SERVER_EXPECT_CLIENT_HELLO
<35>
|
===========unchanged ref 0===========
at: aioquic.tls
CipherSuite(x: Union[str, bytes, bytearray], base: int)
CipherSuite(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
Group(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
SignatureAlgorithm(x: Union[str, bytes, bytearray], base: int)
SignatureAlgorithm(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
KeySchedule(cipher_suite: CipherSuite)
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.__init__
self.__items = list(map(KeySchedule, cipher_suites))
===========changed ref 0===========
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
for k in self.__items:
if k.cipher_suite == cipher_suite:
return k
+ raise KeyError
===========changed ref 1===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 2===========
# module: aioquic.tls
+ def push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None:
- def push_certificate_verify(buf: Buffer, verify: CertificateVerify):
push_uint8(buf, HandshakeType.CERTIFICATE_VERIFY)
with push_block(buf, 3):
+ push_signature_algorithm(buf, verify.algorithm)
- push_uint16(buf, verify.algorithm)
with push_block(buf, 2):
push_bytes(buf, verify.signature)
===========changed ref 3===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 4===========
# module: aioquic.tls
def pull_certificate_verify(buf: Buffer) -> CertificateVerify:
- verify = CertificateVerify()
-
assert pull_uint8(buf) == HandshakeType.CERTIFICATE_VERIFY
with pull_block(buf, 3):
+ algorithm = pull_signature_algorithm(buf)
- verify.algorithm = pull_uint16(buf)
with pull_block(buf, 2) as length:
+ signature = pull_bytes(buf, length)
- verify.signature = pull_bytes(buf, length)
+ return CertificateVerify(algorithm=algorithm, signature=signature)
- return verify
===========changed ref 5===========
# module: aioquic.tls
+ def push_certificate(buf: Buffer, certificate: Certificate) -> None:
- def push_certificate(buf: Buffer, certificate: Certificate):
push_uint8(buf, HandshakeType.CERTIFICATE)
with push_block(buf, 3):
with push_block(buf, 1):
push_bytes(buf, certificate.request_context)
+ def push_certificate_entry(buf: Buffer, entry: CertificateEntry) -> None:
- def push_certificate_entry(buf, entry):
with push_block(buf, 3):
push_bytes(buf, entry[0])
with push_block(buf, 2):
push_bytes(buf, entry[1])
push_list(buf, 3, push_certificate_entry, certificate.certificates)
===========changed ref 6===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 7===========
# module: aioquic.tls
def pull_certificate(buf: Buffer) -> Certificate:
certificate = Certificate()
assert pull_uint8(buf) == HandshakeType.CERTIFICATE
with pull_block(buf, 3):
with pull_block(buf, 1) as length:
certificate.request_context = pull_bytes(buf, length)
+ def pull_certificate_entry(buf: Buffer) -> CertificateEntry:
- def pull_certificate_entry(buf):
with pull_block(buf, 3) as length:
data = pull_bytes(buf, length)
with pull_block(buf, 2) as length:
extensions = pull_bytes(buf, length)
return (data, extensions)
certificate.certificates = pull_list(buf, 3, pull_certificate_entry)
return certificate
===========changed ref 8===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 9===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 10===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 11===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 12===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 13===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 14===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 15===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
|
aioquic.packet/pull_quic_header
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<6>:<add> version = pull_protocol_version(buf)
<del> version = pull_uint32(buf)
|
# module: aioquic.packet
+ def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
- def pull_quic_header(buf, host_cid_length=None):
<0> first_byte = pull_uint8(buf)
<1>
<2> original_destination_cid = b""
<3> token = b""
<4> if is_long_header(first_byte):
<5> # long header packet
<6> version = pull_uint32(buf)
<7> cid_lengths = pull_uint8(buf)
<8>
<9> destination_cid_length = decode_cid_length(cid_lengths // 16)
<10> destination_cid = pull_bytes(buf, destination_cid_length)
<11>
<12> source_cid_length = decode_cid_length(cid_lengths % 16)
<13> source_cid = pull_bytes(buf, source_cid_length)
<14>
<15> if version == QuicProtocolVersion.NEGOTIATION:
<16> # version negotiation
<17> packet_type = None
<18> rest_length = buf.capacity - buf.tell()
<19> else:
<20> if version and not (first_byte & PACKET_FIXED_BIT):
<21> raise ValueError("Packet fixed bit is zero")
<22>
<23> packet_type = first_byte & PACKET_TYPE_MASK
<24> if packet_type == PACKET_TYPE_INITIAL:
<25> token_length = pull_uint_var(buf)
<26> token = pull_bytes(buf, token_length)
<27> rest_length = pull_uint_var(buf)
<28> elif packet_type == PACKET_TYPE_RETRY:
<29> original_destination_cid_length = decode_cid_length(first_byte & 0xF)
<30> original_destination_cid = pull_bytes(
<31> buf, original_destination_cid_length
<32> )
<33> token = pull_bytes(buf, buf.capacity - buf.tell())
<34> rest_length = 0
<35> else:
<36> rest_length = pull_uint_var(buf)
<37>
<38> return</s>
|
===========below chunk 0===========
# module: aioquic.packet
+ def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
- def pull_quic_header(buf, host_cid_length=None):
# offset: 1
version=version,
packet_type=packet_type,
destination_cid=destination_cid,
source_cid=source_cid,
original_destination_cid=original_destination_cid,
token=token,
rest_length=rest_length,
)
else:
# short header packet
if not (first_byte & PACKET_FIXED_BIT):
raise ValueError("Packet fixed bit is zero")
packet_type = first_byte & PACKET_TYPE_MASK
destination_cid = pull_bytes(buf, host_cid_length)
return QuicHeader(
version=None,
packet_type=packet_type,
destination_cid=destination_cid,
source_cid=b"",
token=b"",
rest_length=buf.capacity - buf.tell(),
)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint8(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.buffer.Buffer.__init__
self._data = bytearray(capacity)
self._data = bytearray(data)
self._pos = 0
at: aioquic.buffer.Buffer.seek
self._pos = pos
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
PACKET_TYPE_MASK = 0xF0
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicHeader(version: int, packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
decode_cid_length(length: int) -> int
is_long_header(first_byte: int) -> bool
pull_protocol_version(buf: Buffer) -> QuicProtocolVersion
pull_uint_var(buf: Buffer) -> int
at: aioquic.packet.QuicHeader
version: int
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
===========changed ref 0===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 1===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 2===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_0RTT = 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
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
+ push_protocol_version = push_uint32
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 8===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 9===========
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
for k in self.__items:
if k.cipher_suite == cipher_suite:
return k
+ raise KeyError
===========changed ref 10===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 11===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 12===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 13===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
|
aioquic.packet/push_quic_header
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<1>:<add> push_protocol_version(buf, header.version)
<del> push_uint32(buf, header.version)
|
# module: aioquic.packet
+ def push_quic_header(buf: Buffer, header: QuicHeader) -> None:
- def push_quic_header(buf, header):
<0> push_uint8(buf, header.packet_type)
<1> push_uint32(buf, header.version)
<2> push_uint8(
<3> buf,
<4> (encode_cid_length(len(header.destination_cid)) << 4)
<5> | encode_cid_length(len(header.source_cid)),
<6> )
<7> push_bytes(buf, header.destination_cid)
<8> push_bytes(buf, header.source_cid)
<9> if (header.packet_type & PACKET_TYPE_MASK) == PACKET_TYPE_INITIAL:
<10> push_uint_var(buf, len(header.token))
<11> push_bytes(buf, header.token)
<12> push_uint16(buf, 0) # length
<13> push_uint16(buf, 0) # pn
<14>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
push_uint8(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
QuicHeader(version: int, packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
encode_cid_length(length: int) -> int
push_protocol_version = push_uint32
at: aioquic.packet.QuicHeader
version: int
packet_type: int
destination_cid: bytes
source_cid: bytes
at: aioquic.packet.pull_quic_header
destination_cid = pull_bytes(buf, host_cid_length)
destination_cid = pull_bytes(buf, destination_cid_length)
packet_type = first_byte & PACKET_TYPE_MASK
packet_type = None
===========changed ref 0===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 1===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_0RTT = 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
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
+ push_protocol_version = push_uint32
+
===========changed ref 2===========
# module: aioquic.packet
+ def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
- def pull_quic_header(buf, host_cid_length=None):
first_byte = pull_uint8(buf)
original_destination_cid = b""
token = b""
if is_long_header(first_byte):
# long header packet
+ version = pull_protocol_version(buf)
- version = pull_uint32(buf)
cid_lengths = pull_uint8(buf)
destination_cid_length = decode_cid_length(cid_lengths // 16)
destination_cid = pull_bytes(buf, destination_cid_length)
source_cid_length = decode_cid_length(cid_lengths % 16)
source_cid = pull_bytes(buf, source_cid_length)
if version == QuicProtocolVersion.NEGOTIATION:
# version negotiation
packet_type = None
rest_length = buf.capacity - buf.tell()
else:
if version and not (first_byte & PACKET_FIXED_BIT):
raise ValueError("Packet fixed bit is zero")
packet_type = first_byte & PACKET_TYPE_MASK
if packet_type == PACKET_TYPE_INITIAL:
token_length = pull_uint_var(buf)
token = pull_bytes(buf, token_length)
rest_length = pull_uint_var(buf)
elif packet_type == PACKET_TYPE_RETRY:
original_destination_cid_length = decode_cid_length(first_byte & 0xF)
original_destination_cid = pull_bytes(
buf, original_destination_cid_length
)
token = pull_bytes(buf, buf.capacity - buf.tell())
rest_length = 0
else:
rest_length = pull_uint_var(buf)
return QuicHeader(
version=version,
packet_type=packet_type,
destination_cid</s>
===========changed ref 3===========
# module: aioquic.packet
+ def pull_quic_header(buf: Buffer, host_cid_length: Optional[int] = None) -> QuicHeader:
- def pull_quic_header(buf, host_cid_length=None):
# offset: 1
<s>)
return QuicHeader(
version=version,
packet_type=packet_type,
destination_cid=destination_cid,
source_cid=source_cid,
original_destination_cid=original_destination_cid,
token=token,
rest_length=rest_length,
)
else:
# short header packet
if not (first_byte & PACKET_FIXED_BIT):
raise ValueError("Packet fixed bit is zero")
packet_type = first_byte & PACKET_TYPE_MASK
destination_cid = pull_bytes(buf, host_cid_length)
return QuicHeader(
version=None,
packet_type=packet_type,
destination_cid=destination_cid,
source_cid=b"",
token=b"",
rest_length=buf.capacity - buf.tell(),
)
===========changed ref 4===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 8===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 9===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 10===========
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
for k in self.__items:
if k.cipher_suite == cipher_suite:
return k
+ raise KeyError
===========changed ref 11===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 12===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 13===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
|
aioquic.packet/pull_quic_transport_parameters
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<4>:<add> params.initial_version = pull_protocol_version(buf)
<del> params.initial_version = pull_uint32(buf)
<6>:<add> params.negotiated_version = pull_protocol_version(buf)
<del> params.negotiated_version = pull_uint32(buf)
<7>:<add> params.supported_versions = pull_list(buf, 1, pull_protocol_version)
<del> params.supported_versions = pull_list(buf, 1, pull_uint32)
|
# module: aioquic.packet
+ def pull_quic_transport_parameters(
- def pull_quic_transport_parameters(buf, is_client=None):
+ buf: Buffer, is_client: Optional[bool] = None
+ ) -> QuicTransportParameters:
<0> params = QuicTransportParameters()
<1>
<2> # version < DRAFT_17
<3> if is_client:
<4> params.initial_version = pull_uint32(buf)
<5> elif is_client is False:
<6> params.negotiated_version = pull_uint32(buf)
<7> params.supported_versions = pull_list(buf, 1, pull_uint32)
<8>
<9> with pull_block(buf, 2) as length:
<10> end = buf.tell() + length
<11> while buf.tell() < end:
<12> param_id = pull_uint16(buf)
<13> param_len = pull_uint16(buf)
<14> param_start = buf.tell()
<15> param_name, param_type = PARAMS[param_id]
<16> if param_type == int:
<17> setattr(params, param_name, pull_uint_var(buf))
<18> elif param_type == bytes:
<19> setattr(params, param_name, pull_bytes(buf, param_len))
<20> else:
<21> setattr(params, param_name, True)
<22> assert buf.tell() == param_start + param_len
<23>
<24> return params
<25>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_uint16(buf: Buffer) -> int
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
pull_protocol_version(buf: Buffer) -> QuicProtocolVersion
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, 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: 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
initial_max_stream_data_bidi_local: Optional[int] = None
===========unchanged ref 1===========
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: aioquic.tls
pull_block(buf: Buffer, capacity: int) -> Generator
pull_list(buf: Buffer, capacity: int, func: Callable[[Buffer], T]) -> List[T]
===========changed ref 0===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 1===========
# module: aioquic.packet
# TLS EXTENSION
@dataclass
class QuicTransportParameters:
+ initial_version: Optional[QuicProtocolVersion] = None
+ negotiated_version: Optional[QuicProtocolVersion] = None
- initial_version: int = None
- negotiated_version: int = None
+ supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
- supported_versions: List[int] = field(default_factory=list)
+ original_connection_id: Optional[bytes] = None
- original_connection_id: bytes = None
+ idle_timeout: Optional[int] = None
- idle_timeout: int = None
+ stateless_reset_token: Optional[bytes] = None
- stateless_reset_token: bytes = None
+ max_packet_size: Optional[int] = None
- max_packet_size: int = None
+ initial_max_data: Optional[int] = None
- initial_max_data: int = None
+ initial_max_stream_data_bidi_local: Optional[int] = None
- initial_max_stream_data_bidi_local: int = None
+ initial_max_stream_data_bidi_remote: Optional[int] = None
- initial_max_stream_data_bidi_remote: int = None
+ initial_max_stream_data_uni: Optional[int] = None
- initial_max_stream_data_uni: int = None
+ initial_max_streams_bidi: Optional[int] = None
- initial_max_streams_bidi: int = None
+ initial_max_streams_uni: Optional[int] = None
- initial_max_streams_uni: int = None
+ ack_delay_exponent: Optional[int] = None
- ack_delay_exponent: int = None
+ max_ack_delay: Optional[int] = None
- max_ack_delay: int = None
+ disable_migration: Optional[bool] = False
- disable_migration</s>
===========changed ref 2===========
# module: aioquic.packet
# TLS EXTENSION
@dataclass
class QuicTransportParameters:
# offset: 1
<s> <del> max_ack_delay: int = None
+ disable_migration: Optional[bool] = False
- disable_migration: bool = False
+ preferred_address: Optional[bytes] = None
- preferred_address: bytes = None
===========changed ref 3===========
# module: aioquic.packet
+ def push_quic_header(buf: Buffer, header: QuicHeader) -> None:
- def push_quic_header(buf, header):
push_uint8(buf, header.packet_type)
+ push_protocol_version(buf, header.version)
- 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
===========changed ref 4===========
# module: aioquic.packet
PACKET_LONG_HEADER = 0x80
PACKET_FIXED_BIT = 0x40
PACKET_TYPE_INITIAL = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x00
PACKET_TYPE_0RTT = 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
UINT_VAR_FORMATS = [
(pull_uint8, push_uint8, 0x3F),
(pull_uint16, push_uint16, 0x3FFF),
(pull_uint32, push_uint32, 0x3FFFFFFF),
(pull_uint64, push_uint64, 0x3FFFFFFFFFFFFFFF),
]
+ push_protocol_version = push_uint32
+
|
aioquic.packet/push_quic_transport_parameters
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<2>:<add> push_protocol_version(buf, params.initial_version)
<del> push_uint32(buf, params.initial_version)
<4>:<add> push_protocol_version(buf, params.negotiated_version)
<del> push_uint32(buf, params.negotiated_version)
<5>:<add> push_list(buf, 1, push_protocol_version, params.supported_versions)
<del> push_list(buf, 1, push_uint32, params.supported_versions)
|
# module: aioquic.packet
+ def push_quic_transport_parameters(
+ buf: Buffer, params: QuicTransportParameters, is_client: Optional[bool] = None
+ ) -> None:
- def push_quic_transport_parameters(buf, params, is_client=None):
<0> # version < DRAFT_17
<1> if is_client:
<2> push_uint32(buf, params.initial_version)
<3> elif is_client is False:
<4> push_uint32(buf, params.negotiated_version)
<5> push_list(buf, 1, push_uint32, params.supported_versions)
<6>
<7> with push_block(buf, 2):
<8> for param_id, (param_name, param_type) in enumerate(PARAMS):
<9> param_value = getattr(params, param_name)
<10> if param_value not in [None, False]:
<11> push_uint16(buf, param_id)
<12> with push_block(buf, 2):
<13> if param_type == int:
<14> push_uint_var(buf, param_value)
<15> elif param_type == bytes:
<16> push_bytes(buf, param_value)
<17>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
tell() -> int
at: aioquic.packet
pull_uint_var(buf: Buffer) -> int
push_protocol_version = push_uint32
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, 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: aioquic.packet.QuicTransportParameters
initial_version: Optional[QuicProtocolVersion] = None
negotiated_version: Optional[QuicProtocolVersion] = None
at: aioquic.packet.pull_quic_transport_parameters
params = QuicTransportParameters()
param_len = pull_uint16(buf)
param_start = buf.tell()
param_name, param_type = PARAMS[param_id]
param_name, param_type = PARAMS[param_id]
===========changed ref 0===========
# module: aioquic.packet
# TLS EXTENSION
@dataclass
class QuicTransportParameters:
+ initial_version: Optional[QuicProtocolVersion] = None
+ negotiated_version: Optional[QuicProtocolVersion] = None
- initial_version: int = None
- negotiated_version: int = None
+ supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
- supported_versions: List[int] = field(default_factory=list)
+ original_connection_id: Optional[bytes] = None
- original_connection_id: bytes = None
+ idle_timeout: Optional[int] = None
- idle_timeout: int = None
+ stateless_reset_token: Optional[bytes] = None
- stateless_reset_token: bytes = None
+ max_packet_size: Optional[int] = None
- max_packet_size: int = None
+ initial_max_data: Optional[int] = None
- initial_max_data: int = None
+ initial_max_stream_data_bidi_local: Optional[int] = None
- initial_max_stream_data_bidi_local: int = None
+ initial_max_stream_data_bidi_remote: Optional[int] = None
- initial_max_stream_data_bidi_remote: int = None
+ initial_max_stream_data_uni: Optional[int] = None
- initial_max_stream_data_uni: int = None
+ initial_max_streams_bidi: Optional[int] = None
- initial_max_streams_bidi: int = None
+ initial_max_streams_uni: Optional[int] = None
- initial_max_streams_uni: int = None
+ ack_delay_exponent: Optional[int] = None
- ack_delay_exponent: int = None
+ max_ack_delay: Optional[int] = None
- max_ack_delay: int = None
+ disable_migration: Optional[bool] = False
- disable_migration</s>
===========changed ref 1===========
# module: aioquic.packet
# TLS EXTENSION
@dataclass
class QuicTransportParameters:
# offset: 1
<s> <del> max_ack_delay: int = None
+ disable_migration: Optional[bool] = False
- disable_migration: bool = False
+ preferred_address: Optional[bytes] = None
- preferred_address: bytes = None
===========changed ref 2===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 3===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 4===========
# module: aioquic.packet
+ def push_quic_header(buf: Buffer, header: QuicHeader) -> None:
- def push_quic_header(buf, header):
push_uint8(buf, header.packet_type)
+ push_protocol_version(buf, header.version)
- 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
===========changed ref 5===========
# module: aioquic.packet
+ def pull_quic_transport_parameters(
- def pull_quic_transport_parameters(buf, is_client=None):
+ buf: Buffer, is_client: Optional[bool] = None
+ ) -> QuicTransportParameters:
params = QuicTransportParameters()
# version < DRAFT_17
if is_client:
+ params.initial_version = pull_protocol_version(buf)
- params.initial_version = pull_uint32(buf)
elif is_client is False:
+ params.negotiated_version = pull_protocol_version(buf)
- params.negotiated_version = pull_uint32(buf)
+ params.supported_versions = pull_list(buf, 1, pull_protocol_version)
- params.supported_versions = pull_list(buf, 1, pull_uint32)
with pull_block(buf, 2) as length:
end = buf.tell() + length
while buf.tell() < end:
param_id = pull_uint16(buf)
param_len = pull_uint16(buf)
param_start = buf.tell()
param_name, param_type = PARAMS[param_id]
if param_type == int:
setattr(params, param_name, pull_uint_var(buf))
elif param_type == bytes:
setattr(params, param_name, pull_bytes(buf, param_len))
else:
setattr(params, param_name, True)
assert buf.tell() == param_start + param_len
return params
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<7>:<add> self._recv_waiter: Optional[asyncio.Future[Any]] = None
<del> self._recv_waiter = None
|
# module: aioquic.stream
class QuicStream:
+ def __init__(
+ self, stream_id: Optional[int] = None, connection: Optional[Any] = None
+ ) -> None:
- def __init__(self, stream_id=None, connection=None):
<0> self._connection = connection
<1> self._eof = False
<2> self._loop = asyncio.get_event_loop()
<3>
<4> self._recv_buffer = bytearray()
<5> self._recv_start = 0
<6> self._recv_ranges = RangeSet()
<7> self._recv_waiter = None
<8>
<9> self._send_buffer = bytearray()
<10> self._send_start = 0
<11>
<12> self.__stream_id = stream_id
<13>
|
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.stream.QuicStream._wakeup_waiter
self._recv_waiter = None
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
at: aioquic.stream.QuicStream.feed_eof
self._eof = True
at: aioquic.stream.QuicStream.get_frame
self._send_buffer = self._send_buffer[size:]
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: aioquic.stream.QuicStream.read
self._recv_waiter = self._loop.create_future()
self._recv_waiter = None
at: aioquic.stream.QuicStream.write
self._send_buffer += data
at: asyncio.events
get_event_loop() -> AbstractEventLoop
at: asyncio.futures
Future(*, loop: Optional[AbstractEventLoop]=...)
Future = _CFuture = _asyncio.Future
===========changed ref 0===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 1===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 2===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 7===========
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
for k in self.__items:
if k.cipher_suite == cipher_suite:
return k
+ raise KeyError
===========changed ref 8===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 9===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 10===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 11===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
===========changed ref 12===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 13===========
# module: aioquic.tls
+ def push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None:
- def push_certificate_verify(buf: Buffer, verify: CertificateVerify):
push_uint8(buf, HandshakeType.CERTIFICATE_VERIFY)
with push_block(buf, 3):
+ push_signature_algorithm(buf, verify.algorithm)
- push_uint16(buf, verify.algorithm)
with push_block(buf, 2):
push_bytes(buf, verify.signature)
===========changed ref 14===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 15===========
# module: aioquic.tls
def pull_certificate_verify(buf: Buffer) -> CertificateVerify:
- verify = CertificateVerify()
-
assert pull_uint8(buf) == HandshakeType.CERTIFICATE_VERIFY
with pull_block(buf, 3):
+ algorithm = pull_signature_algorithm(buf)
- verify.algorithm = pull_uint16(buf)
with pull_block(buf, 2) as length:
+ signature = pull_bytes(buf, length)
- verify.signature = pull_bytes(buf, length)
+ return CertificateVerify(algorithm=algorithm, signature=signature)
- return verify
===========changed ref 16===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 17===========
# module: aioquic.tls
+ def push_certificate(buf: Buffer, certificate: Certificate) -> None:
- def push_certificate(buf: Buffer, certificate: Certificate):
push_uint8(buf, HandshakeType.CERTIFICATE)
with push_block(buf, 3):
with push_block(buf, 1):
push_bytes(buf, certificate.request_context)
+ def push_certificate_entry(buf: Buffer, entry: CertificateEntry) -> None:
- def push_certificate_entry(buf, entry):
with push_block(buf, 3):
push_bytes(buf, entry[0])
with push_block(buf, 2):
push_bytes(buf, entry[1])
push_list(buf, 3, push_certificate_entry, certificate.certificates)
|
aioquic.crypto/CryptoContext.__init__
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<0>:<add> self.cipher_suite: Optional[CipherSuite]
<add> self.hp: Optional[bytes]
<add> self.iv: Optional[bytes]
<add>
|
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self) -> None:
- def __init__(self):
<0> self.teardown()
<1>
|
===========changed ref 0===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 1===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 2===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 7===========
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
for k in self.__items:
if k.cipher_suite == cipher_suite:
return k
+ raise KeyError
===========changed ref 8===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 9===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 10===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 11===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
===========changed ref 12===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 13===========
# module: aioquic.tls
+ def push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None:
- def push_certificate_verify(buf: Buffer, verify: CertificateVerify):
push_uint8(buf, HandshakeType.CERTIFICATE_VERIFY)
with push_block(buf, 3):
+ push_signature_algorithm(buf, verify.algorithm)
- push_uint16(buf, verify.algorithm)
with push_block(buf, 2):
push_bytes(buf, verify.signature)
===========changed ref 14===========
# module: aioquic.stream
class QuicStream:
+ def __init__(
+ self, stream_id: Optional[int] = None, connection: Optional[Any] = None
+ ) -> None:
- def __init__(self, stream_id=None, connection=None):
self._connection = connection
self._eof = False
self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
+ self._recv_waiter: Optional[asyncio.Future[Any]] = None
- self._recv_waiter = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 15===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 16===========
# module: aioquic.tls
def pull_certificate_verify(buf: Buffer) -> CertificateVerify:
- verify = CertificateVerify()
-
assert pull_uint8(buf) == HandshakeType.CERTIFICATE_VERIFY
with pull_block(buf, 3):
+ algorithm = pull_signature_algorithm(buf)
- verify.algorithm = pull_uint16(buf)
with pull_block(buf, 2) as length:
+ signature = pull_bytes(buf, length)
- verify.signature = pull_bytes(buf, length)
+ return CertificateVerify(algorithm=algorithm, signature=signature)
- return verify
===========changed ref 17===========
# module: aioquic.tls
def pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions:
extensions = EncryptedExtensions()
assert pull_uint8(buf) == HandshakeType.ENCRYPTED_EXTENSIONS
with pull_block(buf, 3):
+ def pull_extension(buf: Buffer) -> None:
- def pull_extension(buf):
extension_type = pull_uint16(buf)
extension_length = pull_uint16(buf)
extensions.other_extensions.append(
(extension_type, pull_bytes(buf, extension_length))
)
pull_list(buf, 2, pull_extension)
return extensions
===========changed ref 18===========
# module: aioquic.tls
+ def push_certificate(buf: Buffer, certificate: Certificate) -> None:
- def push_certificate(buf: Buffer, certificate: Certificate):
push_uint8(buf, HandshakeType.CERTIFICATE)
with push_block(buf, 3):
with push_block(buf, 1):
push_bytes(buf, certificate.request_context)
+ def push_certificate_entry(buf: Buffer, entry: CertificateEntry) -> None:
- def push_certificate_entry(buf, entry):
with push_block(buf, 3):
push_bytes(buf, entry[0])
with push_block(buf, 2):
push_bytes(buf, entry[1])
push_list(buf, 3, push_certificate_entry, certificate.certificates)
|
aioquic.crypto/CryptoContext.encrypt_packet
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<26>:<add> return bytes(packet)
<del> return packet
|
# module: aioquic.crypto
class CryptoContext:
+ def encrypt_packet(self, plain_header: bytes, plain_payload: bytes) -> bytes:
- def encrypt_packet(self, plain_header, plain_payload):
<0> pn_length = (plain_header[0] & 0x03) + 1
<1> pn_offset = len(plain_header) - pn_length
<2> pn = plain_header[pn_offset : pn_offset + pn_length]
<3>
<4> # payload protection
<5> nonce = bytearray(len(self.iv) - pn_length) + bytearray(pn)
<6> for i in range(len(self.iv)):
<7> nonce[i] ^= self.iv[i]
<8> protected_payload = self.aead.encrypt(nonce, plain_payload, plain_header)
<9>
<10> # header protection
<11> sample_offset = MAX_PN_SIZE - pn_length
<12> sample = protected_payload[sample_offset : sample_offset + SAMPLE_SIZE]
<13> mask = self.header_protection_mask(sample)
<14>
<15> packet = bytearray(plain_header + protected_payload)
<16> if is_long_header(packet[0]):
<17> # long header
<18> packet[0] ^= mask[0] & 0x0F
<19> else:
<20> # short header
<21> packet[0] ^= mask[0] & 0x1F
<22>
<23> for i in range(pn_length):
<24> packet[pn_offset + i] ^= mask[1 + i]
<25>
<26> return packet
<27>
|
===========unchanged ref 0===========
at: aioquic.crypto
MAX_PN_SIZE = 4
SAMPLE_SIZE = 16
CryptoError(*args: object)
at: aioquic.crypto.CryptoContext
header_protection_mask(sample: bytes) -> bytes
at: aioquic.crypto.CryptoContext.__init__
self.iv: Optional[bytes]
at: aioquic.crypto.CryptoContext.decrypt_packet
pn_length = (packet[0] & 0x03) + 1
pn = packet[encrypted_offset : encrypted_offset + pn_length]
plain_header = bytes(packet[: encrypted_offset + pn_length])
payload = self.aead.decrypt(
nonce, bytes(packet[encrypted_offset + pn_length :]), plain_header
)
at: aioquic.crypto.CryptoContext.setup
key, self.iv, self.hp = derive_key_iv_hp(cipher_suite, secret)
self.aead = cipher_suite_aead(cipher_suite, key)
at: aioquic.crypto.CryptoContext.teardown
self.aead = None
self.iv = None
at: aioquic.packet
is_long_header(first_byte: int) -> bool
===========changed ref 0===========
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self) -> None:
- def __init__(self):
+ self.cipher_suite: Optional[CipherSuite]
+ self.hp: Optional[bytes]
+ self.iv: Optional[bytes]
+
self.teardown()
===========changed ref 1===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 2===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 7===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 8===========
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
for k in self.__items:
if k.cipher_suite == cipher_suite:
return k
+ raise KeyError
===========changed ref 9===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 10===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 11===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 12===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
===========changed ref 13===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 14===========
# module: aioquic.tls
+ def push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None:
- def push_certificate_verify(buf: Buffer, verify: CertificateVerify):
push_uint8(buf, HandshakeType.CERTIFICATE_VERIFY)
with push_block(buf, 3):
+ push_signature_algorithm(buf, verify.algorithm)
- push_uint16(buf, verify.algorithm)
with push_block(buf, 2):
push_bytes(buf, verify.signature)
===========changed ref 15===========
# module: aioquic.stream
class QuicStream:
+ def __init__(
+ self, stream_id: Optional[int] = None, connection: Optional[Any] = None
+ ) -> None:
- def __init__(self, stream_id=None, connection=None):
self._connection = connection
self._eof = False
self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
+ self._recv_waiter: Optional[asyncio.Future[Any]] = None
- self._recv_waiter = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 16===========
# module: aioquic.tls
@dataclass
class ServerHello:
+ random: bytes
- random: bytes = None
+ session_id: bytes
- session_id: bytes = None
+ cipher_suite: CipherSuite
+ compression_method: CompressionMethod
- cipher_suite: int = None
- compression_method: int = None
# extensions
+ key_share: Optional[KeyShareEntry] = None
- key_share: Tuple[int, bytes] = None
+ supported_version: Optional[int] = None
- supported_version: int = None
===========changed ref 17===========
# module: aioquic.tls
def pull_certificate_verify(buf: Buffer) -> CertificateVerify:
- verify = CertificateVerify()
-
assert pull_uint8(buf) == HandshakeType.CERTIFICATE_VERIFY
with pull_block(buf, 3):
+ algorithm = pull_signature_algorithm(buf)
- verify.algorithm = pull_uint16(buf)
with pull_block(buf, 2) as length:
+ signature = pull_bytes(buf, length)
- verify.signature = pull_bytes(buf, length)
+ return CertificateVerify(algorithm=algorithm, signature=signature)
- return verify
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<14>:<add> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<del> self.streams = {}
|
<s>=True,
+ certificate: Any = None,
- certificate=None,
+ private_key: Any = None,
- private_key=None,
+ secrets_log_file: TextIO = None,
- secrets_log_file=None,
+ alpn_protocols: Optional[List[str]] = None,
+ server_name: Optional[str] = None,
+ ) -> None:
- alpn_protocols=None,
- server_name=None,
- ):
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams = {}
<15>
<16> # protocol versions
<17> self.supported_versions = [
<18> QuicProtocolVersion.DRAFT_17,
<19> QuicProtocolVersion.DRAFT_18,
<20> QuicProtocolVersion.DRAFT_19,
<21> QuicProtocolVersion.DRAFT_20,
<22> ]
<23> self.version = QuicProtocolVersion.DRAFT_20
<24>
<25> self.quic_transport_parameters = QuicTransportParameters(
<26> idle_timeout=600,
<27> initial_max_data=16777216,
<28> initial_max_stream_data_bidi_local=1048576,
<29> initial_max_stream_data_bidi_remote=1048576,
<30> initial_max_stream_data_uni=1048576,
<31> initial_max_streams_bidi=100,
<32> </s>
|
===========below chunk 0===========
<s> certificate: Any = None,
- certificate=None,
+ private_key: Any = None,
- private_key=None,
+ secrets_log_file: TextIO = None,
- secrets_log_file=None,
+ alpn_protocols: Optional[List[str]] = None,
+ server_name: Optional[str] = None,
+ ) -> None:
- alpn_protocols=None,
- server_name=None,
- ):
# offset: 1
)
self.__close = None
self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
self.__transport = None
===========unchanged ref 0===========
at: aioquic.connection
logger = logging.getLogger("quic")
at: aioquic.connection.QuicConnection._initialize
self.__initialized = True
at: aioquic.connection.QuicConnection._pending_datagrams
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.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
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, 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)
===========unchanged ref 1===========
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
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: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: asyncio.locks
Event(*, loop: Optional[AbstractEventLoop]=...)
at: os
urandom(size: int, /) -> bytes
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
===========changed ref 0===========
# module: aioquic.packet
# TLS EXTENSION
@dataclass
class QuicTransportParameters:
+ initial_version: Optional[QuicProtocolVersion] = None
+ negotiated_version: Optional[QuicProtocolVersion] = None
- initial_version: int = None
- negotiated_version: int = None
+ supported_versions: List[QuicProtocolVersion] = field(default_factory=list)
- supported_versions: List[int] = field(default_factory=list)
+ original_connection_id: Optional[bytes] = None
- original_connection_id: bytes = None
+ idle_timeout: Optional[int] = None
- idle_timeout: int = None
+ stateless_reset_token: Optional[bytes] = None
- stateless_reset_token: bytes = None
+ max_packet_size: Optional[int] = None
- max_packet_size: int = None
+ initial_max_data: Optional[int] = None
- initial_max_data: int = None
+ initial_max_stream_data_bidi_local: Optional[int] = None
- initial_max_stream_data_bidi_local: int = None
+ initial_max_stream_data_bidi_remote: Optional[int] = None
- initial_max_stream_data_bidi_remote: int = None
+ initial_max_stream_data_uni: Optional[int] = None
- initial_max_stream_data_uni: int = None
+ initial_max_streams_bidi: Optional[int] = None
- initial_max_streams_bidi: int = None
+ initial_max_streams_uni: Optional[int] = None
- initial_max_streams_uni: int = None
+ ack_delay_exponent: Optional[int] = None
- ack_delay_exponent: int = None
+ max_ack_delay: Optional[int] = None
- max_ack_delay: int = None
+ disable_migration: Optional[bool] = False
- disable_migration</s>
===========changed ref 1===========
# module: aioquic.packet
# TLS EXTENSION
@dataclass
class QuicTransportParameters:
# offset: 1
<s> <del> max_ack_delay: int = None
+ disable_migration: Optional[bool] = False
- disable_migration: bool = False
+ preferred_address: Optional[bytes] = None
- preferred_address: bytes = None
===========changed ref 2===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 6===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
|
aioquic.connection/QuicConnection.connect
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<3>:<add> await self.__connected.wait()
<del> return await self.__connected.wait()
|
# module: aioquic.connection
class QuicConnection:
+ def connect(self) -> None:
- def connect(self):
<0> """
<1> Wait for the TLS handshake to complete.
<2> """
<3> return await self.__connected.wait()
<4>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection
_send_pending() -> None
===========changed ref 0===========
<s>=True,
+ certificate: Any = None,
- certificate=None,
+ private_key: Any = None,
- private_key=None,
+ secrets_log_file: TextIO = None,
- secrets_log_file=None,
+ alpn_protocols: Optional[List[str]] = None,
+ server_name: Optional[str] = None,
+ ) -> None:
- alpn_protocols=None,
- server_name=None,
- ):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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] = {}
- self.streams = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
</s>
===========changed ref 1===========
<s> certificate: Any = None,
- certificate=None,
+ private_key: Any = None,
- private_key=None,
+ secrets_log_file: TextIO = None,
- secrets_log_file=None,
+ alpn_protocols: Optional[List[str]] = None,
+ server_name: Optional[str] = None,
+ ) -> None:
- alpn_protocols=None,
- server_name=None,
- ):
# offset: 1
<s>i=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
+ self.__close: Optional[Dict] = None
- self.__close = None
self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport: Optional[asyncio.DatagramTransport] = None
- self.__transport = None
===========changed ref 2===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 3===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
===========changed ref 6===========
# module: aioquic.packet
+ def pull_protocol_version(buf: Buffer) -> QuicProtocolVersion:
+ return QuicProtocolVersion(pull_uint32(buf))
+
===========changed ref 7===========
# module: aioquic.tls
+ def pull_key_exchange_mode(buf: Buffer) -> KeyExchangeMode:
+ return KeyExchangeMode(pull_uint8(buf))
+
===========changed ref 8===========
# module: aioquic.tls
@dataclass
class CertificateVerify:
+ algorithm: SignatureAlgorithm
- algorithm: int = None
+ signature: bytes
- signature: bytes = None
===========changed ref 9===========
# module: aioquic.tls
class KeyScheduleProxy:
+ def select(self, cipher_suite: CipherSuite) -> KeySchedule:
- def select(self, cipher_suite):
for k in self.__items:
if k.cipher_suite == cipher_suite:
return k
+ raise KeyError
===========changed ref 10===========
# module: aioquic.crypto
class CryptoContext:
+ def __init__(self) -> None:
- def __init__(self):
+ self.cipher_suite: Optional[CipherSuite]
+ self.hp: Optional[bytes]
+ self.iv: Optional[bytes]
+
self.teardown()
===========changed ref 11===========
# module: aioquic.tls
@dataclass
class Certificate:
request_context: bytes = b""
+ certificates: List[CertificateEntry] = field(default_factory=list)
- certificates: List = field(default_factory=list)
===========changed ref 12===========
# module: aioquic.tls
+ def push_key_share(buf: Buffer, value: KeyShareEntry) -> None:
- def push_key_share(buf: Buffer, value: Tuple[int, bytes]):
+ push_group(buf, value[0])
- push_uint16(buf, value[0])
with push_block(buf, 2):
push_bytes(buf, value[1])
===========changed ref 13===========
# module: aioquic.tls
- # KeyShareEntry
-
-
+ def pull_key_share(buf: Buffer) -> KeyShareEntry:
- def pull_key_share(buf: Buffer) -> Tuple[int, bytes]:
+ group = pull_group(buf)
- group = pull_uint16(buf)
data_length = pull_uint16(buf)
data = pull_bytes(buf, data_length)
return (group, data)
===========changed ref 14===========
# module: aioquic.buffer
class Buffer:
+ def __init__(self, capacity: Optional[int] = 0, data: Optional[bytes] = None):
- def __init__(self, capacity=None, data=None):
if data is not None:
+ self._data = bytearray(data)
- self._data = data
self._length = len(data)
else:
self._data = bytearray(capacity)
self._length = capacity
self._pos = 0
===========changed ref 15===========
# module: aioquic.buffer
# BYTES
def pull_bytes(buf: Buffer, length: int) -> bytes:
"""
Pull bytes.
"""
if buf._pos + length > buf._length:
raise BufferReadError
v = buf._data[buf._pos : buf._pos + length]
buf._pos += length
+ return bytes(v)
- return v
===========changed ref 16===========
# module: aioquic.tls
+ def push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None:
- def push_certificate_verify(buf: Buffer, verify: CertificateVerify):
push_uint8(buf, HandshakeType.CERTIFICATE_VERIFY)
with push_block(buf, 3):
+ push_signature_algorithm(buf, verify.algorithm)
- push_uint16(buf, verify.algorithm)
with push_block(buf, 2):
push_bytes(buf, verify.signature)
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<2>:<add> send_ack = space.ack_queue if self.send_ack[epoch] else None
<del> send_ack = space.ack_queue if self.send_ack[epoch] else False
|
# module: aioquic.connection
class QuicConnection:
+ def _write_application(self) -> Iterator[bytes]:
- def _write_application(self):
<0> epoch = tls.Epoch.ONE_RTT
<1> space = self.spaces[epoch]
<2> send_ack = space.ack_queue if self.send_ack[epoch] else False
<3> if not space.crypto.send.is_valid():
<4> return
<5>
<6> buf = Buffer(capacity=PACKET_MAX_SIZE)
<7>
<8> # write header
<9> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10> push_bytes(buf, self.peer_cid)
<11> push_uint16(buf, self.packet_number)
<12> header_size = buf.tell()
<13>
<14> # ACK
<15> if send_ack:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, send_ack, 0)
<18> self.send_ack[epoch] = False
<19>
<20> # STREAM
<21> for stream_id, stream in self.streams.items():
<22> if isinstance(stream_id, int) and stream.has_data_to_send():
<23> frame = stream.get_frame(
<24> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
<25> )
<26> push_uint_var(buf, QuicFrameType.STREAM_BASE + 0x07)
<27> with push_stream_frame(buf, 0, frame.offset):
<28> push_bytes(buf, frame.data)
<29>
<30> # encrypt
<31> packet_size = buf.tell()
<32> if packet_size > header_size:
<33> data = buf.data
<34> yield space.crypto.encrypt_packet(
<35> data[0:header_size], data[header_size:packet_size]
<36> )
<37>
<38> self.packet_number += 1
<39>
|
===========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.buffer.Buffer
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
SEND_PN_SIZE = 2
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.secrets_log_file = secrets_log_file
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_close
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
===========unchanged ref 1===========
at: aioquic.crypto.CryptoContext
is_valid() -> bool
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
self.recv = CryptoContext()
self.send = CryptoContext()
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
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
push_stream_frame(buf: Buffer, stream_id: int, offset: int) -> Generator
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
offset: int = 0
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
at: aioquic.tls
Direction()
Epoch()
at: aioquic.tls.Context.__init__
self.key_schedule: KeySchedule
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self.key_schedule.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._client_send_hello
self.key_schedule = KeyScheduleProxy(hello.cipher_suites)
at: aioquic.tls.Context._server_handle_hello
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
at: typing.IO
__slots__ = ()
===========unchanged ref 2===========
flush() -> None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self) -> None:
- def connect(self):
"""
Wait for the TLS handshake to complete.
"""
+ await self.__connected.wait()
- return await self.__connected.wait()
===========changed ref 1===========
<s>=True,
+ certificate: Any = None,
- certificate=None,
+ private_key: Any = None,
- private_key=None,
+ secrets_log_file: TextIO = None,
- secrets_log_file=None,
+ alpn_protocols: Optional[List[str]] = None,
+ server_name: Optional[str] = None,
+ ) -> None:
- alpn_protocols=None,
- server_name=None,
- ):
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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] = {}
- self.streams = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
</s>
===========changed ref 2===========
<s> certificate: Any = None,
- certificate=None,
+ private_key: Any = None,
- private_key=None,
+ secrets_log_file: TextIO = None,
- secrets_log_file=None,
+ alpn_protocols: Optional[List[str]] = None,
+ server_name: Optional[str] = None,
+ ) -> None:
- alpn_protocols=None,
- server_name=None,
- ):
# offset: 1
<s>i=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
+ self.__close: Optional[Dict] = None
- self.__close = None
self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
+ self.__transport: Optional[asyncio.DatagramTransport] = None
- self.__transport = None
===========changed ref 3===========
# module: aioquic.tls
+ def pull_group(buf: Buffer) -> Group:
+ return Group(pull_uint16(buf))
+
===========changed ref 4===========
# module: aioquic.tls
+ def pull_signature_algorithm(buf: Buffer) -> SignatureAlgorithm:
+ return SignatureAlgorithm(pull_uint16(buf))
+
===========changed ref 5===========
# module: aioquic.tls
+ def pull_compression_method(buf: Buffer) -> CompressionMethod:
+ return CompressionMethod(pull_uint8(buf))
+
===========changed ref 6===========
# module: aioquic.tls
+ # INTEGERS
+
+
+ def pull_cipher_suite(buf: Buffer) -> CipherSuite:
+ return CipherSuite(pull_uint16(buf))
+
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
89f47ca98a3cb9707641df5527edcdc82a834911
|
Add more type hints
|
<2>:<add> send_ack = space.ack_queue if self.send_ack[epoch] else None
<del> send_ack = space.ack_queue if self.send_ack[epoch] else False
<27>:<add> if send_ack is not None:
<del> if send_ack:
<30>:<add> send_ack = None
<del> send_ack = False
|
# module: aioquic.connection
class QuicConnection:
+ def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
- def _write_handshake(self, epoch):
<0> space = self.spaces[epoch]
<1> stream = self.streams[epoch]
<2> send_ack = space.ack_queue if self.send_ack[epoch] else False
<3> self.send_ack[epoch] = False
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6>
<7> while space.crypto.send.is_valid() and (send_ack or stream.has_data_to_send()):
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12>
<13> # write header
<14> push_quic_header(
<15> buf,
<16> QuicHeader(
<17> version=self.version,
<18> packet_type=packet_type | (SEND_PN_SIZE - 1),
<19> destination_cid=self.peer_cid,
<20> source_cid=self.host_cid,
<21> token=self.peer_token,
<22> ),
<23> )
<24> header_size = buf.tell()
<25>
<26> # ACK
<27> if send_ack:
<28> push_uint_var(buf, QuicFrameType.ACK)
<29> packet.push_ack_frame(buf, send_ack, 0)
<30> send_ack = False
<31>
<32> if stream.has_data_to_send():
<33> # CRYPTO
<34> frame = stream.get_frame(
<35> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4
<36> )
<37> push_uint_var(buf, QuicFrameType.CRYPTO)
<38> with packet.push_crypto_frame(buf, frame.offset):
<39> push_bytes(buf, frame.data)
<40>
<41> # PADDING
<42> if epoch ==</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
+ def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
- def _write_handshake(self, epoch):
# offset: 1
push_bytes(
buf,
bytes(
PACKET_MAX_SIZE - space.crypto.aead_tag_size - buf.tell()
),
)
# finalize length
packet_size = buf.tell()
buf.seek(header_size - SEND_PN_SIZE - 2)
length = packet_size - header_size + 2 + space.crypto.aead_tag_size
push_uint16(buf, length | 0x4000)
push_uint16(buf, self.packet_number)
buf.seek(packet_size)
# encrypt
data = buf.data
yield space.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
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
SEND_PN_SIZE = 2
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
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.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection._initialize
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_close
space = self.spaces[epoch]
buf = Buffer(capacity=PACKET_MAX_SIZE)
header_size = buf.tell()
packet_size = buf.tell()
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
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
QuicHeader(version: int, packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
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: 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.QuicStreamFrame
data: bytes = b""
offset: int = 0
===========unchanged ref 2===========
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
at: aioquic.tls
Epoch()
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
===========changed ref 0===========
# module: aioquic.packet
+ def push_quic_header(buf: Buffer, header: QuicHeader) -> None:
- def push_quic_header(buf, header):
push_uint8(buf, header.packet_type)
+ push_protocol_version(buf, header.version)
- 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
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
+ def connect(self) -> None:
- def connect(self):
"""
Wait for the TLS handshake to complete.
"""
+ await self.__connected.wait()
- return await self.__connected.wait()
|
aioquic.tls/Context.__init__
|
Modified
|
aiortc~aioquic
|
27b74775554988120c53b38d5443eaa1b5e73705
|
Add more type hints
|
<7>:<add> self.key_schedule: Optional[KeySchedule] = None
<del> self.key_schedule: KeySchedule
<9>:<add> self.update_traffic_key_cb: Callable[
<del> self.update_traffic_key_cb = lambda d, e, s: None
<10>:<add> [Direction, Epoch, bytes], None
<add> ] = lambda d, e, s: None
<20>:<add> self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
|
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
<0> self.alpn_protocols: Optional[List[str]] = None
<1> self.certificate: Optional[x509.Certificate] = None
<2> self.certificate_private_key: Optional[
<3> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
<4> ] = None
<5> self.handshake_extensions: List[Extension] = []
<6> self.is_client = is_client
<7> self.key_schedule: KeySchedule
<8> self.server_name: Optional[str] = None
<9> self.update_traffic_key_cb = lambda d, e, s: None
<10>
<11> self._cipher_suites = [
<12> CipherSuite.AES_256_GCM_SHA384,
<13> CipherSuite.AES_128_GCM_SHA256,
<14> CipherSuite.CHACHA20_POLY1305_SHA256,
<15> ]
<16> self._compression_methods = [CompressionMethod.NULL]
<17> self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
<18> self._supported_versions = [TLS_VERSION_1_3]
<19>
<20> self._peer_certificate: Optional[x509.Certificate] = None
<21> self._receive_buffer = b""
<22> self._enc_key: Optional[bytes] = None
<23> self._dec_key: Optional[bytes] = None
<24> self.__logger = logger
<25>
<26> if is_client:
<27> self.client_random = os.urandom(32)
<28> self.session_id = os.urandom(32)
<29> self.private_key = ec.generate_private_key(
<30> ec.SECP256R1(), default_backend()
<31> )
<32> self.state = State.CLIENT_HANDSHAKE_START
<33> else:
<34> self.client_random = None
<35> self.session_id = None
<36> self.private_key =</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
self.state = State.SERVER_EXPECT_CLIENT_HELLO
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
tell() -> int
at: aioquic.tls
TLS_VERSION_1_3 = 0x0304
Direction()
Epoch()
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)
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])
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_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._client_send_hello
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.key_schedule = KeySchedule(cipher_suite)
===========unchanged ref 1===========
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: aioquic.tls.KeySchedule
update_hash(data: bytes) -> None
at: aioquic.tls.KeyScheduleProxy
update_hash(data: bytes) -> None
at: logging
Logger(name: str, level: _Level=...)
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
Generator = _alias(collections.abc.Generator, 3)
|
aioquic.tls/Context._client_send_hello
|
Modified
|
aiortc~aioquic
|
27b74775554988120c53b38d5443eaa1b5e73705
|
Add more type hints
|
<15>:<add> self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
<del> self.key_schedule = KeyScheduleProxy(hello.cipher_suites)
<16>:<add> self._key_schedule_proxy.extract(None)
<del> self.key_schedule.extract(None)
<18>:<add> with push_message(self._key_schedule_proxy, output_buf):
<del> with self._push_message(output_buf):
|
# module: aioquic.tls
class Context:
def _client_send_hello(self, output_buf: Buffer) -> None:
<0> hello = ClientHello(
<1> random=self.client_random,
<2> session_id=self.session_id,
<3> cipher_suites=self._cipher_suites,
<4> compression_methods=self._compression_methods,
<5> alpn_protocols=self.alpn_protocols,
<6> key_exchange_modes=[KeyExchangeMode.PSK_DHE_KE],
<7> key_share=[encode_public_key(self.private_key.public_key())],
<8> server_name=self.server_name,
<9> signature_algorithms=self._signature_algorithms,
<10> supported_groups=[Group.SECP256R1],
<11> supported_versions=self._supported_versions,
<12> other_extensions=self.handshake_extensions,
<13> )
<14>
<15> self.key_schedule = KeyScheduleProxy(hello.cipher_suites)
<16> self.key_schedule.extract(None)
<17>
<18> with self._push_message(output_buf):
<19> push_client_hello(output_buf, hello)
<20>
<21> self._set_state(State.CLIENT_EXPECT_SERVER_HELLO)
<22>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
at: aioquic.tls
AlertUnexpectedMessage(*args: object)
State()
KeyExchangeMode(x: Union[str, bytes, bytearray], base: int)
KeyExchangeMode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
ClientHello(random: bytes, session_id: bytes, cipher_suites: List[CipherSuite], compression_methods: List[CompressionMethod], alpn_protocols: Optional[List[str]]=None, key_exchange_modes: Optional[List[KeyExchangeMode]]=None, key_share: Optional[List[KeyShareEntry]]=None, server_name: Optional[str]=None, signature_algorithms: Optional[List[SignatureAlgorithm]]=None, supported_groups: Optional[List[Group]]=None, supported_versions: Optional[List[int]]=None, other_extensions: List[Extension]=field(default_factory=list))
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
at: aioquic.tls.ClientHello
random: bytes
session_id: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
alpn_protocols: Optional[List[str]] = None
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
key_share: Optional[List[KeyShareEntry]] = None
server_name: Optional[str] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_groups: Optional[List[Group]] = None
supported_versions: Optional[List[int]] = None
other_extensions: List[Extension] = field(default_factory=list)
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
===========unchanged ref 1===========
self.server_name: Optional[str] = None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
self.client_random = None
self.client_random = os.urandom(32)
self.session_id = None
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.private_key = None
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._server_handle_hello
self.client_random = peer_hello.random
self.session_id = peer_hello.session_id
self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
at: aioquic.tls.Context._set_state
self.state = state
at: aioquic.tls.Context.handle_message
input_buf = Buffer(data=message)
===========changed ref 0===========
# module: aioquic.tls
+ @contextmanager
+ def push_message(
+ key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer
+ ) -> Generator:
+ hash_start = buf.tell()
+ yield
+ key_schedule.update_hash(buf.data_slice(hash_start, buf.tell()))
+
===========changed ref 1===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = 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.handshake_extensions: List[Extension] = []
self.is_client = is_client
+ self.key_schedule: Optional[KeySchedule] = None
- self.key_schedule: KeySchedule
self.server_name: Optional[str] = None
+ self.update_traffic_key_cb: Callable[
- self.update_traffic_key_cb = lambda d, e, s: None
+ [Direction, Epoch, bytes], None
+ ] = lambda d, e, s: None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
self._supported_versions = [TLS_VERSION_1_3]
+ self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state</s>
===========changed ref 2===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s> ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.tls/Context._client_handle_hello
|
Modified
|
aiortc~aioquic
|
27b74775554988120c53b38d5443eaa1b5e73705
|
Add more type hints
|
<9>:<add> self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
<del> self.key_schedule = self.key_schedule.select(peer_hello.cipher_suite)
|
# 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> peer_public_key = decode_public_key(peer_hello.key_share)
<7> shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
<8>
<9> self.key_schedule = self.key_schedule.select(peer_hello.cipher_suite)
<10> self.key_schedule.update_hash(input_buf.data)
<11> self.key_schedule.extract(shared_key)
<12>
<13> self._setup_traffic_protection(
<14> Direction.DECRYPT, Epoch.HANDSHAKE, b"s hs traffic"
<15> )
<16>
<17> self._set_state(State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS)
<18>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
State()
push_client_hello(buf: Buffer, hello: ClientHello) -> None
pull_server_hello(buf: Buffer) -> ServerHello
KeyScheduleProxy(cipher_suites: List[CipherSuite])
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
at: aioquic.tls.ClientHello
cipher_suites: List[CipherSuite]
at: aioquic.tls.Context
_set_state(state: State) -> None
at: aioquic.tls.Context.__init__
self.handshake_extensions: List[Extension] = []
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_proxy: Optional[KeyScheduleProxy] = None
at: aioquic.tls.Context._client_send_hello
hello = ClientHello(
random=self.client_random,
session_id=self.session_id,
cipher_suites=self._cipher_suites,
compression_methods=self._compression_methods,
alpn_protocols=self.alpn_protocols,
key_exchange_modes=[KeyExchangeMode.PSK_DHE_KE],
key_share=[encode_public_key(self.private_key.public_key())],
server_name=self.server_name,
signature_algorithms=self._signature_algorithms,
supported_groups=[Group.SECP256R1],
supported_versions=self._supported_versions,
other_extensions=self.handshake_extensions,
)
===========unchanged ref 1===========
at: aioquic.tls.KeyScheduleProxy
extract(key_material: Optional[bytes]=None) -> None
at: aioquic.tls.ServerHello
random: bytes
session_id: bytes
cipher_suite: CipherSuite
compression_method: CompressionMethod
key_share: Optional[KeyShareEntry] = None
supported_version: Optional[int] = None
===========changed ref 0===========
# module: aioquic.tls
+ @contextmanager
+ def push_message(
+ key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer
+ ) -> Generator:
+ hash_start = buf.tell()
+ yield
+ key_schedule.update_hash(buf.data_slice(hash_start, buf.tell()))
+
===========changed ref 1===========
# module: aioquic.tls
class Context:
def _client_send_hello(self, output_buf: Buffer) -> None:
hello = ClientHello(
random=self.client_random,
session_id=self.session_id,
cipher_suites=self._cipher_suites,
compression_methods=self._compression_methods,
alpn_protocols=self.alpn_protocols,
key_exchange_modes=[KeyExchangeMode.PSK_DHE_KE],
key_share=[encode_public_key(self.private_key.public_key())],
server_name=self.server_name,
signature_algorithms=self._signature_algorithms,
supported_groups=[Group.SECP256R1],
supported_versions=self._supported_versions,
other_extensions=self.handshake_extensions,
)
+ self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
- self.key_schedule = KeyScheduleProxy(hello.cipher_suites)
+ self._key_schedule_proxy.extract(None)
- self.key_schedule.extract(None)
+ with push_message(self._key_schedule_proxy, output_buf):
- with self._push_message(output_buf):
push_client_hello(output_buf, hello)
self._set_state(State.CLIENT_EXPECT_SERVER_HELLO)
===========changed ref 2===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = 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.handshake_extensions: List[Extension] = []
self.is_client = is_client
+ self.key_schedule: Optional[KeySchedule] = None
- self.key_schedule: KeySchedule
self.server_name: Optional[str] = None
+ self.update_traffic_key_cb: Callable[
- self.update_traffic_key_cb = lambda d, e, s: None
+ [Direction, Epoch, bytes], None
+ ] = lambda d, e, s: None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
self._supported_versions = [TLS_VERSION_1_3]
+ self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state</s>
===========changed ref 3===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s> ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.tls/Context._server_handle_hello
|
Modified
|
aiortc~aioquic
|
27b74775554988120c53b38d5443eaa1b5e73705
|
Add more type hints
|
# module: aioquic.tls
class Context:
def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> peer_hello = pull_client_hello(input_buf)
<1>
<2> # negotiate parameters
<3> cipher_suite = negotiate(
<4> self._cipher_suites, peer_hello.cipher_suites, "No supported cipher suite"
<5> )
<6> compression_method = negotiate(
<7> self._compression_methods,
<8> peer_hello.compression_methods,
<9> "No supported compression method",
<10> )
<11> signature_algorithm = negotiate(
<12> self._signature_algorithms,
<13> peer_hello.signature_algorithms,
<14> "No supported signature algorithm",
<15> )
<16> supported_version = negotiate(
<17> self._supported_versions,
<18> peer_hello.supported_versions,
<19> "No supported protocol version",
<20> )
<21>
<22> self.client_random = peer_hello.random
<23> self.server_random = os.urandom(32)
<24> self.session_id = peer_hello.session_id
<25> self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
<26>
<27> self.key_schedule = KeySchedule(cipher_suite)
<28> self.key_schedule.extract(None)
<29> self.key_schedule.update_hash(input_buf.data)
<30>
<31> peer_public_key = decode_public_key(peer_hello.key_share[0])
<32> shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
<33>
<34> # send hello
<35> hello = ServerHello(
<36> random=self.server_random,
<37> session_id=self.session_id,
<38> cipher_suite=cipher_suite,
<39> compression_method=compression_method,
<40> key_share=encode_public_key(self.private_key.public_key()),
<41> supported_version=supported_version</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 1
)
with self._push_message(output_buf):
push_server_hello(output_buf, hello)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
# send encrypted extensions
with self._push_message(output_buf):
push_encrypted_extensions(
output_buf,
EncryptedExtensions(other_extensions=self.handshake_extensions),
)
# send certificate
with self._push_message(output_buf):
push_certificate(
output_buf,
Certificate(
request_context=b"",
certificates=[(self.certificate.public_bytes(Encoding.DER), b"")],
),
)
# send certificate verify
algorithm = SIGNATURE_ALGORITHMS[signature_algorithm]()
signature = self.certificate_private_key.sign(
self.key_schedule.certificate_verify_data(
b"TLS 1.3, server CertificateVerify"
),
padding.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
algorithm,
)
with self._push_message(output_buf):
push_certificate_verify(
output_buf,
CertificateVerify(algorithm=signature_algorithm, signature=signature),
)
# send finished
with self._push_message(output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)
),
)
# prepare traffic keys
assert self.key</s>
===========below chunk 1===========
# module: aioquic.tls
class Context:
def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 2
<s>verify_data(self._enc_key)
),
)
# prepare traffic keys
assert self.key_schedule.generation == 2
self.key_schedule.extract(None)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.ONE_RTT, b"s ap traffic"
)
self._next_dec_key = self.key_schedule.derive_secret(b"c ap traffic")
self._set_state(State.SERVER_EXPECT_FINISHED)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
State()
pull_client_hello(buf: Buffer) -> ClientHello
ServerHello(random: bytes, session_id: bytes, cipher_suite: CipherSuite, compression_method: CompressionMethod, key_share: Optional[KeyShareEntry]=None, supported_version: Optional[int]=None)
push_server_hello(buf: Buffer, hello: ServerHello) -> None
pull_new_session_ticket(buf: Buffer) -> NewSessionTicket
EncryptedExtensions(other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
push_encrypted_extensions(buf: Buffer, extensions: EncryptedExtensions) -> None
Certificate(request_context: bytes=b"", certificates: List[CertificateEntry]=field(default_factory=list))
push_certificate(buf: Buffer, certificate: Certificate) -> None
CertificateVerify(algorithm: SignatureAlgorithm, signature: bytes)
push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None
Finished(verify_data: bytes=b"")
push_finished(buf: Buffer, finished: Finished) -> None
KeySchedule(cipher_suite: CipherSuite)
SIGNATURE_ALGORITHMS = {
SignatureAlgorithm.RSA_PSS_RSAE_SHA256: hashes.SHA256,
SignatureAlgorithm.RSA_PSS_RSAE_SHA384: hashes.SHA384,
SignatureAlgorithm.RSA_PSS_RSAE_SHA512: hashes.SHA512,
}
decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
negotiate(supported: List[T], offered: List[T], error_message: str) -> T
===========unchanged ref 1===========
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
at: aioquic.tls.Certificate
request_context: bytes = b""
certificates: List[CertificateEntry] = field(default_factory=list)
at: aioquic.tls.CertificateVerify
algorithm: SignatureAlgorithm
signature: bytes
at: aioquic.tls.ClientHello
random: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_versions: Optional[List[int]] = None
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.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
self._supported_versions = [TLS_VERSION_1_3]
self._enc_key: Optional[bytes] = None
|
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
27b74775554988120c53b38d5443eaa1b5e73705
|
Add more type hints
|
<7>:<add> self._recv_waiter: Optional[asyncio.Future] = None
<del> self._recv_waiter: Optional[asyncio.Future[Any]] = None
|
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
<0> self._connection = connection
<1> self._eof = False
<2> self._loop = asyncio.get_event_loop()
<3>
<4> self._recv_buffer = bytearray()
<5> self._recv_start = 0
<6> self._recv_ranges = RangeSet()
<7> self._recv_waiter: Optional[asyncio.Future[Any]] = None
<8>
<9> self._send_buffer = bytearray()
<10> self._send_start = 0
<11>
<12> self.__stream_id = stream_id
<13>
|
===========unchanged ref 0===========
at: _asyncio
get_event_loop()
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.stream.QuicStream._wakeup_waiter
self._recv_waiter = None
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
at: aioquic.stream.QuicStream.feed_eof
self._eof = True
at: aioquic.stream.QuicStream.get_frame
self._send_buffer = self._send_buffer[size:]
self._send_start += size
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: aioquic.stream.QuicStream.read
self._recv_waiter = self._loop.create_future()
self._recv_waiter = None
at: aioquic.stream.QuicStream.write
self._send_buffer += data
at: asyncio.events
get_event_loop() -> AbstractEventLoop
at: asyncio.futures
Future(*, loop: Optional[AbstractEventLoop]=...)
Future = _CFuture = _asyncio.Future
===========changed ref 0===========
# module: aioquic.tls
+ @contextmanager
+ def push_message(
+ key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer
+ ) -> Generator:
+ hash_start = buf.tell()
+ yield
+ key_schedule.update_hash(buf.data_slice(hash_start, buf.tell()))
+
===========changed ref 1===========
# module: aioquic.tls
class Context:
- @contextmanager
- def _push_message(self, buf: Buffer) -> Generator:
- hash_start = buf.tell()
- yield
- self.key_schedule.update_hash(buf.data_slice(hash_start, buf.tell()))
-
===========changed ref 2===========
# 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
peer_public_key = decode_public_key(peer_hello.key_share)
shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
+ self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
- self.key_schedule = self.key_schedule.select(peer_hello.cipher_suite)
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)
===========changed ref 3===========
# module: aioquic.tls
class Context:
def _client_send_hello(self, output_buf: Buffer) -> None:
hello = ClientHello(
random=self.client_random,
session_id=self.session_id,
cipher_suites=self._cipher_suites,
compression_methods=self._compression_methods,
alpn_protocols=self.alpn_protocols,
key_exchange_modes=[KeyExchangeMode.PSK_DHE_KE],
key_share=[encode_public_key(self.private_key.public_key())],
server_name=self.server_name,
signature_algorithms=self._signature_algorithms,
supported_groups=[Group.SECP256R1],
supported_versions=self._supported_versions,
other_extensions=self.handshake_extensions,
)
+ self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
- self.key_schedule = KeyScheduleProxy(hello.cipher_suites)
+ self._key_schedule_proxy.extract(None)
- self.key_schedule.extract(None)
+ with push_message(self._key_schedule_proxy, output_buf):
- with self._push_message(output_buf):
push_client_hello(output_buf, hello)
self._set_state(State.CLIENT_EXPECT_SERVER_HELLO)
===========changed ref 4===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = 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.handshake_extensions: List[Extension] = []
self.is_client = is_client
+ self.key_schedule: Optional[KeySchedule] = None
- self.key_schedule: KeySchedule
self.server_name: Optional[str] = None
+ self.update_traffic_key_cb: Callable[
- self.update_traffic_key_cb = lambda d, e, s: None
+ [Direction, Epoch, bytes], None
+ ] = lambda d, e, s: None
self._cipher_suites = [
CipherSuite.AES_256_GCM_SHA384,
CipherSuite.AES_128_GCM_SHA256,
CipherSuite.CHACHA20_POLY1305_SHA256,
]
self._compression_methods = [CompressionMethod.NULL]
self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
self._supported_versions = [TLS_VERSION_1_3]
+ self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state</s>
===========changed ref 5===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s> ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<1>:<add>
<add> if stream_id is not None:
<add> self.reader = asyncio.StreamReader()
<add> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<add> else:
<add> self.reader = None
<add> self.writer = None
<del> self._eof = False
<2>:<del> self._loop = asyncio.get_event_loop()
<7>:<del> self._recv_waiter: Optional[asyncio.Future] = None
|
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
<0> self._connection = connection
<1> self._eof = False
<2> self._loop = asyncio.get_event_loop()
<3>
<4> self._recv_buffer = bytearray()
<5> self._recv_start = 0
<6> self._recv_ranges = RangeSet()
<7> self._recv_waiter: Optional[asyncio.Future] = None
<8>
<9> self._send_buffer = bytearray()
<10> self._send_start = 0
<11>
<12> self.__stream_id = stream_id
<13>
|
===========unchanged ref 0===========
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
at: aioquic.stream.QuicStream.get_frame
self._send_buffer = self._send_buffer[size:]
self._send_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
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
|
aioquic.stream/QuicStream.add_frame
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<26>:<add> if self.reader and self.has_data_to_read():
<add> self.reader.feed_data(self.pull_data())
<del> if not pos:
<27>:<del> self._wakeup_waiter()
|
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
<0> """
<1> Add a frame of received data.
<2> """
<3> pos = frame.offset - self._recv_start
<4> count = len(frame.data)
<5>
<6> # frame has been entirely consumed
<7> if pos + count <= 0:
<8> return
<9>
<10> # frame has been partially consumed
<11> if pos < 0:
<12> count += pos
<13> frame.data = frame.data[-pos:]
<14> frame.offset -= pos
<15> pos = 0
<16>
<17> # marked received
<18> self._recv_ranges.add(frame.offset, frame.offset + count)
<19>
<20> # add data
<21> gap = pos - len(self._recv_buffer)
<22> if gap > 0:
<23> self._recv_buffer += bytearray(gap)
<24> self._recv_buffer[pos : pos + count] = frame.data
<25>
<26> if not pos:
<27> self._wakeup_waiter()
<28>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
offset: int = 0
at: aioquic.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
at: aioquic.stream.QuicStream
has_data_to_read() -> bool
pull_data() -> bytes
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: asyncio.streams.StreamReader
_source_traceback = None
feed_data(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
+
+ 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._eof = False
- self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
- self._recv_waiter: Optional[asyncio.Future] = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
aioquic.stream/QuicStream.pull_data
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<3>:<del> # no data, or gap at start
<4>:<del> if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
<5>:<add> if not self.has_data_to_read():
|
# module: aioquic.stream
class QuicStream:
def pull_data(self) -> bytes:
<0> """
<1> Pull received data.
<2> """
<3> # no data, or gap at start
<4> if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
<5> return b""
<6>
<7> r = self._recv_ranges.shift()
<8> pos = r.stop - r.start
<9> data = self._recv_buffer[:pos]
<10> self._recv_buffer = self._recv_buffer[pos:]
<11> self._recv_start = r.stop
<12> return data
<13>
|
===========unchanged ref 0===========
at: aioquic.rangeset.RangeSet
shift() -> range
at: aioquic.stream.QuicStream
has_data_to_read() -> bool
at: aioquic.stream.QuicStream.__init__
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
+ def has_data_to_read(self) -> bool:
+ return (
+ bool(self._recv_ranges) and self._recv_ranges[0].start == self._recv_start
+ )
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
- def feed_eof(self) -> None:
- self._eof = True
- self._wakeup_waiter()
-
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
+
+ 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._eof = False
- self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
- self._recv_waiter: Optional[asyncio.Future] = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
# frame has been entirely consumed
if pos + count <= 0:
return
# frame has been partially consumed
if pos < 0:
count += pos
frame.data = frame.data[-pos:]
frame.offset -= pos
pos = 0
# marked received
self._recv_ranges.add(frame.offset, frame.offset + count)
# add data
gap = pos - len(self._recv_buffer)
if gap > 0:
self._recv_buffer += bytearray(gap)
self._recv_buffer[pos : pos + count] = frame.data
+ if self.reader and self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
- if not pos:
- self._wakeup_waiter()
|
aioquic.connection/QuicConnection.connection_lost
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<1>:<add> if stream.reader:
<add> stream.reader.feed_eof()
<del> stream.feed_eof()
|
# module: aioquic.connection
class QuicConnection:
def connection_lost(self, exc: Exception) -> None:
<0> for stream in self.streams.values():
<1> stream.feed_eof()
<2>
|
===========unchanged ref 0===========
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
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
- def feed_eof(self) -> None:
- self._eof = True
- self._wakeup_waiter()
-
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
+ def has_data_to_read(self) -> bool:
+ return (
+ bool(self._recv_ranges) and self._recv_ranges[0].start == self._recv_start
+ )
+
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
+ # asyncio.Transport
+
+ def get_extra_info(self, name: str, default: Any = None) -> Any:
+ """
+ Returns information about the underlying QUIC stream.
+ """
+ if name == "stream_id":
+ return self.stream_id
+
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
- def _wakeup_waiter(self) -> None:
- """
- Wakeup read() function.
- """
- waiter = self._recv_waiter
- if waiter is not None:
- self._recv_waiter = None
- if not waiter.cancelled():
- waiter.set_result(None)
-
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
def pull_data(self) -> bytes:
"""
Pull received data.
"""
- # no data, or gap at start
- if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
+ if not self.has_data_to_read():
return b""
r = self._recv_ranges.shift()
pos = r.stop - r.start
data = self._recv_buffer[:pos]
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
return data
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
- def read(self) -> bytes:
- """
- Read data from the stream.
- """
- if (
- not self._recv_ranges
- or self._recv_ranges[0].start != self._recv_start
- and not self._eof
- ):
- assert self._recv_waiter is None
- self._recv_waiter = self._loop.create_future()
- try:
- await self._recv_waiter
- finally:
- self._recv_waiter = None
-
- return self.pull_data()
-
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
+
+ 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._eof = False
- self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
- self._recv_waiter: Optional[asyncio.Future] = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
# frame has been entirely consumed
if pos + count <= 0:
return
# frame has been partially consumed
if pos < 0:
count += pos
frame.data = frame.data[-pos:]
frame.offset -= pos
pos = 0
# marked received
self._recv_ranges.add(frame.offset, frame.offset + count)
# add data
gap = pos - len(self._recv_buffer)
if gap > 0:
self._recv_buffer += bytearray(gap)
self._recv_buffer[pos : pos + count] = frame.data
+ if self.reader and self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
- if not pos:
- self._wakeup_waiter()
|
aioquic.connection/QuicConnection.create_stream
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<1>:<add> Create a QUIC stream and return a pair of (reader, writer) objects.
<add>
<add> The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
<add> and :class:`asyncio.StreamWriter` classes.
<del> Create a :class:`QuicStream` and return it.
<6>:<add> stream = self._get_or_create_stream(stream_id)
<del> return self._get_or_create_stream(stream_id)
<7>:<add> return stream.reader, stream.writer
|
# module: aioquic.connection
class QuicConnection:
+ def create_stream(
+ self, is_unidirectional: bool = False
+ ) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
- def create_stream(self, is_unidirectional: bool = False) -> QuicStream:
<0> """
<1> Create a :class:`QuicStream` and return it.
<2> """
<3> stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
<4> while stream_id in self.streams:
<5> stream_id += 4
<6> return self._get_or_create_stream(stream_id)
<7>
|
===========unchanged ref 0===========
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
at: typing
Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def connection_lost(self, exc: Exception) -> None:
for stream in self.streams.values():
+ if stream.reader:
+ stream.reader.feed_eof()
- stream.feed_eof()
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
- def feed_eof(self) -> None:
- self._eof = True
- self._wakeup_waiter()
-
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
+ def has_data_to_read(self) -> bool:
+ return (
+ bool(self._recv_ranges) and self._recv_ranges[0].start == self._recv_start
+ )
+
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
+ # asyncio.Transport
+
+ def get_extra_info(self, name: str, default: Any = None) -> Any:
+ """
+ Returns information about the underlying QUIC stream.
+ """
+ if name == "stream_id":
+ return self.stream_id
+
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
- def _wakeup_waiter(self) -> None:
- """
- Wakeup read() function.
- """
- waiter = self._recv_waiter
- if waiter is not None:
- self._recv_waiter = None
- if not waiter.cancelled():
- waiter.set_result(None)
-
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
def pull_data(self) -> bytes:
"""
Pull received data.
"""
- # no data, or gap at start
- if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
+ if not self.has_data_to_read():
return b""
r = self._recv_ranges.shift()
pos = r.stop - r.start
data = self._recv_buffer[:pos]
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
return data
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
- def read(self) -> bytes:
- """
- Read data from the stream.
- """
- if (
- not self._recv_ranges
- or self._recv_ranges[0].start != self._recv_start
- and not self._eof
- ):
- assert self._recv_waiter is None
- self._recv_waiter = self._loop.create_future()
- try:
- await self._recv_waiter
- finally:
- self._recv_waiter = None
-
- return self.pull_data()
-
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
+
+ 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._eof = False
- self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
- self._recv_waiter: Optional[asyncio.Future] = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 8===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
# frame has been entirely consumed
if pos + count <= 0:
return
# frame has been partially consumed
if pos < 0:
count += pos
frame.data = frame.data[-pos:]
frame.offset -= pos
pos = 0
# marked received
self._recv_ranges.add(frame.offset, frame.offset + count)
# add data
gap = pos - len(self._recv_buffer)
if gap > 0:
self._recv_buffer += bytearray(gap)
self._recv_buffer[pos : pos + count] = frame.data
+ if self.reader and self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
- if not pos:
- self._wakeup_waiter()
|
tests.test_stream/QuicStreamTest.test_recv_ordered_3
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<0>:<add> stream = QuicStream(stream_id=0)
<del> stream = QuicStream()
<5>:<add> data, _ = run(asyncio.gather(stream.reader.read(1024), delay(add_frame)))
<del> data, _ = run(asyncio.gather(stream.read(), delay(add_frame)))
|
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_recv_ordered_3(self):
<0> stream = QuicStream()
<1>
<2> async def add_frame():
<3> stream.add_frame(QuicStreamFrame(offset=0, data=b"01234567"))
<4>
<5> data, _ = run(asyncio.gather(stream.read(), delay(add_frame)))
<6> self.assertEqual(data, b"01234567")
<7>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", offset: int=0)
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
offset: int = 0
at: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
at: asyncio.streams.StreamReader
_source_traceback = None
read(n: int=...) -> bytes
===========unchanged ref 1===========
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 2===========
at: tests.test_stream
delay(coro)
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
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
# frame has been entirely consumed
if pos + count <= 0:
return
# frame has been partially consumed
if pos < 0:
count += pos
frame.data = frame.data[-pos:]
frame.offset -= pos
pos = 0
# marked received
self._recv_ranges.add(frame.offset, frame.offset + count)
# add data
gap = pos - len(self._recv_buffer)
if gap > 0:
self._recv_buffer += bytearray(gap)
self._recv_buffer[pos : pos + count] = frame.data
+ if self.reader and self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
- if not pos:
- self._wakeup_waiter()
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
- def feed_eof(self) -> None:
- self._eof = True
- self._wakeup_waiter()
-
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
+ def has_data_to_read(self) -> bool:
+ return (
+ bool(self._recv_ranges) and self._recv_ranges[0].start == self._recv_start
+ )
+
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
+ # asyncio.Transport
+
+ def get_extra_info(self, name: str, default: Any = None) -> Any:
+ """
+ Returns information about the underlying QUIC stream.
+ """
+ if name == "stream_id":
+ return self.stream_id
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def connection_lost(self, exc: Exception) -> None:
for stream in self.streams.values():
+ if stream.reader:
+ stream.reader.feed_eof()
- stream.feed_eof()
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
- def _wakeup_waiter(self) -> None:
- """
- Wakeup read() function.
- """
- waiter = self._recv_waiter
- if waiter is not None:
- self._recv_waiter = None
- if not waiter.cancelled():
- waiter.set_result(None)
-
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
def pull_data(self) -> bytes:
"""
Pull received data.
"""
- # no data, or gap at start
- if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
+ if not self.has_data_to_read():
return b""
r = self._recv_ranges.shift()
pos = r.stop - r.start
data = self._recv_buffer[:pos]
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
return data
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
- def read(self) -> bytes:
- """
- Read data from the stream.
- """
- if (
- not self._recv_ranges
- or self._recv_ranges[0].start != self._recv_start
- and not self._eof
- ):
- assert self._recv_waiter is None
- self._recv_waiter = self._loop.create_future()
- try:
- await self._recv_waiter
- finally:
- self._recv_waiter = None
-
- return self.pull_data()
-
|
examples.client/run
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<12>:<add> reader, writer = protocol.create_stream()
<del> stream = protocol.create_stream()
<13>:<add> writer.write(b"GET /\r\n")
<del> stream.write(b"GET /\r\n")
<14>:<add> print(await reader.read(1024))
<del> print(await stream.read())
|
# module: examples.client
def run(host, port, **kwargs):
<0> # if host is not an IP address, pass it to enable SNI
<1> try:
<2> ipaddress.ip_address(host)
<3> except ValueError:
<4> kwargs["server_name"] = host
<5>
<6> _, protocol = await loop.create_datagram_endpoint(
<7> lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port)
<8> )
<9> await protocol.connect()
<10>
<11> # perform HTTP/0.9 request
<12> stream = protocol.create_stream()
<13> stream.write(b"GET /\r\n")
<14> print(await stream.read())
<15>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: asyncio.events.AbstractEventLoop
create_datagram_endpoint(protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]]=..., remote_addr: Optional[Tuple[str, int]]=..., *, family: int=..., proto: int=..., flags: int=..., reuse_address: Optional[bool]=..., reuse_port: Optional[bool]=..., allow_broadcast: Optional[bool]=..., sock: Optional[socket]=...) -> _TransProtPair
at: examples.client
loop = asyncio.get_event_loop()
at: ipaddress
ip_address(address: object) -> Any
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
- def feed_eof(self) -> None:
- self._eof = True
- self._wakeup_waiter()
-
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
+ def has_data_to_read(self) -> bool:
+ return (
+ bool(self._recv_ranges) and self._recv_ranges[0].start == self._recv_start
+ )
+
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
+ # asyncio.Transport
+
+ def get_extra_info(self, name: str, default: Any = None) -> Any:
+ """
+ Returns information about the underlying QUIC stream.
+ """
+ if name == "stream_id":
+ return self.stream_id
+
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def connection_lost(self, exc: Exception) -> None:
for stream in self.streams.values():
+ if stream.reader:
+ stream.reader.feed_eof()
- stream.feed_eof()
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
- def _wakeup_waiter(self) -> None:
- """
- Wakeup read() function.
- """
- waiter = self._recv_waiter
- if waiter is not None:
- self._recv_waiter = None
- if not waiter.cancelled():
- waiter.set_result(None)
-
===========changed ref 5===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_recv_ordered_3(self):
+ stream = QuicStream(stream_id=0)
- stream = QuicStream()
async def add_frame():
stream.add_frame(QuicStreamFrame(offset=0, data=b"01234567"))
+ data, _ = run(asyncio.gather(stream.reader.read(1024), delay(add_frame)))
- data, _ = run(asyncio.gather(stream.read(), delay(add_frame)))
self.assertEqual(data, b"01234567")
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
def pull_data(self) -> bytes:
"""
Pull received data.
"""
- # no data, or gap at start
- if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
+ if not self.has_data_to_read():
return b""
r = self._recv_ranges.shift()
pos = r.stop - r.start
data = self._recv_buffer[:pos]
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
return data
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
- def read(self) -> bytes:
- """
- Read data from the stream.
- """
- if (
- not self._recv_ranges
- or self._recv_ranges[0].start != self._recv_start
- and not self._eof
- ):
- assert self._recv_waiter is None
- self._recv_waiter = self._loop.create_future()
- try:
- await self._recv_waiter
- finally:
- self._recv_waiter = None
-
- return self.pull_data()
-
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
+ def create_stream(
+ self, is_unidirectional: bool = False
+ ) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
- def create_stream(self, is_unidirectional: bool = False) -> QuicStream:
"""
+ Create a QUIC stream and return a pair of (reader, writer) objects.
+
+ The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
+ and :class:`asyncio.StreamWriter` classes.
- Create a :class:`QuicStream` and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+ stream = self._get_or_create_stream(stream_id)
- return self._get_or_create_stream(stream_id)
+ return stream.reader, stream.writer
===========changed ref 9===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
+
+ 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._eof = False
- self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
- self._recv_waiter: Optional[asyncio.Future] = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 10===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
# frame has been entirely consumed
if pos + count <= 0:
return
# frame has been partially consumed
if pos < 0:
count += pos
frame.data = frame.data[-pos:]
frame.offset -= pos
pos = 0
# marked received
self._recv_ranges.add(frame.offset, frame.offset + count)
# add data
gap = pos - len(self._recv_buffer)
if gap > 0:
self._recv_buffer += bytearray(gap)
self._recv_buffer[pos : pos + count] = frame.data
+ if self.reader and self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
- if not pos:
- self._wakeup_waiter()
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<19>:<add> client_reader, client_writer = client.create_stream()
<del> client_stream = client.create_stream()
<20>:<add> client_writer.write(b"ping")
<del> client_stream.write(b"ping")
<24>:<add> # FIXME: needs an API
<add> server_reader, server_writer = (
<add> server.streams[0].reader,
<add> server.streams[0].writer,
<add> )
<del> server_stream = server.streams[0]
<25>:<add> self.assertEqual(run(server_reader.read(1024)), b"ping")
<del> self.assertEqual(run(server_stream.read()), b"ping")
<26>:<add> server_writer.write(b"pong")
<del> server_stream.write(b"pong")
<28>:<add> self.assertEqual(run(client_reader.read(1024)), b"pong")
<del> self.assertEqual(run(client_stream.read()), b"pong")
|
# 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> client.version = max(client_versions)
<3>
<4> server = QuicConnection(
<5> is_client=False,
<6> certificate=SERVER_CERTIFICATE,
<7> private_key=SERVER_PRIVATE_KEY,
<8> )
<9> server.supported_versions = server_versions
<10> server.version = max(server_versions)
<11>
<12> # perform handshake
<13> client_transport, server_transport = create_transport(client, server)
<14> self.assertEqual(client_transport.sent, 4)
<15> self.assertEqual(server_transport.sent, 3)
<16> run(client.connect())
<17>
<18> # send data over stream
<19> client_stream = client.create_stream()
<20> client_stream.write(b"ping")
<21> self.assertEqual(client_transport.sent, 5)
<22> self.assertEqual(server_transport.sent, 4)
<23>
<24> server_stream = server.streams[0]
<25> self.assertEqual(run(server_stream.read()), b"ping")
<26> server_stream.write(b"pong")
<27>
<28> self.assertEqual(run(client_stream.read()), b"pong")
<29>
<30> return client, server
<31>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connect() -> None
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
at: asyncio.streams.StreamWriter
write(data: bytes) -> None
at: tests.test_connection
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()
)
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
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
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def create_stream(
+ self, is_unidirectional: bool = False
+ ) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
- def create_stream(self, is_unidirectional: bool = False) -> QuicStream:
"""
+ Create a QUIC stream and return a pair of (reader, writer) objects.
+
+ The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
+ and :class:`asyncio.StreamWriter` classes.
- Create a :class:`QuicStream` and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+ stream = self._get_or_create_stream(stream_id)
- return self._get_or_create_stream(stream_id)
+ return stream.reader, stream.writer
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
- def feed_eof(self) -> None:
- self._eof = True
- self._wakeup_waiter()
-
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
+ def has_data_to_read(self) -> bool:
+ return (
+ bool(self._recv_ranges) and self._recv_ranges[0].start == self._recv_start
+ )
+
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
+ # asyncio.Transport
+
+ def get_extra_info(self, name: str, default: Any = None) -> Any:
+ """
+ Returns information about the underlying QUIC stream.
+ """
+ if name == "stream_id":
+ return self.stream_id
+
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def connection_lost(self, exc: Exception) -> None:
for stream in self.streams.values():
+ if stream.reader:
+ stream.reader.feed_eof()
- stream.feed_eof()
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
- def _wakeup_waiter(self) -> None:
- """
- Wakeup read() function.
- """
- waiter = self._recv_waiter
- if waiter is not None:
- self._recv_waiter = None
- if not waiter.cancelled():
- waiter.set_result(None)
-
===========changed ref 6===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_recv_ordered_3(self):
+ stream = QuicStream(stream_id=0)
- stream = QuicStream()
async def add_frame():
stream.add_frame(QuicStreamFrame(offset=0, data=b"01234567"))
+ data, _ = run(asyncio.gather(stream.reader.read(1024), delay(add_frame)))
- data, _ = run(asyncio.gather(stream.read(), delay(add_frame)))
self.assertEqual(data, b"01234567")
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
def pull_data(self) -> bytes:
"""
Pull received data.
"""
- # no data, or gap at start
- if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
+ if not self.has_data_to_read():
return b""
r = self._recv_ranges.shift()
pos = r.stop - r.start
data = self._recv_buffer[:pos]
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
return data
===========changed ref 8===========
# module: aioquic.stream
class QuicStream:
- def read(self) -> bytes:
- """
- Read data from the stream.
- """
- if (
- not self._recv_ranges
- or self._recv_ranges[0].start != self._recv_start
- and not self._eof
- ):
- assert self._recv_waiter is None
- self._recv_waiter = self._loop.create_future()
- try:
- await self._recv_waiter
- finally:
- self._recv_waiter = None
-
- return self.pull_data()
-
===========changed ref 9===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
+
+ 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._eof = False
- self._loop = asyncio.get_event_loop()
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
- self._recv_waiter: Optional[asyncio.Future] = None
self._send_buffer = bytearray()
self._send_start = 0
self.__stream_id = stream_id
|
tests.test_connection/QuicConnectionTest.test_create_stream
|
Modified
|
aiortc~aioquic
|
24e05e81b4b119de8061683952fdac4d98ff7e78
|
[stream] use asyncio.StreamReader and asyncio.StreamWriter
|
<11>:<add> reader, writer = client.create_stream()
<del> stream = client.create_stream()
<12>:<add> self.assertEqual(writer.get_extra_info("stream_id"), 0)
<del> self.assertEqual(stream.stream_id, 0)
<14>:<add> reader, writer = client.create_stream()
<del> stream = client.create_stream()
<15>:<add> self.assertEqual(writer.get_extra_info("stream_id"), 4)
<del> self.assertEqual(stream.stream_id, 4)
<17>:<add> reader, writer = client.create_stream(is_unidirectional=True)
<del> stream = client.create_stream(is_unidirectional=True)
<18>:<add> self.assertEqual(writer.get_extra_info("stream_id"), 2)
<del> self.assertEqual(stream.stream_id, 2)
<20>:<add> reader, writer = client.create_stream(is_unidirectional=True)
<del> stream = client.create_stream(is_unidirectional=True)
<21>:<add> self.assertEqual(writer.get_extra_info("stream_id"), 6)
<del> self.assertEqual(stream.stream_id, 6)
<24>:<add> reader, writer = server.create_stream()
<del> stream = server.create_stream()
<25>:<add> self.assertEqual(writer.get_extra_info("stream_id"), 1)
<del> self.assertEqual(stream.stream_id, 1)
<27>:<add> reader, writer = server.create_stream()
<del> stream = server.create_stream()
<28>:<add> self.assertEqual(
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_create_stream(self):
<0> client = QuicConnection(is_client=True)
<1> client._initialize(b"")
<2>
<3> server = QuicConnection(
<4> is_client=False,
<5> certificate=SERVER_CERTIFICATE,
<6> private_key=SERVER_PRIVATE_KEY,
<7> )
<8> server._initialize(b"")
<9>
<10> # client
<11> stream = client.create_stream()
<12> self.assertEqual(stream.stream_id, 0)
<13>
<14> stream = client.create_stream()
<15> self.assertEqual(stream.stream_id, 4)
<16>
<17> stream = client.create_stream(is_unidirectional=True)
<18> self.assertEqual(stream.stream_id, 2)
<19>
<20> stream = client.create_stream(is_unidirectional=True)
<21> self.assertEqual(stream.stream_id, 6)
<22>
<23> # server
<24> stream = server.create_stream()
<25> self.assertEqual(stream.stream_id, 1)
<26>
<27> stream = server.create_stream()
<28> self.assertEqual(stream.stream_id, 5)
<29>
<30> stream = server.create_stream(is_unidirectional=True)
<31> self.assertEqual(stream.stream_id, 3)
<32>
<33> stream = server.create_stream(is_unidirectional=True)
<34> self.assertEqual(stream.stream_id, 7)
<35>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
_initialize(peer_cid: bytes) -> None
at: asyncio.streams.StreamWriter
get_extra_info(name: str, default: Any=...) -> Any
at: tests.test_connection
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: aioquic.connection
class QuicConnection:
+ def create_stream(
+ self, is_unidirectional: bool = False
+ ) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
- def create_stream(self, is_unidirectional: bool = False) -> QuicStream:
"""
+ Create a QUIC stream and return a pair of (reader, writer) objects.
+
+ The returned reader and writer objects are instances of :class:`asyncio.StreamReader`
+ and :class:`asyncio.StreamWriter` classes.
- Create a :class:`QuicStream` and return it.
"""
stream_id = (int(is_unidirectional) << 1) | int(not self.is_client)
while stream_id in self.streams:
stream_id += 4
+ stream = self._get_or_create_stream(stream_id)
- return self._get_or_create_stream(stream_id)
+ return stream.reader, stream.writer
===========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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
client_transport, server_transport = create_transport(client, server)
self.assertEqual(client_transport.sent, 4)
self.assertEqual(server_transport.sent, 3)
run(client.connect())
# send data over stream
+ client_reader, client_writer = client.create_stream()
- client_stream = client.create_stream()
+ client_writer.write(b"ping")
- client_stream.write(b"ping")
self.assertEqual(client_transport.sent, 5)
self.assertEqual(server_transport.sent, 4)
+ # FIXME: needs an API
+ server_reader, server_writer = (
+ server.streams[0].reader,
+ server.streams[0].writer,
+ )
- server_stream = server.streams[0]
+ self.assertEqual(run(server_reader.read(1024)), b"ping")
- self.assertEqual(run(server_stream.read()), b"ping")
+ server_writer.write(b"pong")
- server_stream.write(b"pong")
+ self.assertEqual(run(client_reader.read(1024)), b"pong")
- self.assertEqual(run(client_stream.read()), b"pong")
return client, server
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
- def feed_eof(self) -> None:
- self._eof = True
- self._wakeup_waiter()
-
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
+ def has_data_to_read(self) -> bool:
+ return (
+ bool(self._recv_ranges) and self._recv_ranges[0].start == self._recv_start
+ )
+
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
+ # asyncio.Transport
+
+ def get_extra_info(self, name: str, default: Any = None) -> Any:
+ """
+ Returns information about the underlying QUIC stream.
+ """
+ if name == "stream_id":
+ return self.stream_id
+
===========changed ref 5===========
# module: aioquic.connection
class QuicConnection:
def connection_lost(self, exc: Exception) -> None:
for stream in self.streams.values():
+ if stream.reader:
+ stream.reader.feed_eof()
- stream.feed_eof()
===========changed ref 6===========
# module: aioquic.stream
class QuicStream:
- def _wakeup_waiter(self) -> None:
- """
- Wakeup read() function.
- """
- waiter = self._recv_waiter
- if waiter is not None:
- self._recv_waiter = None
- if not waiter.cancelled():
- waiter.set_result(None)
-
===========changed ref 7===========
# module: tests.test_stream
class QuicStreamTest(TestCase):
def test_recv_ordered_3(self):
+ stream = QuicStream(stream_id=0)
- stream = QuicStream()
async def add_frame():
stream.add_frame(QuicStreamFrame(offset=0, data=b"01234567"))
+ data, _ = run(asyncio.gather(stream.reader.read(1024), delay(add_frame)))
- data, _ = run(asyncio.gather(stream.read(), delay(add_frame)))
self.assertEqual(data, b"01234567")
===========changed ref 8===========
# module: aioquic.stream
class QuicStream:
def pull_data(self) -> bytes:
"""
Pull received data.
"""
- # no data, or gap at start
- if not self._recv_ranges or self._recv_ranges[0].start != self._recv_start:
+ if not self.has_data_to_read():
return b""
r = self._recv_ranges.shift()
pos = r.stop - r.start
data = self._recv_buffer[:pos]
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
return data
===========changed ref 9===========
# module: aioquic.stream
class QuicStream:
- def read(self) -> bytes:
- """
- Read data from the stream.
- """
- if (
- not self._recv_ranges
- or self._recv_ranges[0].start != self._recv_start
- and not self._eof
- ):
- assert self._recv_waiter is None
- self._recv_waiter = self._loop.create_future()
- try:
- await self._recv_waiter
- finally:
- self._recv_waiter = None
-
- return self.pull_data()
-
|
aioquic.stream/QuicStream.__init__
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<14>:<add> self._send_fin = False
|
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
<0> self._connection = connection
<1>
<2> if stream_id is not None:
<3> self.reader = asyncio.StreamReader()
<4> self.writer = asyncio.StreamWriter(self, None, self.reader, None)
<5> else:
<6> self.reader = None
<7> self.writer = None
<8>
<9> self._recv_buffer = bytearray()
<10> self._recv_start = 0
<11> self._recv_ranges = RangeSet()
<12>
<13> self._send_buffer = bytearray()
<14> self._send_start = 0
<15>
<16> self.__stream_id = stream_id
<17>
|
===========unchanged ref 0===========
at: aioquic.rangeset
RangeSet(ranges: Iterable[range]=[])
at: aioquic.stream.QuicStream.add_frame
self._recv_buffer += bytearray(gap)
at: aioquic.stream.QuicStream.get_frame
self._send_buffer = self._send_buffer[size:]
self._send_fin = False
self._send_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
at: aioquic.stream.QuicStream.write_eof
self._send_fin = True
at: asyncio.streams
StreamWriter(transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop)
StreamReader(limit: int=..., loop: Optional[events.AbstractEventLoop]=...)
===========changed ref 0===========
# module: aioquic.packet
@dataclass
class QuicStreamFrame:
data: bytes = b""
+ fin: bool = False
offset: int = 0
===========changed ref 1===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
|
aioquic.stream/QuicStream.add_frame
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<6>:<del> # frame has been entirely consumed
<7>:<add> if pos + count > 0:
<del> if pos + count <= 0:
<8>:<add> # frame has been partially consumed
<add> if pos < 0:
<add> count += pos
<add> frame.data = frame.data[-pos:]
<add> frame.offset -= pos
<add> pos = 0
<del> return
<10>:<del> # frame has been partially consumed
<11>:<del> if pos < 0:
<12>:<del> count += pos
<13>:<del> frame.data = frame.data[-pos:]
<14>:<del> frame.offset -= pos
<15>:<del> pos = 0
<16>:<add> # marked received
<add> self._recv_ranges.add(frame.offset, frame.offset + count)
<17>:<add> # add data
<add> gap = pos - len(self._recv_buffer)
<add> if gap > 0:
<add> self._recv_buffer += bytearray(gap)
<add> self._recv_buffer[pos : pos + count] = frame.data
<del> # marked received
<18>:<del> self._recv_ranges.add(frame.offset, frame.offset + count)
<20>:<add> if self.reader:
<add> if self.has_data_to_read():
<add> self.reader.feed_data(self.pull_data())
<add> if frame.fin:
<add> self.reader.feed_eof()
<del> # add data
<21>:<del> gap = pos - len(self._recv_buffer)
<22>:<del> if gap > 0:
<23>:<del> self._recv_buffer += bytearray(gap)
<24>:<del> self._recv_buffer[pos : pos + count] = frame.data
<26>:<del> if self.reader and self.has_data_to_read():
<27>:<del> self.reader.feed_data(self.pull_data())
<28>:<del>
|
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
<0> """
<1> Add a frame of received data.
<2> """
<3> pos = frame.offset - self._recv_start
<4> count = len(frame.data)
<5>
<6> # frame has been entirely consumed
<7> if pos + count <= 0:
<8> return
<9>
<10> # frame has been partially consumed
<11> if pos < 0:
<12> count += pos
<13> frame.data = frame.data[-pos:]
<14> frame.offset -= pos
<15> pos = 0
<16>
<17> # marked received
<18> self._recv_ranges.add(frame.offset, frame.offset + count)
<19>
<20> # add data
<21> gap = pos - len(self._recv_buffer)
<22> if gap > 0:
<23> self._recv_buffer += bytearray(gap)
<24> self._recv_buffer[pos : pos + count] = frame.data
<25>
<26> if self.reader and self.has_data_to_read():
<27> self.reader.feed_data(self.pull_data())
<28>
|
===========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.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
at: aioquic.stream.QuicStream
has_data_to_read() -> bool
pull_data() -> bytes
at: aioquic.stream.QuicStream.__init__
self.reader = asyncio.StreamReader()
self.reader = None
self._recv_buffer = bytearray()
self._recv_start = 0
self._recv_ranges = RangeSet()
at: aioquic.stream.QuicStream.pull_data
self._recv_buffer = self._recv_buffer[pos:]
self._recv_start = r.stop
at: asyncio.streams.StreamReader
_source_traceback = None
feed_data(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.packet
@dataclass
class QuicStreamFrame:
data: bytes = b""
+ fin: bool = False
offset: int = 0
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
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_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
+ self._send_fin = False
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 2===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
|
aioquic.stream/QuicStream.get_frame
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<5>:<add> frame.fin = self._send_fin
<6>:<add> self._send_fin = False
|
# module: aioquic.stream
class QuicStream:
def get_frame(self, size: int) -> QuicStreamFrame:
<0> """
<1> Get a frame of data to send.
<2> """
<3> size = min(size, len(self._send_buffer))
<4> frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
<5> self._send_buffer = self._send_buffer[size:]
<6> self._send_start += size
<7> return frame
<8>
|
===========unchanged ref 0===========
at: aioquic.packet
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
at: aioquic.packet.QuicStreamFrame
fin: bool = False
at: aioquic.stream.QuicStream.__init__
self._send_buffer = bytearray()
self._send_fin = False
self._send_start = 0
at: aioquic.stream.QuicStream.get_frame
self._send_fin = False
self._send_start += size
at: aioquic.stream.QuicStream.write
self._send_buffer += data
at: aioquic.stream.QuicStream.write_eof
self._send_fin = True
===========changed ref 0===========
# module: aioquic.packet
@dataclass
class QuicStreamFrame:
data: bytes = b""
+ fin: bool = False
offset: int = 0
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
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_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
+ self._send_fin = False
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
- # frame has been entirely consumed
+ if pos + count > 0:
- if pos + count <= 0:
+ # frame has been partially consumed
+ if pos < 0:
+ count += pos
+ frame.data = frame.data[-pos:]
+ frame.offset -= pos
+ pos = 0
- return
- # frame has been partially consumed
- if pos < 0:
- count += pos
- frame.data = frame.data[-pos:]
- frame.offset -= pos
- pos = 0
+ # marked received
+ self._recv_ranges.add(frame.offset, frame.offset + count)
+ # add data
+ gap = pos - len(self._recv_buffer)
+ if gap > 0:
+ self._recv_buffer += bytearray(gap)
+ self._recv_buffer[pos : pos + count] = frame.data
- # marked received
- self._recv_ranges.add(frame.offset, frame.offset + count)
+ if self.reader:
+ if self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
+ if frame.fin:
+ self.reader.feed_eof()
- # add data
- gap = pos - len(self._recv_buffer)
- if gap > 0:
- self._recv_buffer += bytearray(gap)
- self._recv_buffer[pos : pos + count] = frame.data
- if self.reader and self.has_data_to_read():
- self.reader.feed_data(self.pull_data())
-
===========changed ref 3===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
|
aioquic.stream/QuicStream.has_data_to_send
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<0>:<add> return bool(self._send_buffer) or self._send_fin
<del> return bool(self._send_buffer)
|
# module: aioquic.stream
class QuicStream:
def has_data_to_send(self) -> bool:
<0> return bool(self._send_buffer)
<1>
|
===========unchanged ref 0===========
at: aioquic.stream.QuicStream.__init__
self._recv_start = 0
self._recv_ranges = RangeSet()
at: aioquic.stream.QuicStream.pull_data
self._recv_start = r.stop
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
def get_frame(self, size: int) -> QuicStreamFrame:
"""
Get a frame of data to send.
"""
size = min(size, len(self._send_buffer))
frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
+ frame.fin = self._send_fin
self._send_buffer = self._send_buffer[size:]
+ self._send_fin = False
self._send_start += size
return frame
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
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_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
+ self._send_fin = False
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
- # frame has been entirely consumed
+ if pos + count > 0:
- if pos + count <= 0:
+ # frame has been partially consumed
+ if pos < 0:
+ count += pos
+ frame.data = frame.data[-pos:]
+ frame.offset -= pos
+ pos = 0
- return
- # frame has been partially consumed
- if pos < 0:
- count += pos
- frame.data = frame.data[-pos:]
- frame.offset -= pos
- pos = 0
+ # marked received
+ self._recv_ranges.add(frame.offset, frame.offset + count)
+ # add data
+ gap = pos - len(self._recv_buffer)
+ if gap > 0:
+ self._recv_buffer += bytearray(gap)
+ self._recv_buffer[pos : pos + count] = frame.data
- # marked received
- self._recv_ranges.add(frame.offset, frame.offset + count)
+ if self.reader:
+ if self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
+ if frame.fin:
+ self.reader.feed_eof()
- # add data
- gap = pos - len(self._recv_buffer)
- if gap > 0:
- self._recv_buffer += bytearray(gap)
- self._recv_buffer[pos : pos + count] = frame.data
- if self.reader and self.has_data_to_read():
- self.reader.feed_data(self.pull_data())
-
===========changed ref 3===========
# module: aioquic.packet
@dataclass
class QuicStreamFrame:
data: bytes = b""
+ fin: bool = False
offset: int = 0
===========changed ref 4===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<29>:<add> if flags & QuicStreamFlag.OFF:
<del> if flags & STREAM_FLAG_OFF:
<33>:<add> if flags & QuicStreamFlag.LEN:
<del> if flags & STREAM_FLAG_LEN:
<37>:<add> frame = QuicStreamFrame(
<add> offset=offset,
<add> data=pull_bytes(buf, length),
<add> fin=bool(flags & QuicStreamFlag.FIN),
<add> )
<del> frame = QuicStreamFrame(offset=offset, data=pull_bytes(buf, length))
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> self.tls.handle_message(data, self.send_buffer)
<18> if not self.__connected.is_set() and self.tls.state in [
<19> tls.State.CLIENT_POST_HANDSHAKE,
<20> tls.State.SERVER_POST_HANDSHAKE,
<21> ]:
<22> self.__connected.set()
<23>
<24> elif frame_type == QuicFrameType.NEW_TOKEN:
<25> packet.pull_new_token_frame(buf)
<26> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<27> flags = frame_type & STREAM_FLAGS
<28> stream_id = pull_uint_var(buf)
<29> if flags & STREAM_FLAG_OFF:
<30> offset = pull_uint_var(buf)
<31> else:
<32> offset = 0
<33> if flags & STREAM_FLAG_LEN:
<34> length = pull_uint_var(buf)
<35> else:
<36> length = buf.capacity - buf.tell()
<37> frame = QuicStreamFrame(offset=offset, data=pull_bytes(buf, length))
<38> stream = self._get</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type in [
QuicFrameType.MAX_STREAMS_BIDI,
QuicFrameType.MAX_STREAMS_UNI,
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
connection_lost(exc: Exception) -> None
_get_or_create_stream(stream_id: int) -> QuicStream
_push_crypto_data() -> None
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__connected = asyncio.Event()
self.__logger = logger
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.QuicConnection._payload_received
buf = Buffer(data=plain)
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]
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
===========unchanged ref 1===========
pull_new_token_frame(buf: Buffer) -> bytes
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
pull_application_close_frame(buf: Buffer) -> Tuple[int, bytes]
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
State()
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.packet
@dataclass
class QuicStreamFrame:
data: bytes = b""
+ fin: bool = False
offset: int = 0
===========changed ref 1===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
- # frame has been entirely consumed
+ if pos + count > 0:
- if pos + count <= 0:
+ # frame has been partially consumed
+ if pos < 0:
+ count += pos
+ frame.data = frame.data[-pos:]
+ frame.offset -= pos
+ pos = 0
- return
- # frame has been partially consumed
- if pos < 0:
- count += pos
- frame.data = frame.data[-pos:]
- frame.offset -= pos
- pos = 0
+ # marked received
+ self._recv_ranges.add(frame.offset, frame.offset + count)
+ # add data
+ gap = pos - len(self._recv_buffer)
+ if gap > 0:
+ self._recv_buffer += bytearray(gap)
+ self._recv_buffer[pos : pos + count] = frame.data
- # marked received
- self._recv_ranges.add(frame.offset, frame.offset + count)
+ if self.reader:
+ if self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
+ if frame.fin:
+ self.reader.feed_eof()
- # add data
- gap = pos - len(self._recv_buffer)
- if gap > 0:
- self._recv_buffer += bytearray(gap)
- self._recv_buffer[pos : pos + count] = frame.data
- if self.reader and self.has_data_to_read():
- self.reader.feed_data(self.pull_data())
-
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<26>:<add> flags = QuicStreamFlag.OFF | QuicStreamFlag.LEN
<add> if frame.fin:
<add> flags |= QuicStreamFlag.FIN
<add> push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
<del> push_uint_var(buf, QuicFrameType.STREAM_BASE + 0x07)
|
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> space = self.spaces[epoch]
<2> send_ack = space.ack_queue if self.send_ack[epoch] else None
<3> if not space.crypto.send.is_valid():
<4> return
<5>
<6> buf = Buffer(capacity=PACKET_MAX_SIZE)
<7>
<8> # write header
<9> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10> push_bytes(buf, self.peer_cid)
<11> push_uint16(buf, self.packet_number)
<12> header_size = buf.tell()
<13>
<14> # ACK
<15> if send_ack:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, send_ack, 0)
<18> self.send_ack[epoch] = False
<19>
<20> # STREAM
<21> for stream_id, stream in self.streams.items():
<22> if isinstance(stream_id, int) and stream.has_data_to_send():
<23> frame = stream.get_frame(
<24> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
<25> )
<26> push_uint_var(buf, QuicFrameType.STREAM_BASE + 0x07)
<27> with push_stream_frame(buf, 0, frame.offset):
<28> push_bytes(buf, frame.data)
<29>
<30> # encrypt
<31> packet_size = buf.tell()
<32> if packet_size > header_size:
<33> data = buf.data
<34> yield space.crypto.encrypt_packet(
<35> data[0:header_size], data[header_size:packet_size]
<36> )
<37>
<38> self.packet_number += 1
<39>
|
===========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.buffer.Buffer
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
SEND_PN_SIZE = 2
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection.__init__
self.peer_cid = os.urandom(8)
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._update_traffic_key
crypto = self.spaces[epoch].crypto
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_close
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
===========unchanged ref 1===========
at: aioquic.crypto.CryptoContext
is_valid() -> bool
setup(cipher_suite: CipherSuite, secret: bytes) -> None
at: aioquic.crypto.CryptoPair.__init__
self.aead_tag_size = 16
self.recv = CryptoContext()
self.send = CryptoContext()
at: aioquic.packet
PACKET_FIXED_BIT = 0x40
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
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
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
at: aioquic.tls
Epoch()
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
at: aioquic.tls.Context._client_handle_hello
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.__init__
self.cipher_suite = cipher_suite
===========unchanged ref 2===========
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
===========changed ref 0===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
===========changed ref 1===========
# module: aioquic.stream
class QuicStream:
def has_data_to_send(self) -> bool:
+ return bool(self._send_buffer) or self._send_fin
- return bool(self._send_buffer)
===========changed ref 2===========
# module: aioquic.stream
class QuicStream:
def get_frame(self, size: int) -> QuicStreamFrame:
"""
Get a frame of data to send.
"""
size = min(size, len(self._send_buffer))
frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
+ frame.fin = self._send_fin
self._send_buffer = self._send_buffer[size:]
+ self._send_fin = False
self._send_start += size
return frame
===========changed ref 3===========
# module: aioquic.connection
logger = logging.getLogger("quic")
PACKET_MAX_SIZE = 1280
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",
],
]
SEND_PN_SIZE = 2
STREAM_FLAGS = 0x07
- STREAM_FLAG_FIN = 1
- STREAM_FLAG_LEN = 2
- STREAM_FLAG_OFF = 4
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
buf = Buffer(data=plain)
is_ack_only = True
while not buf.eof():
frame_type = pull_uint_var(buf)
if frame_type != QuicFrameType.ACK:
is_ack_only = False
if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
pass
elif frame_type == QuicFrameType.ACK:
packet.pull_ack_frame(buf)
elif frame_type == QuicFrameType.CRYPTO:
stream = self.streams[epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
self.tls.handle_message(data, self.send_buffer)
if not self.__connected.is_set() and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
self.__connected.set()
elif frame_type == QuicFrameType.NEW_TOKEN:
packet.pull_new_token_frame(buf)
elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
flags = frame_type & STREAM_FLAGS
stream_id = pull_uint_var(buf)
+ if flags & QuicStreamFlag.OFF:
- if flags & STREAM_FLAG_OFF:
offset = pull_uint_var(buf)
else:
offset = 0
+ if flags & QuicStreamFlag.LEN:
- if flags & STREAM_FLAG_LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
+ frame = QuicStreamFrame(
+ offset=offset,
+ data=pull_bytes(buf, length),
+ fin=bool(flags & Quic</s>
|
examples.client/run
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<14>:<add> writer.write_eof()
|
# module: examples.client
def run(host, port, **kwargs):
<0> # if host is not an IP address, pass it to enable SNI
<1> try:
<2> ipaddress.ip_address(host)
<3> except ValueError:
<4> kwargs["server_name"] = host
<5>
<6> _, protocol = await loop.create_datagram_endpoint(
<7> lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port)
<8> )
<9> await protocol.connect()
<10>
<11> # perform HTTP/0.9 request
<12> reader, writer = protocol.create_stream()
<13> writer.write(b"GET /\r\n")
<14> print(await reader.read(1024))
<15>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: asyncio.events.AbstractEventLoop
create_datagram_endpoint(protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]]=..., remote_addr: Optional[Tuple[str, int]]=..., *, family: int=..., proto: int=..., flags: int=..., reuse_address: Optional[bool]=..., reuse_port: Optional[bool]=..., allow_broadcast: Optional[bool]=..., sock: Optional[socket]=...) -> _TransProtPair
at: examples.client
loop = asyncio.get_event_loop()
at: ipaddress
ip_address(address: object) -> Any
===========changed ref 0===========
# module: aioquic.stream
class QuicStream:
+ def write_eof(self):
+ self._send_fin = True
+ self._connection._send_pending()
+
===========changed ref 1===========
# module: aioquic.packet
@dataclass
class QuicStreamFrame:
data: bytes = b""
+ fin: bool = False
offset: int = 0
===========changed ref 2===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
def has_data_to_send(self) -> bool:
+ return bool(self._send_buffer) or self._send_fin
- return bool(self._send_buffer)
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
def get_frame(self, size: int) -> QuicStreamFrame:
"""
Get a frame of data to send.
"""
size = min(size, len(self._send_buffer))
frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
+ frame.fin = self._send_fin
self._send_buffer = self._send_buffer[size:]
+ self._send_fin = False
self._send_start += size
return frame
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
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_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
+ self._send_fin = False
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 6===========
# module: aioquic.connection
logger = logging.getLogger("quic")
PACKET_MAX_SIZE = 1280
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",
],
]
SEND_PN_SIZE = 2
STREAM_FLAGS = 0x07
- STREAM_FLAG_FIN = 1
- STREAM_FLAG_LEN = 2
- STREAM_FLAG_OFF = 4
===========changed ref 7===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
- # frame has been entirely consumed
+ if pos + count > 0:
- if pos + count <= 0:
+ # frame has been partially consumed
+ if pos < 0:
+ count += pos
+ frame.data = frame.data[-pos:]
+ frame.offset -= pos
+ pos = 0
- return
- # frame has been partially consumed
- if pos < 0:
- count += pos
- frame.data = frame.data[-pos:]
- frame.offset -= pos
- pos = 0
+ # marked received
+ self._recv_ranges.add(frame.offset, frame.offset + count)
+ # add data
+ gap = pos - len(self._recv_buffer)
+ if gap > 0:
+ self._recv_buffer += bytearray(gap)
+ self._recv_buffer[pos : pos + count] = frame.data
- # marked received
- self._recv_ranges.add(frame.offset, frame.offset + count)
+ if self.reader:
+ if self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
+ if frame.fin:
+ self.reader.feed_eof()
- # add data
- gap = pos - len(self._recv_buffer)
- if gap > 0:
- self._recv_buffer += bytearray(gap)
- self._recv_buffer[pos : pos + count] = frame.data
- if self.reader and self.has_data_to_read():
- self.reader.feed_data(self.pull_data())
-
===========changed ref 8===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
epoch = tls.Epoch.ONE_RTT
space = self.spaces[epoch]
send_ack = space.ack_queue if self.send_ack[epoch] else None
if not space.crypto.send.is_valid():
return
buf = Buffer(capacity=PACKET_MAX_SIZE)
# write header
push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
push_bytes(buf, self.peer_cid)
push_uint16(buf, self.packet_number)
header_size = buf.tell()
# ACK
if send_ack:
push_uint_var(buf, QuicFrameType.ACK)
packet.push_ack_frame(buf, send_ack, 0)
self.send_ack[epoch] = False
# STREAM
for stream_id, stream in self.streams.items():
if isinstance(stream_id, int) and stream.has_data_to_send():
frame = stream.get_frame(
PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
)
+ flags = QuicStreamFlag.OFF | QuicStreamFlag.LEN
+ if frame.fin:
+ flags |= QuicStreamFlag.FIN
+ push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
- push_uint_var(buf, QuicFrameType.STREAM_BASE + 0x07)
with push_stream_frame(buf, 0, frame.offset):
push_bytes(buf, frame.data)
# encrypt
packet_size = buf.tell()
if packet_size > header_size:
data = buf.data
yield space.crypto.encrypt_packet(
data[0:header_size], data[header_size:packet_size]
)
self.packet_number += 1
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
dfdd122a0bf64786caf5eaffddcb703edd0bee15
|
[streams] handle FIN flag correctly
|
<31>:<add> self.assertEqual(client_transport.sent, 6)
<add> self.assertEqual(server_transport.sent, 5)
<32>:<add> # client receives pong
<33>:<add>
<add> # client writes EOF
<add> client_writer.write_eof()
<add> self.assertEqual(client_transport.sent, 7)
<add> self.assertEqual(server_transport.sent, 6)
<add>
<add> # server receives EOF
<add> self.assertEqual(run(server_reader.read()), b"")
|
# 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> client.version = max(client_versions)
<3>
<4> server = QuicConnection(
<5> is_client=False,
<6> certificate=SERVER_CERTIFICATE,
<7> private_key=SERVER_PRIVATE_KEY,
<8> )
<9> server.supported_versions = server_versions
<10> server.version = max(server_versions)
<11>
<12> # perform handshake
<13> client_transport, server_transport = create_transport(client, server)
<14> self.assertEqual(client_transport.sent, 4)
<15> self.assertEqual(server_transport.sent, 3)
<16> run(client.connect())
<17>
<18> # send data over stream
<19> client_reader, client_writer = client.create_stream()
<20> client_writer.write(b"ping")
<21> self.assertEqual(client_transport.sent, 5)
<22> self.assertEqual(server_transport.sent, 4)
<23>
<24> # FIXME: needs an API
<25> server_reader, server_writer = (
<26> server.streams[0].reader,
<27> server.streams[0].writer,
<28> )
<29> self.assertEqual(run(server_reader.read(1024)), b"ping")
<30> server_writer.write(b"pong")
<31>
<32> self.assertEqual(run(client_reader.read(1024)), b"pong")
<33>
<34> return client, server
<35>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connect() -> None
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
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: tests.test_connection
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()
)
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.utils
run(coro)
===========unchanged ref 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.stream
class QuicStream:
+ def write_eof(self):
+ self._send_fin = True
+ self._connection._send_pending()
+
===========changed ref 1===========
# module: aioquic.packet
@dataclass
class QuicStreamFrame:
data: bytes = b""
+ fin: bool = False
offset: int = 0
===========changed ref 2===========
# module: aioquic.packet
+ class QuicStreamFlag(IntFlag):
+ FIN = 0x01
+ LEN = 0x02
+ OFF = 0x04
+
===========changed ref 3===========
# module: aioquic.stream
class QuicStream:
def has_data_to_send(self) -> bool:
+ return bool(self._send_buffer) or self._send_fin
- return bool(self._send_buffer)
===========changed ref 4===========
# module: aioquic.stream
class QuicStream:
def get_frame(self, size: int) -> QuicStreamFrame:
"""
Get a frame of data to send.
"""
size = min(size, len(self._send_buffer))
frame = QuicStreamFrame(data=self._send_buffer[:size], offset=self._send_start)
+ frame.fin = self._send_fin
self._send_buffer = self._send_buffer[size:]
+ self._send_fin = False
self._send_start += size
return frame
===========changed ref 5===========
# module: aioquic.stream
class QuicStream:
def __init__(
self, stream_id: Optional[int] = None, connection: Optional[Any] = None
) -> None:
self._connection = connection
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_start = 0
self._recv_ranges = RangeSet()
self._send_buffer = bytearray()
+ self._send_fin = False
self._send_start = 0
self.__stream_id = stream_id
===========changed ref 6===========
# module: examples.client
def run(host, port, **kwargs):
# if host is not an IP address, pass it to enable SNI
try:
ipaddress.ip_address(host)
except ValueError:
kwargs["server_name"] = host
_, protocol = await loop.create_datagram_endpoint(
lambda: QuicConnection(is_client=True, **kwargs), remote_addr=(host, port)
)
await protocol.connect()
# perform HTTP/0.9 request
reader, writer = protocol.create_stream()
writer.write(b"GET /\r\n")
+ writer.write_eof()
print(await reader.read(1024))
===========changed ref 7===========
# module: aioquic.connection
logger = logging.getLogger("quic")
PACKET_MAX_SIZE = 1280
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",
],
]
SEND_PN_SIZE = 2
STREAM_FLAGS = 0x07
- STREAM_FLAG_FIN = 1
- STREAM_FLAG_LEN = 2
- STREAM_FLAG_OFF = 4
===========changed ref 8===========
# module: aioquic.stream
class QuicStream:
def add_frame(self, frame: QuicStreamFrame) -> None:
"""
Add a frame of received data.
"""
pos = frame.offset - self._recv_start
count = len(frame.data)
- # frame has been entirely consumed
+ if pos + count > 0:
- if pos + count <= 0:
+ # frame has been partially consumed
+ if pos < 0:
+ count += pos
+ frame.data = frame.data[-pos:]
+ frame.offset -= pos
+ pos = 0
- return
- # frame has been partially consumed
- if pos < 0:
- count += pos
- frame.data = frame.data[-pos:]
- frame.offset -= pos
- pos = 0
+ # marked received
+ self._recv_ranges.add(frame.offset, frame.offset + count)
+ # add data
+ gap = pos - len(self._recv_buffer)
+ if gap > 0:
+ self._recv_buffer += bytearray(gap)
+ self._recv_buffer[pos : pos + count] = frame.data
- # marked received
- self._recv_ranges.add(frame.offset, frame.offset + count)
+ if self.reader:
+ if self.has_data_to_read():
+ self.reader.feed_data(self.pull_data())
+ if frame.fin:
+ self.reader.feed_eof()
- # add data
- gap = pos - len(self._recv_buffer)
- if gap > 0:
- self._recv_buffer += bytearray(gap)
- self._recv_buffer[pos : pos + count] = frame.data
- if self.reader and self.has_data_to_read():
- self.reader.feed_data(self.pull_data())
-
|
aioquic.tls/Context.__init__
|
Modified
|
aiortc~aioquic
|
32167e261f60da2229b3fcaa1d02b096f0a6180c
|
[tls] add entry for PSK_KE, ensure key exchange is supported
|
<19>:<add> self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
|
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
<0> self.alpn_protocols: Optional[List[str]] = None
<1> self.certificate: Optional[x509.Certificate] = None
<2> self.certificate_private_key: Optional[
<3> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
<4> ] = None
<5> self.handshake_extensions: List[Extension] = []
<6> self.is_client = is_client
<7> self.key_schedule: Optional[KeySchedule] = None
<8> self.server_name: Optional[str] = None
<9> self.update_traffic_key_cb: Callable[
<10> [Direction, Epoch, bytes], None
<11> ] = lambda d, e, s: None
<12>
<13> self._cipher_suites = [
<14> CipherSuite.AES_256_GCM_SHA384,
<15> CipherSuite.AES_128_GCM_SHA256,
<16> CipherSuite.CHACHA20_POLY1305_SHA256,
<17> ]
<18> self._compression_methods = [CompressionMethod.NULL]
<19> self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
<20> self._supported_versions = [TLS_VERSION_1_3]
<21>
<22> self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
<23> self._peer_certificate: Optional[x509.Certificate] = None
<24> self._receive_buffer = b""
<25> self._enc_key: Optional[bytes] = None
<26> self._dec_key: Optional[bytes] = None
<27> self.__logger = logger
<28>
<29> if is_client:
<30> self.client_random = os.urandom(32)
<31> self.session_id = os.urandom(32)
<32> self.private_key = ec.generate_private_key(
<33> ec.SECP256R1(), default_backend()
<34> )
<35> self.state =</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
else:
self.client_random = None
self.session_id = None
self.private_key = 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)
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])
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_finished
self._enc_key = next_enc_key
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._client_send_hello
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.client_random = peer_hello.random
self.session_id = peer_hello.session_id
===========unchanged ref 1===========
self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
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.Context.handle_message
self._receive_buffer += input_data
self._receive_buffer = self._receive_buffer[message_length:]
at: logging
Logger(name: str, level: _Level=...)
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
class KeyExchangeMode(IntEnum):
+ PSK_KE = 0
PSK_DHE_KE = 1
|
aioquic.tls/Context._client_send_hello
|
Modified
|
aiortc~aioquic
|
32167e261f60da2229b3fcaa1d02b096f0a6180c
|
[tls] add entry for PSK_KE, ensure key exchange is supported
|
<6>:<add> key_exchange_modes=self._key_exchange_modes,
<del> key_exchange_modes=[KeyExchangeMode.PSK_DHE_KE],
|
# module: aioquic.tls
class Context:
def _client_send_hello(self, output_buf: Buffer) -> None:
<0> hello = ClientHello(
<1> random=self.client_random,
<2> session_id=self.session_id,
<3> cipher_suites=self._cipher_suites,
<4> compression_methods=self._compression_methods,
<5> alpn_protocols=self.alpn_protocols,
<6> key_exchange_modes=[KeyExchangeMode.PSK_DHE_KE],
<7> key_share=[encode_public_key(self.private_key.public_key())],
<8> server_name=self.server_name,
<9> signature_algorithms=self._signature_algorithms,
<10> supported_groups=[Group.SECP256R1],
<11> supported_versions=self._supported_versions,
<12> other_extensions=self.handshake_extensions,
<13> )
<14>
<15> self._key_schedule_proxy = KeyScheduleProxy(hello.cipher_suites)
<16> self._key_schedule_proxy.extract(None)
<17>
<18> with push_message(self._key_schedule_proxy, output_buf):
<19> push_client_hello(output_buf, hello)
<20>
<21> self._set_state(State.CLIENT_EXPECT_SERVER_HELLO)
<22>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
eof() -> bool
at: aioquic.tls
Group(x: Union[str, bytes, bytearray], base: int)
Group(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
ClientHello(random: bytes, session_id: bytes, cipher_suites: List[CipherSuite], compression_methods: List[CompressionMethod], alpn_protocols: Optional[List[str]]=None, key_exchange_modes: Optional[List[KeyExchangeMode]]=None, key_share: Optional[List[KeyShareEntry]]=None, server_name: Optional[str]=None, signature_algorithms: Optional[List[SignatureAlgorithm]]=None, supported_groups: Optional[List[Group]]=None, supported_versions: Optional[List[int]]=None, other_extensions: List[Extension]=field(default_factory=list))
push_client_hello(buf: Buffer, hello: ClientHello) -> None
KeyScheduleProxy(cipher_suites: List[CipherSuite])
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
at: aioquic.tls.ClientHello
random: bytes
session_id: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
alpn_protocols: Optional[List[str]] = None
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
key_share: Optional[List[KeyShareEntry]] = None
server_name: Optional[str] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_groups: Optional[List[Group]] = None
supported_versions: Optional[List[int]] = None
===========unchanged ref 1===========
other_extensions: List[Extension] = field(default_factory=list)
at: aioquic.tls.Context.__init__
self.alpn_protocols: Optional[List[str]] = None
self.handshake_extensions: List[Extension] = []
self.server_name: Optional[str] = None
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]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self.client_random = None
self.client_random = os.urandom(32)
self.session_id = None
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.private_key = None
at: aioquic.tls.Context._server_handle_hello
self.client_random = peer_hello.random
self.session_id = peer_hello.session_id
self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
at: aioquic.tls.Context.handle_message
input_buf = Buffer(data=message)
at: aioquic.tls.KeyScheduleProxy
extract(key_material: Optional[bytes]=None) -> None
===========changed ref 0===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = 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.handshake_extensions: List[Extension] = []
self.is_client = is_client
self.key_schedule: Optional[KeySchedule] = None
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
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]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else</s>
===========changed ref 1===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s>CP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
===========changed ref 2===========
# module: aioquic.tls
class KeyExchangeMode(IntEnum):
+ PSK_KE = 0
PSK_DHE_KE = 1
|
aioquic.tls/Context._server_handle_hello
|
Modified
|
aiortc~aioquic
|
32167e261f60da2229b3fcaa1d02b096f0a6180c
|
[tls] add entry for PSK_KE, ensure key exchange is supported
|
<10>:<add> )
<add> negotiate(
<add> self._key_exchange_modes,
<add> peer_hello.key_exchange_modes,
<add> "No supported key exchange mode",
|
# module: aioquic.tls
class Context:
def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> peer_hello = pull_client_hello(input_buf)
<1>
<2> # negotiate parameters
<3> cipher_suite = negotiate(
<4> self._cipher_suites, peer_hello.cipher_suites, "No supported cipher suite"
<5> )
<6> compression_method = negotiate(
<7> self._compression_methods,
<8> peer_hello.compression_methods,
<9> "No supported compression method",
<10> )
<11> signature_algorithm = negotiate(
<12> self._signature_algorithms,
<13> peer_hello.signature_algorithms,
<14> "No supported signature algorithm",
<15> )
<16> supported_version = negotiate(
<17> self._supported_versions,
<18> peer_hello.supported_versions,
<19> "No supported protocol version",
<20> )
<21>
<22> self.client_random = peer_hello.random
<23> self.server_random = os.urandom(32)
<24> self.session_id = peer_hello.session_id
<25> self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
<26>
<27> self.key_schedule = KeySchedule(cipher_suite)
<28> self.key_schedule.extract(None)
<29> self.key_schedule.update_hash(input_buf.data)
<30>
<31> peer_public_key = decode_public_key(peer_hello.key_share[0])
<32> shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
<33>
<34> # send hello
<35> hello = ServerHello(
<36> random=self.server_random,
<37> session_id=self.session_id,
<38> cipher_suite=cipher_suite,
<39> compression_method=compression_method,
<40> key_share=encode_public_key(self.private_key.public_key()),
<41> supported_version=supported_version</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 1
)
with push_message(self.key_schedule, output_buf):
push_server_hello(output_buf, hello)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
# send encrypted extensions
with push_message(self.key_schedule, output_buf):
push_encrypted_extensions(
output_buf,
EncryptedExtensions(other_extensions=self.handshake_extensions),
)
# send certificate
with push_message(self.key_schedule, output_buf):
push_certificate(
output_buf,
Certificate(
request_context=b"",
certificates=[(self.certificate.public_bytes(Encoding.DER), b"")],
),
)
# send certificate verify
algorithm = SIGNATURE_ALGORITHMS[signature_algorithm]()
signature = self.certificate_private_key.sign(
self.key_schedule.certificate_verify_data(
b"TLS 1.3, server CertificateVerify"
),
padding.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
algorithm,
)
with push_message(self.key_schedule, output_buf):
push_certificate_verify(
output_buf,
CertificateVerify(algorithm=signature_algorithm, signature=signature),
)
# send finished
with push_message(self.key_schedule, output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)</s>
===========below chunk 1===========
# module: aioquic.tls
class Context:
def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 2
<s>buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)
),
)
# prepare traffic keys
assert self.key_schedule.generation == 2
self.key_schedule.extract(None)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.ONE_RTT, b"s ap traffic"
)
self._next_dec_key = self.key_schedule.derive_secret(b"c ap traffic")
self._set_state(State.SERVER_EXPECT_FINISHED)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
pull_client_hello(buf: Buffer) -> ClientHello
ServerHello(random: bytes, session_id: bytes, cipher_suite: CipherSuite, compression_method: CompressionMethod, key_share: Optional[KeyShareEntry]=None, supported_version: Optional[int]=None)
push_server_hello(buf: Buffer, hello: ServerHello) -> None
pull_new_session_ticket(buf: Buffer) -> NewSessionTicket
EncryptedExtensions(other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
push_encrypted_extensions(buf: Buffer, extensions: EncryptedExtensions) -> None
Certificate(request_context: bytes=b"", certificates: List[CertificateEntry]=field(default_factory=list))
push_certificate(buf: Buffer, certificate: Certificate) -> None
CertificateVerify(algorithm: SignatureAlgorithm, signature: bytes)
push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None
Finished(verify_data: bytes=b"")
push_finished(buf: Buffer, finished: Finished) -> None
KeySchedule(cipher_suite: CipherSuite)
SIGNATURE_ALGORITHMS = {
SignatureAlgorithm.RSA_PSS_RSAE_SHA256: hashes.SHA256,
SignatureAlgorithm.RSA_PSS_RSAE_SHA384: hashes.SHA384,
SignatureAlgorithm.RSA_PSS_RSAE_SHA512: hashes.SHA512,
}
decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
negotiate(supported: List[T], offered: List[T], error_message: str) -> T
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
===========unchanged ref 1===========
at: aioquic.tls.Certificate
request_context: bytes = b""
certificates: List[CertificateEntry] = field(default_factory=list)
at: aioquic.tls.CertificateVerify
algorithm: SignatureAlgorithm
signature: bytes
at: aioquic.tls.ClientHello
random: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_versions: Optional[List[int]] = None
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
at: aioquic.tls.Context.__init__
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.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._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
self._supported_versions = [TLS_VERSION_1_3]
self._enc_key: Optional[bytes] = None
self.client_random = None
self.client_random = os.urandom(32)
self.session_id = None
self.session_id = os.urandom(32)
|
aioquic.tls/Context.handle_message
|
Modified
|
aiortc~aioquic
|
8704e649eeae5ef75cff6ff0337ff5dfce9fb693
|
[tls] encrypted extensions belong in the handshake epoch
|
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
<0> if self.state == State.CLIENT_HANDSHAKE_START:
<1> self._client_send_hello(output_buf[Epoch.INITIAL])
<2> return
<3>
<4> self._receive_buffer += input_data
<5> while len(self._receive_buffer) >= 4:
<6> # determine message length
<7> message_type = self._receive_buffer[0]
<8> message_length = 0
<9> for b in self._receive_buffer[1:4]:
<10> message_length = (message_length << 8) | b
<11> message_length += 4
<12>
<13> # check message is complete
<14> if len(self._receive_buffer) < message_length:
<15> break
<16> message = self._receive_buffer[:message_length]
<17> self._receive_buffer = self._receive_buffer[message_length:]
<18>
<19> input_buf = Buffer(data=message)
<20>
<21> # client states
<22>
<23> if self.state == State.CLIENT_EXPECT_SERVER_HELLO:
<24> if message_type == HandshakeType.SERVER_HELLO:
<25> self._client_handle_hello(input_buf, output_buf[Epoch.INITIAL])
<26> else:
<27> raise AlertUnexpectedMessage
<28> elif self.state == State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS:
<29> if message_type == HandshakeType.ENCRYPTED_EXTENSIONS:
<30> self._client_handle_encrypted_extensions(input_buf)
<31> else:
<32> raise AlertUnexpectedMessage
<33> elif self.state == State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE:
<34> if message_type == HandshakeType.CERTIFICATE:
<35> self._client_handle_certificate(input_buf)
<36> else:
<37> # FIXME: handle certificate request
<38> raise AlertUnexpectedMessage
<39> elif self.state == State.CLIENT_EXPECT_CERTIFICATE</s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
# offset: 1
if message_type == HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._client_handle_finished(input_buf, output_buf[Epoch.HANDSHAKE])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_POST_HANDSHAKE:
if message_type == HandshakeType.NEW_SESSION_TICKET:
self._client_handle_new_session_ticket(input_buf)
else:
raise AlertUnexpectedMessage
# server states
elif self.state == State.SERVER_EXPECT_CLIENT_HELLO:
if message_type == HandshakeType.CLIENT_HELLO:
self._server_handle_hello(input_buf, output_buf[Epoch.INITIAL])
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._server_handle_finished(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_POST_HANDSHAKE:
raise AlertUnexpectedMessage
# should not happen
else:
raise Exception("unhandled state")
assert input_buf.eof()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertUnexpectedMessage(*args: object)
Epoch()
State()
HandshakeType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
HandshakeType(x: Union[str, bytes, bytearray], base: int)
at: aioquic.tls.Context
_client_send_hello(output_buf: Buffer) -> None
_client_handle_hello(input_buf: Buffer, output_buf: Buffer) -> None
_client_handle_encrypted_extensions(input_buf: Buffer) -> None
_client_handle_certificate(input_buf: Buffer) -> None
_client_handle_certificate_verify(input_buf: Buffer) -> None
_client_handle_finished(input_buf: Buffer, output_buf: Buffer) -> None
_client_handle_new_session_ticket(input_buf: Buffer) -> None
_client_handle_new_session_ticket(self, input_buf: Buffer) -> None
_server_handle_hello(input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer) -> None
_server_handle_hello(self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer) -> None
_server_handle_finished(input_buf: Buffer) -> None
at: aioquic.tls.Context.__init__
self._receive_buffer = b""
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: typing
Dict = _alias(dict, 2, inst=False, name='Dict')
|
|
aioquic.tls/Context._server_handle_hello
|
Modified
|
aiortc~aioquic
|
8704e649eeae5ef75cff6ff0337ff5dfce9fb693
|
[tls] encrypted extensions belong in the handshake epoch
|
# module: aioquic.tls
class Context:
+ def _server_handle_hello(
+ self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
+ ) -> None:
- def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
<0> peer_hello = pull_client_hello(input_buf)
<1>
<2> # negotiate parameters
<3> cipher_suite = negotiate(
<4> self._cipher_suites, peer_hello.cipher_suites, "No supported cipher suite"
<5> )
<6> compression_method = negotiate(
<7> self._compression_methods,
<8> peer_hello.compression_methods,
<9> "No supported compression method",
<10> )
<11> negotiate(
<12> self._key_exchange_modes,
<13> peer_hello.key_exchange_modes,
<14> "No supported key exchange mode",
<15> )
<16> signature_algorithm = negotiate(
<17> self._signature_algorithms,
<18> peer_hello.signature_algorithms,
<19> "No supported signature algorithm",
<20> )
<21> supported_version = negotiate(
<22> self._supported_versions,
<23> peer_hello.supported_versions,
<24> "No supported protocol version",
<25> )
<26>
<27> self.client_random = peer_hello.random
<28> self.server_random = os.urandom(32)
<29> self.session_id = peer_hello.session_id
<30> self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
<31>
<32> self.key_schedule = KeySchedule(cipher_suite)
<33> self.key_schedule.extract(None)
<34> self.key_schedule.update_hash(input_buf.data)
<35>
<36> peer_public_key = decode_public_key(peer_hello.key_share[0])
<37> shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
<38>
<39> # send hello
<40> </s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
+ def _server_handle_hello(
+ self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
+ ) -> None:
- def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 1
random=self.server_random,
session_id=self.session_id,
cipher_suite=cipher_suite,
compression_method=compression_method,
key_share=encode_public_key(self.private_key.public_key()),
supported_version=supported_version,
)
with push_message(self.key_schedule, output_buf):
push_server_hello(output_buf, hello)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
# send encrypted extensions
with push_message(self.key_schedule, output_buf):
push_encrypted_extensions(
output_buf,
EncryptedExtensions(other_extensions=self.handshake_extensions),
)
# send certificate
with push_message(self.key_schedule, output_buf):
push_certificate(
output_buf,
Certificate(
request_context=b"",
certificates=[(self.certificate.public_bytes(Encoding.DER), b"")],
),
)
# send certificate verify
algorithm = SIGNATURE_ALGORITHMS[signature_algorithm]()
signature = self.certificate_private_key.sign(
self.key_schedule.certificate_verify_data(
b"TLS 1.3, server CertificateVerify"
),
padding.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
algorithm</s>
===========below chunk 1===========
# module: aioquic.tls
class Context:
+ def _server_handle_hello(
+ self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
+ ) -> None:
- def _server_handle_hello(self, input_buf: Buffer, output_buf: Buffer) -> None:
# offset: 2
<s>.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
algorithm,
)
with push_message(self.key_schedule, output_buf):
push_certificate_verify(
output_buf,
CertificateVerify(algorithm=signature_algorithm, signature=signature),
)
# send finished
with push_message(self.key_schedule, output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)
),
)
# prepare traffic keys
assert self.key_schedule.generation == 2
self.key_schedule.extract(None)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.ONE_RTT, b"s ap traffic"
)
self._next_dec_key = self.key_schedule.derive_secret(b"c ap traffic")
self._set_state(State.SERVER_EXPECT_FINISHED)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
pull_client_hello(buf: Buffer) -> ClientHello
ServerHello(random: bytes, session_id: bytes, cipher_suite: CipherSuite, compression_method: CompressionMethod, key_share: Optional[KeyShareEntry]=None, supported_version: Optional[int]=None)
push_server_hello(buf: Buffer, hello: ServerHello) -> None
pull_new_session_ticket(buf: Buffer) -> NewSessionTicket
EncryptedExtensions(other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
push_encrypted_extensions(buf: Buffer, extensions: EncryptedExtensions) -> None
Certificate(request_context: bytes=b"", certificates: List[CertificateEntry]=field(default_factory=list))
push_certificate(buf: Buffer, certificate: Certificate) -> None
CertificateVerify(algorithm: SignatureAlgorithm, signature: bytes)
push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None
Finished(verify_data: bytes=b"")
push_finished(buf: Buffer, finished: Finished) -> None
KeySchedule(cipher_suite: CipherSuite)
SIGNATURE_ALGORITHMS = {
SignatureAlgorithm.RSA_PSS_RSAE_SHA256: hashes.SHA256,
SignatureAlgorithm.RSA_PSS_RSAE_SHA384: hashes.SHA384,
SignatureAlgorithm.RSA_PSS_RSAE_SHA512: hashes.SHA512,
}
decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
negotiate(supported: List[T], offered: List[T], error_message: str) -> T
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
===========unchanged ref 1===========
at: aioquic.tls.Certificate
request_context: bytes = b""
certificates: List[CertificateEntry] = field(default_factory=list)
at: aioquic.tls.CertificateVerify
algorithm: SignatureAlgorithm
signature: bytes
at: aioquic.tls.ClientHello
random: bytes
session_id: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
alpn_protocols: Optional[List[str]] = None
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
key_share: Optional[List[KeyShareEntry]] = None
server_name: Optional[str] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_groups: Optional[List[Group]] = None
supported_versions: Optional[List[int]] = None
other_extensions: List[Extension] = field(default_factory=list)
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
at: aioquic.tls.Context.__init__
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.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._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
|
|
tests.test_connection/QuicConnectionTest._test_connect_with_version
|
Modified
|
aiortc~aioquic
|
8704e649eeae5ef75cff6ff0337ff5dfce9fb693
|
[tls] encrypted extensions belong in the handshake epoch
|
<15>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 3)
<22>:<add> self.assertEqual(server_transport.sent, 5)
<del> self.assertEqual(server_transport.sent, 4)
<32>:<add> self.assertEqual(server_transport.sent, 6)
<del> self.assertEqual(server_transport.sent, 5)
<40>:<add> self.assertEqual(server_transport.sent, 7)
<del> self.assertEqual(server_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> client.version = max(client_versions)
<3>
<4> server = QuicConnection(
<5> is_client=False,
<6> certificate=SERVER_CERTIFICATE,
<7> private_key=SERVER_PRIVATE_KEY,
<8> )
<9> server.supported_versions = server_versions
<10> server.version = max(server_versions)
<11>
<12> # perform handshake
<13> client_transport, server_transport = create_transport(client, server)
<14> self.assertEqual(client_transport.sent, 4)
<15> self.assertEqual(server_transport.sent, 3)
<16> run(client.connect())
<17>
<18> # send data over stream
<19> client_reader, client_writer = client.create_stream()
<20> client_writer.write(b"ping")
<21> self.assertEqual(client_transport.sent, 5)
<22> self.assertEqual(server_transport.sent, 4)
<23>
<24> # FIXME: needs an API
<25> server_reader, server_writer = (
<26> server.streams[0].reader,
<27> server.streams[0].writer,
<28> )
<29> self.assertEqual(run(server_reader.read(1024)), b"ping")
<30> server_writer.write(b"pong")
<31> self.assertEqual(client_transport.sent, 6)
<32> self.assertEqual(server_transport.sent, 5)
<33>
<34> # client receives pong
<35> self.assertEqual(run(client_reader.read(1024)), b"pong")
<36>
<37> # client writes EOF
<38> client_writer.write_eof()
<39> self.assertEqual(client_transport.sent, 7)
<40> self.assertEqual(server_transport.sent, 6)
<41>
<42> # server receives EOF
<43> self.</s>
|
===========below chunk 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
return client, server
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connect() -> None
create_stream(is_unidirectional: bool=False) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
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: tests.test_connection
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()
)
create_transport(client, server)
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
===========unchanged ref 1===========
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
===========changed ref 0===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
if self.state == State.CLIENT_HANDSHAKE_START:
self._client_send_hello(output_buf[Epoch.INITIAL])
return
self._receive_buffer += input_data
while len(self._receive_buffer) >= 4:
# determine message length
message_type = self._receive_buffer[0]
message_length = 0
for b in self._receive_buffer[1:4]:
message_length = (message_length << 8) | b
message_length += 4
# check message is complete
if len(self._receive_buffer) < message_length:
break
message = self._receive_buffer[:message_length]
self._receive_buffer = self._receive_buffer[message_length:]
input_buf = Buffer(data=message)
# client states
if self.state == State.CLIENT_EXPECT_SERVER_HELLO:
if message_type == HandshakeType.SERVER_HELLO:
self._client_handle_hello(input_buf, output_buf[Epoch.INITIAL])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS:
if message_type == HandshakeType.ENCRYPTED_EXTENSIONS:
self._client_handle_encrypted_extensions(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE:
if message_type == HandshakeType.CERTIFICATE:
self._client_handle_certificate(input_buf)
else:
# FIXME: handle certificate request
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_VERIFY:
if message_type == HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
</s>
===========changed ref 1===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
# offset: 1
<s> HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._client_handle_finished(input_buf, output_buf[Epoch.HANDSHAKE])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_POST_HANDSHAKE:
if message_type == HandshakeType.NEW_SESSION_TICKET:
self._client_handle_new_session_ticket(input_buf)
else:
raise AlertUnexpectedMessage
# server states
elif self.state == State.SERVER_EXPECT_CLIENT_HELLO:
if message_type == HandshakeType.CLIENT_HELLO:
+ self._server_handle_hello(
+ input_buf,
+ output_buf[Epoch.INITIAL],
+ output_buf[Epoch.HANDSHAKE],
+ )
- self._server_handle_hello(input_buf, output_buf[Epoch.INITIAL])
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._server_handle_finished(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_POST_HANDSHAKE:
raise AlertUnexpectedMessage
# should not happen
else:
raise Exception("unhandled state")
assert input_buf.eof()
|
tests.test_connection/QuicConnectionTest.test_connect_with_log
|
Modified
|
aiortc~aioquic
|
8704e649eeae5ef75cff6ff0337ff5dfce9fb693
|
[tls] encrypted extensions belong in the handshake epoch
|
<13>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_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, 4)
<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, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: io
StringIO(initial_value: Optional[str]=..., newline: Optional[str]=...)
at: io.StringIO
getvalue(self) -> str
at: tests.test_connection
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()
)
create_transport(client, server)
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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
client_transport, server_transport = create_transport(client, server)
self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
run(client.connect())
# send data over stream
client_reader, client_writer = client.create_stream()
client_writer.write(b"ping")
self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 5)
- 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")
self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server_transport.sent, 6)
- 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()
self.assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- </s>
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s>assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
return client, server
===========changed ref 2===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
if self.state == State.CLIENT_HANDSHAKE_START:
self._client_send_hello(output_buf[Epoch.INITIAL])
return
self._receive_buffer += input_data
while len(self._receive_buffer) >= 4:
# determine message length
message_type = self._receive_buffer[0]
message_length = 0
for b in self._receive_buffer[1:4]:
message_length = (message_length << 8) | b
message_length += 4
# check message is complete
if len(self._receive_buffer) < message_length:
break
message = self._receive_buffer[:message_length]
self._receive_buffer = self._receive_buffer[message_length:]
input_buf = Buffer(data=message)
# client states
if self.state == State.CLIENT_EXPECT_SERVER_HELLO:
if message_type == HandshakeType.SERVER_HELLO:
self._client_handle_hello(input_buf, output_buf[Epoch.INITIAL])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_ENCRYPTED_EXTENSIONS:
if message_type == HandshakeType.ENCRYPTED_EXTENSIONS:
self._client_handle_encrypted_extensions(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_REQUEST_OR_CERTIFICATE:
if message_type == HandshakeType.CERTIFICATE:
self._client_handle_certificate(input_buf)
else:
# FIXME: handle certificate request
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_CERTIFICATE_VERIFY:
if message_type == HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
</s>
===========changed ref 3===========
# module: aioquic.tls
class Context:
def handle_message(
self, input_data: bytes, output_buf: Dict[Epoch, Buffer]
) -> None:
# offset: 1
<s> HandshakeType.CERTIFICATE_VERIFY:
self._client_handle_certificate_verify(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._client_handle_finished(input_buf, output_buf[Epoch.HANDSHAKE])
else:
raise AlertUnexpectedMessage
elif self.state == State.CLIENT_POST_HANDSHAKE:
if message_type == HandshakeType.NEW_SESSION_TICKET:
self._client_handle_new_session_ticket(input_buf)
else:
raise AlertUnexpectedMessage
# server states
elif self.state == State.SERVER_EXPECT_CLIENT_HELLO:
if message_type == HandshakeType.CLIENT_HELLO:
+ self._server_handle_hello(
+ input_buf,
+ output_buf[Epoch.INITIAL],
+ output_buf[Epoch.HANDSHAKE],
+ )
- self._server_handle_hello(input_buf, output_buf[Epoch.INITIAL])
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_EXPECT_FINISHED:
if message_type == HandshakeType.FINISHED:
self._server_handle_finished(input_buf)
else:
raise AlertUnexpectedMessage
elif self.state == State.SERVER_POST_HANDSHAKE:
raise AlertUnexpectedMessage
# should not happen
else:
raise Exception("unhandled state")
assert input_buf.eof()
|
tests.test_connection/QuicConnectionTest.test_decryption_error
|
Modified
|
aiortc~aioquic
|
8704e649eeae5ef75cff6ff0337ff5dfce9fb693
|
[tls] encrypted extensions belong in the handshake epoch
|
<11>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 3)
<21>:<add> self.assertEqual(server_transport.sent, 5)
<del> self.assertEqual(server_transport.sent, 4)
|
# 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, 3)
<12>
<13> # mess with encryption key
<14> server.spaces[tls.Epoch.ONE_RTT].crypto.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, 4)
<22>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
close(error_code: int, frame_type: Optional[int]=None, reason_phrase: bytes=b"") -> None
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
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
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()
)
create_transport(client, server)
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, 4)
+ self.assertEqual(server_transport.sent, 4)
- 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 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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
client_transport, server_transport = create_transport(client, server)
self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
run(client.connect())
# send data over stream
client_reader, client_writer = client.create_stream()
client_writer.write(b"ping")
self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 5)
- 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")
self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server_transport.sent, 6)
- 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()
self.assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- </s>
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s>assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
return client, server
|
tests.test_connection/QuicConnectionTest.test_application_close
|
Modified
|
aiortc~aioquic
|
8704e649eeae5ef75cff6ff0337ff5dfce9fb693
|
[tls] encrypted extensions belong in the handshake epoch
|
<11>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 3)
<16>:<add> self.assertEqual(server_transport.sent, 5)
<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_application_close(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, 3)
<12>
<13> # close
<14> server.close(error_code=QuicErrorCode.NO_ERROR)
<15> self.assertEqual(client_transport.sent, 5)
<16> self.assertEqual(server_transport.sent, 4)
<17>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
close(error_code: int, frame_type: Optional[int]=None, reason_phrase: bytes=b"") -> None
at: aioquic.packet
QuicErrorCode(x: Union[str, bytes, bytearray], base: int)
QuicErrorCode(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
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()
)
create_transport(client, server)
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(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
# mess with encryption key
server.spaces[tls.Epoch.ONE_RTT].crypto.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(server_transport.sent, 5)
- self.assertEqual(server_transport.sent, 4)
===========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(server_transport.sent, 4)
- 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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
client_transport, server_transport = create_transport(client, server)
self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
run(client.connect())
# send data over stream
client_reader, client_writer = client.create_stream()
client_writer.write(b"ping")
self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 5)
- 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")
self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server_transport.sent, 6)
- 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()
self.assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- </s>
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s>assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
return client, server
|
tests.test_connection/QuicConnectionTest.test_transport_close
|
Modified
|
aiortc~aioquic
|
8704e649eeae5ef75cff6ff0337ff5dfce9fb693
|
[tls] encrypted extensions belong in the handshake epoch
|
<11>:<add> self.assertEqual(server_transport.sent, 4)
<del> self.assertEqual(server_transport.sent, 3)
<18>:<add> self.assertEqual(server_transport.sent, 5)
<del> self.assertEqual(server_transport.sent, 4)
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_transport_close(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, 3)
<12>
<13> # close
<14> server.close(
<15> error_code=QuicErrorCode.NO_ERROR, frame_type=QuicFrameType.PADDING
<16> )
<17> self.assertEqual(client_transport.sent, 5)
<18> self.assertEqual(server_transport.sent, 4)
<19>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
close(error_code: int, frame_type: Optional[int]=None, reason_phrase: bytes=b"") -> 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
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()
)
create_transport(client, server)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_application_close(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(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
# close
server.close(error_code=QuicErrorCode.NO_ERROR)
self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 5)
- 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(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
# mess with encryption key
server.spaces[tls.Epoch.ONE_RTT].crypto.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(server_transport.sent, 5)
- self.assertEqual(server_transport.sent, 4)
===========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(server_transport.sent, 4)
- 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
client.version = max(client_versions)
server = QuicConnection(
is_client=False,
certificate=SERVER_CERTIFICATE,
private_key=SERVER_PRIVATE_KEY,
)
server.supported_versions = server_versions
server.version = max(server_versions)
# perform handshake
client_transport, server_transport = create_transport(client, server)
self.assertEqual(client_transport.sent, 4)
+ self.assertEqual(server_transport.sent, 4)
- self.assertEqual(server_transport.sent, 3)
run(client.connect())
# send data over stream
client_reader, client_writer = client.create_stream()
client_writer.write(b"ping")
self.assertEqual(client_transport.sent, 5)
+ self.assertEqual(server_transport.sent, 5)
- 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")
self.assertEqual(client_transport.sent, 6)
+ self.assertEqual(server_transport.sent, 6)
- 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()
self.assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- </s>
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def _test_connect_with_version(self, client_versions, server_versions):
# offset: 1
<s>assertEqual(client_transport.sent, 7)
+ self.assertEqual(server_transport.sent, 7)
- self.assertEqual(server_transport.sent, 6)
# server receives EOF
self.assertEqual(run(server_reader.read()), b"")
return client, server
|
aioquic.tls/Context.__init__
|
Modified
|
aiortc~aioquic
|
386276fd726dce4113f8fa5010b65845079ef9c7
|
[tls] add support for PKCS1 signatures
|
<20>:<add> self._signature_algorithms = [
<add> SignatureAlgorithm.RSA_PSS_RSAE_SHA256,
<del> self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
<21>:<add> SignatureAlgorithm.RSA_PKCS1_SHA256,
<add> SignatureAlgorithm.RSA_PKCS1_SHA1,
<add> ]
|
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
<0> self.alpn_protocols: Optional[List[str]] = None
<1> self.certificate: Optional[x509.Certificate] = None
<2> self.certificate_private_key: Optional[
<3> Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
<4> ] = None
<5> self.handshake_extensions: List[Extension] = []
<6> self.is_client = is_client
<7> self.key_schedule: Optional[KeySchedule] = None
<8> self.server_name: Optional[str] = None
<9> self.update_traffic_key_cb: Callable[
<10> [Direction, Epoch, bytes], None
<11> ] = lambda d, e, s: None
<12>
<13> self._cipher_suites = [
<14> CipherSuite.AES_256_GCM_SHA384,
<15> CipherSuite.AES_128_GCM_SHA256,
<16> CipherSuite.CHACHA20_POLY1305_SHA256,
<17> ]
<18> self._compression_methods = [CompressionMethod.NULL]
<19> self._key_exchange_modes = [KeyExchangeMode.PSK_DHE_KE]
<20> self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
<21> self._supported_versions = [TLS_VERSION_1_3]
<22>
<23> self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
<24> self._peer_certificate: Optional[x509.Certificate] = None
<25> self._receive_buffer = b""
<26> self._enc_key: Optional[bytes] = None
<27> self._dec_key: Optional[bytes] = None
<28> self.__logger = logger
<29>
<30> if is_client:
<31> self.client_random = os.urandom(32)
<32> self.session_id = os.urandom(32)
<33> self.private_key = ec.generate_private_key(
<34> </s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.buffer.Buffer
data_slice(start: int, end: int) -> bytes
tell() -> int
at: aioquic.tls
Direction()
Epoch()
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)
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])
at: aioquic.tls.Context._client_handle_hello
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
update_hash(data: bytes) -> None
at: aioquic.tls.KeyScheduleProxy
update_hash(data: bytes) -> None
at: aioquic.tls.signature_algorithm_params
padding_cls, algorithm_cls = SIGNATURE_ALGORITHMS[signature_algorithm]
algorithm = algorithm_cls()
===========unchanged ref 1===========
at: contextlib
contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]
at: logging
Logger(name: str, level: _Level=...)
at: typing
Callable = _CallableType(collections.abc.Callable, 2)
List = _alias(list, 1, inst=False, name='List')
Generator = _alias(collections.abc.Generator, 3)
===========changed ref 0===========
# module: aioquic.tls
+ def signature_algorithm_params(
+ signature_algorithm: SignatureAlgorithm
+ ) -> Tuple[padding.AsymmetricPadding, hashes.HashAlgorithm]:
+ padding_cls, algorithm_cls = SIGNATURE_ALGORITHMS[signature_algorithm]
+ algorithm = algorithm_cls()
+ if padding_cls == padding.PSS:
+ padding_obj = padding_cls(
+ mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size
+ )
+ else:
+ padding_obj = padding_cls()
+ return padding_obj, algorithm
+
===========changed ref 1===========
# module: aioquic.tls
CIPHER_SUITES = {
CipherSuite.AES_128_GCM_SHA256: (aead.AESGCM, hashes.SHA256),
CipherSuite.AES_256_GCM_SHA384: (aead.AESGCM, hashes.SHA384),
CipherSuite.CHACHA20_POLY1305_SHA256: (aead.ChaCha20Poly1305, hashes.SHA256),
}
SIGNATURE_ALGORITHMS = {
+ SignatureAlgorithm.RSA_PKCS1_SHA1: (padding.PKCS1v15, hashes.SHA1),
+ SignatureAlgorithm.RSA_PKCS1_SHA256: (padding.PKCS1v15, hashes.SHA256),
+ SignatureAlgorithm.RSA_PKCS1_SHA384: (padding.PKCS1v15, hashes.SHA384),
+ SignatureAlgorithm.RSA_PKCS1_SHA512: (padding.PKCS1v15, hashes.SHA512),
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA256: (padding.PSS, hashes.SHA256),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA256: hashes.SHA256,
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA384: (padding.PSS, hashes.SHA384),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA384: hashes.SHA384,
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA512: (padding.PSS, hashes.SHA512),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA512: hashes.SHA512,
}
GROUP_TO_CURVE = {
Group.SECP256R1: ec.SECP256R1,
Group.SECP384R1: ec.SECP384R1,
Group.SECP521R1: ec.SECP521R1,
}
CURVE_TO_GROUP = dict((v, k) for k, v in GROUP_TO_CURVE.items())
|
aioquic.tls/Context._client_handle_certificate_verify
|
Modified
|
aiortc~aioquic
|
386276fd726dce4113f8fa5010b65845079ef9c7
|
[tls] add support for PKCS1 signatures
|
<2>:<add> assert verify.algorithm in self._signature_algorithms
<add>
<3>:<del> algorithm = SIGNATURE_ALGORITHMS[verify.algorithm]()
<9>:<del> padding.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
<10>:<del> algorithm,
<11>:<add> *signature_algorithm_params(verify.algorithm),
|
# module: aioquic.tls
class Context:
def _client_handle_certificate_verify(self, input_buf: Buffer) -> None:
<0> verify = pull_certificate_verify(input_buf)
<1>
<2> # check signature
<3> algorithm = SIGNATURE_ALGORITHMS[verify.algorithm]()
<4> self._peer_certificate.public_key().verify(
<5> verify.signature,
<6> self.key_schedule.certificate_verify_data(
<7> b"TLS 1.3, server CertificateVerify"
<8> ),
<9> padding.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
<10> 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
Direction()
Epoch()
State()
pull_encrypted_extensions(buf: Buffer) -> EncryptedExtensions
pull_certificate(buf: Buffer) -> Certificate
at: aioquic.tls.Certificate
request_context: bytes = b""
certificates: List[CertificateEntry] = field(default_factory=list)
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.key_schedule: Optional[KeySchedule] = None
self._peer_certificate: Optional[x509.Certificate] = None
at: aioquic.tls.Context._client_handle_hello
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
update_hash(data: bytes) -> None
===========changed ref 0===========
# module: aioquic.tls
+ def signature_algorithm_params(
+ signature_algorithm: SignatureAlgorithm
+ ) -> Tuple[padding.AsymmetricPadding, hashes.HashAlgorithm]:
+ padding_cls, algorithm_cls = SIGNATURE_ALGORITHMS[signature_algorithm]
+ algorithm = algorithm_cls()
+ if padding_cls == padding.PSS:
+ padding_obj = padding_cls(
+ mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size
+ )
+ else:
+ padding_obj = padding_cls()
+ return padding_obj, algorithm
+
===========changed ref 1===========
# module: aioquic.tls
CIPHER_SUITES = {
CipherSuite.AES_128_GCM_SHA256: (aead.AESGCM, hashes.SHA256),
CipherSuite.AES_256_GCM_SHA384: (aead.AESGCM, hashes.SHA384),
CipherSuite.CHACHA20_POLY1305_SHA256: (aead.ChaCha20Poly1305, hashes.SHA256),
}
SIGNATURE_ALGORITHMS = {
+ SignatureAlgorithm.RSA_PKCS1_SHA1: (padding.PKCS1v15, hashes.SHA1),
+ SignatureAlgorithm.RSA_PKCS1_SHA256: (padding.PKCS1v15, hashes.SHA256),
+ SignatureAlgorithm.RSA_PKCS1_SHA384: (padding.PKCS1v15, hashes.SHA384),
+ SignatureAlgorithm.RSA_PKCS1_SHA512: (padding.PKCS1v15, hashes.SHA512),
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA256: (padding.PSS, hashes.SHA256),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA256: hashes.SHA256,
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA384: (padding.PSS, hashes.SHA384),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA384: hashes.SHA384,
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA512: (padding.PSS, hashes.SHA512),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA512: hashes.SHA512,
}
GROUP_TO_CURVE = {
Group.SECP256R1: ec.SECP256R1,
Group.SECP384R1: ec.SECP384R1,
Group.SECP521R1: ec.SECP521R1,
}
CURVE_TO_GROUP = dict((v, k) for k, v in GROUP_TO_CURVE.items())
===========changed ref 2===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = 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.handshake_extensions: List[Extension] = []
self.is_client = is_client
self.key_schedule: Optional[KeySchedule] = None
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
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,
- self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
+ SignatureAlgorithm.RSA_PKCS1_SHA256,
+ SignatureAlgorithm.RSA_PKCS1_SHA1,
+ ]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_</s>
===========changed ref 3===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = None):
# offset: 1
<s> logger
if is_client:
self.client_random = os.urandom(32)
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.state = State.CLIENT_HANDSHAKE_START
else:
self.client_random = None
self.session_id = None
self.private_key = None
self.state = State.SERVER_EXPECT_CLIENT_HELLO
|
aioquic.tls/Context._server_handle_hello
|
Modified
|
aiortc~aioquic
|
386276fd726dce4113f8fa5010b65845079ef9c7
|
[tls] add support for PKCS1 signatures
|
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
<0> peer_hello = pull_client_hello(input_buf)
<1>
<2> # negotiate parameters
<3> cipher_suite = negotiate(
<4> self._cipher_suites, peer_hello.cipher_suites, "No supported cipher suite"
<5> )
<6> compression_method = negotiate(
<7> self._compression_methods,
<8> peer_hello.compression_methods,
<9> "No supported compression method",
<10> )
<11> negotiate(
<12> self._key_exchange_modes,
<13> peer_hello.key_exchange_modes,
<14> "No supported key exchange mode",
<15> )
<16> signature_algorithm = negotiate(
<17> self._signature_algorithms,
<18> peer_hello.signature_algorithms,
<19> "No supported signature algorithm",
<20> )
<21> supported_version = negotiate(
<22> self._supported_versions,
<23> peer_hello.supported_versions,
<24> "No supported protocol version",
<25> )
<26>
<27> self.client_random = peer_hello.random
<28> self.server_random = os.urandom(32)
<29> self.session_id = peer_hello.session_id
<30> self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
<31>
<32> self.key_schedule = KeySchedule(cipher_suite)
<33> self.key_schedule.extract(None)
<34> self.key_schedule.update_hash(input_buf.data)
<35>
<36> peer_public_key = decode_public_key(peer_hello.key_share[0])
<37> shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
<38>
<39> # send hello
<40> hello = ServerHello(
<41> random=self.server_random,
<42> session_id=self.session_id,
<43> </s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
# offset: 1
compression_method=compression_method,
key_share=encode_public_key(self.private_key.public_key()),
supported_version=supported_version,
)
with push_message(self.key_schedule, initial_buf):
push_server_hello(initial_buf, hello)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
# send encrypted extensions
with push_message(self.key_schedule, output_buf):
push_encrypted_extensions(
output_buf,
EncryptedExtensions(other_extensions=self.handshake_extensions),
)
# send certificate
with push_message(self.key_schedule, output_buf):
push_certificate(
output_buf,
Certificate(
request_context=b"",
certificates=[(self.certificate.public_bytes(Encoding.DER), b"")],
),
)
# send certificate verify
algorithm = SIGNATURE_ALGORITHMS[signature_algorithm]()
signature = self.certificate_private_key.sign(
self.key_schedule.certificate_verify_data(
b"TLS 1.3, server CertificateVerify"
),
padding.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
algorithm,
)
with push_message(self.key_schedule, output_buf):
push_certificate_verify(
output_buf,
CertificateVerify(algorithm=signature_algorithm, signature=signature),
)
# send finished
with push</s>
===========below chunk 1===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
# offset: 2
<s>buf,
CertificateVerify(algorithm=signature_algorithm, signature=signature),
)
# send finished
with push_message(self.key_schedule, output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)
),
)
# prepare traffic keys
assert self.key_schedule.generation == 2
self.key_schedule.extract(None)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.ONE_RTT, b"s ap traffic"
)
self._next_dec_key = self.key_schedule.derive_secret(b"c ap traffic")
self._set_state(State.SERVER_EXPECT_FINISHED)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
Direction()
Epoch()
State()
pull_client_hello(buf: Buffer) -> ClientHello
ServerHello(random: bytes, session_id: bytes, cipher_suite: CipherSuite, compression_method: CompressionMethod, key_share: Optional[KeyShareEntry]=None, supported_version: Optional[int]=None)
push_server_hello(buf: Buffer, hello: ServerHello) -> None
pull_new_session_ticket(buf: Buffer) -> NewSessionTicket
EncryptedExtensions(other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
push_encrypted_extensions(buf: Buffer, extensions: EncryptedExtensions) -> None
Certificate(request_context: bytes=b"", certificates: List[CertificateEntry]=field(default_factory=list))
push_certificate(buf: Buffer, certificate: Certificate) -> None
CertificateVerify(algorithm: SignatureAlgorithm, signature: bytes)
push_certificate_verify(buf: Buffer, verify: CertificateVerify) -> None
Finished(verify_data: bytes=b"")
push_finished(buf: Buffer, finished: Finished) -> None
KeySchedule(cipher_suite: CipherSuite)
decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
negotiate(supported: List[T], offered: List[T], error_message: str) -> T
signature_algorithm_params(signature_algorithm: SignatureAlgorithm) -> Tuple[padding.AsymmetricPadding, hashes.HashAlgorithm]
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
at: aioquic.tls.CertificateVerify
algorithm: SignatureAlgorithm
signature: bytes
at: aioquic.tls.ClientHello
random: bytes
===========unchanged ref 1===========
session_id: bytes
cipher_suites: List[CipherSuite]
compression_methods: List[CompressionMethod]
alpn_protocols: Optional[List[str]] = None
key_exchange_modes: Optional[List[KeyExchangeMode]] = None
key_share: Optional[List[KeyShareEntry]] = None
server_name: Optional[str] = None
signature_algorithms: Optional[List[SignatureAlgorithm]] = None
supported_groups: Optional[List[Group]] = None
supported_versions: Optional[List[int]] = None
other_extensions: List[Extension] = field(default_factory=list)
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.certificate: Optional[x509.Certificate] = None
self.certificate_private_key: Optional[
Union[dsa.DSAPublicKey, ec.EllipticCurvePublicKey, rsa.RSAPublicKey]
] = None
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
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]
|
|
tests.test_tls/ContextTest.test_handshake
|
Modified
|
aiortc~aioquic
|
386276fd726dce4113f8fa5010b65845079ef9c7
|
[tls] add support for PKCS1 signatures
|
<8>:<add> self.assertEqual(len(server_input), 250)
<del> self.assertEqual(len(server_input), 246)
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake(self):
<0> client = self.create_client()
<1> server = self.create_server()
<2>
<3> # send client hello
<4> client_buf = create_buffers()
<5> client.handle_message(b"", client_buf)
<6> self.assertEqual(client.state, State.CLIENT_EXPECT_SERVER_HELLO)
<7> server_input = merge_buffers(client_buf)
<8> self.assertEqual(len(server_input), 246)
<9> reset_buffers(client_buf)
<10>
<11> # handle client hello
<12> # send server hello, encrypted extensions, certificate, certificate verify, finished
<13> server_buf = create_buffers()
<14> server.handle_message(server_input, server_buf)
<15> self.assertEqual(server.state, State.SERVER_EXPECT_FINISHED)
<16> client_input = merge_buffers(server_buf)
<17> self.assertEqual(len(client_input), 2227)
<18> reset_buffers(server_buf)
<19>
<20> # handle server hello, encrypted extensions, certificate, certificate verify, finished
<21> # send finished
<22> client.handle_message(client_input, client_buf)
<23> self.assertEqual(client.state, State.CLIENT_POST_HANDSHAKE)
<24> server_input = merge_buffers(client_buf)
<25> self.assertEqual(len(server_input), 52)
<26> reset_buffers(client_buf)
<27>
<28> # handle finished
<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> self.assertEqual(len(client_input), 0)
<33>
<34> # check keys match
<35> self.assertEqual(client._dec_key, server._enc_key)
<36> self.assertEqual(client._enc_key, server._dec_key)
<37>
<38> </s>
|
===========below chunk 0===========
# module: tests.test_tls
class ContextTest(TestCase):
def test_handshake(self):
# offset: 1
new_session_ticket = binascii.unhexlify(
"04000035000151809468b842000020441fc19f9eb6ea425b48989c800258495"
"a2bc30cac3a55032a7c0822feb842eb0008002a0004ffffffff"
)
client.handle_message(new_session_ticket, client_buf)
server_input = merge_buffers(client_buf)
self.assertEqual(len(server_input), 0)
===========unchanged ref 0===========
at: aioquic.tls
State()
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
at: aioquic.tls.Context.__init__
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._server_handle_finished
self._dec_key = self._next_dec_key
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: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_tls
create_buffers()
merge_buffers(buffers)
reset_buffers(buffers)
at: tests.test_tls.ContextTest
create_client()
create_server()
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.tls
+ def signature_algorithm_params(
+ signature_algorithm: SignatureAlgorithm
+ ) -> Tuple[padding.AsymmetricPadding, hashes.HashAlgorithm]:
+ padding_cls, algorithm_cls = SIGNATURE_ALGORITHMS[signature_algorithm]
+ algorithm = algorithm_cls()
+ if padding_cls == padding.PSS:
+ padding_obj = padding_cls(
+ mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size
+ )
+ else:
+ padding_obj = padding_cls()
+ return padding_obj, algorithm
+
===========changed ref 1===========
# module: aioquic.tls
class Context:
def _client_handle_certificate_verify(self, input_buf: Buffer) -> None:
verify = pull_certificate_verify(input_buf)
+ assert verify.algorithm in self._signature_algorithms
+
# check signature
- algorithm = SIGNATURE_ALGORITHMS[verify.algorithm]()
self._peer_certificate.public_key().verify(
verify.signature,
self.key_schedule.certificate_verify_data(
b"TLS 1.3, server CertificateVerify"
),
- padding.PSS(mgf=padding.MGF1(algorithm), salt_length=algorithm.digest_size),
- algorithm,
+ *signature_algorithm_params(verify.algorithm),
)
self.key_schedule.update_hash(input_buf.data)
self._set_state(State.CLIENT_EXPECT_FINISHED)
===========changed ref 2===========
# module: aioquic.tls
CIPHER_SUITES = {
CipherSuite.AES_128_GCM_SHA256: (aead.AESGCM, hashes.SHA256),
CipherSuite.AES_256_GCM_SHA384: (aead.AESGCM, hashes.SHA384),
CipherSuite.CHACHA20_POLY1305_SHA256: (aead.ChaCha20Poly1305, hashes.SHA256),
}
SIGNATURE_ALGORITHMS = {
+ SignatureAlgorithm.RSA_PKCS1_SHA1: (padding.PKCS1v15, hashes.SHA1),
+ SignatureAlgorithm.RSA_PKCS1_SHA256: (padding.PKCS1v15, hashes.SHA256),
+ SignatureAlgorithm.RSA_PKCS1_SHA384: (padding.PKCS1v15, hashes.SHA384),
+ SignatureAlgorithm.RSA_PKCS1_SHA512: (padding.PKCS1v15, hashes.SHA512),
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA256: (padding.PSS, hashes.SHA256),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA256: hashes.SHA256,
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA384: (padding.PSS, hashes.SHA384),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA384: hashes.SHA384,
+ SignatureAlgorithm.RSA_PSS_RSAE_SHA512: (padding.PSS, hashes.SHA512),
- SignatureAlgorithm.RSA_PSS_RSAE_SHA512: hashes.SHA512,
}
GROUP_TO_CURVE = {
Group.SECP256R1: ec.SECP256R1,
Group.SECP384R1: ec.SECP384R1,
Group.SECP521R1: ec.SECP521R1,
}
CURVE_TO_GROUP = dict((v, k) for k, v in GROUP_TO_CURVE.items())
===========changed ref 3===========
# module: aioquic.tls
class Context:
def __init__(self, is_client: bool, logger: logging.Logger = 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.handshake_extensions: List[Extension] = []
self.is_client = is_client
self.key_schedule: Optional[KeySchedule] = None
self.server_name: Optional[str] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
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,
- self._signature_algorithms = [SignatureAlgorithm.RSA_PSS_RSAE_SHA256]
+ SignatureAlgorithm.RSA_PKCS1_SHA256,
+ SignatureAlgorithm.RSA_PKCS1_SHA1,
+ ]
self._supported_versions = [TLS_VERSION_1_3]
self._key_schedule_proxy: Optional[KeyScheduleProxy] = None
self._peer_certificate: Optional[x509.Certificate] = None
self._receive_buffer = b""
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.__logger = logger
if is_client:
self.client_random = os.urandom(32)
self.session_</s>
|
tests.test_connection/FakeTransport.sendto
|
Modified
|
aiortc~aioquic
|
5429d6076a6802cf6b9dc474c8abd3b1c4a08d46
|
[connection] add error_received() callback
|
<2>:<add> self.target.datagram_received(data, None)
<del> self.target.datagram_received(data)
|
# module: tests.test_connection
class FakeTransport:
def sendto(self, data):
<0> self.sent += 1
<1> if self.target is not None:
<2> self.target.datagram_received(data)
<3>
|
===========unchanged ref 0===========
at: tests.test_connection.FakeTransport
sent = 0
target = None
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def error_received(self, exc: OSError) -> None:
+ self.__logger.warning(exc)
+
|
tests.test_connection/QuicConnectionTest.test_retry
|
Modified
|
aiortc~aioquic
|
5429d6076a6802cf6b9dc474c8abd3b1c4a08d46
|
[connection] add error_received() callback
|
<8>:<add> client.datagram_received(load("retry.bin"), None)
<del> client.datagram_received(load("retry.bin"))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_retry(self):
<0> client = QuicConnection(is_client=True)
<1> client.host_cid = binascii.unhexlify("c98343fe8f5f0ff4")
<2> client.peer_cid = binascii.unhexlify("85abb547bf28be97")
<3>
<4> client_transport = FakeTransport()
<5> client.connection_made(client_transport)
<6> self.assertEqual(client_transport.sent, 1)
<7>
<8> client.datagram_received(load("retry.bin"))
<9> self.assertEqual(client_transport.sent, 2)
<10>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.DatagramTransport) -> None
error_received(exc: OSError) -> 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: binascii
unhexlify(hexstr: _Ascii, /) -> bytes
at: tests.test_connection
FakeTransport()
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
+ def error_received(self, exc: OSError) -> None:
+ self.__logger.warning(exc)
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_error_received(self):
+ client = QuicConnection(is_client=True)
+ client.error_received(OSError('foo'))
+
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data):
self.sent += 1
if self.target is not None:
+ self.target.datagram_received(data, None)
- self.target.datagram_received(data)
|
tests.test_connection/QuicConnectionTest.test_version_negotiation_fail
|
Modified
|
aiortc~aioquic
|
5429d6076a6802cf6b9dc474c8abd3b1c4a08d46
|
[connection] add error_received() callback
|
<8>:<add> client.datagram_received(load("version_negotiation.bin"), None)
<del> client.datagram_received(load("version_negotiation.bin"))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_fail(self):
<0> client = QuicConnection(is_client=True)
<1> client.supported_versions = [QuicProtocolVersion.DRAFT_19]
<2>
<3> client_transport = FakeTransport()
<4> client.connection_made(client_transport)
<5> self.assertEqual(client_transport.sent, 1)
<6>
<7> # no common version, no retry
<8> client.datagram_received(load("version_negotiation.bin"))
<9> self.assertEqual(client_transport.sent, 1)
<10>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.DatagramTransport) -> None
at: aioquic.connection.QuicConnection.__init__
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
at: tests.test_connection
FakeTransport()
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.test_connection.QuicConnectionTest.test_transport_close
client_transport, server_transport = create_transport(client, server)
client_transport, server_transport = create_transport(client, server)
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
class QuicConnectionTest(TestCase):
+ def test_error_received(self):
+ client = QuicConnection(is_client=True)
+ client.error_received(OSError('foo'))
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_retry(self):
client = QuicConnection(is_client=True)
client.host_cid = binascii.unhexlify("c98343fe8f5f0ff4")
client.peer_cid = binascii.unhexlify("85abb547bf28be97")
client_transport = FakeTransport()
client.connection_made(client_transport)
self.assertEqual(client_transport.sent, 1)
+ client.datagram_received(load("retry.bin"), None)
- client.datagram_received(load("retry.bin"))
self.assertEqual(client_transport.sent, 2)
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data):
self.sent += 1
if self.target is not None:
+ self.target.datagram_received(data, None)
- self.target.datagram_received(data)
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
+ def error_received(self, exc: OSError) -> None:
+ self.__logger.warning(exc)
+
|
tests.test_connection/QuicConnectionTest.test_version_negotiation_ok
|
Modified
|
aiortc~aioquic
|
5429d6076a6802cf6b9dc474c8abd3b1c4a08d46
|
[connection] add error_received() callback
|
<7>:<add> client.datagram_received(load("version_negotiation.bin"), None)
<del> client.datagram_received(load("version_negotiation.bin"))
|
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_ok(self):
<0> client = QuicConnection(is_client=True)
<1>
<2> client_transport = FakeTransport()
<3> client.connection_made(client_transport)
<4> self.assertEqual(client_transport.sent, 1)
<5>
<6> # found a common version, retry
<7> client.datagram_received(load("version_negotiation.bin"))
<8> self.assertEqual(client_transport.sent, 2)
<9>
|
===========unchanged ref 0===========
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.DatagramTransport) -> None
datagram_received(data: bytes, addr: Any) -> None
at: tests.test_connection
FakeTransport()
at: tests.test_connection.FakeTransport.sendto
self.sent += 1
at: tests.test_connection.QuicConnectionTest.test_version_negotiation_fail
client = QuicConnection(is_client=True)
client_transport = FakeTransport()
at: tests.utils
load(name)
at: unittest.case.TestCase
assertEqual(first: Any, second: Any, msg: Any=...) -> None
===========changed ref 0===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_error_received(self):
+ client = QuicConnection(is_client=True)
+ client.error_received(OSError('foo'))
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_fail(self):
client = QuicConnection(is_client=True)
client.supported_versions = [QuicProtocolVersion.DRAFT_19]
client_transport = FakeTransport()
client.connection_made(client_transport)
self.assertEqual(client_transport.sent, 1)
# no common version, no retry
+ client.datagram_received(load("version_negotiation.bin"), None)
- client.datagram_received(load("version_negotiation.bin"))
self.assertEqual(client_transport.sent, 1)
===========changed ref 2===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_retry(self):
client = QuicConnection(is_client=True)
client.host_cid = binascii.unhexlify("c98343fe8f5f0ff4")
client.peer_cid = binascii.unhexlify("85abb547bf28be97")
client_transport = FakeTransport()
client.connection_made(client_transport)
self.assertEqual(client_transport.sent, 1)
+ client.datagram_received(load("retry.bin"), None)
- client.datagram_received(load("retry.bin"))
self.assertEqual(client_transport.sent, 2)
===========changed ref 3===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data):
self.sent += 1
if self.target is not None:
+ self.target.datagram_received(data, None)
- self.target.datagram_received(data)
===========changed ref 4===========
# module: aioquic.connection
class QuicConnection:
+ def error_received(self, exc: OSError) -> None:
+ self.__logger.warning(exc)
+
|
examples.server/QuicServerProtocol.datagram_received
|
Modified
|
aiortc~aioquic
|
5429d6076a6802cf6b9dc474c8abd3b1c4a08d46
|
[connection] add error_received() callback
|
<7>:<add> connection.datagram_received(datagram, addr)
<del> connection.datagram_received(datagram)
|
# module: examples.server
class QuicServerProtocol(asyncio.DatagramProtocol):
def datagram_received(self, datagram, addr):
<0> buf = Buffer(data=datagram)
<1> header = pull_quic_header(buf, host_cid_length=8)
<2> connection = self._connections.get(header.destination_cid, None)
<3> if connection is None:
<4> connection = QuicConnection(is_client=False, **self._kwargs)
<5> connection.connection_made(QuicConnectionTransport(self, addr))
<6> self._connections[connection.host_cid] = connection
<7> connection.datagram_received(datagram)
<8>
|
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.connection
QuicConnection(is_client: bool=True, certificate: Any=None, private_key: Any=None, secrets_log_file: TextIO=None, alpn_protocols: Optional[List[str]]=None, server_name: Optional[str]=None)
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.DatagramTransport) -> None
at: aioquic.connection.QuicConnection.__init__
self.host_cid = os.urandom(8)
at: aioquic.packet
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: aioquic.packet.QuicHeader
version: int
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: asyncio.protocols.DatagramProtocol
__slots__ = ()
datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None
at: examples.server
QuicConnectionTransport(protocol, addr)
at: examples.server.QuicServerProtocol.__init__
self._connections = {}
self._kwargs = kwargs
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
class QuicConnection:
+ def error_received(self, exc: OSError) -> None:
+ self.__logger.warning(exc)
+
===========changed ref 1===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
+ def test_error_received(self):
+ client = QuicConnection(is_client=True)
+ client.error_received(OSError('foo'))
+
===========changed ref 2===========
# module: tests.test_connection
class FakeTransport:
def sendto(self, data):
self.sent += 1
if self.target is not None:
+ self.target.datagram_received(data, None)
- self.target.datagram_received(data)
===========changed ref 3===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_ok(self):
client = QuicConnection(is_client=True)
client_transport = FakeTransport()
client.connection_made(client_transport)
self.assertEqual(client_transport.sent, 1)
# found a common version, retry
+ client.datagram_received(load("version_negotiation.bin"), None)
- client.datagram_received(load("version_negotiation.bin"))
self.assertEqual(client_transport.sent, 2)
===========changed ref 4===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_version_negotiation_fail(self):
client = QuicConnection(is_client=True)
client.supported_versions = [QuicProtocolVersion.DRAFT_19]
client_transport = FakeTransport()
client.connection_made(client_transport)
self.assertEqual(client_transport.sent, 1)
# no common version, no retry
+ client.datagram_received(load("version_negotiation.bin"), None)
- client.datagram_received(load("version_negotiation.bin"))
self.assertEqual(client_transport.sent, 1)
===========changed ref 5===========
# module: tests.test_connection
class QuicConnectionTest(TestCase):
def test_retry(self):
client = QuicConnection(is_client=True)
client.host_cid = binascii.unhexlify("c98343fe8f5f0ff4")
client.peer_cid = binascii.unhexlify("85abb547bf28be97")
client_transport = FakeTransport()
client.connection_made(client_transport)
self.assertEqual(client_transport.sent, 1)
+ client.datagram_received(load("retry.bin"), None)
- client.datagram_received(load("retry.bin"))
self.assertEqual(client_transport.sent, 2)
|
aioquic.tls/negotiate
|
Modified
|
aiortc~aioquic
|
42d4f83a6d34b316851c1cc2fcec294f533ee3e3
|
[tls] add AlertDescription enum
|
<4>:<add> raise exc
<del> raise AlertHandshakeFailure(error_message)
|
# module: aioquic.tls
+ def negotiate(supported: List[T], offered: List[T], exc: Alert) -> T:
- def negotiate(supported: List[T], offered: List[T], error_message: str) -> T:
<0> for c in supported:
<1> if c in offered:
<2> return c
<3>
<4> raise AlertHandshakeFailure(error_message)
<5>
|
===========unchanged ref 0===========
at: aioquic.tls
SignatureAlgorithm(x: Union[str, bytes, bytearray], base: int)
SignatureAlgorithm(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
===========changed ref 0===========
# module: aioquic.tls
+ class AlertProtocolVersion(Alert):
+ description = AlertDescription.protocol_version
+
===========changed ref 1===========
# module: aioquic.tls
class AlertUnexpectedMessage(Alert):
+ description = AlertDescription.unexpected_message
- pass
===========changed ref 2===========
# module: aioquic.tls
class Alert(Exception):
+ description: AlertDescription
- pass
===========changed ref 3===========
# module: aioquic.tls
class AlertHandshakeFailure(Alert):
+ description = AlertDescription.handshake_failure
- pass
===========changed ref 4===========
# module: aioquic.tls
+ class AlertDescription(IntEnum):
+ close_notify = 0
+ unexpected_message = 10
+ bad_record_mac = 20
+ record_overflow = 22
+ handshake_failure = 40
+ bad_certificate = 42
+ unsupported_certificate = 43
+ certificate_revoked = 44
+ certificate_expired = 45
+ certificate_unknown = 46
+ illegal_parameter = 47
+ unknown_ca = 48
+ access_denied = 49
+ decode_error = 50
+ decrypt_error = 51
+ protocol_version = 70
+ insufficient_security = 71
+ internal_error = 80
+ inappropriate_fallback = 86
+ user_canceled = 90
+ missing_extension = 109
+ unsupported_extension = 110
+ unrecognized_name = 112
+ bad_certificate_status_response = 113
+ unknown_psk_identity = 115
+ certificate_required = 116
+ no_application_protocol = 120
+
|
aioquic.tls/Context._server_handle_hello
|
Modified
|
aiortc~aioquic
|
42d4f83a6d34b316851c1cc2fcec294f533ee3e3
|
[tls] add AlertDescription enum
|
<4>:<add> self._cipher_suites,
<add> peer_hello.cipher_suites,
<add> AlertHandshakeFailure("No supported cipher suite"),
<del> self._cipher_suites, peer_hello.cipher_suites, "No supported cipher suite"
<9>:<add> AlertHandshakeFailure("No supported compression method"),
<del> "No supported compression method",
<14>:<add> AlertHandshakeFailure("No supported key exchange mode"),
<del> "No supported key exchange mode",
<19>:<add> AlertHandshakeFailure("No supported signature algorithm"),
<del> "No supported signature algorithm",
<24>:<add> AlertProtocolVersion("No supported protocol version"),
<del> "No supported protocol version",
|
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
<0> peer_hello = pull_client_hello(input_buf)
<1>
<2> # negotiate parameters
<3> cipher_suite = negotiate(
<4> self._cipher_suites, peer_hello.cipher_suites, "No supported cipher suite"
<5> )
<6> compression_method = negotiate(
<7> self._compression_methods,
<8> peer_hello.compression_methods,
<9> "No supported compression method",
<10> )
<11> negotiate(
<12> self._key_exchange_modes,
<13> peer_hello.key_exchange_modes,
<14> "No supported key exchange mode",
<15> )
<16> signature_algorithm = negotiate(
<17> self._signature_algorithms,
<18> peer_hello.signature_algorithms,
<19> "No supported signature algorithm",
<20> )
<21> supported_version = negotiate(
<22> self._supported_versions,
<23> peer_hello.supported_versions,
<24> "No supported protocol version",
<25> )
<26>
<27> self.client_random = peer_hello.random
<28> self.server_random = os.urandom(32)
<29> self.session_id = peer_hello.session_id
<30> self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
<31>
<32> self.key_schedule = KeySchedule(cipher_suite)
<33> self.key_schedule.extract(None)
<34> self.key_schedule.update_hash(input_buf.data)
<35>
<36> peer_public_key = decode_public_key(peer_hello.key_share[0])
<37> shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
<38>
<39> # send hello
<40> hello = ServerHello(
<41> random=self.server_random,
<42> session_id=self.session_id,
<43> </s>
|
===========below chunk 0===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
# offset: 1
compression_method=compression_method,
key_share=encode_public_key(self.private_key.public_key()),
supported_version=supported_version,
)
with push_message(self.key_schedule, initial_buf):
push_server_hello(initial_buf, hello)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
# send encrypted extensions
with push_message(self.key_schedule, output_buf):
push_encrypted_extensions(
output_buf,
EncryptedExtensions(other_extensions=self.handshake_extensions),
)
# send certificate
with push_message(self.key_schedule, output_buf):
push_certificate(
output_buf,
Certificate(
request_context=b"",
certificates=[(self.certificate.public_bytes(Encoding.DER), b"")],
),
)
# send certificate verify
signature = self.certificate_private_key.sign(
self.key_schedule.certificate_verify_data(
b"TLS 1.3, server CertificateVerify"
),
*signature_algorithm_params(signature_algorithm),
)
with push_message(self.key_schedule, output_buf):
push_certificate_verify(
output_buf,
CertificateVerify(algorithm=signature_algorithm, signature=signature),
)
# send finished
with push_message(self.key_schedule, output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.</s>
===========below chunk 1===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
# offset: 2
<s>schedule, output_buf):
push_finished(
output_buf,
Finished(
verify_data=self.key_schedule.finished_verify_data(self._enc_key)
),
)
# prepare traffic keys
assert self.key_schedule.generation == 2
self.key_schedule.extract(None)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.ONE_RTT, b"s ap traffic"
)
self._next_dec_key = self.key_schedule.derive_secret(b"c ap traffic")
self._set_state(State.SERVER_EXPECT_FINISHED)
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
at: aioquic.tls
AlertHandshakeFailure(*args: object)
AlertProtocolVersion(*args: object)
Direction()
Epoch()
State()
pull_client_hello(buf: Buffer) -> ClientHello
ServerHello(random: bytes, session_id: bytes, cipher_suite: CipherSuite, compression_method: CompressionMethod, key_share: Optional[KeyShareEntry]=None, supported_version: Optional[int]=None)
push_server_hello(buf: Buffer, hello: ServerHello) -> None
pull_new_session_ticket(buf: Buffer) -> NewSessionTicket
EncryptedExtensions(other_extensions: List[Tuple[int, bytes]]=field(default_factory=list))
push_encrypted_extensions(buf: Buffer, extensions: EncryptedExtensions) -> None
Certificate(request_context: bytes=b"", certificates: List[CertificateEntry]=field(default_factory=list))
push_certificate(buf: Buffer, certificate: Certificate) -> None
Finished(verify_data: bytes=b"")
pull_finished(buf: Buffer) -> Finished
push_finished(buf: Buffer, finished: Finished) -> None
KeySchedule(cipher_suite: CipherSuite)
decode_public_key(key_share: KeyShareEntry) -> ec.EllipticCurvePublicKey
encode_public_key(public_key: ec.EllipticCurvePublicKey) -> KeyShareEntry
negotiate(supported: List[T], offered: List[T], exc: Alert) -> T
push_message(key_schedule: Union[KeySchedule, KeyScheduleProxy], buf: Buffer) -> Generator
at: aioquic.tls.Context
_setup_traffic_protection(direction: Direction, epoch: Epoch, label: bytes) -> None
_set_state(state: State) -> None
===========unchanged ref 1===========
at: aioquic.tls.Context.__init__
self.handshake_extensions: List[Extension] = []
self.key_schedule: Optional[KeySchedule] = None
self.update_traffic_key_cb: Callable[
[Direction, Epoch, bytes], None
] = lambda d, e, s: None
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.RSA_PKCS1_SHA256,
SignatureAlgorithm.RSA_PKCS1_SHA1,
]
self._supported_versions = [TLS_VERSION_1_3]
self._enc_key: Optional[bytes] = None
self._dec_key: Optional[bytes] = None
self.client_random = None
self.client_random = os.urandom(32)
self.session_id = None
self.session_id = os.urandom(32)
self.private_key = ec.generate_private_key(
ec.SECP256R1(), default_backend()
)
self.private_key = None
at: aioquic.tls.Context._client_handle_hello
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._setup_traffic_protection
self._enc_key = key
self._dec_key = key
===========unchanged ref 2===========
at: aioquic.tls.EncryptedExtensions
other_extensions: List[Tuple[int, bytes]] = field(default_factory=list)
at: aioquic.tls.Finished
verify_data: bytes = b""
at: aioquic.tls.KeySchedule
finished_verify_data(secret: bytes) -> bytes
derive_secret(label: bytes) -> bytes
extract(key_material: Optional[bytes]=None) -> None
update_hash(data: bytes) -> None
at: aioquic.tls.KeySchedule.__init__
self.generation = 0
at: aioquic.tls.KeySchedule.extract
self.generation += 1
at: aioquic.tls.ServerHello
random: bytes
session_id: bytes
cipher_suite: CipherSuite
compression_method: CompressionMethod
key_share: Optional[KeyShareEntry] = None
supported_version: Optional[int] = None
at: os
urandom(size: int, /) -> bytes
|
tests.test_tls/ContextTest.test_server_unsupported_version
|
Modified
|
aiortc~aioquic
|
42d4f83a6d34b316851c1cc2fcec294f533ee3e3
|
[tls] add AlertDescription enum
|
<5>:<add> with self.assertRaises(tls.AlertProtocolVersion) as cm:
<del> with self.assertRaises(tls.AlertHandshakeFailure) as cm:
|
# module: tests.test_tls
class ContextTest(TestCase):
def test_server_unsupported_version(self):
<0> client = self.create_client()
<1> client._supported_versions = [tls.TLS_VERSION_1_2]
<2>
<3> server = self.create_server()
<4>
<5> with self.assertRaises(tls.AlertHandshakeFailure) as cm:
<6> self._server_fail_hello(client, server)
<7> self.assertEqual(str(cm.exception), "No supported protocol version")
<8>
|
===========unchanged ref 0===========
at: aioquic.tls
TLS_VERSION_1_2 = 0x0303
AlertProtocolVersion(*args: object)
at: aioquic.tls.Context.__init__
self._supported_versions = [TLS_VERSION_1_3]
at: tests.test_tls.ContextTest
create_client()
create_server()
_server_fail_hello(client, server)
at: unittest.case.TestCase
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
_testMethodName: str
_testMethodDoc: str
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: aioquic.tls
+ class AlertProtocolVersion(Alert):
+ description = AlertDescription.protocol_version
+
===========changed ref 1===========
# module: aioquic.tls
class Alert(Exception):
+ description: AlertDescription
- pass
===========changed ref 2===========
# module: aioquic.tls
class AlertUnexpectedMessage(Alert):
+ description = AlertDescription.unexpected_message
- pass
===========changed ref 3===========
# module: aioquic.tls
class AlertHandshakeFailure(Alert):
+ description = AlertDescription.handshake_failure
- pass
===========changed ref 4===========
# module: aioquic.tls
+ def negotiate(supported: List[T], offered: List[T], exc: Alert) -> T:
- def negotiate(supported: List[T], offered: List[T], error_message: str) -> T:
for c in supported:
if c in offered:
return c
+ raise exc
- raise AlertHandshakeFailure(error_message)
===========changed ref 5===========
# module: aioquic.tls
+ class AlertDescription(IntEnum):
+ close_notify = 0
+ unexpected_message = 10
+ bad_record_mac = 20
+ record_overflow = 22
+ handshake_failure = 40
+ bad_certificate = 42
+ unsupported_certificate = 43
+ certificate_revoked = 44
+ certificate_expired = 45
+ certificate_unknown = 46
+ illegal_parameter = 47
+ unknown_ca = 48
+ access_denied = 49
+ decode_error = 50
+ decrypt_error = 51
+ protocol_version = 70
+ insufficient_security = 71
+ internal_error = 80
+ inappropriate_fallback = 86
+ user_canceled = 90
+ missing_extension = 109
+ unsupported_extension = 110
+ unrecognized_name = 112
+ bad_certificate_status_response = 113
+ unknown_psk_identity = 115
+ certificate_required = 116
+ no_application_protocol = 120
+
===========changed ref 6===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
peer_hello = pull_client_hello(input_buf)
# negotiate parameters
cipher_suite = negotiate(
+ self._cipher_suites,
+ peer_hello.cipher_suites,
+ AlertHandshakeFailure("No supported cipher suite"),
- self._cipher_suites, peer_hello.cipher_suites, "No supported cipher suite"
)
compression_method = negotiate(
self._compression_methods,
peer_hello.compression_methods,
+ AlertHandshakeFailure("No supported compression method"),
- "No supported compression method",
)
negotiate(
self._key_exchange_modes,
peer_hello.key_exchange_modes,
+ AlertHandshakeFailure("No supported key exchange mode"),
- "No supported key exchange mode",
)
signature_algorithm = negotiate(
self._signature_algorithms,
peer_hello.signature_algorithms,
+ AlertHandshakeFailure("No supported signature algorithm"),
- "No supported signature algorithm",
)
supported_version = negotiate(
self._supported_versions,
peer_hello.supported_versions,
+ AlertProtocolVersion("No supported protocol version"),
- "No supported protocol version",
)
self.client_random = peer_hello.random
self.server_random = os.urandom(32)
self.session_id = peer_hello.session_id
self.private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
self.key_schedule = KeySchedule(cipher_suite)
self.key_schedule.extract(None)
self.key_schedule.update_hash(input_buf.data)
peer_public_key = decode_public_key(peer_hello.key_share[0])
shared_key = self.private_key.exchange</s>
===========changed ref 7===========
# module: aioquic.tls
class Context:
def _server_handle_hello(
self, input_buf: Buffer, initial_buf: Buffer, output_buf: Buffer
) -> None:
# offset: 1
<s> = decode_public_key(peer_hello.key_share[0])
shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
# send hello
hello = ServerHello(
random=self.server_random,
session_id=self.session_id,
cipher_suite=cipher_suite,
compression_method=compression_method,
key_share=encode_public_key(self.private_key.public_key()),
supported_version=supported_version,
)
with push_message(self.key_schedule, initial_buf):
push_server_hello(initial_buf, hello)
self.key_schedule.extract(shared_key)
self._setup_traffic_protection(
Direction.ENCRYPT, Epoch.HANDSHAKE, b"s hs traffic"
)
self._setup_traffic_protection(
Direction.DECRYPT, Epoch.HANDSHAKE, b"c hs traffic"
)
# send encrypted extensions
with push_message(self.key_schedule, output_buf):
push_encrypted_extensions(
output_buf,
EncryptedExtensions(other_extensions=self.handshake_extensions),
)
# send certificate
with push_message(self.key_schedule, output_buf):
push_certificate(
output_buf,
Certificate(
request_context=b"",
certificates=[(self.certificate.public_bytes(Encoding.DER), b"")],
),
)
# send certificate verify
signature = self.certificate_private_key.sign(
self.key_schedule.certificate_verify_data(
b"TLS 1.3</s>
|
aioquic.connection/QuicConnection.__init__
|
Modified
|
aiortc~aioquic
|
7bcfe178619e857230f672a846506b64bba68823
|
[connection] close connection on TLS error
|
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
<0> if not is_client:
<1> assert certificate is not None, "SSL certificate is required"
<2> assert private_key is not None, "SSL private key is required"
<3>
<4> self.alpn_protocols = alpn_protocols
<5> self.certificate = certificate
<6> self.is_client = is_client
<7> self.host_cid = os.urandom(8)
<8> self.peer_cid = os.urandom(8)
<9> self.peer_cid_set = False
<10> self.peer_token = b""
<11> self.private_key = private_key
<12> self.secrets_log_file = secrets_log_file
<13> self.server_name = server_name
<14> self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
<15>
<16> # protocol versions
<17> self.supported_versions = [
<18> QuicProtocolVersion.DRAFT_17,
<19> QuicProtocolVersion.DRAFT_18,
<20> QuicProtocolVersion.DRAFT_19,
<21> QuicProtocolVersion.DRAFT_20,
<22> ]
<23> self.version = QuicProtocolVersion.DRAFT_20
<24>
<25> self.quic_transport_parameters = QuicTransportParameters(
<26> idle_timeout=600,
<27> initial_max_data=16777216,
<28> initial_max_stream_data_bidi_local=1048576,
<29> initial_max_stream_data_bidi_remote=1048576,
<30> initial_max_stream_data_uni=1048576,
<31> initial_max_streams_bidi=100,
<32> ack_delay_exponent=10,
<33> </s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
self.__initialized = False
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
self.peer_cid_set = True
at: aioquic.packet
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
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, 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: 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
===========unchanged ref 1===========
initial_max_data: Optional[int] = None
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: aioquic.stream
QuicStream(stream_id: Optional[int]=None, connection: Optional[Any]=None)
at: aioquic.tls
Epoch()
at: os
urandom(size: int, /) -> bytes
at: typing
List = _alias(list, 1, inst=False, name='List')
Dict = _alias(dict, 2, inst=False, name='Dict')
TextIO()
===========changed ref 0===========
# module: aioquic.connection
+ def push_close(
+ buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes
+ ):
+ if frame_type is None:
+ push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
+ packet.push_application_close_frame(buf, error_code, reason_phrase)
+ else:
+ push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
+ packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
+
===========changed ref 1===========
# module: aioquic.packet
class QuicErrorCode(IntEnum):
NO_ERROR = 0x0
INTERNAL_ERROR = 0x1
SERVER_BUSY = 0x2
FLOW_CONTROL_ERROR = 0x3
STREAM_LIMIT_ERROR = 0x4
STREAM_STATE_ERROR = 0x5
FINAL_SIZE_ERROR = 0x6
FRAME_ENCODING_ERROR = 0x7
TRANSPORT_PARAMETER_ERROR = 0x8
PROTOCOL_VIOLATION = 0xA
INVALID_MIGRATION = 0xC
CRYPTO_BUFFER_EXCEEDED = 0xD
+ CRYPTO_ERROR = 0x100
|
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
7bcfe178619e857230f672a846506b64bba68823
|
[connection] close connection on TLS error
|
<17>:<add> try:
<add> self.tls.handle_message(data, self.send_buffer)
<del> self.tls.handle_message(data, self.send_buffer)
<18>:<add> except tls.Alert as exc:
<add> self.__logger.warning("TLS error: %s" % exc)
<add> self.close(
<add> QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<add> frame_type,
<add> str(exc).encode("ascii"),
<add> )
<add> return
<add> if self.tls.state in [
<del> if not self.__connected.is_set() and self.tls.state in [
<22>:<add> if not self.__connected.is_set():
<add> self.__connected.set()
<del> self.__connected.set()
<23>:<add> self.__epoch = tls.Epoch.ONE_RTT
<add> else:
<add> self.__epoch = tls.Epoch.HANDSHAKE
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> self.tls.handle_message(data, self.send_buffer)
<18> if not self.__connected.is_set() and self.tls.state in [
<19> tls.State.CLIENT_POST_HANDSHAKE,
<20> tls.State.SERVER_POST_HANDSHAKE,
<21> ]:
<22> self.__connected.set()
<23>
<24> elif frame_type == QuicFrameType.NEW_TOKEN:
<25> packet.pull_new_token_frame(buf)
<26> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<27> flags = frame_type & STREAM_FLAGS
<28> stream_id = pull_uint_var(buf)
<29> if flags & QuicStreamFlag.OFF:
<30> offset = pull_uint_var(buf)
<31> else:
<32> offset = 0
<33> if flags & QuicStreamFlag.LEN:
<34> length = pull_uint_var(buf)
<35> else:
<36> length = buf.capacity - buf.tell()
<37> frame = QuicStreamFrame(
<38> offset=offset,
<39> data=pull_bytes(buf, length),</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
)
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type in [
QuicFrameType.MAX_STREAMS_BIDI,
QuicFrameType.MAX_STREAMS_UNI,
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
PacketSpace()
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
close(error_code: int, frame_type: Optional[int]=None, reason_phrase: bytes=b"") -> None
_get_or_create_stream(stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__logger = logger
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),
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
===========unchanged ref 1===========
at: aioquic.crypto.CryptoPair
setup_initial(cid: bytes, is_client: bool) -> None
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
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_new_token_frame(buf: Buffer) -> bytes
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)
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
at: aioquic.tls.Alert
description: AlertDescription
at: aioquic.tls.Context
handle_message(input_data: bytes, output_buf: Dict[Epoch, Buffer]) -> None
===========unchanged ref 2===========
at: aioquic.tls.Context.__init__
self.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
at: logging.Logger
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
===========changed ref 0===========
# module: aioquic.packet
class QuicErrorCode(IntEnum):
NO_ERROR = 0x0
INTERNAL_ERROR = 0x1
SERVER_BUSY = 0x2
FLOW_CONTROL_ERROR = 0x3
STREAM_LIMIT_ERROR = 0x4
STREAM_STATE_ERROR = 0x5
FINAL_SIZE_ERROR = 0x6
FRAME_ENCODING_ERROR = 0x7
TRANSPORT_PARAMETER_ERROR = 0x8
PROTOCOL_VIOLATION = 0xA
INVALID_MIGRATION = 0xC
CRYPTO_BUFFER_EXCEEDED = 0xD
+ CRYPTO_ERROR = 0x100
===========changed ref 1===========
# module: aioquic.connection
+ def push_close(
+ buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes
+ ):
+ if frame_type is None:
+ push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
+ packet.push_application_close_frame(buf, error_code, reason_phrase)
+ else:
+ push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
+ packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
+
|
aioquic.connection/QuicConnection._pending_datagrams
|
Modified
|
aiortc~aioquic
|
7bcfe178619e857230f672a846506b64bba68823
|
[connection] close connection on TLS error
|
<5>:<del> if self.__close is not None:
<6>:<del> close = self.__close
<7>:<del> self.__close = None
<8>:<del> yield from self._write_close(tls.Epoch.ONE_RTT, **close)
<9>:<del>
|
# module: aioquic.connection
class QuicConnection:
def _pending_datagrams(self) -> Iterator[bytes]:
<0> for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
<1> yield from self._write_handshake(epoch)
<2>
<3> yield from self._write_application()
<4>
<5> if self.__close is not None:
<6> close = self.__close
<7> self.__close = None
<8> yield from self._write_close(tls.Epoch.ONE_RTT, **close)
<9>
|
===========unchanged ref 0===========
at: aioquic.connection.QuicConnection.__init__
self.__logger = logger
at: aioquic.connection.QuicConnection._payload_received
buf = Buffer(data=plain)
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_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
at: logging.Logger
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
+ def push_close(
+ buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes
+ ):
+ if frame_type is None:
+ push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
+ packet.push_application_close_frame(buf, error_code, reason_phrase)
+ else:
+ push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
+ packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
if not is_client:
assert certificate is not None, "SSL certificate is required"
assert private_key is not None, "SSL private key is required"
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] = {}
# protocol versions
self.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
+ self.__epoch = tls.Epoch</s>
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
def __init__(
self,
is_client: bool = True,
certificate: Any = None,
private_key: Any = None,
secrets_log_file: TextIO = None,
alpn_protocols: Optional[List[str]] = None,
server_name: Optional[str] = None,
) -> None:
# offset: 1
<s> self.__close: Optional[Dict] = None
self.__connected = asyncio.Event()
+ self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
===========changed ref 3===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
buf = Buffer(data=plain)
is_ack_only = True
while not buf.eof():
frame_type = pull_uint_var(buf)
if frame_type != QuicFrameType.ACK:
is_ack_only = False
if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
pass
elif frame_type == QuicFrameType.ACK:
packet.pull_ack_frame(buf)
elif frame_type == QuicFrameType.CRYPTO:
stream = self.streams[epoch]
stream.add_frame(packet.pull_crypto_frame(buf))
data = stream.pull_data()
if data:
+ try:
+ self.tls.handle_message(data, self.send_buffer)
- self.tls.handle_message(data, self.send_buffer)
+ except tls.Alert as exc:
+ self.__logger.warning("TLS error: %s" % exc)
+ self.close(
+ QuicErrorCode.CRYPTO_ERROR + int(exc.description),
+ frame_type,
+ str(exc).encode("ascii"),
+ )
+ return
+ if self.tls.state in [
- if not self.__connected.is_set() and self.tls.state in [
tls.State.CLIENT_POST_HANDSHAKE,
tls.State.SERVER_POST_HANDSHAKE,
]:
+ if not self.__connected.is_set():
+ self.__connected.set()
- self.__connected.set()
+ self.__epoch = tls.Epoch.ONE_RTT
+ else:
+ self.__epoch = tls.Epoch.HANDSHAKE
elif frame_type == QuicFrameType.NEW_TOKEN:
packet.pull_new_token_frame(buf)
elif (frame_type & ~STREAM_FLAGS) == Qu</s>
|
aioquic.connection/QuicConnection._write_application
|
Modified
|
aiortc~aioquic
|
7bcfe178619e857230f672a846506b64bba68823
|
[connection] close connection on TLS error
|
<19>:<add>
<add> # CLOSE
<add> if self.__close and self.__epoch == epoch:
<add> push_close(buf, **self.__close)
<add> self.__close = None
|
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
<0> epoch = tls.Epoch.ONE_RTT
<1> space = self.spaces[epoch]
<2> send_ack = space.ack_queue if self.send_ack[epoch] else None
<3> if not space.crypto.send.is_valid():
<4> return
<5>
<6> buf = Buffer(capacity=PACKET_MAX_SIZE)
<7>
<8> # write header
<9> push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
<10> push_bytes(buf, self.peer_cid)
<11> push_uint16(buf, self.packet_number)
<12> header_size = buf.tell()
<13>
<14> # ACK
<15> if send_ack:
<16> push_uint_var(buf, QuicFrameType.ACK)
<17> packet.push_ack_frame(buf, send_ack, 0)
<18> self.send_ack[epoch] = False
<19>
<20> # STREAM
<21> for stream_id, stream in self.streams.items():
<22> if isinstance(stream_id, int) and stream.has_data_to_send():
<23> frame = stream.get_frame(
<24> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 6
<25> )
<26> flags = QuicStreamFlag.OFF | QuicStreamFlag.LEN
<27> if frame.fin:
<28> flags |= QuicStreamFlag.FIN
<29> push_uint_var(buf, QuicFrameType.STREAM_BASE | flags)
<30> with push_stream_frame(buf, 0, frame.offset):
<31> push_bytes(buf, frame.data)
<32>
<33> # encrypt
<34> packet_size = buf.tell()
<35> if packet_size > header_size:
<36> data = buf.data
<37> yield space.crypto.encrypt_packet(
<38> data[0:header_size], data[header_size:packet_size]
<39> )
</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _write_application(self) -> Iterator[bytes]:
# offset: 1
self.packet_number += 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.buffer.Buffer
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
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",
],
]
SEND_PN_SIZE = 2
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection.__init__
self.is_client = is_client
self.peer_cid = os.urandom(8)
self.secrets_log_file = secrets_log_file
self.quic_transport_parameters = QuicTransportParameters(
idle_timeout=600,
initial_max_data=16777216,
initial_max_stream_data_bidi_local=1048576,
initial_max_stream_data_bidi_remote=1048576,
initial_max_stream_data_uni=1048576,
initial_max_streams_bidi=100,
ack_delay_exponent=10,
)
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection._initialize
self.tls = tls.Context(is_client=self.is_client, logger=self.__logger)
self.send_ack = {
tls.Epoch.INITIAL: False,
tls.Epoch.HANDSHAKE: False,
tls.Epoch.ONE_RTT: False,
}
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.packet_number = 0
at: aioquic.connection.QuicConnection._serialize_parameters
buf = Buffer(capacity=512)
is_client = None
is_client = self.is_client
at: aioquic.connection.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
at: aioquic.connection.QuicConnection.datagram_received
self.peer_cid = header.source_cid
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_FIXED_BIT = 0x40
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
at: aioquic.tls
Direction()
Epoch()
===========unchanged ref 2===========
at: aioquic.tls.Context.__init__
self.key_schedule: Optional[KeySchedule] = None
self.client_random = None
self.client_random = os.urandom(32)
at: aioquic.tls.Context._client_handle_hello
self.key_schedule = self._key_schedule_proxy.select(peer_hello.cipher_suite)
at: aioquic.tls.Context._server_handle_hello
self.client_random = peer_hello.random
self.key_schedule = KeySchedule(cipher_suite)
at: aioquic.tls.KeySchedule.__init__
self.cipher_suite = cipher_suite
at: enum.Enum
name: str
value: Any
_name_: str
_value_: Any
_member_names_: List[str] # undocumented
_member_map_: Dict[str, Enum] # undocumented
_value2member_map_: Dict[int, Enum] # undocumented
_ignore_: Union[str, List[str]]
_order_: str
__order__: str
at: typing
Iterator = _alias(collections.abc.Iterator, 1)
at: typing.IO
__slots__ = ()
flush() -> None
write(s: AnyStr) -> int
===========changed ref 0===========
# module: aioquic.connection
class QuicConnection:
def _pending_datagrams(self) -> Iterator[bytes]:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
yield from self._write_handshake(epoch)
yield from self._write_application()
- if self.__close is not None:
- close = self.__close
- self.__close = None
- yield from self._write_close(tls.Epoch.ONE_RTT, **close)
-
===========changed ref 1===========
# module: aioquic.connection
+ def push_close(
+ buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes
+ ):
+ if frame_type is None:
+ push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
+ packet.push_application_close_frame(buf, error_code, reason_phrase)
+ else:
+ push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
+ packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
+
|
aioquic.connection/QuicConnection._write_handshake
|
Modified
|
aiortc~aioquic
|
7bcfe178619e857230f672a846506b64bba68823
|
[connection] close connection on TLS error
|
<31>:<add>
<add> # CLOSE
<add> if self.__close and self.__epoch == epoch:
<add> push_close(buf, **self.__close)
<add> self.__close = None
|
# module: aioquic.connection
class QuicConnection:
def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
<0> space = self.spaces[epoch]
<1> stream = self.streams[epoch]
<2> send_ack = space.ack_queue if self.send_ack[epoch] else None
<3> self.send_ack[epoch] = False
<4>
<5> buf = Buffer(capacity=PACKET_MAX_SIZE)
<6>
<7> while space.crypto.send.is_valid() and (send_ack or stream.has_data_to_send()):
<8> if epoch == tls.Epoch.INITIAL:
<9> packet_type = PACKET_TYPE_INITIAL
<10> else:
<11> packet_type = PACKET_TYPE_HANDSHAKE
<12>
<13> # write header
<14> push_quic_header(
<15> buf,
<16> QuicHeader(
<17> version=self.version,
<18> packet_type=packet_type | (SEND_PN_SIZE - 1),
<19> destination_cid=self.peer_cid,
<20> source_cid=self.host_cid,
<21> token=self.peer_token,
<22> ),
<23> )
<24> header_size = buf.tell()
<25>
<26> # ACK
<27> if send_ack is not None:
<28> push_uint_var(buf, QuicFrameType.ACK)
<29> packet.push_ack_frame(buf, send_ack, 0)
<30> send_ack = None
<31>
<32> if stream.has_data_to_send():
<33> # CRYPTO
<34> frame = stream.get_frame(
<35> PACKET_MAX_SIZE - buf.tell() - space.crypto.aead_tag_size - 4
<36> )
<37> push_uint_var(buf, QuicFrameType.CRYPTO)
<38> with packet.push_crypto_frame(buf, frame.offset):
<39> push_bytes(buf, frame.data)
<40>
<41> # PADDING
<42> if epoch == tls.Epoch.INITIAL and self.is_client:</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _write_handshake(self, epoch: tls.Epoch) -> Iterator[bytes]:
# offset: 1
buf,
bytes(
PACKET_MAX_SIZE - space.crypto.aead_tag_size - buf.tell()
),
)
# finalize length
packet_size = buf.tell()
buf.seek(header_size - SEND_PN_SIZE - 2)
length = packet_size - header_size + 2 + space.crypto.aead_tag_size
push_uint16(buf, length | 0x4000)
push_uint16(buf, self.packet_number)
buf.seek(packet_size)
# encrypt
data = buf.data
yield space.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
push_uint16(buf: Buffer, v: int) -> None
at: aioquic.buffer.Buffer
seek(pos: int) -> None
tell() -> int
at: aioquic.connection
PACKET_MAX_SIZE = 1280
SEND_PN_SIZE = 2
push_close(buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes)
at: aioquic.connection.PacketSpace.__init__
self.crypto = CryptoPair()
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.version = QuicProtocolVersion.DRAFT_20
self.__close: Optional[Dict] = None
self.__epoch = tls.Epoch.INITIAL
at: aioquic.connection.QuicConnection._initialize
self.packet_number = 0
at: aioquic.connection.QuicConnection._payload_received
self.__epoch = tls.Epoch.ONE_RTT
self.__epoch = tls.Epoch.HANDSHAKE
at: aioquic.connection.QuicConnection._write_application
self.__close = None
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
space = self.spaces[epoch]
stream = self.streams[epoch]
buf = Buffer(capacity=PACKET_MAX_SIZE)
packet_type = PACKET_TYPE_INITIAL
packet_type = PACKET_TYPE_HANDSHAKE
at: aioquic.connection.QuicConnection.close
self.__close = {
"error_code": error_code,
"frame_type": frame_type,
"reason_phrase": reason_phrase,
}
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.datagram_received
self.version = QuicProtocolVersion(max(common))
self.peer_cid = header.source_cid
self.peer_token = header.token
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
QuicHeader(version: int, packet_type: int, destination_cid: bytes, source_cid: bytes, original_destination_cid: bytes=b"", token: bytes=b"", rest_length: int=0)
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: 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.QuicStreamFrame
data: bytes = b""
offset: int = 0
at: aioquic.stream.QuicStream
get_frame(size: int) -> QuicStreamFrame
has_data_to_send() -> bool
at: aioquic.tls
Epoch()
===========changed ref 0===========
# module: aioquic.connection
+ def push_close(
+ buf: Buffer, error_code: int, frame_type: Optional[int], reason_phrase: bytes
+ ):
+ if frame_type is None:
+ push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
+ packet.push_application_close_frame(buf, error_code, reason_phrase)
+ else:
+ push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
+ packet.push_transport_close_frame(buf, error_code, frame_type, reason_phrase)
+
===========changed ref 1===========
# module: aioquic.connection
class QuicConnection:
def _pending_datagrams(self) -> Iterator[bytes]:
for epoch in [tls.Epoch.INITIAL, tls.Epoch.HANDSHAKE]:
yield from self._write_handshake(epoch)
yield from self._write_application()
- if self.__close is not None:
- close = self.__close
- self.__close = None
- yield from self._write_close(tls.Epoch.ONE_RTT, **close)
-
===========changed ref 2===========
# module: aioquic.connection
class QuicConnection:
- def _write_close(
- self, epoch: tls.Epoch, error_code: int, frame_type: int, reason_phrase: bytes
- ) -> Iterator[bytes]:
- assert epoch == tls.Epoch.ONE_RTT
- space = self.spaces[epoch]
-
- buf = Buffer(capacity=PACKET_MAX_SIZE)
-
- # write header
- push_uint8(buf, PACKET_FIXED_BIT | (SEND_PN_SIZE - 1))
- push_bytes(buf, self.peer_cid)
- push_uint16(buf, self.packet_number)
- header_size = buf.tell()
-
- # write frame
- if frame_type is None:
- push_uint_var(buf, QuicFrameType.APPLICATION_CLOSE)
- packet.push_application_close_frame(buf, error_code, reason_phrase)
- else:
- push_uint_var(buf, QuicFrameType.TRANSPORT_CLOSE)
- packet.push_transport_close_frame(
- buf, error_code, frame_type, reason_phrase
- )
-
- # finalize length
- packet_size = buf.tell()
- buf.seek(header_size - SEND_PN_SIZE - 2)
- length = packet_size - header_size + 2 + space.crypto.aead_tag_size
- push_uint16(buf, length | 0x4000)
- push_uint16(buf, self.packet_number)
- buf.seek(packet_size)
-
- # encrypt
- data = buf.data
- yield space.crypto.encrypt_packet(
- data[0:header_size], data[header_size:packet_size]
- )
- self.packet_number += 1
-
|
aioquic.connection/QuicConnection.datagram_received
|
Modified
|
aiortc~aioquic
|
8dcf957d462fde5bd7480b49e6643d7180986582
|
[connection] rework packet writing
|
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
<0> """
<1> Handle an incoming datagram.
<2> """
<3> buf = Buffer(data=data)
<4>
<5> while not buf.eof():
<6> start_off = buf.tell()
<7> header = pull_quic_header(buf, host_cid_length=len(self.host_cid))
<8>
<9> if self.is_client and header.version == QuicProtocolVersion.NEGOTIATION:
<10> # version negotiation
<11> versions = []
<12> while not buf.eof():
<13> versions.append(pull_uint32(buf))
<14> common = set(self.supported_versions).intersection(versions)
<15> if not common:
<16> self.__logger.error("Could not find a common protocol version")
<17> return
<18> self.version = QuicProtocolVersion(max(common))
<19> self.__logger.info("Retrying with %s" % self.version)
<20> self.connection_made(self.__transport)
<21> return
<22> elif self.is_client and header.packet_type == PACKET_TYPE_RETRY:
<23> # stateless retry
<24> if (
<25> header.destination_cid == self.host_cid
<26> and header.original_destination_cid == self.peer_cid
<27> ):
<28> self.__logger.info("Performing stateless retry")
<29> self.peer_cid = header.source_cid
<30> self.peer_token = header.token
<31> self.connection_made(self.__transport)
<32> return
<33>
<34> encrypted_off = buf.tell() - start_off
<35> end_off = buf.tell() + header.rest_length
<36> pull_bytes(buf, header.rest_length)
<37>
<38> if not self.is_client and not self.__initialized:
<39> self._initialize(header.destination_cid)
<40>
<41> epoch = get_epoch(header.packet_type)
<42> space = self.spaces</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def datagram_received(self, data: bytes, addr: Any) -> None:
# offset: 1
try:
plain_header, plain_payload, packet_number = space.crypto.decrypt_packet(
data[start_off:end_off], encrypted_off
)
except CryptoError as exc:
self.__logger.warning(exc)
return
if not self.peer_cid_set:
self.peer_cid = header.source_cid
self.peer_cid_set = True
# handle payload
is_ack_only = self._payload_received(epoch, plain_payload)
# record packet as received
space.ack_queue.add(packet_number)
if not is_ack_only:
self.send_ack[epoch] = True
self._send_pending()
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
pull_uint32(buf: Buffer) -> int
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
get_epoch(packet_type: int) -> tls.Epoch
at: aioquic.connection.PacketSpace.__init__
self.ack_queue = RangeSet()
self.crypto = CryptoPair()
at: aioquic.connection.QuicConnection
connection_made(transport: asyncio.DatagramTransport) -> None
_initialize(peer_cid: bytes) -> None
_payload_received(epoch: tls.Epoch, plain: bytes) -> bool
_payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool
at: aioquic.connection.QuicConnection.__init__
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.supported_versions = [
QuicProtocolVersion.DRAFT_17,
QuicProtocolVersion.DRAFT_18,
QuicProtocolVersion.DRAFT_19,
QuicProtocolVersion.DRAFT_20,
]
self.version = QuicProtocolVersion.DRAFT_20
self.__initialized = False
self.__logger = logger
self.__transport: Optional[asyncio.DatagramTransport] = None
at: aioquic.connection.QuicConnection._initialize
self.spaces = {
tls.Epoch.INITIAL: PacketSpace(),
tls.Epoch.HANDSHAKE: PacketSpace(),
tls.Epoch.ONE_RTT: PacketSpace(),
}
self.__initialized = True
===========unchanged ref 1===========
at: aioquic.connection.QuicConnection.connection_made
self.__transport = transport
at: aioquic.crypto
CryptoError(*args: object)
at: aioquic.crypto.CryptoPair
decrypt_packet(packet: bytes, encrypted_offset: int) -> Tuple[bytes, bytes, int]
at: aioquic.packet
PACKET_TYPE_RETRY = PACKET_LONG_HEADER | PACKET_FIXED_BIT | 0x30
QuicProtocolVersion(x: Union[str, bytes, bytearray], base: int)
QuicProtocolVersion(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
pull_quic_header(buf: Buffer, host_cid_length: Optional[int]=None) -> QuicHeader
at: aioquic.packet.QuicHeader
version: int
packet_type: int
destination_cid: bytes
source_cid: bytes
original_destination_cid: bytes = b""
token: bytes = b""
rest_length: int = 0
at: aioquic.rangeset.RangeSet
add(start: int, stop: Optional[int]=None) -> None
at: aioquic.tls
Alert(*args: object)
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
error(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
|
aioquic.connection/QuicConnection._payload_received
|
Modified
|
aiortc~aioquic
|
8dcf957d462fde5bd7480b49e6643d7180986582
|
[connection] rework packet writing
|
<26>:<add> raise
<del> return
<27>:<add>
<add> # update current epoch
|
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
<0> buf = Buffer(data=plain)
<1>
<2> is_ack_only = True
<3> while not buf.eof():
<4> frame_type = pull_uint_var(buf)
<5> if frame_type != QuicFrameType.ACK:
<6> is_ack_only = False
<7>
<8> if frame_type in [QuicFrameType.PADDING, QuicFrameType.PING]:
<9> pass
<10> elif frame_type == QuicFrameType.ACK:
<11> packet.pull_ack_frame(buf)
<12> elif frame_type == QuicFrameType.CRYPTO:
<13> stream = self.streams[epoch]
<14> stream.add_frame(packet.pull_crypto_frame(buf))
<15> data = stream.pull_data()
<16> if data:
<17> try:
<18> self.tls.handle_message(data, self.send_buffer)
<19> except tls.Alert as exc:
<20> self.__logger.warning("TLS error: %s" % exc)
<21> self.close(
<22> QuicErrorCode.CRYPTO_ERROR + int(exc.description),
<23> frame_type,
<24> str(exc).encode("ascii"),
<25> )
<26> return
<27> if self.tls.state in [
<28> tls.State.CLIENT_POST_HANDSHAKE,
<29> tls.State.SERVER_POST_HANDSHAKE,
<30> ]:
<31> if not self.__connected.is_set():
<32> self.__connected.set()
<33> self.__epoch = tls.Epoch.ONE_RTT
<34> else:
<35> self.__epoch = tls.Epoch.HANDSHAKE
<36>
<37> elif frame_type == QuicFrameType.NEW_TOKEN:
<38> packet.pull_new_token_frame(buf)
<39> elif (frame_type & ~STREAM_FLAGS) == QuicFrameType.STREAM_BASE:
<40> flags = frame_type & STREAM_FLAGS
<41> stream_</s>
|
===========below chunk 0===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 1
if flags & QuicStreamFlag.OFF:
offset = pull_uint_var(buf)
else:
offset = 0
if flags & QuicStreamFlag.LEN:
length = pull_uint_var(buf)
else:
length = buf.capacity - buf.tell()
frame = QuicStreamFrame(
offset=offset,
data=pull_bytes(buf, length),
fin=bool(flags & QuicStreamFlag.FIN),
)
stream = self._get_or_create_stream(stream_id)
stream.add_frame(frame)
elif frame_type == QuicFrameType.MAX_DATA:
pull_uint_var(buf)
elif frame_type in [
QuicFrameType.MAX_STREAMS_BIDI,
QuicFrameType.MAX_STREAMS_UNI,
]:
pull_uint_var(buf)
elif frame_type == QuicFrameType.NEW_CONNECTION_ID:
packet.pull_new_connection_id_frame(buf)
elif frame_type == QuicFrameType.TRANSPORT_CLOSE:
error_code, frame_type, reason_phrase = packet.pull_transport_close_frame(
buf
)
self.__logger.info(
"Transport close code 0x%X, reason %s" % (error_code, reason_phrase)
)
self.connection_lost(None)
elif frame_type == QuicFrameType.APPLICATION_CLOSE:
error_code, reason_phrase = packet.pull_application_close_frame(buf)
self.__logger.info(
"Application close code 0x%X, reason %s"
% (error_code, reason_phrase)
)
self.connection_lost(None)
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self</s>
===========below chunk 1===========
# module: aioquic.connection
class QuicConnection:
def _payload_received(self, epoch: tls.Epoch, plain: bytes) -> bool:
# offset: 2
<s>
else:
self.__logger.warning("unhandled frame type %d", frame_type)
break
self._push_crypto_data()
return is_ack_only
===========unchanged ref 0===========
at: aioquic.buffer
Buffer(capacity: Optional[int]=0, data: Optional[bytes]=None)
pull_bytes(buf: Buffer, length: int) -> bytes
at: aioquic.buffer.Buffer
eof() -> bool
tell() -> int
at: aioquic.connection
STREAM_FLAGS = 0x07
at: aioquic.connection.QuicConnection
close(error_code: int, frame_type: Optional[int]=None, reason_phrase: bytes=b"") -> None
connection_lost(exc: Exception) -> None
_get_or_create_stream(stream_id: int) -> QuicStream
at: aioquic.connection.QuicConnection.__init__
self.streams: Dict[Union[tls.Epoch, int], QuicStream] = {}
self.__connected = asyncio.Event()
self.__epoch = tls.Epoch.INITIAL
self.__initialized = False
self.__logger = logger
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.QuicConnection._write_application
self.packet_number += 1
at: aioquic.connection.QuicConnection._write_handshake
self.packet_number += 1
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
===========unchanged ref 1===========
QuicFrameType(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicFrameType(x: Union[str, bytes, bytearray], base: int)
pull_ack_frame(buf: Buffer) -> Tuple[RangeSet, int]
QuicStreamFlag(x: Union[str, bytes, bytearray], base: int)
QuicStreamFlag(x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc]=...)
QuicStreamFrame(data: bytes=b"", fin: bool=False, offset: int=0)
pull_crypto_frame(buf: Buffer) -> QuicStreamFrame
pull_new_token_frame(buf: Buffer) -> bytes
pull_new_connection_id_frame(buf: Buffer) -> Tuple[int, bytes, bytes]
pull_transport_close_frame(buf: Buffer) -> Tuple[int, int, bytes]
pull_application_close_frame(buf: Buffer) -> Tuple[int, bytes]
at: aioquic.packet.QuicStreamFrame
data: bytes = b""
fin: bool = False
offset: int = 0
at: aioquic.stream.QuicStream
add_frame(frame: QuicStreamFrame) -> None
pull_data() -> bytes
at: aioquic.tls
Alert(*args: object)
Epoch()
State()
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.state = State.CLIENT_HANDSHAKE_START
self.state = State.SERVER_EXPECT_CLIENT_HELLO
at: aioquic.tls.Context._set_state
self.state = state
at: asyncio.locks.Event
is_set() -> bool
set() -> None
===========unchanged ref 2===========
at: logging.Logger
info(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
warning(msg: Any, *args: Any, exc_info: _ExcInfoType=..., stack_info: bool=..., extra: Optional[Dict[str, Any]]=..., **kwargs: Any) -> None
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.