HEX
Server: LiteSpeed
System: Linux php-prod-1.spaceapp.ru 5.15.0-157-generic #167-Ubuntu SMP Wed Sep 17 21:35:53 UTC 2025 x86_64
User: xnsbb3110 (1041)
PHP: 8.1.33
Disabled: NONE
$ pwd: /usr/local/CyberPanel/lib64/python3.10/site-packages/OpenSSL/__pycache__/
Upload Files
File: //usr/local/CyberPanel/lib64/python3.10/site-packages/OpenSSL/__pycache__/SSL.cpython-310.pyc
o

�hh��@s"UddlZddlZddlZddlmZddlmZmZddlm	Z	m
Z
ddlmZddlm
Z
mZmZmZmZmZmZddlmZddlmZdd	lmZdd
lmZddlmZddlmZ dd
lm!Z"ddlm#Z$ddlm%Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.gd�Z/ej0Z0e1e2d<ej3Z3e1e2d<ej4Z4e1e2d<ej5Z5e1e2d<ej6Z6e1e2d<ej7Z7e1e2d<e3Z8e4Z9e5Z:e6Z;e7Z<ej=Z>ej?Z@dZAdZBdZCdZDdZEdZFdZGdZHd ZId!ZJejKZKe1e2d"<ejLZLe1e2d#<ejMZMe1e2d$<ejNZNe1e2d%<ejOZOe1e2d&<ejPZQe1e2d'<ejRZSe1e2d(<ejTZUe1e2d)<ejVZWe1e2d*<ejXZYe1e2d+<zejZZ[e1e2d,<e/�\d,�Wn
e]�y3Ynwej^Z_e1e2d-<ej`Zae1e2d.<ejbZce1e2d/<ejdZee1e2d0<ejfZge1e2d1<ejhZie1e2d2<ejjZke1e2d3<ejlZme1e2d4<ejnZoe1e2d5<ejpZqe1e2d6<ejrZse1e2d7<ejtZue1e2d8<ejvZwe1e2d9<ejxZye1e2d:<ejzZ{e1e2d;<ej|Z}e1e2d<<ej~Zej�Z�e1e2d=<ej�Z�e1e2d><ej�Z�e1e2d?<ej�Z�e1e2d@<ej�Z�e1e2dA<ej�Z�e1e2dB<ej�Z�e1e2dC<zej�Z�e1e2dD<e/�\dD�Wn
e]�y�Ynwzej�Z�e1e2dE<e/�\dE�Wn
e]�y	Ynwzej�Z�e1e2dF<e/�\dF�Wn
e]�y"Ynwej�Z�e1e2dG<ej�Z�e1e2dH<ej�Z�e1e2dI<ej�Z�e1e2dJ<ej�Z�e1e2dK<ej�Z�e1e2dL<ej�Z�e1e2dM<ej�Z�e1e2dN<ej�Z�e1e2dO<ej�Z�e1e2dP<ej�Z�e1e2dQ<ej�Z�e1e2dR<ej�Z�e1e2dS<ej�Z�e1e2dT<ej�Z�e1e2dU<ej�Z�e1e2dV<ej�Z�e1e2dW<ej�Z�e1e2dX<ej�Z�e1e2dY<ej�Z�e1e2dZ<ej�Z�e1e2d[<ej�Z�e1e2d\<ej�Z�e1e2d]<ej�Z�e1e2d^<ej�Z�e1e2d_<ej�Z�e1e2d`<ej�Z�e1e2da<ej�Z�e1e2db<ej�Z�e1e2dc<edd�Z�Gdedf�df�Z�e��Z�edgej�ee�e�fgdfZ�edgge�fZ�edge�ge�fZ�edge�ee�ge�fZ�edgee�ge�fZ�ee1e�ee�ge�fZ�edge)e1e1e1ge�fZ�Gdhdi�di�Z�gdj�Z�dkgZ�dlZ�dmZ�Gdndo�doeЃZ�eeeуZ�e eуZ�Gdpdq�dqeуZ�Gdrds�dseуZ�Gdtdu�dueуZ�Gdvdw�dweуZ�Gdxdy�dyeуZ�Gdzd{�d{�Z�Gd|d}�d}eكZ�Gd~d�deكZ�Gd�d��d�eكZ�Gd�d��d�eكZ�Gd�d��d�eكZ�Gd�d��d�eكZ�d�e
d�e1fd�d��Z�d�e1d�e�fd�d��Z�e�Z�d�e1d�e�d�ee�ge�ffd�d��Z�e�ej�d��Z�e�e�ed�d�d��Z�Gd�d��d��Z�Gd�d��d��Z�Gd�dg�dg�Z�dS)��N)�	errorcode)�partial�wraps)�chain�count)�platform)�Any�Callable�List�Optional�Sequence�Tuple�TypeVar)�WeakValueDictionary)�StrOrBytesPath)�exception_from_error_queue)�ffi)�lib)�make_assert)�no_zero_allocator)�
path_bytes)�text_to_bytes_and_warn)�FILETYPE_PEM�X509�PKey�X509Name�	X509Store�_EllipticCurve�_PassphraseHelper)b�OPENSSL_VERSION_NUMBER�SSLEAY_VERSION�
SSLEAY_CFLAGS�SSLEAY_PLATFORM�
SSLEAY_DIR�SSLEAY_BUILT_ON�OPENSSL_VERSION�OPENSSL_CFLAGS�OPENSSL_PLATFORM�OPENSSL_DIR�OPENSSL_BUILT_ON�
SENT_SHUTDOWN�RECEIVED_SHUTDOWN�
SSLv23_METHOD�TLSv1_METHOD�TLSv1_1_METHOD�TLSv1_2_METHOD�
TLS_METHOD�TLS_SERVER_METHOD�TLS_CLIENT_METHOD�DTLS_METHOD�DTLS_SERVER_METHOD�DTLS_CLIENT_METHOD�SSL3_VERSION�TLS1_VERSION�TLS1_1_VERSION�TLS1_2_VERSION�TLS1_3_VERSION�OP_NO_SSLv2�OP_NO_SSLv3�OP_NO_TLSv1�
OP_NO_TLSv1_1�
OP_NO_TLSv1_2�MODE_RELEASE_BUFFERS�OP_SINGLE_DH_USE�OP_SINGLE_ECDH_USE�OP_EPHEMERAL_RSA�OP_MICROSOFT_SESS_ID_BUG�OP_NETSCAPE_CHALLENGE_BUG�#OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG�OP_SSLREF2_REUSE_CERT_TYPE_BUG�OP_MICROSOFT_BIG_SSLV3_BUFFER�OP_MSIE_SSLV2_RSA_PADDING�OP_SSLEAY_080_CLIENT_DH_BUG�
OP_TLS_D5_BUG�OP_TLS_BLOCK_PADDING_BUG�OP_DONT_INSERT_EMPTY_FRAGMENTS�OP_CIPHER_SERVER_PREFERENCE�OP_TLS_ROLLBACK_BUG�OP_PKCS1_CHECK_1�OP_PKCS1_CHECK_2�OP_NETSCAPE_CA_DN_BUG�"OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG�OP_NO_COMPRESSION�OP_NO_QUERY_MTU�OP_COOKIE_EXCHANGE�OP_NO_TICKET�OP_ALL�VERIFY_PEER�VERIFY_FAIL_IF_NO_PEER_CERT�VERIFY_CLIENT_ONCE�VERIFY_NONE�SESS_CACHE_OFF�SESS_CACHE_CLIENT�SESS_CACHE_SERVER�SESS_CACHE_BOTH�SESS_CACHE_NO_AUTO_CLEAR�SESS_CACHE_NO_INTERNAL_LOOKUP�SESS_CACHE_NO_INTERNAL_STORE�SESS_CACHE_NO_INTERNAL�SSL_ST_CONNECT�
SSL_ST_ACCEPT�SSL_ST_MASK�SSL_CB_LOOP�SSL_CB_EXIT�SSL_CB_READ�SSL_CB_WRITE�SSL_CB_ALERT�SSL_CB_READ_ALERT�SSL_CB_WRITE_ALERT�SSL_CB_ACCEPT_LOOP�SSL_CB_ACCEPT_EXIT�SSL_CB_CONNECT_LOOP�SSL_CB_CONNECT_EXIT�SSL_CB_HANDSHAKE_START�SSL_CB_HANDSHAKE_DONE�Error�
WantReadError�WantWriteError�WantX509LookupError�ZeroReturnError�SysCallError�NO_OVERLAPPING_PROTOCOLS�SSLeay_version�Session�Context�
Connection�X509VerificationCodesrr%r&r'r(r)�������	�
��r6r7r8r9r:r;r<r=r>r?�
OP_NO_TLSv1_3r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrQrRrSrTrUrVrW�OP_NO_RENEGOTIATION�OP_IGNORE_UNEXPECTED_EOF�OP_LEGACY_SERVER_CONNECTrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrt�_Tc@�eZdZdS)�_NoOverlappingProtocolsN��__name__�
__module__�__qualname__�r�r��A/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/SSL.pyr��r�rc@sfeZdZdZejZejZej	Z
ejZej
ZejZejZejZejZejZejZejZejZejZ ej!Z"ej#Z$ej%Z&ej'Z(ej)Z*ej+Z,ej-Z.ej/Z0ej1Z2ej3Z4ej5Z6ej7Z8ej9Z:ej;Z<ej=Z>ej?Z@ejAZBejCZDejEZFejGZHejIZJejKZLejMZNejOZPejQZRejSZTejUZVejWZXejYZZej[Z\ej]Z^ej_Z`ejaZbejcZdejeZfejgZhejiZjejkZlejmZnejoZpejqZrejsZtejuZvdS)r�a\
    Success and error codes for X509 verification, as returned by the
    underlying ``X509_STORE_CTX_get_error()`` function and passed by pyOpenSSL
    to verification callback functions.

    See `OpenSSL Verification Errors
    <https://www.openssl.org/docs/manmaster/man3/X509_verify_cert_error_string.html#ERROR-CODES>`_
    for details.
    N)wr�r�r��__doc__�_lib�	X509_V_OK�OK�$X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT�ERR_UNABLE_TO_GET_ISSUER_CERT�X509_V_ERR_UNABLE_TO_GET_CRL�ERR_UNABLE_TO_GET_CRL�+X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE�$ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE�*X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE�#ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE�-X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY�&ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY�!X509_V_ERR_CERT_SIGNATURE_FAILURE�ERR_CERT_SIGNATURE_FAILURE� X509_V_ERR_CRL_SIGNATURE_FAILURE�ERR_CRL_SIGNATURE_FAILURE�X509_V_ERR_CERT_NOT_YET_VALID�ERR_CERT_NOT_YET_VALID�X509_V_ERR_CERT_HAS_EXPIRED�ERR_CERT_HAS_EXPIRED�X509_V_ERR_CRL_NOT_YET_VALID�ERR_CRL_NOT_YET_VALID�X509_V_ERR_CRL_HAS_EXPIRED�ERR_CRL_HAS_EXPIRED�)X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD�"ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD�(X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD�!ERR_ERROR_IN_CERT_NOT_AFTER_FIELD�)X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD�"ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD�)X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD�"ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD�X509_V_ERR_OUT_OF_MEM�ERR_OUT_OF_MEM�&X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT�ERR_DEPTH_ZERO_SELF_SIGNED_CERT�$X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN�ERR_SELF_SIGNED_CERT_IN_CHAIN�,X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY�%ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY�*X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE�#ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE�X509_V_ERR_CERT_CHAIN_TOO_LONG�ERR_CERT_CHAIN_TOO_LONG�X509_V_ERR_CERT_REVOKED�ERR_CERT_REVOKED�X509_V_ERR_INVALID_CA�ERR_INVALID_CA�X509_V_ERR_PATH_LENGTH_EXCEEDED�ERR_PATH_LENGTH_EXCEEDED�X509_V_ERR_INVALID_PURPOSE�ERR_INVALID_PURPOSE�X509_V_ERR_CERT_UNTRUSTED�ERR_CERT_UNTRUSTED�X509_V_ERR_CERT_REJECTED�ERR_CERT_REJECTED�"X509_V_ERR_SUBJECT_ISSUER_MISMATCH�ERR_SUBJECT_ISSUER_MISMATCH�X509_V_ERR_AKID_SKID_MISMATCH�ERR_AKID_SKID_MISMATCH�&X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH�ERR_AKID_ISSUER_SERIAL_MISMATCH�X509_V_ERR_KEYUSAGE_NO_CERTSIGN�ERR_KEYUSAGE_NO_CERTSIGN�#X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER�ERR_UNABLE_TO_GET_CRL_ISSUER�'X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION� ERR_UNHANDLED_CRITICAL_EXTENSION�X509_V_ERR_KEYUSAGE_NO_CRL_SIGN�ERR_KEYUSAGE_NO_CRL_SIGN�+X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION�$ERR_UNHANDLED_CRITICAL_CRL_EXTENSION�X509_V_ERR_INVALID_NON_CA�ERR_INVALID_NON_CA�%X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED�ERR_PROXY_PATH_LENGTH_EXCEEDED�(X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE�!ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE�)X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED�"ERR_PROXY_CERTIFICATES_NOT_ALLOWED�X509_V_ERR_INVALID_EXTENSION�ERR_INVALID_EXTENSION�#X509_V_ERR_INVALID_POLICY_EXTENSION�ERR_INVALID_POLICY_EXTENSION�X509_V_ERR_NO_EXPLICIT_POLICY�ERR_NO_EXPLICIT_POLICY�X509_V_ERR_DIFFERENT_CRL_SCOPE�ERR_DIFFERENT_CRL_SCOPE�(X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE�!ERR_UNSUPPORTED_EXTENSION_FEATURE�X509_V_ERR_UNNESTED_RESOURCE�ERR_UNNESTED_RESOURCE�X509_V_ERR_PERMITTED_VIOLATION�ERR_PERMITTED_VIOLATION�X509_V_ERR_EXCLUDED_VIOLATION�ERR_EXCLUDED_VIOLATION�X509_V_ERR_SUBTREE_MINMAX�ERR_SUBTREE_MINMAX�&X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE�ERR_UNSUPPORTED_CONSTRAINT_TYPE�(X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX�!ERR_UNSUPPORTED_CONSTRAINT_SYNTAX�"X509_V_ERR_UNSUPPORTED_NAME_SYNTAX�ERR_UNSUPPORTED_NAME_SYNTAX�$X509_V_ERR_CRL_PATH_VALIDATION_ERROR�ERR_CRL_PATH_VALIDATION_ERROR�X509_V_ERR_HOSTNAME_MISMATCH�ERR_HOSTNAME_MISMATCH�X509_V_ERR_EMAIL_MISMATCH�ERR_EMAIL_MISMATCH�X509_V_ERR_IP_ADDRESS_MISMATCH�ERR_IP_ADDRESS_MISMATCH�#X509_V_ERR_APPLICATION_VERIFICATION�ERR_APPLICATION_VERIFICATIONr�r�r�r�r�+s�
