o 6Wj=@sUddlmZdZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z ddlmZddlmZmZmZd d lmZmZmZmZmZd d lmZmZd d lmZmZmZm Z m!Z!m"Z"ej#d krqddlm$Z$m%Z%nddl&m$Z$m%Z%ej#dkrddlm'Z'nddl&m'Z'edZ(e$dZ)e*e*e+e+fdfZ,de-d<e*e,dfZ.de-d<GdddeZ/e ddGdddeZ0e ddGddde!e0Z1Gdd d e Z2dS)!) annotations) TLSAttributeTLSConnectable TLSListener TLSStreamN)CallableMapping) dataclass)wraps) SSLContext)Any TypeAliasTypeVar)BrokenResourceError EndOfStreamaclose_forcefullyget_cancelled_exc_class to_thread)TypedAttributeSettyped_attribute) AnyByteStreamAnyByteStreamConnectable ByteStreamByteStreamConnectableListener TaskGroup) ) TypeVarTupleUnpack)r )overrideT_RetvalPosArgsT.r _PCTRTT_PCTRTTTc@seZdZUdZeZded<eZded<eZded<eZ ded <eZ d ed <eZ d ed <eZ ded<eZ ded<eZd ed<eZded<dS)rz5Contains Transport Layer Security related attributes. str | None alpn_protocolbyteschannel_binding_tls_uniqueztuple[str, str, int]cipherz*None | dict[str, str | _PCTRTTT | _PCTRTT]peer_certificatez bytes | Nonepeer_certificate_binarybool server_sidez!list[tuple[str, str, int]] | Noneshared_ciphers ssl.SSLObject ssl_objectstandard_compatiblestr tls_versionN)__name__ __module__ __qualname____doc__rr(__annotations__r*r+r,r-r/r0r2r3r5r;r;`/home/esfera/Documents/content_generation/venv/lib/python3.10/site-packages/anyio/streams/tls.pyr5s rF)eqc@seZdZUdZded<ded<ded<ded <ded <ed d d d d d2ddZd3ddZd4dd Zd5d"d#Z d6d7d(d)Z d8d+d,Z d5d-d.Z e d9d0d1Zd S):ra A stream wrapper that encrypts all sent data and decrypts received data. This class has no public initializer; use :meth:`wrap` instead. All extra attributes from :class:`~TLSAttribute` are supported. :var AnyByteStream transport_stream: the wrapped stream rtransport_streamr.r3r1 _ssl_objectz ssl.MemoryBIO _read_bio _write_bioNT)r/hostname ssl_contextr3r/ bool | NonerBr'rCssl.SSLContext | Nonereturnc s|dur| }|s'|rtjjntjj}t|}ttdr'|jtjM_t}t}|dur>ddl m } | |} nd} t |tj urQ|j |||| d} nt|j |||| dIdH} |||| ||d} | | jIdH| S)a Wrap an existing stream with Transport Layer Security. This performs a TLS handshake with the peer. :param transport_stream: a bytes-transporting stream to wrap :param server_side: ``True`` if this is the server side of the connection, ``False`` if this is the client side (if omitted, will be set to ``False`` if ``hostname`` has been provided, ``False`` otherwise). Used only to create a default context when an explicit context has not been provided. :param hostname: host name of the peer (if host name checking is desired) :param ssl_context: the SSLContext object to use (if not provided, a secure default will be created) :param standard_compatible: if ``False``, skip the closing handshake when closing the connection, and don't raise an exception if the peer does the same :raises ~ssl.SSLError: if the TLS handshake fails NOP_IGNORE_UNEXPECTED_EOFr)idna2008_resolve)r/server_hostname)r>r3r?r@rA)sslPurpose CLIENT_AUTH SERVER_AUTHcreate_default_contexthasattroptionsrG MemoryBIO_core._socketsrHtyper wrap_biorrun_sync_call_sslobject_method do_handshake) clsr>r/rBrCr3purposebio_inbio_outrHrIr2wrapperr;r;r<wrapcsN      zTLSStream.wrapfunc&Callable[[Unpack[PosArgsT]], T_Retval]argsUnpack[PosArgsT]r#c s z||}WntjyYz|jjr!|j|jIdH|jIdH}Wn&ty8|j Ynt yP}z |j |j t |d}~ww|j |Ynotjyn|j|jIdHYnZtjy}z |j |j t |d}~wtjy}z"|j |j t|tjs|jrd|jvr|jrt |tdd}~ww|jjr|j|jIdH|Sq)NTUNEXPECTED_EOF_WHILE_READING)rJSSLWantReadErrorrApendingr>sendreadreceiverr@ write_eofOSErrorrwriteSSLWantWriteErrorSSLSyscallErrorSSLError isinstance SSLEOFErrorstrerrorr3)selfr^r`resultdataexcr;r;r<rVsV           z TLSStream._call_sslobject_methodtuple[AnyByteStream, bytes]cs:||jjIdH|j|j|j|jfS)z Does the TLS closing handshake. :return: a tuple of (wrapped byte stream, bytes left in the read buffer) N)rVr?unwrapr@rhrAr>rfrqr;r;r<rvs   zTLSStream.unwrapNonecsP|jrz |IdHWntyt|jIdHw|jIdHdSN)r3rv BaseExceptionrr>acloserwr;r;r<r{s zTLSStream.aclose max_bytesintr)cs4|dkr td||jj|IdH}|st|S)Nz$max_bytes must be a positive integer) ValueErrorrVr?rfr)rqr}rsr;r;r<rgszTLSStream.receiveitemcs||jj|IdHdSry)rVr?rj)rqrr;r;r<reszTLSStream.sendcsb|tj}td|}|r-t|dt|dpd}}||fdkr-td|td)NzTLSv(\d+)(?:\.(\d+))?rrr)rrz;send_eof() requires at least TLSv1.3; current session uses z7send_eof() has not yet been implemented for TLS streams)extrarr5rematchr~groupNotImplementedError)rqr5rmajorminorr;r;r<send_eofs  " zTLSStream.send_eofMapping[Any, Callable[[], Any]]csijjtjjjtjjjtjjjtj fddtj fddtj fddtj fddtj fddtjfddtjjji S)Nc jdS)NFr? getpeercertr;rwr;r<s z,TLSStream.extra_attributes..cr)NTrr;rwr;r<r scsjjSry)r?r/r;rwr;r<r#scsjjr jSdSry)r?r/r0r;rwr;r<r$s cjSryr3r;rwr;r<r)crry)r?r;rwr;r<r*r)r>extra_attributesrr(r?selected_alpn_protocolr*get_channel_bindingr+r,r-r/r0r3r2r5versionrwr;rwr<rs   zTLSStream.extra_attributes) r>rr/rDrBr'rCrEr3r.rFr)r^r_r`rarFr#)rFrurFrx)r|)r}r~rFr))rr)rFrxrFr)r6r7r8r9r: classmethodr]rVrvr{rgrerpropertyrr;r;r;r<rQs*   R . rc@sneZdZUdZded<ded<dZded<d Zd ed <ed ddZ d!d"ddZ d#ddZ e d$ddZ dS)%ra A convenience listener that wraps another listener and auto-negotiates a TLS session on every accepted connection. If the TLS handshake times out or raises an exception, :meth:`handle_handshake_error` is called to do whatever post-mortem processing is deemed necessary. Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute. :param Listener listener: the listener to wrap :param ssl_context: the SSL context object :param standard_compatible: a flag passed through to :meth:`TLSStream.wrap` :param handshake_timeout: time limit for the TLS handshake (passed to :func:`~anyio.fail_after`) z Listener[Any]listenerzssl.SSLContextrCTr.r3floathandshake_timeoutrtrzstreamrrFrxcsLt|IdHt|tsttjd|dt|tr#t|tr$dS)a Handle an exception raised during the TLS handshake. This method does 3 things: #. Forcefully closes the original stream #. Logs the exception (unless it was a cancellation exception) using the ``anyio.streams.tls`` logger #. Reraises the exception if it was a base exception or a cancellation exception :param exc: the exception :param stream: the original stream NzError during TLS handshake)exc_info)rrnrlogging getLoggerr6 exception Exception)rtrr;r;r<handle_handshake_errorGs  z"TLSListener.handle_handshake_errorNhandlerCallable[[TLSStream], Any] task_groupTaskGroup | Nonecs2tdfdd }j||IdHdS)NrrrFrxc sddlm}z$|jtj|jjdIdH}Wdn1s%wYWntyG}z||IdHWYd}~dSd}~ww|IdHdS)Nr) fail_after)rCr3) rrrr]rCr3rzr)rrwrapped_streamrtrrqr;r<handler_wrapperls    z*TLSListener.serve..handler_wrapper)rrrFrx)r rserve)rqrrrr;rr<rgszTLSListener.servecs|jIdHdSry)rr{rwr;r;r<r{~szTLSListener.aclosercstjfddiS)Ncrryrr;rwr;r<rrz.TLSListener.extra_attributes..)rr3rwr;rwr<rszTLSListener.extra_attributes)rtrzrrrFrxry)rrrrrFrxrr) r6r7r8r9r:r3r staticmethodrrr{rrr;r;r;r<r/s    " rc@s2eZdZdZdddddddZedddZdS)ra Wraps another connectable and does TLS negotiation after a successful connection. :param connectable: the connectable to wrap :param hostname: host name of the server (if host name checking is desired) :param ssl_context: the SSLContext object to use (if not provided, a secure default will be created) :param standard_compatible: if ``False``, skip the closing handshake when closing the connection, and don't raise an exception if the server does the same NTrBrCr3 connectablerrBr'rCrEr3r.rFrxcCsN||_|p ttjj|_t|jtjstdt |jj ||_ ||_ dS)Nz7ssl_context must be an instance of ssl.SSLContext, not ) rrJrNrKrMrCrnr TypeErrorrSr6rBr3)rqrrBrCr3r;r;r<__init__s  zTLSConnectable.__init__rcsR|jIdH}ztj||j|j|jdIdHWSty(t|IdHw)Nr) rconnectrr]rBrCr3rzr)rqrr;r;r<rs zTLSConnectable.connect) rrrBr'rCrEr3r.rFrx)rFr)r6r7r8r9rr"rr;r;r;r<rsr)3 __future__r__all__rrrJsyscollections.abcrr dataclassesr functoolsr r typingr r rrrrrrr_core._typedattrrrabcrrrrrr version_inforr typing_extensionsr"r#r$tupler4r%r:r&rrrrr;r;r;r<s>       ^X