File: //usr/local/CyberCP/lib64/python3.10/site-packages/anyio/streams/__pycache__/tls.cpython-310.pyc
o
�h�; � @ s� U d dl mZ d dlZd dlZd dlZd dlZd dlmZmZ d dl m
Z
d dl m Z d dlm
Z
d dlmZmZ dd lmZmZmZmZmZ dd
lmZmZ dd lmZm Z m Z m Z m Z m Z ej!d krkd d
lm"Z" nd d
l#m"Z" ej!dkrd dlm$Z$m%Z% nd dl#m$Z$m%Z% ej!dkr�d dlm&Z& nd dl#m&Z& ed�Z'e$d�Z(e)e)e*e*f df Z+de,d< e)e+df Z-de,d< G dd� de�Z.e
dd�G d d � d e ��Z/e
dd�G d d � d e e/ ��Z0G d d!� d!e �Z1dS )"� )� annotationsN)�Callable�Mapping)� dataclass)�wraps)�
SSLContext)�Any�TypeVar� )�BrokenResourceError� EndOfStream�aclose_forcefully�get_cancelled_exc_class� to_thread)�TypedAttributeSet�typed_attribute)�
AnyByteStream�AnyByteStreamConnectable�
ByteStream�ByteStreamConnectable�Listener� TaskGroup)� �
)� TypeAlias)r � )� TypeVarTuple�Unpack)r � )�override�T_Retval�PosArgsT.r �_PCTRTT�_PCTRTTTc @ s� e Zd ZU dZe� Zded< e� Zded< e� Zded< e� Z ded < e� Z
d
ed < e� Z d ed
< e� Z ded< e� Z
ded< e� Zd ed< e� Zded< dS )� TLSAttributez5Contains Transport Layer Security related attributes.�
str | None�
alpn_protocol�bytes�channel_binding_tls_uniqueztuple[str, str, int]�cipherz*None | dict[str, str | _PCTRTTT | _PCTRTT]�peer_certificatez bytes | None�peer_certificate_binary�bool� server_sidez!list[tuple[str, str, int]] | None�shared_ciphers�
ssl.SSLObject�
ssl_object�standard_compatible�str� tls_versionN)�__name__�
__module__� __qualname__�__doc__r r& �__annotations__r( r) r* r+ r- r. r0 r1 r3 � r9 r9 �D/usr/local/CyberCP/lib/python3.10/site-packages/anyio/streams/tls.pyr$ 3 s
r$ F)�eqc @ s� e Zd ZU dZded< ded< ded< ded < ded
< ed d d d d
�d2dd��Zd3d d �Zd4d d �Zd5d"d#�Z d6d7d(d)�Z
d8d+d,�Z d5d-d.�Z e
d9d0d1��Zd S ):� TLSStreama
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
r �transport_streamr, r1 r/ � _ssl_objectz
ssl.MemoryBIO� _read_bio�
_write_bioNT)r- �hostname� ssl_contextr1 r- � bool | NonerA r% rB �ssl.SSLContext | None�returnc � s� �|du r| }|s'|rt jjnt jj}t �|�}tt d�r'| jt j M _t �� }t �� }t |�t j
u r@|j ||||d�} nt �
|j ||||d�I dH } | ||| ||d�}
|
�| j�I dH |
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
N�OP_IGNORE_UNEXPECTED_EOF)r- �server_hostname)r= r1 r> r? r@ )�ssl�Purpose� CLIENT_AUTH� SERVER_AUTH�create_default_context�hasattr�optionsrF � MemoryBIO�typer �wrap_bior �run_sync�_call_sslobject_method� do_handshake) �clsr= r- rA rB r1 �purpose�bio_in�bio_outr0 �wrapperr9 r9 r: �wrapa s@ � �
�
� �zTLSStream.wrap�func�&Callable[[Unpack[PosArgsT]], T_Retval]�args�Unpack[PosArgsT]r c
� s� � z||� }W n� t jyY z| jjr!| j�| j�� �I d H | j�� I d H }W n& ty8 | j �
� Y n t yP } z
| j �
� | j�
� t |�d }~ww | j �
|� Y no t jyn | j�| j�� �I d H Y nZ t jy� } z
| j �
� | j�
� t |�d }~w t jy� } z"| j �
� | j�
� t|t j�s�|jr�d|jv r�| jr�t |�td �� d }~ww | jjr�| j�| j�� �I d H |S q)NT� UNEXPECTED_EOF_WHILE_READING)rH �SSLWantReadErrorr@ �pendingr= �send�read�receiver r? � write_eof�OSErrorr �write�SSLWantWriteError�SSLSyscallError�SSLError�
isinstance� SSLEOFError�strerrorr1 )�selfr[ r] �result�data�excr9 r9 r: rS � sV �
�� �
�
�
���z TLSStream._call_sslobject_method�tuple[AnyByteStream, bytes]c � s: �| � | jj�I dH | j�� | j�� | j| j�� fS )z�
Does the TLS closing handshake.
:return: a tuple of (wrapped byte stream, bytes left in the read buffer)
N)rS r> �unwrapr? re r@ r= rc �rn r9 r9 r: rs � s
�
zTLSStream.unwrap�Nonec � sP �| j r z | �� I d H W n ty t| j�I d H � w | j�� I d H d S �N)r1 rs �
BaseExceptionr
r= �aclosert r9 r9 r: rx � s � �zTLSStream.aclose� � max_bytes�intr' c � s$ �| � | jj|�I d H }|st�|S rv )rS r> rc r )rn rz rp r9 r9 r: rd � s
�zTLSStream.receive�itemc � s �| � | jj|�I d H d S rv )rS r> rg )rn r| r9 r9 r: rb � s �zTLSStream.sendc � sb �| � tj�}t�d|�}|r-t|�d��t|�d�p d�}}||fdk r-td|� ���td��)NzTLSv(\d+)(?:\.(\d+))?� r
r )r} r z;send_eof() requires at least TLSv1.3; current session uses z7send_eof() has not yet been implemented for TLS streams)�extrar$ r3 �re�matchr{ �group�NotImplementedError)rn r3 r� �major�minorr9 r9 r: �send_eof� s � " ���zTLSStream.send_eof� Mapping[Any, Callable[[], Any]]c s� i � j j�tj� jjtj� jjtj� jjtj � fdd�tj
� fdd�tj � fdd�tj � fdd�tj
� fdd�tj� fdd�tj� jji
�S )Nc � � j �d�S )NF�r> � getpeercertr9 rt r9 r: �<lambda> s z,TLSStream.extra_attributes.<locals>.<lambda>c r� )NTr� r9 rt r9 r: r� s �c s � j jS rv )r> r- r9 rt r9 r: r� s c s � j jr � j �� S d S rv )r> r- r. r9 rt r9 r: r� s �c � � j S rv �r1 r9 rt r9 r: r� � c r� rv )r> r9 rt r9 r: r� r� )r= �extra_attributesr$ r& r> �selected_alpn_protocolr( �get_channel_bindingr) r* r+ r- r. r1 r0 r3 �versionrt r9 rt r: r� s �
�zTLSStream.extra_attributes) r= r r- rC rA r% rB rD r1 r, rE r< )r[ r\ r] r^ rE r )rE rr �rE ru )ry )rz r{ rE r' )r| r' rE ru �rE r� )r4 r5 r6 r7 r8 � classmethodrZ rS rs rx rd rb r� �propertyr� r9 r9 r9 r: r< O s*
�
F
.
r< c @ sn e Zd ZU dZded< ded< dZded< d Zd
ed < ed dd��Z d!d"dd�Z d#dd �Z
e d$d d ��Z dS )%� TLSListenera�
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.SSLContextrB Tr, r1 � �float�handshake_timeoutrq rw �streamr rE ru c � sL �t |�I dH t| t� �st�t�jd| d� t| t�r#t| t� �r$� 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)r
rk r �logging� getLoggerr4 � exception� Exception)rq r� r9 r9 r: �handle_handshake_error4 s �
��z"TLSListener.handle_handshake_errorN�handler�Callable[[TLSStream], Any]�
task_group�TaskGroup | Nonec � s2 �t � �d� �fdd� �}�j�||�I d H d S )Nr� r rE ru c
� s� �ddl m} z$|�j�� tj| �j�jd�I d H }W d � n1 s%w Y W n tyG } z��|| �I d H W Y d }~d S d }~ww � |�I d H d S )Nr
)�
fail_after)rB r1 ) � r� r� r< rZ rB r1 rw r� )r� r� �wrapped_streamrq �r� rn r9 r: �handler_wrapperY s � � �� ��z*TLSListener.serve.<locals>.handler_wrapper)r� r rE ru )r r� �serve)rn r� r� r� r9 r� r: r� T s �zTLSListener.servec � s �| j �� I d H d S rv )r� rx rt r9 r9 r: rx k s �zTLSListener.acloser� c s t j� fdd�iS )Nc r� rv r� r9 rt r9 r: r� q r� z.TLSListener.extra_attributes.<locals>.<lambda>)r$ r1 rt r9 rt r: r� n s �z TLSListener.extra_attributes)rq rw r� r rE ru rv )r� r� r� r� rE ru r� r� )
r4 r5 r6 r7 r8 r1 r� � staticmethodr� r� rx r� r� r9 r9 r9 r: r� s
" �
r� c @ s2 e Zd ZdZdddd�ddd�Zeddd��ZdS )�TLSConnectablea�
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
NT�rA rB r1 � connectabler rA r% rB rD r1 r, rE ru c C sN || _ |p t�tjj�| _t| jtj�s tdt | j�j
� ���|| _ || _ d S )Nz7ssl_context must be an instance of ssl.SSLContext, not )
r� rH rL rI rK rB rk r � TypeErrorrP r4 rA r1 )rn r� rA rB r1 r9 r9 r: �__init__� s �
��
zTLSConnectable.__init__r< c � sR �| j �� I d H }ztj|| j| j| jd�I d H W S ty( t|�I d H � w )Nr� ) r� �connectr< rZ rA rB r1 rw r
)rn r� r9 r9 r: r� � s �� �zTLSConnectable.connect)
r� r rA r% rB rD r1 r, rE ru )rE r< )r4 r5 r6 r7 r� r r� r9 r9 r9 r: r� u s �r� )2�
__future__r r� r rH �sys�collections.abcr r � dataclassesr � functoolsr r �typingr r r� r r r
r r �_core._typedattrr r �abcr r r r r r � version_infor �typing_extensionsr r r r r! �tupler2 r" r8 r# r$ r< r� r� r9 r9 r9 r: �<module> sB
MX