������������������
r�)z"/etc/ssl/certs/ca-certificates.crtz /etc/pki/tls/certs/ca-bundle.crtz/etc/ssl/ca-bundle.pemz/etc/pki/tls/cacert.pemz1/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pemz/etc/ssl/certss$/opt/pyca/cryptography/openssl/certss'/opt/pyca/cryptography/openssl/cert.pemc@seZdZdZdS)ruz4
    An error occurred in an `OpenSSL.SSL` API.
    N)r�r�r�r�r�r�r�r�ru�sruc@r�)rvNr�r�r�r�r�rv�r�rvc@r�)rwNr�r�r�r�r�rw�r�rwc@r�)rxNr�r�r�r�r�rx�r�rxc@r�)ryNr�r�r�r�r�ry�r�ryc@r�)rzNr�r�r�r�r�rz�r�rzc@s$eZdZdZddd�Zddd�ZdS)	�_CallbackExceptionHelpera�
    A base class for wrapper classes that allow for intelligent exception
    handling in OpenSSL callbacks.

    :ivar list _problems: Any exceptions that occurred while executing in a
        context where they could not be raised in the normal way.  Typically
        this is because OpenSSL has called into some Python code and requires a
        return value.  The exceptions are saved to be raised later when it is
        possible to do so.
    �returnNcCs
g|_dS�N)�	_problems��selfr�r�r��__init__�s
z!_CallbackExceptionHelper.__init__cCs4|jrzt�Wn	tyYnw|j�d��dS)z�
        Raise an exception from the OpenSSL error queue or that was previously
        captured whe running a callback.
        rN)r�_raise_current_errorru�poprr�r�r��raise_if_problem�s
��z)_CallbackExceptionHelper.raise_if_problem�rN)r�r�r�r�rrr�r�r�r�r
�s
r
c@�"eZdZdZdeddfdd�ZdS)�
_VerifyHelperz^
    Wrap a callback such that it can be used as a certificate verification
    callback.
    �callbackrNc�2t���t����fdd��}t�d|��_dS)Nc
s�t�|�}t�|�t�|�}t�|�}t�|�}t��}t�||�}t	j
|}z
�|||||�}	WntyK}
z
�j�
|
�WYd}
~
dSd}
~
ww|	rWt�|tj�dSdS�Nr�)r��X509_STORE_CTX_get_current_cert�X509_up_refr�_from_raw_x509_ptr�X509_STORE_CTX_get_error�X509_STORE_CTX_get_error_depth�"SSL_get_ex_data_X509_STORE_CTX_idx�X509_STORE_CTX_get_ex_datar�_reverse_mapping�	Exceptionr�append�X509_STORE_CTX_set_errorr�)�ok�	store_ctx�x509�cert�error_number�error_depth�index�ssl�
connection�result�e�rrr�r��wrapper�s*






���z'_VerifyHelper.__init__.<locals>.wrapperzint (*)(int, X509_STORE_CTX *)�r
rr�_ffir�rrr5r�r4r�r�s

�z_VerifyHelper.__init__)r�r�r�r��_VerifyCallbackrr�r�r�r�r�src@r)�_ALPNSelectHelperzQ
    Wrap a callback such that it can be used as an ALPN selection callback.
    rrNcr)Nc
szptj|}t�||�dd�}g}|r/|d}	|d|	d�}
|�|
�||	dd�}|s�||�}d}|tur?d}d}n	t|t�sHtd��t�	dt
|��t�	d|�g|_|jdd|d<|jd|d<|smtj
WStjWSty�}
z�j�|
�tjWYd}
~
Sd}
~
ww)	NrrT�Fz^ALPN callback must return a bytestring or the special NO_OVERLAPPING_PROTOCOLS sentinel value.zunsigned char *�unsigned char[])rr%r7�bufferr'r{�
isinstance�bytes�	TypeError�new�len�_alpn_select_callback_argsr��SSL_TLSEXT_ERR_NOACK�SSL_TLSEXT_ERR_OKr&r�SSL_TLSEXT_ERR_ALERT_FATAL)r0�out�outlen�in_�inlen�arg�conn�instr�	protolist�encoded_len�proto�outbytes�any_acceptedr3r4r�r�r5s@

�

�	
���z+_ALPNSelectHelper.__init__.<locals>.wrapperz^int (*)(SSL *, unsigned char **, unsigned char *, const unsigned char *, unsigned int, void *)r6r8r�r4r�rs
+
�z_ALPNSelectHelper.__init__)r�r�r�r��_ALPNSelectCallbackrr�r�r�r�r:
sr:c@�&eZdZdZdeeddfdd�ZdS)�_OCSPServerCallbackHelpera�
    Wrap a callback such that it can be used as an OCSP callback for the server
    side.

    Annoyingly, OpenSSL defines one OCSP callback but uses it in two different
    ways. For servers, that callback is expected to retrieve some OCSP data and
    hand it to OpenSSL, and may return only SSL_TLSEXT_ERR_OK,
    SSL_TLSEXT_ERR_FATAL, and SSL_TLSEXT_ERR_NOACK. For clients, that callback
    is expected to check the OCSP data, and returns a negative value on error,
    0 if the response is not acceptable, or positive if it is. These are
    mutually exclusive return code behaviours, and they mean that we need two
    helpers so that we always return an appropriate error code if the user's
    code throws an exception.

    Given that we have to have two helpers anyway, these helpers are a bit more
    helpery than most: specifically, they hide a few more of the OpenSSL
    functions so that the user has an easier time writing these callbacks.

    This helper implements the server side.
    rrNcr)Nc
