File: //usr/local/lib/python3.10/dist-packages/anyio/streams/__pycache__/tls.cpython-310.pyc
o
���g�1 � @ sL d dl mZ d dlZd dlZd dlZd dlZd dlmZmZ d dl m
Z
d dl m Z d dl
mZmZ ddlmZmZmZmZ dd lmZmZ dd
lmZmZmZm Z ej d kr`d d l
m Z m Z nd d l m Z m Z ed
�Z!e d�Z"e#e#e$e$f df Z%e#e%df Z&G dd� de�Z'e
dd�G dd� de��Z(e
dd�G dd� dee( ��Z)dS )� )� annotationsN)�Callable�Mapping)� dataclass)�wraps)�Any�TypeVar� )�BrokenResourceError� EndOfStream�aclose_forcefully�get_cancelled_exc_class)�TypedAttributeSet�typed_attribute)�
AnyByteStream�
ByteStream�Listener� TaskGroup)� � )� TypeVarTuple�Unpack�T_Retval�PosArgsT.c @ 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$ r& r' r) � r/ r/ �</usr/local/lib/python3.10/dist-packages/anyio/streams/tls.pyr 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" r' r% � _ssl_objectz
ssl.MemoryBIO� _read_bio�
_write_bioNT)r# �hostname� ssl_contextr' r# � bool | Noner7 r r8 �ssl.SSLContext | None�returnc � s� �|du r| }|s'|rt jjnt jj}t �|�}tt d�r'| jt j M _t �� }t �� }|j ||||d�} | ||| ||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)r3 r' r4 r5 r6 ) �ssl�Purpose� CLIENT_AUTH� SERVER_AUTH�create_default_context�hasattr�optionsr< � MemoryBIO�wrap_bio�_call_sslobject_method� do_handshake) �clsr3 r# r7 r8 r' �purpose�bio_in�bio_outr& �wrapperr/ r/ r0 �wrapN 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)r> �SSLWantReadErrorr6 �pendingr3 �send�read�receiver r5 � write_eof�OSErrorr
�write�SSLWantWriteError�SSLSyscallError�SSLError�
isinstance� SSLEOFError�strerrorr' )�selfrO rQ �result�data�excr/ r/ r0 rG � 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)rG r4 �unwrapr5 rY r6 r3 rW �rb r/ r/ r0 rg � 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)r' rg �
BaseExceptionr r3 �acloserh r/ r/ r0 rl � s � �zTLSStream.aclose� � max_bytes�intr c � s$ �| � | jj|�I d H }|st�|S rj )rG r4 rW r )rb rn rd r/ r/ r0 rX � s
�zTLSStream.receive�itemc � s �| � | jj|�I d H d S rj )rG r4 r[ )rb rp r/ r/ r0 rV � s �zTLSStream.sendc � sb �| � tj�}t�d|�}|r-t|�d��t|�d�p d�}}||fdk r-td|� ���td��)NzTLSv(\d+)(?:\.(\d+))?� r r )rq r z;send_eof() requires at least TLSv1.3; current session uses z7send_eof() has not yet been implemented for TLS streams)�extrar r) �re�matchro �group�NotImplementedError)rb r) rt �major�minorr/ r/ r0 �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�r4 � getpeercertr/ rh r/ r0 �<lambda>� s z,TLSStream.extra_attributes.<locals>.<lambda>c r{ )NTr| r/ rh r/ r0 r~ � s �c s � j jS rj )r4 r# r/ rh r/ r0 r~ � s c s � j jr � j �� S d S rj )r4 r# r$ r/ rh r/ r0 r~ � s �c � � j S rj �r' r/ rh r/ r0 r~ � � c r rj )r4 r/ rh r/ r0 r~ � r� )r3 �extra_attributesr r r4 �selected_alpn_protocolr �get_channel_bindingr r r! r# r$ r' r& r) �versionrh r/ rh r0 r� � s �
�zTLSStream.extra_attributes) r3 r r# r9 r7 r r8 r: r' r" r; r2 )rO rP rQ rR r; r )r; rf �r; ri )rm )rn ro r; r )rp r r; ri �r; rz )r* r+ r, r- r. � classmethodrN rG rg rl rX rV ry �propertyr� r/ r/ r/ r0 r2 < s*
�
8
.
r2 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.SSLContextr8 Tr" r' � �float�handshake_timeoutre rk �streamr r; ri 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 r_ r
�logging� getLoggerr* � exception� Exception)re r� r/ r/ r0 �handle_handshake_error 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 r; ri 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)r8 r' ) � r� r� r2 rN r8 r' rk r� )r� r� �wrapped_streamre �r� rb r/ r0 �handler_wrapper8 s � � �� ��z*TLSListener.serve.<locals>.handler_wrapper)r� r r; ri )r r� �serve)rb r� r� r� r/ r� r0 r� 3 s �zTLSListener.servec � s �| j �� I d H d S rj )r� rl rh r/ r/ r0 rl J s �zTLSListener.acloserz c s t j� fdd�iS )Nc r rj r� r/ rh r/ r0 r~ P r� z.TLSListener.extra_attributes.<locals>.<lambda>)r r' rh r/ rh r0 r� M s �z TLSListener.extra_attributes)re rk r� r r; ri rj )r� r� r� r� r; ri r� r� )
r* r+ r, r- r. r' r� � staticmethodr� r� rl r� r� r/ r/ r/ r0 r� � s
" �
r� )*�
__future__r r� rs r> �sys�collections.abcr r � dataclassesr � functoolsr �typingr r r� r
r r r
�_core._typedattrr r �abcr r r r � version_infor r �typing_extensionsr r �tupler( �_PCTRTT�_PCTRTTTr r2 r� r/ r/ r/ r0 �<module> s2
?