o US`c@sFddlZddlZddlZddlZddlmZddlZddlZddlZddl Z ddl Z ddl m Z m Z dZddZddZd d ZGd d d ejZGd ddejZGdddZdZGdddeZddZddZedZdedefddZe j GdddZ!dd Z"d!d"Z#ed#Z$e j Gd$d%d%Z%d&d'Z&d(d)Z'd*d+Z(e j Gd,d-d-Z)e j Gd.d/d/Z*e j Gd0d1d1Z+d2d3Z,Gd4d5d5Z-d6Z.d7Z/d8Z0d9Z1d7Z2d:d;Z3dd?Z5d@dAZ6dBdCZ7GdDdEdEZ8dFdGZ9dHdIZ:dJdKZ;e j GdLdMdMZee dPZ?GdQdRdRe dPZ@dS)SN)count)NoPublicConstructorFinalicCs|jtjjkr dSdS)N0)familytriosocketAF_INETsockr 5/usr/local/lib/python3.10/dist-packages/trio/_dtls.pypacket_header_overheadsrcCs&|jtjjkr dt|Sdt|S)Ni@i)rrr r rr r r rworst_case_mtu!s  rcCs dt|S)Ni)rr r r rbest_guess_mtu( rc@s eZdZdZdZdZdZdZdS) ContentTypeN)__name__ __module__ __qualname__change_cipher_specalert handshakeZapplication_data heartbeatr r r rr/s rc@s`eZdZdZdZdZdZdZdZdZ dZ dZ d Z d Z d Zd Zd ZdZdZdZdZdZdZdZdS) HandshakeTyper rrrrrN)rrrZ hello_request client_helloZ server_hellohello_verify_requestZnew_session_ticketZend_of_early_dataZencrypted_extensionsZ certificateZserver_key_exchangeZcertificate_requestZserver_hello_doneZcertificate_verifyZclient_key_exchangefinishedZcertificate_urlZcertificate_statusZsupplemental_dataZ key_updateZcompressed_certificateZekt_keyZ message_hashr r r rr 7s,r c@s$eZdZeddgZeddgZdS)ProtocolVersionr.N)rrrbytesDTLS10ZDTLS12r r r rr2Os r2lc@s eZdZdS) BadPacketN)rrrr r r rr7\sr7cCs|dddkS)Nr#sr packetr r rpart_of_handshake_untrustedfsr;cCs4z|dtjko|dtjkWStyYdSw)Nrr(F)rrr r/ IndexErrorr9r r ris_client_hello_untrustedms  r=z!B2sQHdatareturncCs|SN)hex)r>r r rto_hexsrBc@sFeZdZUeed<ejedZe ed<eed<ejedZ e ed<dS)Record content_typereprversion epoch_seqnopayloadN) rrrint__annotations__attribrBrGr5rIr r r rrCs rCc csd}|t|krSz t||\}}}}Wntjy'}ztd|d}~ww|tj7}||||}t||kr?td||7}t||||V|t|ks dSdS)Nrzinvalid record headerz short record)len RECORD_HEADER unpack_fromstructerrorr7sizerC)r:ictrGrHZ payload_lenexcrIr r rrecords_untrusteds     rWcCs&t|j|j|jt|j}||jSr@)rOpackrDrGrHrNrI)recordheaderr r r encode_records r[z !B3sH3s3sc@sJeZdZUeed<eed<eed<eed<eed<ejedZe ed<dS) HandshakeFragmentmsg_typemsg_lenmsg_seq frag_offsetfrag_lenrEfragN) rrrrJrKrLrMrBrbr5r r r rr\s r\c Csz t|\}}}}}Wntjy}ztd|d}~wwt|d}t|d}t|d} |tjd} t| | krBtdt ||||| | S)Nzbad handshake message headerbigz5handshake fragment length doesn't match record length) HANDSHAKE_MESSAGE_HEADERrPrQrRr7rJ from_bytesrSrNr\) rIr] msg_len_bytesr_frag_offset_bytesfrag_len_bytesrVr^r`rarbr r r#decode_handshake_fragment_untrusteds4     ric Cs>t|j|jdd|j|jdd|jdd}||jS)Nr#rc) rdrXr]r^to_bytesr_r`rarb)ZhsfZ hs_headerr r rencode_handshake_fragments    rkc Cszntt|}|jtjkrtdt|j}|jt j kr td|j dkr)td|j |j kr3td|j}|d}d|}||}|d}||}|d|} |||} ||d} t| |krftd|j| | | fWStjtfy} ztd | d} ~ ww) Nznot a handshake recordznot a ClientHellorzfragmented ClientHello"#r!z short cookiezbad ClientHello)nextrWrDrrr7rirIr]r r/r`rar^rbrNrHrQrRr<) r:rYfragmentbodyZsession_id_lenZcookie_len_offsetZ cookie_lenZ cookie_startZ cookie_endZ before_cookiecookieZ after_cookierVr r rdecode_client_hello_untrusteds6            rrc@sFeZdZUejedZeed<e ed<e ed<ejedZ e ed<dS)HandshakeMessagerErecord_versionr]r_rpN) rrrrLrMrBrtr5rKr rJrp bytearrayr r r rrs-s rsc@s>eZdZUejedZeed<e ed<ejedZ eed<dS)PseudoHandshakeMessagerErtrDrIN) rrrrLrMrBrtr5rKrJrIr r r rrv7s rvc@eZdZUeed<dS)OpaqueHandshakeMessagerYN)rrrrCrKr r r rrxC rxcCsg}i}t|D]}|jt@r|t|q|jtjtjfvr-|t |j |j|j q|jtj ks5Jt |j }t|j}|j|vr[t|j ||jt|j}|||||j<n||j}|j|jkshJ|j|jkspJt|j|jkszJ|j|j|j|j|j<q|Sr@)rWrH EPOCH_MASKappendrxrDrrrrvrGrIrrir r]r_rsrur^rNrprbr`ra)ZvolleymessagesZmessages_by_seqrYror]msgr r rdecode_volley_trustedLs@         r~c@s$eZdZddZddZddZdS) RecordEncodercCs t|_dSr@r _record_seqselfr r r__init__yrzRecordEncoder.__init__cCst||_dSr@r)rnr r rset_first_record_number|sz%RecordEncoder.set_first_record_numberc Csg}t}|D]}t|tr4t|j}|t|t|dkr'||t}||7}t||ks3Jqt|trs|t|tj t|j }|dkrS||t}|t |j |j t|jt|j 7}||j 7}t||ksrJqt|jdd}d} d} | t|jks| s|t|tj tj }|dkr||t}q|j| | |} | dd} t| dd} | t| 7} |t tj|j t|jtj t| 7}|t |j||j| | 7}|| 7}| d7} t||ksJ| t|jks| rq|r|||S)Nrr#rcr!)ru isinstancerxr[rYrNr{rvrOrSrIrXrDrtrnrrprjrdrrr]r_)rr|Zmtupacketsr:messageencodedspacerfr`Z frags_encodedrbrgrhr r r encode_volleys          $ zRecordEncoder.encode_volleyN)rrrrrrr r r rrxs r sha256r%cCstttSr@)rJr current_timeCOOKIE_REFRESH_INTERVALr r r r_current_cookie_ticksrcGs8g}|D]}|tdt|||qd|S)N!Q)r{rQrXrNjoin)fieldsoutfieldr r r _signable s   rcCs^t|tksJt|tksJt|td|tdd|D|}|t||tdt S)Nrcss|] }t|VqdSr@)strencode).0partr r r sz_make_cookie..) rN SALT_BYTES KEY_BYTESrrQrXhmacdigest COOKIE_HASH COOKIE_LENGTH)keysalttickaddressclient_hello_bitsZ signable_datar r r _make_cookies  rcCsdt|tkr0|dt}t}t|||||}t||t|dd||}t||t||BSdS)Nr!rF)rNrrrmaxrcompare_digest)rrqrrrrZ cur_cookieZ old_cookier r r valid_cookie!s  rc Csxtt}t}t|||||}tjtt|g|}t t j t|ddt||d}t |} t ttjtj|| } | S)Nr)r]r^r_r`rarb)osurandomrrrr2r6r5rNr\r r0rkr[rCrr) rrrHrrrrqrphsrIr:r r r challenge_for5s" rc@seZdZddZdS)_QueuecCst|\|_|_dSr@)rZopen_memory_channelsr)rincoming_packets_bufferr r rr^sz_Queue.__init__N)rrrrr r r rr]s rcCs>g} z|d}Wn tjyYnw||qd|S)NTi@r)SSL WantReadErrorr{r)Zread_fnchunkschunkr r r _read_loopbs   rc s|jdurdSz t|\}}}Wn tyYdSw|jdur'tt|_t|j|||sqt|j|||}z,|j 4IdH|j ||IdHWdIdHWdS1IdHs\wYWdSt t jfypYdSwt|||j}|j|z |j||jWn tjyYdSw|j||j|}|dur|j||fkrdS|||f|_||j|<|jj|dSr@)_listening_contextrrr7_listening_keyrrrrr _send_lockr sendtoOSErrorrClosedResourceError DTLSChannel_create_record_encoderr_ssl bio_writeZ DTLSv1_listenrError_streamsget _client_hello _set_replaced_incoming_connections_qr send_nowait) endpointrr:rHrqbitsZchallenge_packetstreamZ old_streamr r rhandle_client_hello_untrustedmsL     2      rc sLz} z |tIdH\}}Wnty(}z |jtjkr#WYd}~qd}~ww|}zO|dur6W~WdSt|rDt|||IdHn5||jvrx|j|}|jr]t |r]| IdHnz |j j |Wntjyw|jd7_Ynw W~n~wqtjyYdSty}z|jtjtjfvrWYd}~dSd}~ww)NTr!)recvfromMAX_UDP_PACKET_SIZErerrno ECONNRESETr=rr_did_handshaker;_resend_final_volley_qrrrZ WouldBlock_packets_dropped_in_triorEBADFENOTSOCK)Z endpoint_refr r:rrVrrr r rdtls_receive_loopsN     )rc@rw)DTLSChannelStatisticsZ incoming_packets_dropped_in_trioN)rrrrJrKr r r rrryrc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddddZ ddZddZddZddZd d!Zd"S)#ru`A DTLS connection. This class has no public constructor – you get instances by calling `DTLSEndpoint.serve` or `~DTLSEndpoint.connect`. .. attribute:: endpoint The `DTLSEndpoint` that this connection is using. .. attribute:: peer_address The IP/port of the remote peer that this connection is associated with. cCs||_||_d|_d|_d|_|tjtjBt ||_ d|_ | t |jjd|_d|_t|j|_t|_t|_dS)NrF)r peer_addressrrrZ set_optionsrZOP_NO_QUERY_MTUOP_NO_RENEGOTIATION Connectionr_handshake_mtuset_ciphertext_mturr _replaced_closedrrrrLock_handshake_lockrr)rrrctxr r rrs    zDTLSChannel.__init__cCsd|_|jjdSNT)rrrcloserr r rrszDTLSChannel._set_replacedcCs|jrtddS)Nz1peer tore down this connection to start a new one)rrZBrokenResourceErrorrr r r_check_replaceds zDTLSChannel._check_replacedcCs@|jrdSd|_|jj|j|ur|jj|j=|jjdS)uClose this connection. `DTLSChannel`\s don't actually own any OS-level resources – the socket is owned by the `DTLSEndpoint`, not the individual connections. So you don't really *have* to call this. But it will interrupt any other tasks calling `receive` with a `ClosedResourceError`, and cause future attempts to use this connection to fail. You can also use this object as a synchronous or asynchronous context manager. NT)rrrrrrrrrr r rr,s   zDTLSChannel.closecC|Sr@r rr r r __enter__AzDTLSChannel.__enter__cG |dSr@rrargsr r r__exit__DrzDTLSChannel.__exit__cs|tjIdHdS)zClose this connection, but asynchronously. This is included to satisfy the `trio.abc.Channel` contract. It's identical to `close`, but async. N)rrlowlevel checkpointrr r racloseGszDTLSChannel.aclosec st|j||j}|D],}|jj4IdH|jj||jIdHWdIdHn 1IdHs2wYq dSr@)rrrrrr rr)rvolley_messagesrr:r r r _send_volleyQs(zDTLSChannel._send_volleycs||jIdHdSr@)r _final_volleyrr r rrYsz DTLSChannel._resend_final_volleyg?)initial_retransmit_timeoutc s*j4IdHjr WdIdHdS|}gd}fdd}zjWn tjy6Ynw|sAtd sFJIdHj t |}j j2zl3dHW}j|zjWn tjtjfyYn#wd_|_jIdHWdWdIdHdS|}|rt|dtr|djtjkr|IdHn ||dkr|}d}n qa6jsJWdn1swY|jrtd|d}|d 7}|dkrtjtj j_qB1IdHswYdS) uPerform the handshake. Calling this is optional – if you don't, then it will be automatically called the first time you call `send` or `receive`. But calling it explicitly can be useful in case you want to control the retransmit timeout, use a cancel scope to place an overall timeout on the handshake, or catch errors from the handshake specifically. It's safe to call this multiple times, or call it simultaneously from multiple tasks – the first call will perform the handshake, and the rest will be no-ops. Args: initial_retransmit_timeout (float): Since UDP is an unreliable protocol, it's possible that some of the packets we send during the handshake will get lost. To handle this, DTLS uses a timer to automatically retransmit handshake packets that don't receive a response. This lets you set the timeout we use to detect packet loss. Ideally, it should be set to ~1.5 times the round-trip time to your peer, but 1 second is a reasonable default. There's `some useful guidance here `__. This is the *initial* timeout, because if packets keep being lost then Trio will automatically back off to longer values, to avoid overloading the network. NrcsFtjj}t|}|r!r!t|dtr!|djdjkr!gS|S)Nr)rrbio_readr~rrsr_)Z volley_bytesZnew_volley_messagesrrr r read_volleys  z-DTLSChannel.do_handshake..read_volleyz'something wrong with peer's ClientHelloTr"gN@r!)rrr do_handshakerrrrrr_ensure_receive_looprZ move_on_afterrrrrrrvrDrrrZcancelled_caughtminrrr )rrtimeoutZvolley_failed_sendsrZcscoper:Z maybe_volleyr rrr\s|     >  ), zDTLSChannel.do_handshakec s|jrtj|s td|js|IdH||j||j j 4IdH|j j t |jj|jIdHWdIdHdS1IdHsKwYdS)z Send a packet of data, securely.z2openssl doesn't support sending empty DTLS packetsN)rrr ValueErrorrrrrwriterrr rrrr)rr>r r rsends  .zDTLSChannel.sendcsx|js |IdH z |jjIdH}Wntjy*|js$J|Ynw|j |t |j j }|r;|Sq )aFetch the next packet of data from this connection's peer, waiting if necessary. This is safe to call from multiple tasks simultaneously, in case you have some reason to do that. And more importantly, it's cancellation-safe, meaning that cancelling a call to `receive` will never cause a packet to be lost or corrupt the underlying connection. N) rrrrreceiverZ EndOfChannelrrrrrread)rr:Z cleartextr r rrs     zDTLSChannel.receivecCs||_|j|dS)ujTells Trio the `largest amount of data that can be sent in a single packet to this peer `__. Trio doesn't actually enforce this limit – if you pass a huge packet to `send`, then we'll dutifully encrypt it and attempt to send it. But calling this method does have two useful effects: - If called before the handshake is performed, then Trio will automatically fragment handshake messages to fit within the given MTU. It also might fragment them even smaller, if it detects signs of packet loss, so setting this should never be necessary to make a successful connection. But, the packet loss detection only happens after multiple timeouts have expired, so if you have reason to believe that a smaller MTU is required, then you can set this to skip those timeouts and establish the connection more quickly. - It changes the value returned from `get_cleartext_mtu`. So if you have some kind of estimate of the network-level MTU, then you can use this to figure out how much overhead DTLS will need for hashes/padding/etc., and how much space you have left for your application data. The MTU here is measuring the largest UDP *payload* you think can be sent, the amount of encrypted data that can be handed to the operating system in a single call to `send`. It should *not* include IP/UDP headers. Note that OS estimates of the MTU often are link-layer MTUs, so you have to subtract off 28 bytes on IPv4 and 48 bytes on IPv6 to get the ciphertext MTU. By default, Trio assumes an MTU of 1472 bytes on IPv4, and 1452 bytes on IPv6, which correspond to the common Ethernet MTU of 1500 bytes after accounting for IP/UDP overhead. N)rrr)rZnew_mtur r rrs zDTLSChannel.set_ciphertext_mtucCs|jstj|jS)zReturns the largest number of bytes that you can pass in a single call to `send` while still fitting within the network-level MTU. See `set_ciphertext_mtu` for more details. )rrZNeedHandshakeErrorrget_cleartext_mturr r rr+s zDTLSChannel.get_cleartext_mtucCs t|jS)aReturns an object with statistics about this connection. Currently this has only one attribute: - ``incoming_packets_dropped_in_trio`` (``int``): Gives a count of the number of incoming packets from this peer that Trio successfully received from the network, but then got dropped because the internal channel buffer was full. If this is non-zero, then you might want to call ``receive`` more often, or use a larger ``incoming_packets_buffer``, or just not worry about it because your UDP-based protocol should be able to handle the occasional lost packet, right? )rrrr r r statistics6s zDTLSChannel.statisticsN)rrr__doc__rrrrrrrrrrrrrrrr r r rrs$  # r) metaclassc@sfeZdZdZddddZddZdd Zd d Zd d ZddZ ddZ e j dddZ ddZdS) DTLSEndpointaA DTLS endpoint. A single UDP socket can handle arbitrarily many DTLS connections simultaneously, acting as a client or server as needed. A `DTLSEndpoint` object holds a UDP socket and manages these connections, which are represented as `DTLSChannel` objects. Args: socket: (trio.socket.SocketType): A ``SOCK_DGRAM`` socket. If you want to accept incoming connections in server mode, then you should probably bind the socket to some known port. incoming_packets_buffer (int): Each `DTLSChannel` using this socket has its own buffer that holds incoming packets until you call `~DTLSChannel.receive` to read them. This lets you adjust the size of this buffer. `~DTLSChannel.statistics` lets you check if the buffer has overflowed. .. attribute:: socket incoming_packets_buffer Both constructor arguments are also exposed as attributes, in case you need to access them later. )rcCs~ddlmad|_|jtjjkrtd||_||_tj |_ t |_ d|_d|_ttd|_t|_d|_d|_dS)Nr)rz!DTLS requires a SOCK_DGRAM socketinfF)ZOpenSSLrr typer SOCK_DGRAMrrrZcurrent_trio_token_tokenweakrefWeakValueDictionaryrrrrfloatrrrr_receive_loop_spawned)rr rr r rr^s     zDTLSEndpoint.__init__cCs,|jstjtt||jd|_dSdSr)rrrZspawn_system_taskrrrefr rr r rrxs  z!DTLSEndpoint._ensure_receive_loopcCsX|jdurdS|js*z |j|jWn tyYnwtjd|t|ddSdS)Nzunclosed DTLS endpoint )source) r rrZ run_sync_soonr RuntimeErrorwarningswarnResourceWarningrr r r__del__s    zDTLSEndpoint.__del__cCs<d|_|jt|jD]}|q|jjdS)z}Close this socket, and all associated DTLS connections. This object can also be used as a context manager. TN)rr rlistrvaluesrr)rrr r rrs   zDTLSEndpoint.closecCrr@r rr r rrrzDTLSEndpoint.__enter__cGrr@rrr r rrrzDTLSEndpoint.__exit__cCs|jrtjdSr@)rrrrr r r _check_closedszDTLSEndpoint._check_closed) task_statusc s||jdurtdz|jWn ty!tdw|| ddzJ||_| fdd}t 4IdH}|j j 2z 3dHW}|||qI6WdIdHn1IdHsgwYWd|_dSWd|_dSd|_w)aListen for incoming connections, and spawn a handler for each using an internal nursery. Similar to `~trio.serve_tcp`, this function never returns until cancelled, or the `DTLSEndpoint` is closed and all handlers have exited. Usage commonly looks like:: async def handler(dtls_channel): ... async with trio.open_nursery() as nursery: await nursery.start(dtls_endpoint.serve, ssl_context, handler) # ... do other things here ... The ``dtls_channel`` passed into the handler function has already performed the "cookie exchange" part of the DTLS handshake, so the peer address is trustworthy. But the actual cryptographic handshake doesn't happen until you start using it, giving you a chance for any last minute configuration, and the option to catch and handle handshake errors. Args: ssl_context (OpenSSL.SSL.Context): The PyOpenSSL context object to use for incoming connections. async_fn: The handler function that will be invoked for each incoming connection. Nz!another task is already listeningz-DTLS socket must be bound before it can servecWsdSrr )_r r rsz$DTLSEndpoint.serve..csB||gRIdHWddS1swYdSr@r )rrasync_fnr rhandler_wrappers"z+DTLSEndpoint.serve..handler_wrapper)rrrZBusyResourceErrorr getsocknamerrrZset_cookie_verify_callbackstartedZ open_nurseryrrZ start_soon)r ssl_contextr!rrr"Znurseryrr r rserves.   * zDTLSEndpoint.servecCsJ|t|||}|j|j|}|dur|||j|<|S)uInitiate an outgoing DTLS connection. Notice that this is a synchronous method. That's because it doesn't actually initiate any I/O – it just sets up a `DTLSChannel` object. The actual handshake doesn't occur until you start using the `DTLSChannel`. This gives you a chance to do further configuration first, like setting MTU etc. Args: address: The address to connect to. Usually a (host, port) tuple, like ``("127.0.0.1", 12345)``. ssl_context (OpenSSL.SSL.Context): The PyOpenSSL context object to use for this connection. Returns: DTLSChannel N)rrrrZset_connect_staterrr)rrr%ZchannelZ old_channelr r rconnects   zDTLSEndpoint.connectN)rrrrrrrrrrrrZTASK_STATUS_IGNOREDr&r'r r r rr Fs   8r )ArQrrenum itertoolsrrrrrLrZ trio._utilrrrrrrIntEnumrr r2rz Exceptionr7r;r=StructrOr5rrBfrozenrCrWr[rdr\rirkrrrsrvrxr~rrrrrrrrrrrrrrrrabcZChannelrr r r r rs|      E  ,| ( I7V