s�zBtj|}|tjkrt�|�}nd}�||�}t|t�s!td��|s&WdSt|�}t	�
|�}|t�||�dd�<t	�|||�WdSt
y[}z
�j�|�WYd}~dSd}~ww)Nz'OCSP callback must return a bytestring.r�r�)rr%r7�NULL�from_handler>r?r@rBr��OPENSSL_mallocr=�SSL_set_tlsext_status_ocsp_respr&rr')r0�cdatarL�data�	ocsp_data�ocsp_data_length�data_ptrr3r4r�r�r5`s,




���z3_OCSPServerCallbackHelper.__init__.<locals>.wrapper�int (*)(SSL *, void *)r6r8r�r4r�r]s
&z"_OCSPServerCallbackHelper.__init__)r�r�r�r��_OCSPServerCallbackrrr�r�r�r�rUG�rUc@rT)�_OCSPClientCallbackHelpera�
    Wrap a callback such that it can be used as an OCSP callback for the client
    side.

    Annoyingly, OpenSSL defines one OCSP callback but uses it in two different
    ways. For servers, that callback is expected to retrieve some OCSP data and
    hand it to OpenSSL, and may return only SSL_TLSEXT_ERR_OK,
    SSL_TLSEXT_ERR_FATAL, and SSL_TLSEXT_ERR_NOACK. For clients, that callback
    is expected to check the OCSP data, and returns a negative value on error,
    0 if the response is not acceptable, or positive if it is. These are
    mutually exclusive return code behaviours, and they mean that we need two
    helpers so that we always return an appropriate error code if the user's
    code throws an exception.

    Given that we have to have two helpers anyway, these helpers are a bit more
    helpery than most: specifically, they hide a few more of the OpenSSL
    functions so that the user has an easier time writing these callbacks.

    This helper implements the client side.
    rrNcr)Nc	
s�z=tj|}|tjkrt�|�}nd}t�d�}t�||�}|dkr%d}nt�|d|�dd�}�|||�}t	t
|��WStyV}z
�j�
|�WYd}~dSd}~ww)N�unsigned char **rr;���)rr%r7rWrXrAr��SSL_get_tlsext_status_ocsp_respr=�int�boolr&rr')	r0r[rLr\�ocsp_ptr�ocsp_lenr]�validr3r4r�r�r5�s"


��z3_OCSPClientCallbackHelper.__init__.<locals>.wrapperr`r6r8r�r4r�r�s
z"_OCSPClientCallbackHelper.__init__)r�r�r�r��_OCSPClientCallbackrrr�r�r�r�rc�rbrcc@�eZdZdeddfdd�ZdS)�_CookieGenerateCallbackHelperrrNcr)Nc
shztj|}�|�}||dt|��<t|�|d<WdSty3}z
�j�|�WYd}~dSd}~wwr)rr%rBr&rr')r0rGrHrL�cookier3r4r�r�r5�s
��z7_CookieGenerateCallbackHelper.__init__.<locals>.wrapperz/int (*)(SSL *, unsigned char *, unsigned int *)r6r8r�r4r�r�s

�z&_CookieGenerateCallbackHelper.__init__)r�r�r��_CookieGenerateCallbackrr�r�r�r�rn��rnc@rm)�_CookieVerifyCallbackHelperrrNcr)Nc
sVztj|}�|t|d|���WSty*}z
�j�|�WYd}~dSd}~ww�Nr)rr%r?r&rr')r0�c_cookie�
cookie_lenrLr3r4r�r�r5�s
��z5_CookieVerifyCallbackHelper.__init__.<locals>.wrapperz-int (*)(SSL *, unsigned char *, unsigned int)r6r8r�r4r�r�s

�z$_CookieVerifyCallbackHelper.__init__)r�r�r��_CookieVerifyCallbackrr�r�r�r�rr�rqrr�objrcCsbd}t|t�st|dd�}|dur|�}t|t�r|}t|t�s$td��|dkr/td|f��|S)N�filenoz3argument must be an int, or have a fileno() method.rz1file descriptor cannot be a negative integer (%i))r>rg�getattrr@�
ValueError)rw�fd�methr�r�r��_asFileDescriptor�s


�r}�typecCst�t�|��S)z�
    Return a string describing the version of OpenSSL in use.

    :param type: One of the :const:`OPENSSL_` constants defined in this module.
    )r7�stringr��OpenSSL_version)r~r�r�r�r�sr��flag�errorcs��fdd�}|S)a�
    Builds a decorator that ensures that functions that rely on OpenSSL
    functions that are not present in this build raise NotImplementedError,
    rather than AttributeError coming out of cryptography.

    :param flag: A cryptography flag that guards the functions, e.g.
        ``Cryptography_HAS_NEXTPROTONEG``.
    :param error: The string to be used in the exception if the flag is false.
    cs �st|��fdd��}|S|S)Ncst���r��NotImplementedError)�args�kwargs)r�r�r��explodesz<_make_requires.<locals>._requires_decorator.<locals>.explode)r)�funcr��r�r�r�r��_requires_decorators
z+_make_requires.<locals>._requires_decoratorr�)r�r�r�r�r�r��_make_requiressr�zALPN not available�Cryptography_HAS_KEYLOGzKey logging not availablec@seZdZUdZeed<dS)r}z�
    A class representing an SSL session.  A session defines certain connection
    parameters which may be re-used to speed up the setup of subsequent
    connections.

    .. versionadded:: 0.14
    �_sessionN)r�r�r�r�r�__annotations__r�r�r�r�r}2s
r}c@s�eZdZUdZeejdfeejefe	eje
feejefe
ejdfeejdfeejdfeejdfeejdfeejdfi
Zejejeejegefe effe!d<deddfdd�Z"deddfd	d
�Z#deddfdd�Z$	d�d
e e%de e%ddfdd�Z&de'e(de)fdd�Z*	d�de'e(de e(ddfdd�Z+d�dd�Z,de-de-de.fdd�Z/de0e-de0e-ddfdd �Z1d!e%ddfd"d#�Z2e3fd!e%d$eddfd%d&�Z4d'e5ddfd(d)�Z6d*e5ddfd+d,�Z7d�d-d.�Z8e3fd/e%d$eddfd0d1�Z9d2e:ddfd3d4�Z;d�d5d6�Z<d
e=ddfd7d8�Z>d9e=ddfd:d;�Z?d<eddfd=d>�Z@defd?d@�ZA	d�d<ede eBddfdAdB�ZCdCeddfdDdE�ZDdefdFdG�ZEdefdHdI�ZFdJe%ddfdKdL�ZGdMeHddfdNdO�ZIdPe=ddfdQdR�ZJdSeKeLddfdTdU�ZMdVe5ddfdWdX�ZNdYeddfdZd[�ZOdefd\d]�ZPded^eegdfddfd_d`�ZQeRded^e=gdfddfdadb��ZSdefdcdd�ZTdeeddfdfdg�ZUde eVfdhdi�ZWdjeddfdkdl�ZXd<eddfdmdn�ZYded^gdfddfdodp�ZZdqe=ddfdrds�Z[e\dte0e=ddfdudv��Z]e\de^ddfdwdx��Z_dyej`eaebfdee eddfdzd{�Zc	d�dede(dee e(ddfd|d}�Ze	d�defe(dee e(ddfd~d�Zgdehddfd�d��Zidejddfd�d��ZkdS)�r~au
    :class:`OpenSSL.SSL.Context` instances define the parameters for setting
    up new SSL connections.

    :param method: One of TLS_METHOD, TLS_CLIENT_METHOD, TLS_SERVER_METHOD,
                   DTLS_METHOD, DTLS_CLIENT_METHOD, or DTLS_SERVER_METHOD.
                   SSLv23_METHOD, TLSv1_METHOD, etc. are deprecated and should
                   not be used.
    N�_methods�methodrcCst|t�s	td��z	|j|\}}Wntytd��w|�}t|tjk�t	�
|�}t|tjk�t�|t	j�}||_
d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_|�t	j�|dur�|� |�|�!|�dSdS)Nzmethod must be an integerzNo such protocol)"r>rgr@r��KeyErrorrz�_openssl_assertr7rWr��SSL_CTX_new�gc�SSL_CTX_free�_context�_passphrase_helper�_passphrase_callback�_passphrase_userdata�_verify_helper�_verify_callback�_info_callback�_keylog_callback�_tlsext_servername_callback�	_app_data�_alpn_select_helper�_alpn_select_callback�_ocsp_helper�_ocsp_callback�
_ocsp_data�_cookie_generate_helper�_cookie_verify_helper�set_mode�SSL_MODE_ENABLE_PARTIAL_WRITE�set_min_proto_version�set_max_proto_version)rr��method_func�version�
method_obj�contextr�r�r�rXsL
�
����
�zContext.__init__r�cC�tt�|j|�dk�dS)aD
        Set the minimum supported protocol version. Setting the minimum
        version to 0 will enable protocol versions down to the lowest version
        supported by the library.

        If the underlying OpenSSL build is missing support for the selected
        version, this method will raise an exception.
        rN)r�r��SSL_CTX_set_min_proto_versionr��rr�r�r�r�r���	�zContext.set_min_proto_versioncCr�)aC
        Set the maximum supported protocol version. Setting the maximum
        version to 0 will enable protocol versions up to the highest version
        supported by the library.

        If the underlying OpenSSL build is missing support for the selected
        version, this method will raise an exception.
        rN)r�r��SSL_CTX_set_max_proto_versionr�r�r�r�r�r��r�zContext.set_max_proto_version�cafile�capathcCsR|durtj}nt|�}|durtj}nt|�}t�|j||�}|s't�dSdS)aM
        Let SSL know where we can find trusted certificates for the certificate
        chain.  Note that the certificates have to be in PEM format.

        If capath is passed, it must be a directory prepared using the
        ``c_rehash`` tool included with OpenSSL.  Either, but not both, of
        *pemfile* or *capath* may be :data:`None`.

        :param cafile: In which file we can find the certificates (``bytes`` or
            ``str``).
        :param capath: In which directory we can find the certificates
            (``bytes`` or ``str``).

        :return: None
        N)r7rW�_path_bytesr��SSL_CTX_load_verify_locationsr�r)rr�r��load_resultr�r�r��load_verify_locations�s�
�zContext.load_verify_locationsrc	s8t��dtdtdtdtf��fdd��}tt|ddd�S)	N�size�verify�userdatarcs�||�j�Sr)r�)r�r�r�r4r�r�r5�sz'Context._wrap_callback.<locals>.wrapperT)�	more_args�truncate)rrgrhrr?rrr8r�r4r��_wrap_callback�s
"�zContext._wrap_callbackr�cCs@t|�std��|�|�|_|jj|_t�|j|j�||_	dS)a�
        Set the passphrase callback.  This function will be called
        when a private key with a passphrase is loaded.

        :param callback: The Python callback to use.  This must accept three
            positional arguments.  First, an integer giving the maximum length
            of the passphrase it may return.  If the returned passphrase is
            longer than this, it will be truncated.  Second, a boolean value
            which will be true if the user should be prompted for the
            passphrase twice and the callback should verify that the two values
            supplied are equal. Third, the value given as the *userdata*
            parameter to :meth:`set_passwd_cb`.  The *callback* must return
            a byte string. If an error occurs, *callback* should return a false
            value (e.g. an empty string).
        :param userdata: (optional) A Python object which will be given as
                         argument to the callback
        :return: None
        �callback must be callableN)
�callabler@r�r�rr�r��SSL_CTX_set_default_passwd_cbr�r�)rrr�r�r�r��
set_passwd_cb�s
�
zContext.set_passwd_cbcCs�t�|j�}t|dk�t�t����d�}t�t����d�}|�	||�sDt�t�
��}t�t���}|tkrF|t
krH|�tt�dSdSdSdS)a�
        Specify that the platform provided CA certificates are to be used for
        verification purposes. This method has some caveats related to the
        binary wheels that cryptography (pyOpenSSL's primary dependency) ships:

        *   macOS will only load certificates using this method if the user has
            the ``openssl@1.1`` `Homebrew <https://brew.sh>`_ formula installed
            in the default location.
        *   Windows will not work.
        *   manylinux cryptography wheels will work on most common Linux
            distributions in pyOpenSSL 17.1.0 and above.  pyOpenSSL detects the
            manylinux wheel and attempts to load roots via a fallback path.

        :return: None
        r�asciiN)r�� SSL_CTX_set_default_verify_pathsr�r�r7r�X509_get_default_cert_dir_env�decode�X509_get_default_cert_file_env�_check_env_vars_set�X509_get_default_cert_dir�X509_get_default_cert_file�_CRYPTOGRAPHY_MANYLINUX_CA_DIR�_CRYPTOGRAPHY_MANYLINUX_CA_FILE�_fallback_default_verify_paths�_CERTIFICATE_FILE_LOCATIONS�_CERTIFICATE_PATH_LOCATIONS)r�
set_result�dir_env_var�file_env_var�default_dir�default_filer�r�r��set_default_verify_paths�s*�����z Context.set_default_verify_pathsr�r�cCs tj�|�duptj�|�duS)zp
        Check to see if the default cert dir/file environment vars are present.

        :return: bool
        N)�os�environ�get)rr�r�r�r�r�r�!s�zContext._check_env_vars_set�	file_path�dir_pathcCsP|D]}tj�|�r|�|�nq|D]}tj�|�r%|�d|�dSqdS)aV
        Default verify paths are based on the compiled version of OpenSSL.
        However, when pyca/cryptography is compiled as a manylinux wheel
        that compiled location can potentially be wrong. So, like Go, we
        will try a predefined set of paths and attempt to load roots
        from there.

        :return: None
        N)r��path�isfiler��isdir)rr�r�r�r�r�r�r�r�,s
���z&Context._fallback_default_verify_paths�certfilecCs(t|�}t�|j|�}|st�dSdS)z�
        Load a certificate chain from a file.

        :param certfile: The name of the certificate chain file (``bytes`` or
            ``str``).  Must be PEM encoded.

        :return: None
        N)r�r��"SSL_CTX_use_certificate_chain_filer�r)rr�r2r�r�r��use_certificate_chain_fileBs	�
�z"Context.use_certificate_chain_file�filetypecCs<t|�}t|t�s
td��t�|j||�}|st�dSdS)ad
        Load a certificate from a file

        :param certfile: The name of the certificate file (``bytes`` or
            ``str``).
        :param filetype: (optional) The encoding of the file, which is either
            :const:`FILETYPE_PEM` or :const:`FILETYPE_ASN1`.  The default is
            :const:`FILETYPE_PEM`.

        :return: None
        �filetype must be an integerN)r�r>rgr@r��SSL_CTX_use_certificate_filer�r)rr�r��
use_resultr�r�r��use_certificate_fileSs
�
�zContext.use_certificate_filer,cC�4t|t�s	td��t�|j|j�}|st�dSdS�zs
        Load a certificate from a X509 object

        :param cert: The X509 object
        :return: None
        zcert must be an X509 instanceN)r>rr@r��SSL_CTX_use_certificater��_x509r�rr,r�r�r�r��use_certificatek�

�zContext.use_certificate�certobjcCsHt|t�s	td��t�|j�}t�|j|�}|s"t�|�t	�dSdS)z�
        Add certificate to chain

        :param certobj: The X509 certificate object to add to the chain
        :return: None
        z certobj must be an X509 instanceN)
r>rr@r��X509_dupr��SSL_CTX_add_extra_chain_certr��	X509_freer)rr��copy�
add_resultr�r�r��add_extra_chain_certzs


�zContext.add_extra_chain_certcCs |jdur|j�t�t�dSr)r�rrurrr�r�r��_raise_passphrase_exception�s

z#Context._raise_passphrase_exception�keyfilecCs>t|�}t|t�s
td��t�|j||�}|s|��dSdS)aN
        Load a private key from a file

        :param keyfile: The name of the key file (``bytes`` or ``str``)
        :param filetype: (optional) The encoding of the file, which is either
            :const:`FILETYPE_PEM` or :const:`FILETYPE_ASN1`.  The default is
            :const:`FILETYPE_PEM`.

        :return: None
        r�N)r�r>rgr@r��SSL_CTX_use_PrivateKey_filer�r�)rr�r�r�r�r�r��use_privatekey_file�s
��zContext.use_privatekey_file�pkeycCs6t|t�s	td��t�|j|j�}|s|��dSdS�zs
        Load a private key from a PKey object

        :param pkey: The PKey object
        :return: None
        zpkey must be a PKey instanceN)r>rr@r��SSL_CTX_use_PrivateKeyr��_pkeyr��rr�r�r�r�r��use_privatekey�s
�zContext.use_privatekeycCst�|j�st�dSdS)z�
        Check if the private key (loaded with :meth:`use_privatekey`) matches
        the certificate (loaded with :meth:`use_certificate`)

        :return: :data:`None` (raises :exc:`Error` if something's wrong)
        N)r��SSL_CTX_check_private_keyr�rrr�r�r��check_privatekey�s
�zContext.check_privatekeycCs0t�td|��}t|tjk�t�|j|�dS)a%
        Load the trusted certificates that will be sent to the client.  Does
        not actually imply any of the certificates are trusted; that must be
        configured separately.

        :param bytes cafile: The path to a certificates file in PEM format.
        :return: None
        r�N)r��SSL_load_client_CA_file�_text_to_bytes_and_warnr�r7rW�SSL_CTX_set_client_CA_listr�)rr��ca_listr�r�r��load_client_ca�s
	�zContext.load_client_ca�bufcCs*td|�}tt�|j|t|��dk�dS)aV
        Set the session id to *buf* within which a session can be reused for
        this Context object.  This is needed when doing session resumption,
        because there is no way for a stored session to know which Context
        object it is associated with.

        :param bytes buf: The session id.

        :returns: None
        rrN)rr�r��SSL_CTX_set_session_id_contextr�rB)rrr�r�r��set_session_id�s
��zContext.set_session_id�modecC� t|t�s	td��t�|j|�S)a�
        Set the behavior of the session cache used by all connections using
        this Context.  The previously set mode is returned.  See
        :const:`SESS_CACHE_*` for details about particular modes.

        :param mode: One or more of the SESS_CACHE_* flags (combine using
            bitwise or)
        :returns: The previously set caching mode.

        .. versionadded:: 0.14
        �mode must be an integer)r>rgr@r��SSL_CTX_set_session_cache_moder��rr	r�r�r��set_session_cache_mode�s
zContext.set_session_cache_modecC�t�|j�S)z�
        Get the current session cache mode.

        :returns: The currently used cache mode.

        .. versionadded:: 0.14
        )r��SSL_CTX_get_session_cache_moder�rr�r�r��get_session_cache_mode�szContext.get_session_cache_modecC�vt|t�s	td��|durd|_d|_t�|j|tj	�dSt
|�s&td��t|�|_|jj|_t�|j||j�dS)a�
        Set the verification flags for this Context object to *mode* and
        specify that *callback* should be used for verification callbacks.

        :param mode: The verify mode, this should be one of
            :const:`VERIFY_NONE` and :const:`VERIFY_PEER`. If
            :const:`VERIFY_PEER` is used, *mode* can be OR:ed with
            :const:`VERIFY_FAIL_IF_NO_PEER_CERT` and
            :const:`VERIFY_CLIENT_ONCE` to further control the behaviour.
        :param callback: The optional Python verification callback to use.
            This should take five arguments: A Connection object, an X509
            object, and three integer variables, which are in turn potential
            error number, error depth and return code. *callback* should
            return True if verification passes and False otherwise.
            If omitted, OpenSSL's default verification is used.
        :return: None

        See SSL_CTX_set_verify(3SSL) for further details.
        rNr�)
r>rgr@r�r�r��SSL_CTX_set_verifyr�r7rWr�rr�rr	rr�r�r��
set_verify�s


zContext.set_verify�depthcC�$t|t�s	td��t�|j|�dS)z�
        Set the maximum depth for the certificate chain verification that shall
        be allowed for this Context object.

        :param depth: An integer specifying the verify depth
        :return: None
        zdepth must be an integerN)r>rgr@r��SSL_CTX_set_verify_depthr�)rrr�r�r��set_verify_depth"�
zContext.set_verify_depthcCr)z�
        Retrieve the Context object's verify mode, as set by
        :meth:`set_verify`.

        :return: The verify mode
        )r��SSL_CTX_get_verify_moder�rr�r�r��get_verify_mode/�zContext.get_verify_modecCr)z�
        Retrieve the Context object's verify depth, as set by
        :meth:`set_verify_depth`.

        :return: The verify depth
        )r��SSL_CTX_get_verify_depthr�rr�r�r��get_verify_depth8rzContext.get_verify_depth�dhfilecCstt|�}t�|d�}|tjkrt�t�|tj�}t�|tjtjtj�}t�|tj	�}t�
|j|�}t|dk�dS)z�
        Load parameters for Ephemeral Diffie-Hellman

        :param dhfile: The file to load EDH parameters from (``bytes`` or
            ``str``).

        :return: None
        �rrN)
r�r��BIO_new_filer7rWrr��BIO_free�PEM_read_bio_DHparams�DH_free�SSL_CTX_set_tmp_dhr�r�)rr �bio�dh�resr�r�r��load_tmp_dhAs	
zContext.load_tmp_dh�curvecCst�|j|���dS)a

        Select a curve to use for ECDHE key exchange.

        :param curve: A curve object to use as returned by either
            :meth:`OpenSSL.crypto.get_elliptic_curve` or
            :meth:`OpenSSL.crypto.get_elliptic_curves`.

        :return: None
        N)r��SSL_CTX_set_tmp_ecdhr��
_to_EC_KEY)rr+r�r�r��set_tmp_ecdhVs
zContext.set_tmp_ecdh�cipher_listcCsZtd|�}t|t�std��tt�|j|�dk�t|d�}|�	�gd�kr+t
dg��dS)z�
        Set the list of ciphers to be used in this context.

        See the OpenSSL manual for more information (e.g.
        :manpage:`ciphers(1)`).

        :param bytes cipher_list: An OpenSSL cipher string.
        :return: None
        r/z"cipher_list must be a byte string.rN)�TLS_AES_256_GCM_SHA384�TLS_CHACHA20_POLY1305_SHA256�TLS_AES_128_GCM_SHA256)zSSL routines�SSL_CTX_set_cipher_listzno cipher match)rr>r?r@r�r�r3r�r�get_cipher_listru)rr/�tmpconnr�r�r��set_cipher_listbs


�
���zContext.set_cipher_list�certificate_authoritiescCs�t��}t|tjk�z4|D]/}t|t�s tdt|�j	�d���t�
|j�}t|tjk�t�||�}|s=t�
|�t�qWn
tyLt�|��wt�|j|�dS)a_
        Set the list of preferred client certificate signers for this server
        context.

        This list of certificate authorities will be sent to the client when
        the server requests a client certificate.

        :param certificate_authorities: a sequence of X509Names.
        :return: None

        .. versionadded:: 0.10
        z)client CAs must be X509Name objects, not z objectsN)r��sk_X509_NAME_new_nullr�r7rWr>rr@r~r��
X509_NAME_dup�_name�sk_X509_NAME_push�X509_NAME_freerr&�sk_X509_NAME_freerr�)rr7�
name_stack�ca_namer��push_resultr�r�r��set_client_ca_list�s.
��
��
�zContext.set_client_ca_list�certificate_authoritycC�2t|t�s	td��t�|j|j�}t|dk�dS)ai
        Add the CA certificate to the list of preferred signers for this
        context.

        The list of certificate authorities will be sent to the client when the
        server requests a client certificate.

        :param certificate_authority: certificate authority's X509 certificate.
        :return: None

        .. versionadded:: 0.10
        z.certificate_authority must be an X509 instancerN)r>rr@r��SSL_CTX_add_client_CAr�r�r�)rrBr�r�r�r��
add_client_ca�s

�zContext.add_client_ca�timeoutcCr
)aQ
        Set the timeout for newly created sessions for this Context object to
        *timeout*.  The default value is 300 seconds. See the OpenSSL manual
        for more information (e.g. :manpage:`SSL_CTX_set_timeout(3)`).

        :param timeout: The timeout in (whole) seconds
        :return: The previous session timeout
        ztimeout must be an integer)r>rgr@r��SSL_CTX_set_timeoutr�)rrFr�r�r��set_timeout�s
	zContext.set_timeoutcCr)z�
        Retrieve session timeout, as set by :meth:`set_timeout`. The default
        is 300 seconds.

        :return: The session timeout
        )r��SSL_CTX_get_timeoutr�rr�r�r��get_timeout�rzContext.get_timeoutrc�6t���fdd��}t�d|�|_t�|j|j�dS)a�
        Set the information callback to *callback*. This function will be
        called from time to time during SSL handshakes.

        :param callback: The Python callback to use.  This should take three
            arguments: a Connection object and two integers.  The first integer
            specifies where in the SSL handshake the function was called, and
            the other the return code from a (possibly failed) internal
            function call.
        :return: None
        cs�tj|||�dSr�rr%)r0�where�return_code�rr�r�r5�sz*Context.set_info_callback.<locals>.wrapperzvoid (*)(const SSL *, int, int)N)rr7rr�r��SSL_CTX_set_info_callbackr�r8r�rOr��set_info_callback�s�zContext.set_info_callbackcrK)a
        Set the TLS key logging callback to *callback*. This function will be
        called whenever TLS key material is generated or received, in order
        to allow applications to store this keying material for debugging
        purposes.

        :param callback: The Python callback to use.  This should take two
            arguments: a Connection object and a bytestring that contains
            the key material in the format used by NSS for its SSLKEYLOGFILE
            debugging output.
        :return: None
        cst�|�}�tj||�dSr)r7rrr%)r0�linerOr�r�r5s
z,Context.set_keylog_callback.<locals>.wrapperz#void (*)(const SSL *, const char *)N)rr7rr�r��SSL_CTX_set_keylog_callbackr�r8r�rOr��set_keylog_callback�s�zContext.set_keylog_callbackcC�|jS)zw
        Get the application data (supplied via :meth:`set_app_data()`)

        :return: The application data
        �r�rr�r�r��get_app_data
�zContext.get_app_datar\cC�
||_dS)z�
        Set the application data (will be returned from get_app_data())

        :param data: Any Python object
        :return: None
        NrV�rr\r�r�r��set_app_data�
zContext.set_app_datacCs.t�|j�}|tjkr
dSt�t�}||_|S)z�
        Get the certificate store for the context.  This can be used to add
        "trusted" certificates without using the
        :meth:`load_verify_locations` method.

        :return: A X509Store object or None if it does not have one.
        N)r��SSL_CTX_get_cert_storer�r7rWr�__new__�_store)r�store�pystorer�r�r��get_cert_stores

zContext.get_cert_store�optionscCr
)z�
        Add options. Options set before are not cleared!
        This method should be used with the :const:`OP_*` constants.

        :param options: The options to add.
        :return: The new option bitmask.
        zoptions must be an integer)r>rgr@r��SSL_CTX_set_optionsr�)rrcr�r�r��set_options/�
zContext.set_optionscCr
)z�
        Add modes via bitmask. Modes set before are not cleared!  This method
        should be used with the :const:`MODE_*` constants.

        :param mode: The mode to add.
        :return: The new mode bitmask.
        r)r>rgr@r��SSL_CTX_set_moder�r
r�r�r�r�<rfzContext.set_modecrK)a
        Specify a callback function to be called when clients specify a server
        name.

        :param callback: The callback function.  It will be invoked with one
            argument, the Connection instance.

        .. versionadded:: 0.13
        cs�tj|�dSrsrL)r0�alertrKrOr�r�r5Vsz7Context.set_tlsext_servername_callback.<locals>.wrapperzint (*)(SSL *, int *, void *)N)rr7rr�r��&SSL_CTX_set_tlsext_servername_callbackr�r8r�rOr��set_tlsext_servername_callbackIs
��z&Context.set_tlsext_servername_callback�profilescCs,t|t�s	td��tt�|j|�dk�dS)z�
        Enable support for negotiating SRTP keying material.

        :param bytes profiles: A colon delimited list of protection profile
            names, like ``b'SRTP_AES128_CM_SHA1_80:SRTP_AES128_CM_SHA1_32'``.
        :return: None
        zprofiles must be a byte string.rN)r>r?r@r�r��SSL_CTX_set_tlsext_use_srtpr�)rrkr�r�r��set_tlsext_use_srtpbs

�zContext.set_tlsext_use_srtp�protoscC�R|std��d�t�dd�|D���}t�d|�}tt�|j	|t
|��dk�dS)a�
        Specify the protocols that the client is prepared to speak after the
        TLS connection has been negotiated using Application Layer Protocol
        Negotiation.

        :param protos: A list of the protocols to be offered to the server.
            This list should be a Python list of bytestrings representing the
            protocols to offer, e.g. ``[b'http/1.1', b'spdy/2']``.
        �'at least one protocol must be specifiedr;cs�"�|]}tt|�f�|fVqdSr�r?rB��.0�pr�r�r��	<genexpr>��� z*Context.set_alpn_protos.<locals>.<genexpr>r<rN)rz�joinr�
from_iterabler7rAr�r��SSL_CTX_set_alpn_protosr�rB�rrn�protostr�	input_strr�r�r��set_alpn_protosqs����zContext.set_alpn_protoscCs,t|�|_|jj|_t�|j|jtj�dS)a�
        Specify a callback function that will be called on the server when a
        client offers protocols using ALPN.

        :param callback: The callback function.  It will be invoked with two
            arguments: the Connection, and a list of offered protocols as
            bytestrings, e.g ``[b'http/1.1', b'spdy/2']``.  It can return
            one of those bytestrings to indicate the chosen protocol, the
            empty bytestring to terminate the TLS connection, or the
            :py:obj:`NO_OVERLAPPING_PROTOCOLS` to indicate that no offered
            protocol was selected, but that the connection should not be
            aborted.
        N)	r:r�rr�r��SSL_CTX_set_alpn_select_cbr�r7rW�rrr�r�r��set_alpn_select_callback�s


�z Context.set_alpn_select_callback�helpercCsh||_|j|_|durtj|_nt�|�|_t�|j	|j�}t
|dk�t�|j	|j�}t
|dk�dS)z�
        This internal helper does the common work for
        ``set_ocsp_server_callback`` and ``set_ocsp_client_callback``, which is
        almost all of it.
        Nr)r�rr�r7rWr��
new_handler��SSL_CTX_set_tlsext_status_cbr�r��SSL_CTX_set_tlsext_status_arg)rr�r\�rcr�r�r��_set_ocsp_callback�s
�zContext._set_ocsp_callbackcC�t|�}|�||�dS)a�
        Set a callback to provide OCSP data to be stapled to the TLS handshake
        on the server side.

        :param callback: The callback function. It will be invoked with two
            arguments: the Connection, and the optional arbitrary data you have
            provided. The callback must return a bytestring that contains the
            OCSP data to staple to the handshake. If no OCSP data is available
            for this connection, return the empty bytestring.
        :param data: Some opaque data that will be passed into the callback
            function when called. This can be used to avoid needing to do
            complex data lookups or to keep track of what context is being
            used. This parameter is optional.
        N)rUr��rrr\r�r�r�r��set_ocsp_server_callback�sz Context.set_ocsp_server_callbackcCr�)a�
        Set a callback to validate OCSP data stapled to the TLS handshake on
        the client side.

        :param callback: The callback function. It will be invoked with three
            arguments: the Connection, a bytestring containing the stapled OCSP
            assertion, and the optional arbitrary data you have provided. The
            callback must return a boolean that indicates the result of
            validating the OCSP data: ``True`` if the OCSP data is valid and
            the certificate can be trusted, or ``False`` if either the OCSP
            data is invalid or the certificate has been revoked.
        :param data: Some opaque data that will be passed into the callback
            function when called. This can be used to avoid needing to do
            complex data lookups or to keep track of what context is being
            used. This parameter is optional.
        N)rcr�r�r�r�r��set_ocsp_client_callback�sz Context.set_ocsp_client_callbackcC� t|�|_t�|j|jj�dSr)rnr�r��SSL_CTX_set_cookie_generate_cbr�rr�r�r�r��set_cookie_generate_callback��

�z$Context.set_cookie_generate_callbackcCr�r)rrr�r��SSL_CTX_set_cookie_verify_cbr�rr�r�r�r��set_cookie_verify_callback�r�z"Context.set_cookie_verify_callbackrr)lr�r�r�r�r,r��
TLS_methodr-r7r.r8r/r9r0r1�TLS_server_methodr2�TLS_client_methodr3�DTLS_methodr4�DTLS_server_methodr5�DTLS_client_methodr��typing�ClassVar�Dictrgr
r	rrr�rr�r��_StrOrBytesPathr��_PassphraseCallbackr�rr�r�r��strrhr�r
r�r�rr�rr�r�r�r�rr�rr?rrrrr9rrrrr*rr.r6rrrArErHrJrQ�_requires_keylogrTrWr[rrbrer�rjrm�_requires_alpnr~rSr��UnionrcrUr�rar�rlr�rpr�rvr�r�r�r�r�r~>s<










��"�/
���
�$�
����
�
!0��
����
�
���
�

���
�%
		'�
�%	�
���	

�
�%���
����
����
��
�	��r~c	@s,eZdZUe�Zejedfed<	d�de	de
ejddfdd�Zde
defd	d
�Zdededdfd
d�Zde	fdd�Zde	ddfdd�Zde
efdd�Z	d�dede
eddfdd�Zdefdd�Zdeddfdd�Zdeddfdd �Zd!eddfd"d#�Zdefd$d%�Zdeddfd&d'�Zdefd(d)�Zd�d+ed,edefd-d.�Z e Z!d�d+ed,edefd/d0�Z"d�d1ed,e
edefd2d3�Z#e#Z$		d�d4ed5e
ed,e
edefd6d7�Z%d8ededej&fd9d:�Z'd1edefd;d<�Z(d+edefd=d>�Z)de*fd?d@�Z+d�dAdB�Z,de*fdCdD�Z-defdEdF�Z.dGeddfdHdI�Z/dGedefdJdK�Z0de1deffdLdM�Z2d�dNdO�Z3de
efdPdQ�Z4de*fdRdS�Z5d�dTdU�Z6de*fdVdW�Z7de8e
fdXdY�Z9de8e:fdZd[�Z;d\ed]edej&fd^d_�Z<defd`da�Z=dbeddfdcdd�Z>defdedf�Z?dgeddfdhdi�Z@defdjdk�ZAde
efdldm�ZBde
efdndo�ZCde
efdpdq�ZD	d�dredsede
edefdtdu�ZEd\ed]eddfdvdw�ZFde
efdxdy�ZGde
efdzd{�ZHeId|ede8efd}d~��ZJde
e8efdd��ZKde
e8efd�d��ZLde*fd�d��ZMde*fd�d��ZNd�d�d��ZOd�d�d��ZPde
eQfd�d��ZRd�eQddfd�d��ZSd�eTeeegefde
efd�d��ZUde
efd�d��ZVde
efd�d��ZWde
e
fd�d��ZXde
efd�d��ZYde
e
fd�d��ZZde
fd�d��Z[defd�d��Z\e]d�e8eddfd�d���Z^e]defd�d���Z_defd�d��Z`d�d�d��ZadS)�rr%Nr��socketrcCst|t�s	td��t�|j�}t�|tj�|_	t�
|j	tj�||_d|_d|_
|j|_|j|_|j|_|j|_||j|j	<|durqd|_t�t���|_t|jtjk�t�t���|_t|jtjk�t�|j	|j|j�dSd|_d|_||_t�|j	t|j��}t|dk�dS)z�
        Create a new Connection object, using the given OpenSSL.SSL.Context
        instance and socket.

        :param context: An SSL Context to use for this connection
        :param socket: The socket to use for transport layer
        �"context must be a Context instanceNr)r>r~r@r��SSL_newr�r7r��SSL_free�_ssl�SSL_set_mode�SSL_MODE_AUTO_RETRYr�rCr�r�r�r�r%�_socket�BIO_new�	BIO_s_mem�	_into_sslr�rW�	_from_ssl�SSL_set_bio�
SSL_set_fdr})rr�r�r0r�r�r�r�rs6

�zConnection.__init__�namecCs0|jdurtd|jj�d|�d���t|j|�S)zy
        Look up attributes on the wrapped socket object if they are not found
        on the Connection object.
        N�'z' object has no attribute ')r��AttributeError�	__class__r�ry�rr�r�r�r��__getattr__Hs

�zConnection.__getattr__r0r2cCsj|jjdur|jj��|jjdur|jj��|jjdur$|jj��t�||�}|tjkr2t��|tj	kr:t
��|tjkrBt��|tj
krJt��|tjkr}t��dkrx|dkrstdkrdt��d}ntj}|dkrst|t�|���tdd��t�dS|tjkr�t��dkr�t��}t�|�}tjr�t|tjk�t��tdd��t�dS|tjkr�dSt�dS)Nr�win32rezUnexpected EOF) r�r�rr�r�r��
SSL_get_error�SSL_ERROR_WANT_READrv�SSL_ERROR_WANT_WRITErw�SSL_ERROR_ZERO_RETURNry�SSL_ERROR_WANT_X509_LOOKUPrx�SSL_ERROR_SYSCALL�ERR_peek_errorrr7�getwinerror�errnorzrr�r�
SSL_ERROR_SSL�ERR_GET_REASON�-Cryptography_HAS_UNEXPECTED_EOF_WHILE_READINGr��"SSL_R_UNEXPECTED_EOF_WHILE_READING�ERR_clear_error�SSL_ERROR_NONE)rr0r2r�r��peeked_error�reasonr�r�r��_raise_ssl_errorTsL







�



zConnection._raise_ssl_errorcCrU)zh
        Retrieve the :class:`Context` object associated with this
        :class:`Connection`.
        )r�rr�r�r��get_context�szConnection.get_contextcCs,t|t�s	td��t�|j|j�||_dS)z�
        Switch this connection to a new session context.

        :param context: A :class:`Context` instance giving the new session
            context to use.
        r�N)r>r~r@r��SSL_set_SSL_CTXr�r�)rr�r�r�r��set_context�s

zConnection.set_contextcCs(t�|jtj�}|tjkrdSt�|�S)z�
        Retrieve the servername extension value if provided in the client hello
        message, or None if there wasn't one.

        :return: A byte string giving the server name or :data:`None`.

        .. versionadded:: 0.13
        N)r��SSL_get_servernamer��TLSEXT_NAMETYPE_host_namer7rWrr�r�r�r��get_servername�s	�

zConnection.get_servernamer	rcCr)z�
        Override the Context object's verification flags for this specific
        connection. See :py:meth:`Context.set_verify` for details.
        rNr�)
r>rgr@r�r�r��SSL_set_verifyr�r7rWr�rrrr�r�r�r�s


zConnection.set_verifycCr)z�
        Retrieve the Connection object's verify mode, as set by
        :meth:`set_verify`.

        :return: The verify mode
        )r��SSL_get_verify_moder�rr�r�r�r�rzConnection.get_verify_moder,cCr�r�)r>rr@r��SSL_use_certificater�r�rr�r�r�r�r��r�zConnection.use_certificater�cCs8t|t�s	td��t�|j|j�}|s|j��dSdSr�)	r>rr@r��SSL_use_PrivateKeyr�r�r�r�r�r�r�r�r��s
�zConnection.use_privatekey�mtucCst�|j|�dS)aK
        For DTLS, set the maximum UDP payload size (*not* including IP/UDP
        overhead).

        Note that you might have to set :data:`OP_NO_QUERY_MTU` to prevent
        OpenSSL from spontaneously clearing this.

        :param mtu: An integer giving the maximum transmission unit.

        .. versionadded:: 21.1
        N)r��SSL_set_mtur�)rr�r�r�r��set_ciphertext_mtu�szConnection.set_ciphertext_mtucCsttd�s	td��t�|j�S)a

        For DTLS, get the maximum size of unencrypted data you can pass to
        :meth:`write` without exceeding the MTU (as passed to
        :meth:`set_ciphertext_mtu`).

        :return: The effective MTU as an integer.

        .. versionadded:: 21.1
        �DTLS_get_data_mtuz requires OpenSSL 1.1.1 or better)�hasattrr�r�r�r�rr�r�r��get_cleartext_mtu�s
zConnection.get_cleartext_mtucCs4t|t�s	td��d|vrtd��t�|j|�dS)z�
        Set the value of the servername extension to send in the client hello.

        :param name: A byte string giving the name.

        .. versionadded:: 0.13
        zname must be a byte string�zname must not contain NUL byteN)r>r?r@r��SSL_set_tlsext_host_namer�r�r�r�r��set_tlsext_host_name
s

zConnection.set_tlsext_host_namecCr)z�
        Get the number of bytes that can be safely read from the SSL buffer
        (**not** the underlying transport buffer).

        :return: The number of bytes available in the receive buffer.
        )r��SSL_pendingr�rr�r�r��pendingrzConnection.pendingrr�flagscCsrtd|�}t�|��%}t|�dkrtd��t�|j|t|��}|�|j|�|Wd�S1s2wYdS)a�
        Send data on the connection. NOTE: If you get one of the WantRead,
        WantWrite or WantX509Lookup exceptions on this, you have to call the
        method again with the SAME buffer.

        :param buf: The string, buffer or memoryview to send
        :param flags: (optional) Included for compatibility with the socket
                      API, the value is ignored
        :return: The number of bytes written
        r��z,Cannot send more than 2**31-1 bytes at once.N)	rr7�from_bufferrBrzr��	SSL_writer�r�)rrr�r\r2r�r�r��send#s
�$�zConnection.sendcCs�td|�}t�|��0}t|�}d}|r1t�|j||t|d��}|�|j|�||7}||8}|s|Wd�S1s=wYdS)a�
        Send "all" data on the connection. This calls send() repeatedly until
        all data is sent. If an error occurs, it's impossible to tell how much
        data has been sent.

        :param buf: The string, buffer or memoryview to send
        :param flags: (optional) Included for compatibility with the socket
                      API, the value is ignored
        :return: The number of bytes written
        rrr�N)	rr7r�rBr�r�r��minr�)rrr�r\�left_to_send�
total_sentr2r�r�r��sendall?s
��
$�zConnection.sendall�bufsizcCs`td|�}|dur|tj@rt�|j||�}nt�|j||�}|�|j|�t�	||�dd�S)a
        Receive data on the connection.

        :param bufsiz: The maximum number of bytes to read
        :param flags: (optional) The only supported flag is ``MSG_PEEK``,
            all other flags are ignored.
        :return: The string read from the Connection
        �char[]N)
�_no_zero_allocatorr��MSG_PEEKr��SSL_peekr��SSL_readr�r7r=)rr�r�rr2r�r�r��recv\s
	zConnection.recvr=�nbytescCs�|dur	t|�}nt|t|��}td|�}|dur'|tj@r't�|j||�}nt�|j||�}|�	|j|�t
t�||��|d|�<|S)ae
        Receive data on the connection and copy it directly into the provided
        buffer, rather than creating a new string.

        :param buffer: The buffer to copy into.
        :param nbytes: (optional) The maximum number of bytes to read into the
            buffer. If not present, defaults to the size of the buffer. If
            larger than the size of the buffer, is reduced to the size of the
            buffer.
        :param flags: (optional) The only supported flag is ``MSG_PEEK``,
            all other flags are ignored.
        :return: The number of bytes read into the buffer.
        Nr�)
rBr�r�r�r�r�r�r�r�r��
memoryviewr7r=)rr=r�r�rr2r�r�r��	recv_intoos

zConnection.recv_intor'cCsNt�|�r"t�|�r
t��t�|�rt��t�|�rtd��td��t�dS)N�BIO_should_io_specialzunknown bio failure)	r��BIO_should_retry�BIO_should_readrv�BIO_should_writerwr�rzr)rr'r2r�r�r��_handle_bio_errors�s




zConnection._handle_bio_errorscCsh|jdur	td��t|t�std��td|�}t�|j||�}|dkr*|�|j|�t�	||�dd�S)a�
        If the Connection was created with a memory BIO, this method can be
        used to read bytes from the write end of that memory BIO.  Many
        Connection methods will add bytes which must be read in this manner or
        the buffer will eventually fill up and the Connection will be able to
        take no further actions.

        :param bufsiz: The maximum number of bytes to read
        :return: The string read.
        N�Connection sock was not Nonezbufsiz must be an integerr�r)
r�r@r>rgr�r��BIO_readr�r7r=)rr�rr2r�r�r��bio_read�s


zConnection.bio_readcCsxtd|�}|jdurtd��t�|��}t�|j|t|��}|dkr)|�|j|�|Wd�S1s5wYdS)aj
        If the Connection was created with a memory BIO, this method can be
        used to add bytes to the read end of that memory BIO.  The Connection
        can then read the bytes (for example, in response to a call to
        :meth:`recv`).

        :param buf: The string to put into the memory BIO.
        :return: The number of bytes written
        rNr�r)	rr�r@r7r�r��	BIO_writerBr�)rrr\r2r�r�r��	bio_write�s


$�zConnection.bio_writecCs$|��stt�|j�dk�dSdS)zv
        Renegotiate the session.

        :return: True if the renegotiation can be started, False otherwise
        rTF)�renegotiate_pendingr�r��SSL_renegotiater�rr�r�r��renegotiate�szConnection.renegotiatecCst�|j�}|�|j|�dS)a
        Perform an SSL handshake (usually called after :meth:`renegotiate` or
        one of :meth:`set_accept_state` or :meth:`set_connect_state`). This can
        raise the same exceptions as :meth:`send` and :meth:`recv`.

        :return: None.
        N)r��SSL_do_handshaker�r��rr2r�r�r��do_handshake�szConnection.do_handshakecCst�|j�dkS)z�
        Check if there's a renegotiation in progress, it will return False once
        a renegotiation is finished.

        :return: Whether there's a renegotiation in progress
        r)r��SSL_renegotiate_pendingr�rr�r�r�r���zConnection.renegotiate_pendingcCr)zn
        Find out the total number of renegotiations.

        :return: The number of renegotiations.
        )r��SSL_total_renegotiationsr�rr�r�r��total_renegotiations�szConnection.total_renegotiations�addrcCst�|j�|j�|�S)a4
        Call the :meth:`connect` method of the underlying socket and set up SSL
        on the socket, using the :class:`Context` object supplied to this
        :class:`Connection` object at creation.

        :param addr: A remote address
        :return: What the socket's connect method returns
        )r��SSL_set_connect_stater�r��connect)rrr�r�r�r�s	zConnection.connectcCs|jj}|��||�S)a�
        Call the :meth:`connect_ex` method of the underlying socket and set up
        SSL on the socket, using the Context object supplied to this Connection
        object at creation. Note that if the :meth:`connect_ex` method of the
        socket doesn't return 0, SSL won't be initialized.

        :param addr: A remove address
        :return: What the socket's connect_ex method returns
        )r��
connect_ex�set_connect_state)rrrr�r�r�r	s
zConnection.connect_excCs*|j��\}}t|j|�}|��||fS)a�
        Call the :meth:`accept` method of the underlying socket and set up SSL
        on the returned socket, using the Context object supplied to this
        :class:`Connection` object at creation.

        :return: A *(conn, addr)* pair where *conn* is the new
            :class:`Connection` object created, and *address* is as returned by
            the socket's :meth:`accept`.
        )r��acceptrr��set_accept_state)r�clientrrLr�r�r�r		s
zConnection.acceptc	Cs�t��}zt�|j|�}Wt�|�nt�|�w|jdur#|j��|jdur-|j��|dkr4t��|dkrA|�	|j|�dSdS)z�
        Call the OpenSSL function DTLSv1_listen on this connection. See the
        OpenSSL manual for more details.

        :return: None
        Nr)
r��BIO_ADDR_new�
DTLSv1_listenr��
BIO_ADDR_freer�rr�rvr�)r�bio_addrr2r�r�r�r
(	s



�zConnection.DTLSv1_listencCs<t�d�}t�d�}t�|j||�r|d|ddSdS)a}
        Determine when the DTLS SSL object next needs to perform internal
        processing due to the passage of time.

        When the returned number of seconds have passed, the
        :meth:`DTLSv1_handle_timeout` method needs to be called.

        :return: The time left in seconds before the next timeout or `None`
            if no timeout is currently active.
        ztime_t *zlong *ri@BN)r7rAr��Cryptography_DTLSv1_get_timeoutr�)r�ptv_sec�ptv_usecr�r�r��DTLSv1_get_timeoutB	s


zConnection.DTLSv1_get_timeoutcCs2t�|j�}|dkr|�|j|�Jd��t|�S)z�
        Handles any timeout events which have become pending on a DTLS SSL
        object.

        :return: `True` if there was a pending timeout, `False` otherwise.
        rF�unreachable)r��DTLSv1_handle_timeoutr�r�rhr�r�r�r�rT	s
z Connection.DTLSv1_handle_timeoutcCs$|jdur	td��t�|jd�dS)z�
        If the Connection was created with a memory BIO, this method can be
        used to indicate that *end of file* has been reached on the read end of
        that memory BIO.

        :return: None
        Nr�r)r�r@r��BIO_set_mem_eof_returnr�rr�r�r��bio_shutdownb	rzConnection.bio_shutdowncCs:t�|j�}|dkr|�|j|�Jd��|dkrdSdS)aQ
        Send the shutdown message to the Connection.

        :return: True if the shutdown completed successfully (i.e. both sides
                 have sent closure alerts), False otherwise (in which case you
                 call :meth:`recv` or :meth:`send` when the connection becomes
                 readable/writeable).
        rFrT)r��SSL_shutdownr�r�r�r�r�r��shutdowno	s	zConnection.shutdowncCsHg}t�D]}t�|j|�}|tjkr|S|�t�|��d��q|S)z�
        Retrieve the list of ciphers used by the Connection object.

        :return: A list of native cipher strings.
        �utf-8)	rr��SSL_get_cipher_listr�r7rWr'rr�)r�ciphers�ir2r�r�r�r4�	s

�zConnection.get_cipher_listcCs~t�|j�}|tjkr
gSg}tt�|��D]&}t�||�}t�|�}t	|tjk�t
�t
�}t�|tj
�|_|�|�q|S)a�
        Get CAs whose certificates are suggested for client authentication.

        :return: If this is a server connection, the list of certificate
            authorities that will be sent or has been sent to the client, as
            controlled by this :class:`Connection`'s :class:`Context`.

            If this is a client connection, the list will be empty until the
            connection with the server is established.

        .. versionadded:: 0.10
        )r��SSL_get_client_CA_listr�r7rW�range�sk_X509_NAME_num�sk_X509_NAME_valuer9r�rr^r�r<r:r')r�ca_namesr2rr�r��pynamer�r�r��get_client_ca_list�	s


zConnection.get_client_ca_listr�r�cOstd��)z�
        The makefile() method is not implemented, since there is no dup
        semantics for SSL connections

        :raise: NotImplementedError
        z1Cannot make file object of OpenSSL.SSL.Connectionr��rr�r�r�r�r��makefile�	s�zConnection.makefilecCrU)zr
        Retrieve application data as set by :meth:`set_app_data`.

        :return: The application data
        rVrr�r�r�rW�	rXzConnection.get_app_datar\cCrY)zg
        Set application data

        :param data: The application data
        :return: None
        NrVrZr�r�r�r[�	r\zConnection.set_app_datacCr)z�
        Get the shutdown state of the Connection.

        :return: The shutdown state, a bitvector of SENT_SHUTDOWN,
            RECEIVED_SHUTDOWN.
        )r��SSL_get_shutdownr�rr�r�r��get_shutdown�	rzConnection.get_shutdown�statecCr)z�
        Set the shutdown state of the Connection.

        :param state: bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN.
        :return: None
        zstate must be an integerN)r>rgr@r��SSL_set_shutdownr�)rr)r�r�r��set_shutdown�	s
zConnection.set_shutdowncCst�t�|j��S)z�
        Retrieve a verbose string detailing the state of the Connection.

        :return: A string representing the state
        )r7rr��SSL_state_string_longr�rr�r�r��get_state_string�	szConnection.get_state_stringcC�ft�|j�}|tjkr
dSt�|jtjd�}t|dk�td|�}t�|j||�t�||�dd�S)z�
        Retrieve the random value used with the server hello message.

        :return: A string representing the state
        Nrr<)	r��SSL_get_sessionr�r7rW�SSL_get_server_randomr�r�r=�r�session�length�outpr�r�r��
server_random�	s

zConnection.server_randomcCr.)z�
        Retrieve the random value used with the client hello message.

        :return: A string representing the state
        Nrr<)	r�r/r�r7rW�SSL_get_client_randomr�r�r=r1r�r�r��
client_random�	s

zConnection.client_randomcCsbt�|j�}|tjkr
dSt�|tjd�}t|dk�td|�}t�|||�t�||�dd�S)zz
        Retrieve the value of the master key for this session.

        :return: A string representing the state
        Nrr<)	r�r/r�r7rW�SSL_SESSION_get_master_keyr�r�r=r1r�r�r��
master_key
s

zConnection.master_key�label�olenc	
Csntd|�}tj}d}d}|dur|}t|�}d}t�|j|||t|�|||�}t|dk�t�||�dd�S)aH
        Obtain keying material for application use.

        :param: label - a disambiguating label string as described in RFC 5705
        :param: olen - the length of the exported key material in bytes
        :param: context - a per-association context value
        :return: the exported key material bytes or None
        r<rNr)	r�r7rWrBr��SSL_export_keying_materialr�r�r=)	rr:r;r�r4�context_buf�context_len�use_context�successr�r�r��export_keying_material
s(
�
z!Connection.export_keying_materialcOs|jj|i|��S)z�
        Call the :meth:`shutdown` method of the underlying socket.
        See :manpage:`shutdown(2)`.

        :return: What the socket's shutdown() method returns
        )r�rr%r�r�r��
sock_shutdown4
szConnection.sock_shutdowncCs.t�|j�}|tjkrt�|�t�|�SdS)za
        Retrieve the local certificate (if any)

        :return: The local certificate
        N)r��SSL_get_certificater�r7rWrrr �rr,r�r�r��get_certificate=
s



zConnection.get_certificatecCs$t�|j�}|tjkrt�|�SdS)zi
        Retrieve the other side's certificate (if any)

        :return: The peer's certificate
        N)r��SSL_get_peer_certificater�r7rWrr rDr�r�r��get_peer_certificateI
s

zConnection.get_peer_certificate�
cert_stackcCs`g}tt�|��D]$}t�||�}t|tjk�t�|�}t|dk�t�	|�}|�
|�q	|S)zb
        Internal helper to convert a STACK_OF(X509) to a list of X509
        instances.
        r)rr��sk_X509_num�
sk_X509_valuer�r7rWrrr r')rHr2rr,r)�pycertr�r�r��_cert_stack_to_listT
s

zConnection._cert_stack_to_listcC�$t�|j�}|tjkr
dS|�|�S)z�
        Retrieve the other side's certificate (if any)

        :return: A list of X509 instances giving the peer's certificate chain,
                 or None if it does not have one.
        N)r��SSL_get_peer_cert_chainr�r7rWrL�rrHr�r�r��get_peer_cert_chaind
s

zConnection.get_peer_cert_chaincCrM)a�
        Retrieve the verified certificate chain of the peer including the
        peer's end entity certificate. It must be called after a session has
        been successfully established. If peer verification was not successful
        the chain may be incomplete, invalid, or None.

        :return: A list of X509 instances giving the peer's verified
                 certificate chain, or None if it does not have one.

        .. versionadded:: 20.0
        N)r��SSL_get0_verified_chainr�r7rWrLrOr�r�r��get_verified_chainq
s

zConnection.get_verified_chaincCr)z�
        Checks if more data has to be read from the transport layer to complete
        an operation.

        :return: True iff more data has to be read
        )r��
SSL_want_readr�rr�r�r��	want_read�
rzConnection.want_readcCr)z�
        Checks if there is data to write to the transport layer to complete an
        operation.

        :return: True iff there is data to write
        )r��SSL_want_writer�rr�r�r��
want_write�
rzConnection.want_writecC�t�|j�dS)z�
        Set the connection to work in server mode. The handshake will be
        handled automatically by read/write.

        :return: None
        N)r��SSL_set_accept_stater�rr�r�r�r
�
rzConnection.set_accept_statecCrW)z�
        Set the connection to work in client mode. The handshake will be
        handled automatically by read/write.

        :return: None
        N)r�rr�rr�r�r�r�
rzConnection.set_connect_statecCs8t�|j�}|tjkr
dSt�t�}t�|tj�|_	|S)z�
        Returns the Session currently used.

        :return: An instance of :class:`OpenSSL.SSL.Session` or
            :obj:`None` if no session exists.

        .. versionadded:: 0.14
        N)
r��SSL_get1_sessionr�r7rWr}r^r��SSL_SESSION_freer�)rr2�	pysessionr�r�r��get_session�
s	

zConnection.get_sessionr2cCrC)z�
        Set the session to be used when the TLS/SSL connection is established.

        :param session: A Session instance representing the session to use.
        :returns: None

        .. versionadded:: 0.14
        z"session must be a Session instancerN)r>r}r@r��SSL_set_sessionr�r�r�)rr2r2r�r�r��set_session�
s
	zConnection.set_session�functioncCsRt�dd�}||j|d�}|dkrdStd|�}||j||�t�||�dd�S)aN
        Helper to implement :meth:`get_finished` and
        :meth:`get_peer_finished`.

        :param function: Either :data:`SSL_get_finished`: or
            :data:`SSL_get_peer_finished`.

        :return: :data:`None` if the desired message has not yet been
            received, otherwise the contents of the message.
        r�rN)r7rAr�r�r=)rr_�emptyr�rr�r�r��_get_finished_message�
s
z Connection._get_finished_messagecC�|�tj�S)z�
        Obtain the latest TLS Finished message that we sent.

        :return: The contents of the message or :obj:`None` if the TLS
            handshake has not yet completed.

        .. versionadded:: 0.15
        )rar��SSL_get_finishedrr�r�r��get_finished�
�	zConnection.get_finishedcCrb)z�
        Obtain the latest TLS Finished message that we received from the peer.

        :return: The contents of the message or :obj:`None` if the TLS
            handshake has not yet completed.

        .. versionadded:: 0.15
        )rar��SSL_get_peer_finishedrr�r�r��get_peer_finished�
rezConnection.get_peer_finishedcC�4t�|j�}|tjkr
dSt�t�|��}|�d�S)z�
        Obtain the name of the currently used cipher.

        :returns: The name of the currently used cipher or :obj:`None`
            if no connection has been established.

        .. versionadded:: 0.15
        Nr)r��SSL_get_current_cipherr�r7rWr�SSL_CIPHER_get_namer�)r�cipherr�r�r�r��get_cipher_name�
	

zConnection.get_cipher_namecCs(t�|j�}|tjkr
dSt�|tj�S)z�
        Obtain the number of secret bits of the currently used cipher.

        :returns: The number of secret bits of the currently used cipher
            or :obj:`None` if no connection has been established.

        .. versionadded:: 0.15
        N)r�rir�r7rW�SSL_CIPHER_get_bits)rrkr�r�r��get_cipher_bitss	
zConnection.get_cipher_bitscCrh)z�
        Obtain the protocol version of the currently used cipher.

        :returns: The protocol name of the currently used cipher
            or :obj:`None` if no connection has been established.

        .. versionadded:: 0.15
        Nr)r�rir�r7rWr�SSL_CIPHER_get_versionr�)rrkr�r�r�r��get_cipher_version rmzConnection.get_cipher_versioncCst�t�|j��}|�d�S)a
        Retrieve the protocol version of the current connection.

        :returns: The TLS version of the current connection, for example
            the value for TLS 1.2 would be ``TLSv1.2``or ``Unknown``
            for connections that were not successfully established.
        r)r7rr��SSL_get_versionr�r�r�r�r�r��get_protocol_version_name0s
z$Connection.get_protocol_version_namecCst�|j�}|S)z�
        Retrieve the SSL or TLS protocol version of the current connection.

        :returns: The TLS version of the current connection.  For example,
            it will return ``0x769`` for connections made over TLS version 1.
        )r��SSL_versionr�r�r�r�r��get_protocol_version;szConnection.get_protocol_versionrncCro)ah
        Specify the client's ALPN protocol list.

        These protocols are offered to the server during protocol negotiation.

        :param protos: A list of the protocols to be offered to the server.
            This list should be a Python list of bytestrings representing the
            protocols to offer, e.g. ``[b'http/1.1', b'spdy/2']``.
        rpr;csrqrrrrsr�r�r�rvYrwz-Connection.set_alpn_protos.<locals>.<genexpr>r<rN)rzrxrryr7rAr�r��SSL_set_alpn_protosr�rBr{r�r�r�r~Es��zConnection.set_alpn_protoscCsHt�d�}t�d�}t�|j||�|sdSt�|d|d�dd�S)z�
        Get the protocol that was negotiated by ALPN.

        :returns: A bytestring of the protocol name.  If no protocol has been
            negotiated yet, returns an empty bytestring.
        rdzunsigned int *r;rN)r7rAr��SSL_get0_alpn_selectedr�r=)rr\�data_lenr�r�r��get_alpn_proto_negotiatedhs

z$Connection.get_alpn_proto_negotiatedcCs t�|j�}|s
dSt�|j�S)z�
        Get the SRTP protocol which was negotiated.

        :returns: A bytestring of the SRTP profile name. If no profile has been
            negotiated yet, returns an empty bytestring.
        r;)r��SSL_get_selected_srtp_profiler�r7rr�)r�profiler�r�r��get_selected_srtp_profilezsz$Connection.get_selected_srtp_profilecCs t�|jtj�}t|dk�dS)a
        Called to request that the server sends stapled OCSP data, if
        available. If this is not called on the client side then the server
        will not send OCSP data. Should be used in conjunction with
        :meth:`Context.set_ocsp_client_callback`.
        rN)r��SSL_set_tlsext_status_typer��TLSEXT_STATUSTYPE_ocspr�)rr�r�r�r��request_ocsp�s�zConnection.request_ocspr)r)NNr)br�r�r�rr%r��MutableMappingrr�r~rr�rr�r�rgr�r�r�r?r�r9rrrr�rr�r�r�r�r�r��writer�r��readr��NoReturnr�r�r�rhr�r�r�rrrr
r	r
rrrrr
r4rr$r&rWr[r(r+r-r5r7r9rArBrErG�staticmethodrLrPrRrTrVr
rr}r\r^r	rardrgrlrorqrsrur�r~ryr|rr�r�r�r�rs�
����
�<7
���
�		����
�*
	


		����
� 	
	
	
		�
�#
"
)�r�r�r�r�r�	functoolsrr�	itertoolsrr�sysrrr	r
rrr
r�weakrefr�
OpenSSL._utilrr�r�_exception_from_error_queuerr7rr�r�_make_assertrr�rr�rr�OpenSSL.cryptorrrrrrr�__all__rrgr�r%r&r'r(r)r r!r"r#r$�SSL_SENT_SHUTDOWNr*�SSL_RECEIVED_SHUTDOWNr+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:�SSL_OP_NO_SSLv2r;�SSL_OP_NO_SSLv3r<�SSL_OP_NO_TLSv1r=�SSL_OP_NO_TLSv1_1r>�SSL_OP_NO_TLSv1_2r?�SSL_OP_NO_TLSv1_3r�r'r��SSL_MODE_RELEASE_BUFFERSr@�SSL_OP_SINGLE_DH_USErA�SSL_OP_SINGLE_ECDH_USErB�SSL_OP_EPHEMERAL_RSArC�SSL_OP_MICROSOFT_SESS_ID_BUGrD�SSL_OP_NETSCAPE_CHALLENGE_BUGrE�'SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUGrF�"SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUGrG�!SSL_OP_MICROSOFT_BIG_SSLV3_BUFFERrH�SSL_OP_MSIE_SSLV2_RSA_PADDINGrI�SSL_OP_SSLEAY_080_CLIENT_DH_BUGrJ�SSL_OP_TLS_D5_BUGrK�SSL_OP_TLS_BLOCK_PADDING_BUGrL�"SSL_OP_DONT_INSERT_EMPTY_FRAGMENTSrM�SSL_OP_CIPHER_SERVER_PREFERENCErN�SSL_OP_TLS_ROLLBACK_BUGrO�SSL_OP_PKCS1_CHECK_1rP�SSL_OP_PKCS1_CHECK_2rQ�SSL_OP_NETSCAPE_CA_DN_BUGrR�&SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUGrS�SSL_OP_NO_COMPRESSIONrT�SSL_OP_NO_QUERY_MTUrU�SSL_OP_COOKIE_EXCHANGErV�SSL_OP_NO_TICKETrW�SSL_OP_NO_RENEGOTIATIONr��SSL_OP_IGNORE_UNEXPECTED_EOFr��SSL_OP_LEGACY_SERVER_CONNECTr��
SSL_OP_ALLrX�SSL_VERIFY_PEERrY�SSL_VERIFY_FAIL_IF_NO_PEER_CERTrZ�SSL_VERIFY_CLIENT_ONCEr[�SSL_VERIFY_NONEr\�SSL_SESS_CACHE_OFFr]�SSL_SESS_CACHE_CLIENTr^�SSL_SESS_CACHE_SERVERr_�SSL_SESS_CACHE_BOTHr`�SSL_SESS_CACHE_NO_AUTO_CLEARra�!SSL_SESS_CACHE_NO_INTERNAL_LOOKUPrb� SSL_SESS_CACHE_NO_INTERNAL_STORErc�SSL_SESS_CACHE_NO_INTERNALrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtr�r�r{r�r?rSrprhrvrlrar�r9r�r�r�r�r�r&rurr�rvrwrxryrzr
rr:rUrcrnrrr}r�r|r�r��Cryptography_HAS_ALPNr�ryr�r}r~rr�r�r�r��<module>sx
$$
f�
�
�������k	�
(=C;	 ��P
@ Telegram