File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/OpenSSL.tar
Back
__pycache__/SSL.cpython-310.pyc 0000644 00000260035 15030415060 0012116 0 ustar 00 o �hh� � @ s" U d dl Z d dlZd dlZd dlmZ d dlmZmZ d dlm Z m Z d dl m Z d dlm Z mZmZmZmZmZmZ d dlmZ d dlmZ d d lmZ d d lmZ d d lm Z d d lm Z d d lm!Z" d dlm#Z$ d dlm%Z& d dl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. g d�Z/e j0Z0e1e2d< e j3Z3e1e2d< e j4Z4e1e2d< e j5Z5e1e2d< e j6Z6e1e2d< e j7Z7e1e2d< e3Z8e4Z9e5Z:e6Z;e7Z<e j=Z>e j?Z@dZAdZBdZCdZDd ZEd ZFd ZGd ZHd ZId!ZJe jKZKe1e2d"< e jLZLe1e2d#< e jMZMe1e2d$< e jNZNe1e2d%< e jOZOe1e2d&< e jPZQe1e2d'< e jRZSe1e2d(< e jTZUe1e2d)< e jVZWe1e2d*< e jXZYe1e2d+< ze jZZ[e1e2d,< e/�\d,� W n e]�y3 Y nw e j^Z_e1e2d-< e j`Zae1e2d.< e jbZce1e2d/< e jdZee1e2d0< e jfZge1e2d1< e jhZie1e2d2< e jjZke1e2d3< e jlZme1e2d4< e jnZoe1e2d5< e jpZqe1e2d6< e jrZse1e2d7< e jtZue1e2d8< e jvZwe1e2d9< e jxZye1e2d:< e jzZ{e1e2d;< e j|Z}e1e2d<< e j~Ze j�Z�e1e2d=< e j�Z�e1e2d>< e j�Z�e1e2d?< e j�Z�e1e2d@< e j�Z�e1e2dA< e j�Z�e1e2dB< e j�Z�e1e2dC< ze j�Z�e1e2dD< e/�\dD� W n e]�y� Y nw ze j�Z�e1e2dE< e/�\dE� W n e]�y Y nw ze j�Z�e1e2dF< e/�\dF� W n e]�y" Y nw e j�Z�e1e2dG< e j�Z�e1e2dH< e j�Z�e1e2dI< e j�Z�e1e2dJ< e j�Z�e1e2dK< e j�Z�e1e2dL< e j�Z�e1e2dM< e j�Z�e1e2dN< e j�Z�e1e2dO< e j�Z�e1e2dP< e j�Z�e1e2dQ< e j�Z�e1e2dR< e j�Z�e1e2dS< e j�Z�e1e2dT< e j�Z�e1e2dU< e j�Z�e1e2dV< e j�Z�e1e2dW< e j�Z�e1e2dX< e j�Z�e1e2dY< e j�Z�e1e2dZ< e j�Z�e1e2d[< e j�Z�e1e2d\< e j�Z�e1e2d]< e j�Z�e1e2d^< e j�Z�e1e2d_< e j�Z�e1e2d`< e j�Z�e1e2da< e j�Z�e1e2db< e j�Z�e1e2dc< edd�Z�G dedf� df�Z�e�� Z�edgej�ee� e�f gdf Z�edgge�f Z�edge�ge�f Z�edge�ee� ge�f Z�edgee� ge�f Z�ee1e�ee� ge�f Z�edge)e1e1e1ge�f Z�G dhdi� di�Z�g dj�Z�dkgZ�dlZ�dmZ�G dndo� doeЃZ�eeeуZ�e eуZ�G dpdq� dqeуZ�G drds� dseуZ�G dtdu� dueуZ�G dvdw� dweуZ�G dxdy� dyeуZ�G dzd{� d{�Z�G d|d}� d}eكZ�G d~d� deكZ�G d�d�� d�eكZ�G d�d�� d�eكZ�G d�d�� d�eكZ�G d�d�� d�eكZ�d�e d�e1fd�d��Z�d�e1d�e�fd�d��Z�e�Z�d�e1d�e�d�ee�ge�f fd�d��Z�e�e j�d��Z�e�e�e d�d �d��Z�G d�d�� d��Z�G d�d�� d��Z�G d�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�X509VerificationCodesr r% r& r' r( r) � � � � � � � � � � r6 r7 r8 r9 r: r; r< r= r> r? � OP_NO_TLSv1_3r@ rA rB rC rD rE rF rG rH rI rJ rK rL rM rN rO rQ rR rS rT rU rV rW �OP_NO_RENEGOTIATION�OP_IGNORE_UNEXPECTED_EOF�OP_LEGACY_SERVER_CONNECTrX rY rZ r[ r\ r] r^ r_ r` ra rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt �_Tc @ � e Zd ZdS )�_NoOverlappingProtocolsN��__name__� __module__� __qualname__� r� r� �A/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/SSL.pyr� � r� r c @ sf e Zd ZdZejZejZej Z ej Z ej ZejZejZejZejZejZejZejZ ej Z ej Z 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 @ s e Zd ZdZdS )ru z4 An error occurred in an `OpenSSL.SSL` API. N)r� r� r� r� r� r� r� r� ru � s ru c @ r� )rv Nr� r� r� r� r� rv � r� rv c @ r� )rw Nr� r� r� r� r� rw � r� rw c @ r� )rx Nr� r� r� r� r� rx � r� rx c @ r� )ry Nr� r� r� r� r� ry � r� ry c @ r� )rz Nr� r� r� r� r� rz � r� rz c @ s$ e Zd ZdZddd�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. �returnNc C s g | _ d S �N)� _problems��selfr� r� r� �__init__� s z!_CallbackExceptionHelper.__init__c C s4 | j rzt� W n ty Y nw | j �d��dS )z� Raise an exception from the OpenSSL error queue or that was previously captured whe running a callback. r N)r �_raise_current_errorru �popr r� r� r� �raise_if_problem� s � �z)_CallbackExceptionHelper.raise_if_problem�r N)r� r� r� r� r r r� r� r� r� r � s r c @ �" e Zd ZdZdeddfdd�ZdS )� _VerifyHelperz^ Wrap a callback such that it can be used as a certificate verification callback. �callbackr Nc �2 t ��� t� �� �fdd��}t�d|��_d S )Nc s� t �|�}t �|� t�|�}t �|�}t �|�}t �� }t �||�}t j | }z � ||||| �} W n t yK } z �j � | � W Y d } ~ dS d } ~ ww | rWt �|t j� dS dS �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�r r r� r� �wrapper� s* � ��z'_VerifyHelper.__init__.<locals>.wrapperz int (*)(int, X509_STORE_CTX *)�r r r �_ffir �r r r5 r� r4 r� r � s �z_VerifyHelper.__init__)r� r� r� r� �_VerifyCallbackr r� r� r� r� r � s r c @ r )�_ALPNSelectHelperzQ Wrap a callback such that it can be used as an ALPN selection callback. r r Nc r )Nc s zpt j| }t�||�d d � }g }|r/|d } |d| d � } |�| � || d d � }|s� ||�} d} | tu r?d} d} n t| t�sHtd��t� dt | ��t� d| �g|_ |j d d |d< |j d |d< | smt j W S t jW S ty� } z�j�| � t jW Y d } ~ S d } ~ ww ) Nr r T� Fz^ALPN callback must return a bytestring or the special NO_OVERLAPPING_PROTOCOLS sentinel value.zunsigned char *�unsigned char[])r r% 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_acceptedr3 r4 r� r� r5 s@ � � � ��z+_ALPNSelectHelper.__init__.<locals>.wrapperz^int (*)(SSL *, unsigned char **, unsigned char *, const unsigned char *, unsigned int, void *)r6 r8 r� r4 r� r s + �z_ALPNSelectHelper.__init__)r� r� r� r� �_ALPNSelectCallbackr r� r� r� r� r: s r: c @ �& e Zd ZdZdee ddfdd�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. r r Nc r )Nc s� zBt j| }|tjkrt�|�}nd }� ||�}t|t�s!td��|s&W dS t|�}t � |�}|t� ||�d d �< t � | ||� W dS t y[ } z �j�|� W Y d }~dS d }~ww )Nz'OCSP callback must return a bytestring.r� r � )r r% r7 �NULL� from_handler> r? r@ rB r� �OPENSSL_mallocr= � SSL_set_tlsext_status_ocsp_respr& r r' )r0 �cdatarL �data� ocsp_data�ocsp_data_length�data_ptrr3 r4 r� r� r5 ` s, � ��z3_OCSPServerCallbackHelper.__init__.<locals>.wrapper�int (*)(SSL *, void *)r6 r8 r� r4 r� r ] s &z"_OCSPServerCallbackHelper.__init__)r� r� r� r� �_OCSPServerCallbackr r r� r� r� r� rU G � rU c @ 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. r r Nc r )Nc s� z=t j| }|tjkrt�|�}nd }t�d�}t�| |�}|dk r%d}n t�|d |�d d � }� |||�}t t |��W S t yV } z �j � |� W Y d }~dS d }~ww )N�unsigned char **r r; ���)r r% r7 rW rX rA r� � SSL_get_tlsext_status_ocsp_respr= �int�boolr& r r' ) r0 r[ rL r\ �ocsp_ptr�ocsp_lenr] �validr3 r4 r� r� r5 � s" ��z3_OCSPClientCallbackHelper.__init__.<locals>.wrapperr` r6 r8 r� r4 r� r � s z"_OCSPClientCallbackHelper.__init__)r� r� r� r� �_OCSPClientCallbackr r r� r� r� r� rc � rb rc c @ � e Zd Zdeddfdd�ZdS )� _CookieGenerateCallbackHelperr r Nc r )Nc sh zt j| }� |�}||dt|��< t|�|d< W dS ty3 } z �j�|� W Y d }~dS d }~ww r )r r% rB r& r r' )r0 rG rH rL �cookier3 r4 r� r� r5 � s ��z7_CookieGenerateCallbackHelper.__init__.<locals>.wrapperz/int (*)(SSL *, unsigned char *, unsigned int *)r6 r8 r� r4 r� r � s �z&_CookieGenerateCallbackHelper.__init__)r� r� r� �_CookieGenerateCallbackr r� r� r� r� rn � � rn c @ rm )�_CookieVerifyCallbackHelperr r Nc r )Nc sV zt j| }� |t|d|� ��W S ty* } z �j�|� W Y d }~dS d }~ww �Nr )r r% r? r& r r' )r0 �c_cookie� cookie_lenrL r3 r4 r� r� r5 � s ��z5_CookieVerifyCallbackHelper.__init__.<locals>.wrapperz-int (*)(SSL *, unsigned char *, unsigned int)r6 r8 r� r4 r� r � s �z$_CookieVerifyCallbackHelper.__init__)r� r� r� �_CookieVerifyCallbackr r� r� r� r� rr � rq rr �objr c C sb d }t | t�st| dd �}|d ur|� } t | t�r| }t |t�s$td��|dk r/td|f ��|S )N�filenoz3argument must be an int, or have a fileno() method.r z1file descriptor cannot be a negative integer (%i))r> rg �getattrr@ � ValueError)rw �fd�methr� r� r� �_asFileDescriptor� s �r} �typec C s t �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� s r� �flag�errorc s � �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. c s �st | �� fdd��}|S | S )Nc s t � ��r ��NotImplementedError)�args�kwargs)r� r� r� �explode s z<_make_requires.<locals>._requires_decorator.<locals>.explode)r )�funcr� �r� r� r� r� �_requires_decorator s z+_make_requires.<locals>._requires_decoratorr� )r� r� r� r� r� r� �_make_requires s r� zALPN not available�Cryptography_HAS_KEYLOGzKey logging not availablec @ s e Zd ZU dZeed< 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} 2 s r} c @ s� e Zd ZU dZeejdfeejefe eje fe eje fe ejdfeejdfeejdfeejdfeejdfeejdfi Zejeje ej e g e f e e f f e!d< de ddfdd�Z"de ddfd d �Z#de ddfd d �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/d e0e- d e0e- ddfd d �Z1d!e%ddfd"d#�Z2e3fd!e%d$e ddfd%d&�Z4d'e5ddfd(d)�Z6d*e5ddfd+d,�Z7d�d-d.�Z8e3fd/e%d$e ddfd0d1�Z9d2e:ddfd3d4�Z;d�d5d6�Z<d e=ddfd7d8�Z>d9e=ddfd:d;�Z?d<e ddfd=d>�Z@de fd?d@�ZA d�d<e de eB ddfdAdB�ZCdCe ddfdDdE�ZDde fdFdG�ZEde fdHdI�ZFdJe%ddfdKdL�ZGdMeHddfdNdO�ZIdPe=ddfdQdR�ZJdSeKeL ddfdTdU�ZMdVe5ddfdWdX�ZNdYe ddfdZd[�ZOde fd\d]�ZPde d^e e gdf ddfd_d`�ZQeRde d^e=gdf ddfdadb��ZSde fdcdd�ZTdee ddfdfdg�ZUde eV fdhdi�ZWdje ddfdkdl�ZXd<e ddfdmdn�ZYde d^gdf ddfdodp�ZZdqe=ddfdrds�Z[e\dte0e= ddfdudv��Z]e\de^ddfdwdx��Z_dyej`eaebf dee e ddfdzd{�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�methodr c C s t |t�s td��z | j| \}}W n ty td��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 � |d ur�| � |� | �!|� d S d S )Nzmethod must be an integerzNo such protocol)"r> rg r@ r� �KeyErrorrz �_openssl_assertr7 rW r� � 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)r r� � method_func�version� method_obj�contextr� r� r� r X sL � ���� �zContext.__init__r� c C � t t�| 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. r N)r� r� � SSL_CTX_set_min_proto_versionr� �r r� r� r� r� r� � � �z Context.set_min_proto_versionc C r� )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. r N)r� r� � SSL_CTX_set_max_proto_versionr� r� r� r� r� r� � r� z Context.set_max_proto_version�cafile�capathc C sR |du rt j}nt|�}|du rt j}nt|�}t�| j||�}|s't� dS dS )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)r7 rW � _path_bytesr� � SSL_CTX_load_verify_locationsr� r )r r� r� � load_resultr� r� r� �load_verify_locations� s � �z Context.load_verify_locationsr c s8 t � �dtdtdtdtf� �fdd� �}tt|ddd�S ) N�size�verify�userdatar c s � | |�j �S r )r� )r� r� r� r4 r� r� r5 � s z'Context._wrap_callback.<locals>.wrapperT)� more_args�truncate)r rg rh r r? r r r8 r� r4 r� �_wrap_callback� s "�zContext._wrap_callbackr� c C s@ 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� r r� r� � SSL_CTX_set_default_passwd_cbr� r� )r r r� r� r� r� � set_passwd_cb� s � zContext.set_passwd_cbc C s� t �| j�}t|dk� t�t �� ��d�}t�t �� ��d�}| � ||�sDt�t � � �}t�t � � �}|t krF|t krH| �tt� dS dS dS dS )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� r7 r � 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� c C s t j�|�dupt j�|�duS )zp Check to see if the default cert dir/file environment vars are present. :return: bool N)�os�environ�get)r r� r� r� r� r� r� ! s �zContext._check_env_vars_set� file_path�dir_pathc C sP |D ]}t j�|�r| �|� nq|D ]}t j�|�r%| �d|� dS qdS )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)r r� r� r� r� r� r� r� r� , s � ��z&Context._fallback_default_verify_paths�certfilec C s( t |�}t�| j|�}|st� dS dS )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 )r r� r2 r� r� r� �use_certificate_chain_fileB s � �z"Context.use_certificate_chain_file�filetypec C s< t |�}t|t�s td��t�| j||�}|s t� dS dS )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> rg r@ r� � SSL_CTX_use_certificate_filer� r )r r� r� � use_resultr� r� r� �use_certificate_fileS s � �z Context.use_certificate_filer, c C �4 t |t�s td��t�| j|j�}|st� dS dS �zs Load a certificate from a X509 object :param cert: The X509 object :return: None z cert must be an X509 instanceN)r> r r@ r� �SSL_CTX_use_certificater� �_x509r �r r, r� r� r� r� �use_certificatek � �zContext.use_certificate�certobjc C sH t |t�s td��t�|j�}t�| j|�}|s"t�|� t � dS dS )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> r r@ r� �X509_dupr� � SSL_CTX_add_extra_chain_certr� � X509_freer )r r� �copy� add_resultr� r� r� �add_extra_chain_certz s �z Context.add_extra_chain_certc C s | j d ur | j �t� t� d S r )r� r ru r r r� r� r� �_raise_passphrase_exception� s z#Context._raise_passphrase_exception�keyfilec C s> t |�}t|t�s td��t�| j||�}|s | �� dS dS )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> rg r@ r� �SSL_CTX_use_PrivateKey_filer� r� )r r� r� r� r� r� r� �use_privatekey_file� s � �zContext.use_privatekey_file�pkeyc C s6 t |t�s td��t�| j|j�}|s| �� dS dS �zs Load a private key from a PKey object :param pkey: The PKey object :return: None z pkey must be a PKey instanceN)r> r r@ r� �SSL_CTX_use_PrivateKeyr� �_pkeyr� �r r� r� r� r� r� �use_privatekey� s �zContext.use_privatekeyc C s t �| j�s t� dS dS )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� r r r� r� r� �check_privatekey� s �zContext.check_privatekeyc C s0 t �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� r7 rW �SSL_CTX_set_client_CA_listr� )r r� �ca_listr� r� r� �load_client_ca� s �zContext.load_client_ca�bufc C s* t d|�}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 r r N)r r� r� � SSL_CTX_set_session_id_contextr� rB )r r r� r� r� �set_session_id� s ��zContext.set_session_id�modec C � 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> rg r@ r� � SSL_CTX_set_session_cache_moder� �r r r� r� r� �set_session_cache_mode� s z Context.set_session_cache_modec C � 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� r r� r� r� �get_session_cache_mode� s z Context.get_session_cache_modec C �v t |t�s td��|du r d| _d| _t�| j|tj � dS t |�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. r Nr� ) r> rg r@ r� r� r� �SSL_CTX_set_verifyr� r7 rW r� r r �r r r r� r� r� � set_verify� s zContext.set_verify�depthc C �$ 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> rg r@ r� �SSL_CTX_set_verify_depthr� )r r r� r� r� �set_verify_depth" � zContext.set_verify_depthc C r )z� Retrieve the Context object's verify mode, as set by :meth:`set_verify`. :return: The verify mode )r� �SSL_CTX_get_verify_moder� r r� r� r� �get_verify_mode/ � zContext.get_verify_modec C r )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� r r� r� r� �get_verify_depth8 r zContext.get_verify_depth�dhfilec C st t |�}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 � rr N) r� r� � BIO_new_filer7 rW r r� �BIO_free�PEM_read_bio_DHparams�DH_free�SSL_CTX_set_tmp_dhr� r� )r r �bio�dh�resr� r� r� � load_tmp_dhA s zContext.load_tmp_dh�curvec C s t �| 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)r r+ r� r� r� � set_tmp_ecdhV s zContext.set_tmp_ecdh� cipher_listc C sZ t d|�}t|t�std��tt�| j|�dk� t| d�}|� � g d�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.r N)�TLS_AES_256_GCM_SHA384� TLS_CHACHA20_POLY1305_SHA256�TLS_AES_128_GCM_SHA256)z SSL routines�SSL_CTX_set_cipher_listzno cipher match) r r> r? r@ r� r� r3 r� r �get_cipher_listru )r r/ �tmpconnr� r� r� �set_cipher_listb s � ���zContext.set_cipher_list�certificate_authoritiesc C s� t �� }t|tjk� z4|D ]/}t|t�s tdt|�j � d���t � |j �}t|tjk� t � ||�}|s=t � |� t� qW n tyL t �|� � w t �| 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� r7 rW r> r r@ r~ r� � X509_NAME_dup�_name�sk_X509_NAME_push�X509_NAME_freer r& �sk_X509_NAME_freer r� )r r7 � name_stack�ca_namer� � push_resultr� r� r� �set_client_ca_list� s. �� �� �zContext.set_client_ca_list�certificate_authorityc C �2 t |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 instancer N)r> r r@ r� �SSL_CTX_add_client_CAr� r� r� )r rB r� r� r� r� � add_client_ca� s �zContext.add_client_ca�timeoutc C r )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> rg r@ r� �SSL_CTX_set_timeoutr� )r rF r� r� r� � set_timeout� s zContext.set_timeoutc C r )z� Retrieve session timeout, as set by :meth:`set_timeout`. The default is 300 seconds. :return: The session timeout )r� �SSL_CTX_get_timeoutr� r r� r� r� � get_timeout� r zContext.get_timeoutr c �6 t � �� 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 c s � t j| ||� d S r �r r% )r0 �where� return_code�r r� r� r5 � s z*Context.set_info_callback.<locals>.wrapperz void (*)(const SSL *, int, int)N)r r7 r r� r� �SSL_CTX_set_info_callbackr� r8 r� rO r� �set_info_callback� s �zContext.set_info_callbackc rK )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 c s t �|�}� tj| |� d S r )r7 r r r% )r0 �linerO r� r� r5 s z,Context.set_keylog_callback.<locals>.wrapperz#void (*)(const SSL *, const char *)N)r r7 r r� r� �SSL_CTX_set_keylog_callbackr� r8 r� rO r� �set_keylog_callback� s �zContext.set_keylog_callbackc C � | j S )zw Get the application data (supplied via :meth:`set_app_data()`) :return: The application data �r� r r� r� r� � get_app_data � zContext.get_app_datar\ c C � || _ dS )z� Set the application data (will be returned from get_app_data()) :param data: Any Python object :return: None NrV �r r\ r� r� r� � set_app_data � zContext.set_app_datac C s. t �| j�}|tjkr dS t�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� r7 rW r �__new__�_store)r �store�pystorer� r� r� �get_cert_store s zContext.get_cert_store�optionsc C r )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> rg r@ r� �SSL_CTX_set_optionsr� )r rc r� r� r� � set_options/ � zContext.set_optionsc C r )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> rg r@ r� �SSL_CTX_set_moder� r r� r� r� r� < rf zContext.set_modec rK )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 c s � t j| � dS rs rL )r0 �alertrK rO r� r� r5 V s z7Context.set_tlsext_servername_callback.<locals>.wrapperz int (*)(SSL *, int *, void *)N)r r7 r r� r� �&SSL_CTX_set_tlsext_servername_callbackr� r8 r� rO r� � set_tlsext_servername_callbackI s ��z&Context.set_tlsext_servername_callback�profilesc C s, 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 z profiles must be a byte string.r N)r> r? r@ r� r� �SSL_CTX_set_tlsext_use_srtpr� )r rk r� r� r� �set_tlsext_use_srtpb s �zContext.set_tlsext_use_srtp�protosc C �R |st d��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; c s �" � | ] }t t|�f�|fV qd S r �r? rB ��.0�pr� r� r� � <genexpr>� � � z*Context.set_alpn_protos.<locals>.<genexpr>r< r N) rz �joinr � from_iterabler7 rA r� r� �SSL_CTX_set_alpn_protosr� rB �r rn �protostr� input_strr� r� r� �set_alpn_protosq s � ���zContext.set_alpn_protosc C s, 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� r r� r� �SSL_CTX_set_alpn_select_cbr� r7 rW �r r r� r� r� �set_alpn_select_callback� s �z Context.set_alpn_select_callback�helperc C sh || _ |j| _|du rtj| _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� r r� r7 rW r� � new_handler� � SSL_CTX_set_tlsext_status_cbr� r� � SSL_CTX_set_tlsext_status_arg)r r� r\ �rcr� r� r� �_set_ocsp_callback� s � zContext._set_ocsp_callbackc C � 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)rU r� �r r r\ r� r� r� r� �set_ocsp_server_callback� s z Context.set_ocsp_server_callbackc C r� )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)rc r� r� r� r� r� �set_ocsp_client_callback� s z Context.set_ocsp_client_callbackc C � t |�| _t�| j| jj� d S r )rn r� r� � SSL_CTX_set_cookie_generate_cbr� r r� r� r� r� � set_cookie_generate_callback� � �z$Context.set_cookie_generate_callbackc C r� r )rr r� r� � SSL_CTX_set_cookie_verify_cbr� r r� r� r� r� �set_cookie_verify_callback� r� z"Context.set_cookie_verify_callbackr r )lr� r� r� r� r, r� � TLS_methodr- r7 r. r8 r/ r9 r0 r1 �TLS_server_methodr2 �TLS_client_methodr3 � DTLS_methodr4 �DTLS_server_methodr5 �DTLS_client_methodr� �typing�ClassVar�Dictrg r r r r r� r r� r� �_StrOrBytesPathr� �_PassphraseCallbackr� r r� r� r� �strrh r� r r� r� r r� r r� r� r� r� r r� r r? r r r r r9 r r r r r* r r. r6 r r rA rE rH rJ rQ �_requires_keylogrT rW r[ r rb re r� rj rm �_requires_alpnr~ rS r� �Unionrc rU r� ra r� rl r� rp r� rv r� r� r� r� r� r~ > s< ��"�/ ��� �$� ���� � !0 �� ���� � ��� � ��� �% '� �% � �� � � �%��� � ��� ���� �� � ��r~ c @ s, e Zd ZU e� Zejed f ed< d�de de e j ddfdd�Z de defd d �Zd ed eddfd d�Zde fdd�Zde ddfdd�Zde e fdd�Z d�dede e ddfdd�Zdefdd�Zdeddfd d �Zd eddfd d �Zd!eddfd"d#�Z defd$d%�Z deddfd&d'�Z defd(d)�Z d�d+ed,edefd-d.�Z e Z!d�d+ed,edefd/d0�Z"d�d1ed,e e defd2d3�Z#e#Z$ d�d4ed5e e d,e e defd6d7�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�Z0de1d ef fdLdM�Z2d�dNdO�Z3de e fdPdQ�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 e fdldm�ZBde e fdndo�ZCde e fdpdq�ZD d�dredsede e defdtdu�ZEd\ed]eddfdvdw�ZFde e fdxdy�ZGde e fdzd{�ZHeId|ede8e fd}d~��ZJde e8e fdd��ZKde e8e fd�d��ZLde*fd�d��ZMde*fd�d��ZNd�d�d��ZOd�d�d��ZPde eQ fd�d��ZRd�eQddfd�d��ZSd�eTeeegef de e fd�d��ZUde e fd�d��ZVde e fd�d��ZWde e fd�d��ZXde e fd�d��ZYde e fd�d��ZZde fd�d��Z[defd�d��Z\e]d�e8e ddfd�d���Z^e]defd�d���Z_defd�d��Z`d�d�d��ZadS )�r r% Nr� �socketr c C s t |t�s td��t�|j�}t�|tj�| _ t� | j tj � || _d| _ d| _ |j| _|j| _|j| _|j| _| | j| j < |du rqd| _t�t�� �| _t| jtjk� t�t�� �| _t| jtjk� t�| j | j| j� dS d| _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� r7 r� �SSL_free�_ssl� SSL_set_mode�SSL_MODE_AUTO_RETRYr� rC r� r� r� r� r% �_socket�BIO_new� BIO_s_mem� _into_sslr� rW � _from_ssl� SSL_set_bio� SSL_set_fdr} )r r� r� r0 r� r� r� r� r s6 �zConnection.__init__�namec C s0 | j du rtd| 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 �r r� r� r� r� � __getattr__H s � zConnection.__getattr__r0 r2 c C sj | j jd ur | j j�� | j jd ur| j j�� | j jd ur$| j j�� t�||�}|tjkr2t� �|tj kr:t � �|tj krBt � �|tj krJt� �|tjkr}t�� dkrx|dk rstdkrdt�� d }ntj}|dkrst|t�|���tdd��t� d S |tjkr�t�� dkr�t�� }t�|�}tjr�t |tj k� t� � tdd��t� d S |tj kr�d S t� d S )Nr �win32re zUnexpected EOF) r� r� r r� 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_errorr r7 � getwinerror�errnorz r r� 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)r r0 r2 r� r� � peeked_error�reasonr� r� r� �_raise_ssl_errorT sL � zConnection._raise_ssl_errorc C rU )zh Retrieve the :class:`Context` object associated with this :class:`Connection`. )r� r r� r� r� � get_context� s zConnection.get_contextc C s, 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� )r r� r� r� r� � set_context� s zConnection.set_contextc C s( t �| jt j�}|tjkrdS t�|�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_namer7 rW r r� r� r� r� �get_servername� s � zConnection.get_servernamer r c C r )z� Override the Context object's verification flags for this specific connection. See :py:meth:`Context.set_verify` for details. r Nr� ) r> rg r@ r� r� r� �SSL_set_verifyr� r7 rW r� r r r r� r� r� r � s zConnection.set_verifyc C r )z� Retrieve the Connection object's verify mode, as set by :meth:`set_verify`. :return: The verify mode )r� �SSL_get_verify_moder� r r� r� r� r � r zConnection.get_verify_moder, c C r� r� )r> r r@ r� �SSL_use_certificater� r� r r� r� r� r� r� � r� zConnection.use_certificater� c C s8 t |t�s td��t�| j|j�}|s| j�� dS dS r� ) r> r r@ r� �SSL_use_PrivateKeyr� r� r� r� r� r� r� r� r� � s �zConnection.use_privatekey�mtuc C s t �| 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� )r r� r� r� r� �set_ciphertext_mtu� s z Connection.set_ciphertext_mtuc C s t td�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� r r� r� r� �get_cleartext_mtu� s z Connection.get_cleartext_mtuc C s4 t |t�s td��d|v rtd��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� z name must not contain NUL byteN)r> r? r@ r� �SSL_set_tlsext_host_namer� r� r� r� r� �set_tlsext_host_name s z Connection.set_tlsext_host_namec C r )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� r r� r� r� �pending r zConnection.pendingr r �flagsc C sr t d|�}t�|��%}t|�dkrtd��t�| j|t|��}| �| j|� |W d � S 1 s2w Y dS )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) r r7 � from_bufferrB rz r� � SSL_writer� r� )r r r� r\ r2 r� r� r� �send# s �$�zConnection.sendc C s� t d|�}t�|��0}t|�}d}|r1t�| j|| t|d��}| �| j|� ||7 }||8 }|s|W d � S 1 s=w Y dS )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 r r r� N) r r7 r� rB r� r� r� �minr� )r r r� r\ � left_to_send� total_sentr2 r� r� r� �sendall? s �� $�zConnection.sendall�bufsizc C s` t d|�}|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� r7 r= )r r� r� r r2 r� r� r� �recv\ s zConnection.recvr= �nbytesc C s� |du r 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� ) rB r� r� r� r� r� r� r� r� r� � memoryviewr7 r= )r r= r� r� r r2 r� r� r� � recv_intoo s zConnection.recv_intor' c C sN t �|�r"t �|�r t� �t �|�rt� �t �|�r td��td��t� d S )N�BIO_should_io_specialzunknown bio failure) r� �BIO_should_retry�BIO_should_readrv �BIO_should_writerw r� rz r )r r' r2 r� r� r� �_handle_bio_errors� s z Connection._handle_bio_errorsc C sh | j du r 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> rg r� r� �BIO_readr� r7 r= )r r� r r2 r� r� r� �bio_read� s zConnection.bio_readc C sx t d|�}| jdu rtd��t�|�� }t�| j|t|��}|dkr)| �| j|� |W d � S 1 s5w Y dS )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 r Nr� r ) r r� r@ r7 r� r� � BIO_writerB r� )r r r\ r2 r� r� r� � bio_write� s $�zConnection.bio_writec C s$ | � � stt�| j�dk� dS dS )zv Renegotiate the session. :return: True if the renegotiation can be started, False otherwise r TF)�renegotiate_pendingr� r� �SSL_renegotiater� r r� r� r� � renegotiate� s zConnection.renegotiatec C s t �| 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� �r r2 r� r� r� � do_handshake� s zConnection.do_handshakec C s t �| 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� r r� r� r� r� � � z Connection.renegotiate_pendingc C r )zn Find out the total number of renegotiations. :return: The number of renegotiations. )r� �SSL_total_renegotiationsr� r r� r� r� �total_renegotiations� s z Connection.total_renegotiations�addrc C s t �| 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)r r r� r� r� r � s zConnection.connectc C s | j j}| �� ||�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)r r r r� r� r� r s zConnection.connect_exc C s* | 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� �acceptr r� �set_accept_state)r �clientr rL r� r� r� r s zConnection.acceptc C s� t �� }zt �| j|�}W t �|� nt �|� w | jdur#| j�� | jdur-| j�� |dkr4t� �|dk rA| � | j|� dS dS )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� r r� rv r� )r �bio_addrr2 r� r� r� r ( s �zConnection.DTLSv1_listenc C s< t �d�}t �d�}t�| j||�r |d |d d S dS )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 *r i@B N)r7 rA r� � Cryptography_DTLSv1_get_timeoutr� )r �ptv_sec�ptv_usecr� r� r� �DTLSv1_get_timeoutB s z Connection.DTLSv1_get_timeoutc C s2 t �| j�}|dk r| �| j|� J d��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. r F� unreachable)r� �DTLSv1_handle_timeoutr� r� rh r� r� r� r� r T s z Connection.DTLSv1_handle_timeoutc C s$ | j du r 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� r r� r� r� � bio_shutdownb r zConnection.bio_shutdownc C s: t �| j�}|dk r| �| j|� J d��|dkrdS dS )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). r Fr T)r� � SSL_shutdownr� r� r� r� r� r� �shutdowno s zConnection.shutdownc C sH g }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) r r� �SSL_get_cipher_listr� r7 rW r' r r� )r �ciphers�ir2 r� r� r� r4 � s �zConnection.get_cipher_listc C s~ t �| j�}|tjkr g S g }tt �|��D ]&}t �||�}t �|�}t |tjk� t � t �}t� |t j �|_|�|� 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� r7 rW �range�sk_X509_NAME_num�sk_X509_NAME_valuer9 r� r r^ r� r< r: r' )r �ca_namesr2 r r� r� �pynamer� r� r� �get_client_ca_list� s z Connection.get_client_ca_listr� r� c O s t d��)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� �r r� r� r� r� r� �makefile� s �zConnection.makefilec C rU )zr Retrieve application data as set by :meth:`set_app_data`. :return: The application data rV r r� r� r� rW � rX zConnection.get_app_datar\ c C rY )zg Set application data :param data: The application data :return: None NrV rZ r� r� r� r[ � r\ zConnection.set_app_datac C r )z� Get the shutdown state of the Connection. :return: The shutdown state, a bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN. )r� �SSL_get_shutdownr� r r� r� r� � get_shutdown� r zConnection.get_shutdown�statec C r )z� Set the shutdown state of the Connection. :param state: bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN. :return: None zstate must be an integerN)r> rg r@ r� �SSL_set_shutdownr� )r r) r� r� r� � set_shutdown� s zConnection.set_shutdownc C s t �t�| j��S )z� Retrieve a verbose string detailing the state of the Connection. :return: A string representing the state )r7 r r� �SSL_state_string_longr� r r� r� r� �get_state_string� s zConnection.get_state_stringc C �f t �| j�}|tjkr dS t �| 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 Nr r< ) r� �SSL_get_sessionr� r7 rW �SSL_get_server_randomr� r� r= �r �session�length�outpr� r� r� � server_random� s zConnection.server_randomc C r. )z� Retrieve the random value used with the client hello message. :return: A string representing the state Nr r< ) r� r/ r� r7 rW �SSL_get_client_randomr� r� r= r1 r� r� r� � client_random� s zConnection.client_randomc C sb t �| j�}|tjkr dS t �|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 Nr r< ) r� r/ r� r7 rW �SSL_SESSION_get_master_keyr� r� r= r1 r� r� r� � master_key s zConnection.master_key�label�olenc C sn t d|�}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< r Nr ) r� r7 rW rB r� �SSL_export_keying_materialr� r� r= ) r r: r; r� r4 � context_buf� context_len� use_context�successr� r� r� �export_keying_material s( � z!Connection.export_keying_materialc O s | j j|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� r r% r� r� r� � sock_shutdown4 s zConnection.sock_shutdownc C s. t �| j�}|tjkrt �|� t�|�S dS )za Retrieve the local certificate (if any) :return: The local certificate N)r� �SSL_get_certificater� r7 rW r r r �r r, r� r� r� �get_certificate= s zConnection.get_certificatec C s$ t �| j�}|tjkrt�|�S dS )zi Retrieve the other side's certificate (if any) :return: The peer's certificate N)r� �SSL_get_peer_certificater� r7 rW r r rD r� r� r� �get_peer_certificateI s z Connection.get_peer_certificate� cert_stackc C s` g }t t�| ��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 ) r r� � sk_X509_num� sk_X509_valuer� r7 rW r r r r' )rH r2 r r, r) �pycertr� r� r� �_cert_stack_to_listT s z Connection._cert_stack_to_listc C �$ 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� r7 rW rL �r rH r� r� r� �get_peer_cert_chaind s z Connection.get_peer_cert_chainc C rM )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� r7 rW rL rO r� r� r� �get_verified_chainq s z Connection.get_verified_chainc C r )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� r r� r� r� � want_read� r zConnection.want_readc C r )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� r r� r� r� � want_write� r zConnection.want_writec C � 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� r r� r� r� r � r zConnection.set_accept_statec C rW )z� Set the connection to work in client mode. The handshake will be handled automatically by read/write. :return: None N)r� r r� r r� r� r� r � r z Connection.set_connect_statec C s8 t �| j�}|tjkr dS t�t�}t�|t j�|_ |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� r7 rW r} r^ r� �SSL_SESSION_freer� )r r2 � pysessionr� r� r� � get_session� s zConnection.get_sessionr2 c C rC )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 instancer N)r> r} r@ r� �SSL_set_sessionr� r� r� )r r2 r2 r� r� r� � set_session� s zConnection.set_session�functionc C sR t �dd�}|| j|d�}|dkrdS td|�}|| 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� r N)r7 rA r� r� r= )r r_ �emptyr� r r� r� r� �_get_finished_message� s z Connection._get_finished_messagec C � | � 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 )ra r� �SSL_get_finishedr r� r� r� � get_finished� � zConnection.get_finishedc C rb )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 )ra r� �SSL_get_peer_finishedr r� r� r� �get_peer_finished� re z Connection.get_peer_finishedc C �4 t �| j�}|tjkr dS t�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� r7 rW r �SSL_CIPHER_get_namer� )r �cipherr� r� r� r� �get_cipher_name � zConnection.get_cipher_namec C s( t �| j�}|tjkr dS t �|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� ri r� r7 rW �SSL_CIPHER_get_bits)r rk r� r� r� �get_cipher_bits s zConnection.get_cipher_bitsc C rh )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� ri r� r7 rW r �SSL_CIPHER_get_versionr� )r rk r� r� r� r� �get_cipher_version rm z Connection.get_cipher_versionc C s t �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 )r7 r r� �SSL_get_versionr� r� r� r� r� r� �get_protocol_version_name0 s z$Connection.get_protocol_version_namec C s t �| 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 z Connection.get_protocol_versionrn c C ro )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']``. rp r; c s rq r rr rs r� r� r� rv Y rw z-Connection.set_alpn_protos.<locals>.<genexpr>r< r N) rz rx r ry r7 rA r� r� �SSL_set_alpn_protosr� rB r{ r� r� r� r~ E s � �zConnection.set_alpn_protosc C sH t �d�}t �d�}t�| j||� |sdS t �|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. rd zunsigned int *r; r N)r7 rA r� �SSL_get0_alpn_selectedr� r= )r r\ �data_lenr� r� r� �get_alpn_proto_negotiatedh s z$Connection.get_alpn_proto_negotiatedc C s t �| j�}|s dS t�|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� r7 r r� )r �profiler� r� r� �get_selected_srtp_profilez s z$Connection.get_selected_srtp_profilec C s t �| jt j�}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`. r N)r� �SSL_set_tlsext_status_typer� �TLSEXT_STATUSTYPE_ocspr� )r r� r� r� r� � request_ocsp� s �zConnection.request_ocspr )r )NNr )br� r� r� r r% r� �MutableMappingr r� r~ r r� r r� r� rg r� r� r� r? r� r9 r r r r� r r� r� r� r� r� r� �writer� r� �readr� �NoReturnr� r� r� rh r� r� r� r r r r r r r r r r r r4 r r$ r& rW r[ r( r+ r- r5 r7 r9 rA rB rE rG � staticmethodrL rP rR rT rV r r r} r\ r^ r ra rd rg rl ro rq rs ru r� r~ ry r| r r� r� r� r� r s� ���� �< 7 ��� � ���� �* ���� � � �# " )�r� r� r� r� r � functoolsr r � itertoolsr r �sysr r r r r r r r �weakrefr � OpenSSL._utilr r� r �_exception_from_error_queuer r7 r r� r � _make_assertr r� r r� r r �OpenSSL.cryptor r r r r r r �__all__r rg r� r% r& r' r( r) r r! r" r# r$ �SSL_SENT_SHUTDOWNr* �SSL_RECEIVED_SHUTDOWNr+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: �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_INTERNALrd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt r� r� r{ r� r? rS rp rh rv rl ra r� r9 r� r� r� r� r� r& ru r r� rv rw rx ry rz r r r: rU rc rn rr r} r� r| r� r� �Cryptography_HAS_ALPNr� ry r� r} r~ r r� r� r� r� �<module> sx $ $ f� � �������k � (=C; � � P __pycache__/version.cpython-310.pyc 0000644 00000001202 15030415060 0013127 0 ustar 00 o �h� � @ s6 d Z g d�ZdZdZdZdZdZdZdZd e� �Z d S ) z9 pyOpenSSL - A simple wrapper around the OpenSSL library )� __author__� __copyright__� __email__� __license__� __summary__� __title__�__uri__� __version__z24.2.1� pyOpenSSLzhttps://pyopenssl.org/z0Python wrapper module around the OpenSSL libraryzThe pyOpenSSL developerszcryptography-dev@python.orgzApache License, Version 2.0zCopyright 2001-2024 N) �__doc__�__all__r r r r r r r r � r r �E/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/version.py�<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000001056 15030415060 0013210 0 ustar 00 o �h� � @ sH d Z ddlmZmZ ddlmZmZmZmZm Z m Z m Z m Z g d�Z dS )z9 pyOpenSSL - A simple wrapper around the OpenSSL library � )�SSL�crypto)� __author__� __copyright__� __email__� __license__� __summary__� __title__�__uri__� __version__) r r r r r r r r r r N)�__doc__�OpenSSLr r �OpenSSL.versionr r r r r r r r �__all__� r r �F/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/__init__.py�<module> s ( __pycache__/debug.cpython-310.pyc 0000644 00000002141 15030415060 0012533 0 ustar 00 o �h� � @ s� d dl Z d dlZd dlZd dlZd dlZddlmZ djej ej j � ej j j��d�ej�ejj��d�ee dd�ej ej ejejejejd� Zed krRee� dS dS ) � N� )�versionaA pyOpenSSL: {pyopenssl} cryptography: {cryptography} cffi: {cffi} cryptography's compiled against OpenSSL: {crypto_openssl_compile} cryptography's linked OpenSSL: {crypto_openssl_link} Python's OpenSSL: {python_openssl} Python executable: {python} Python version: {python_version} Platform: {platform} sys.path: {sys_path}�ascii�OPENSSL_VERSIONzn/a) � pyopenssl�crypto_openssl_compile�crypto_openssl_link�python_openssl� cryptography�cffi�python�python_version�platform�sys_path�__main__)�ssl�sysr r � OpenSSL.SSL�OpenSSL� r �format� __version__�_util�ffi�string�lib�OPENSSL_VERSION_TEXT�decode�SSL�SSLeay_version�SSLEAY_VERSION�getattr� executabler �path� _env_info�__name__�print� r' r' �C/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/debug.py�<module> s8 �� � � __pycache__/rand.cpython-310.pyc 0000644 00000002502 15030415060 0012372 0 ustar 00 o �h- � @ s8 d Z ddlmZ dededdfdd�Zdefd d �ZdS ) z* PRNG management routines, thin wrappers. � )�lib�buffer�entropy�returnNc C s: t | t�s td��t |t�std��t�| t| �|� dS )a� Mix bytes from *string* into the PRNG state. The *entropy* argument is (the lower bound of) an estimate of how much randomness is contained in *string*, measured in bytes. For more information, see e.g. :rfc:`1750`. This function is only relevant if you are forking Python processes and need to reseed the CSPRNG after fork. :param buffer: Buffer with random data. :param entropy: The entropy (in bytes) measurement of the buffer. :return: :obj:`None` z buffer must be a byte stringzentropy must be an integerN)� isinstance�bytes� TypeError�int�_lib�RAND_add�len)r r � r �B/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/rand.py�add s r c C s t �� S )z} Check whether the PRNG has been seeded with enough data. :return: 1 if the PRNG is seeded enough, 0 otherwise. )r � RAND_statusr r r r �status" s r )�__doc__� OpenSSL._utilr r r r r r r r r r �<module> s __pycache__/crypto.cpython-310.pyc 0000644 00000247413 15030415060 0013002 0 ustar 00 o �h� � @ s� U d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dlmZ d dlm Z m Z m Z m Z m Z mZmZmZmZmZmZ d dlmZmZ d dlmZmZmZmZm Z d dl m Z d d l m Z! d d l m"Z# d d l m$Z% d d l m&Z' d d l m(Z) d dl m*Z+ d dl m,Z- g d�Z.eej/ej0ej1ej2ej3ej4ej5ej6e j7e j8f Z9ee:e;ef Z<ee;e de;f f Z=e'j>Z?e@eAd< e'jBZCe@eAd< dZDe'jEZFe@eAd< e'jGZHe@eAd< e'jIZJe@eAd< e'jKZLe@eAd< G dd� deM�ZNee#eN�ZOe)eN�ZPde:d e fd d �ZQdwd ee; d e fd d!�ZRd"e d e;fd#d$�ZSd%e d&e;d dfd'd(�ZTd&e;d e fd)d*�ZUd+e d ee; fd,d-�ZVG d.d/� d/�ZWG d0d1� d1�ZXG d2d3� d3�ZYd ed3 fd4d5�ZZd6e:d eYfd7d8�Z[ej\G d9d:� d:��Z]G d;d<� d<�Z^e^Z_ej`e^ead=ebd<d>� G d?d@� d@�ZcecZdej`eceadAebd@d>� G dBdC� dC�ZeG dDdE� dE�ZfG dFdG� dG�ZgG dHdI� dIeM�ZhG dJdK� dK�ZidLe@d e;d eefdMdN�ZjdLe@dOeed e;fdPdQ�ZkdLe@dReXd e;fdSdT�Zl dxdLe@dReXdUee: dVee= d e;f dWdX�ZmG dYdZ� dZ�ZnenZoej`enead[ebdZd>� G d\d]� d]�ZpepZqej`epead[ebd]d>� G d^d_� d_�ZrdLe@d ee:e;f d eXfd`da�Zs dwdLe@d ee:e;f dVee= d eXfdbdc�ZtdLe@ddecd e;fdedf�ZueuZvej`eueadAebdfd>� dLe@d e;d ecfdgdh�ZwewZxej`eweadAebdhd>� dReXdiee:e;f dje:d e;fdkdl�Zyej`eyeadmebdld>� dOeedne;diee:e;f dje:d df dodp�Zzej`ezeadqebdpd>� dLe@dreqd e;fdsdt�Z{e{Z|ej`e{ead[ebdtd>� dLe@d ee:e;f d eqfdudv�Z}e}Z~ej`e}ead[ebdvd>� dS )y� N)� b16encode)�partial)�PathLike) �Any�Callable�Iterable�List�NoReturn�Optional�Sequence�Set�Tuple�Type�Union)�utils�x509)�dsa�ec�ed448�ed25519�rsa)� UNSPECIFIED)� byte_string)�exception_from_error_queue)�ffi)�lib)� make_assert)� path_bytes)�text_to_bytes_and_warn) � FILETYPE_PEM� FILETYPE_ASN1� FILETYPE_TEXT�TYPE_RSA�TYPE_DSA�Error�PKey�get_elliptic_curves�get_elliptic_curve�X509Name� X509Extension�X509Req�X509�X509StoreFlags� X509Store�X509StoreContextError�X509StoreContext�load_certificate�dump_certificate�dump_publickey�dump_privatekey�Revoked�CRL�load_publickey�load_privatekey�dump_certificate_request�load_certificate_request�sign�verify�dump_crl�load_crl.r r i�� r" r# �TYPE_DH�TYPE_ECc @ s e Zd ZdZdS )r$ z7 An error occurred in an `OpenSSL.crypto` API. N)�__name__� __module__� __qualname__�__doc__� rD rD �D/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/crypto.pyr$ w s r$ �where�returnc C s t d| � d���)z� An OpenSSL API failed somehow. Additionally, the failure which was encountered isn't one that's exercised by the test suite so future behavior of pyOpenSSL is now somewhat less predictable. zUnknown z failure)� RuntimeError)rF rD rD rE �_untested_error� s rI �bufferc C sr | du rt �t �� �}t j}nt�d| �}t �|t| ��}|fdtdtdtfdd�}t |tj k� t� ||�}|S )z� Allocate a new OpenSSL memory BIO. Arrange for the garbage collector to clean it up automatically. :param buffer: None or some bytes to use to put into the BIO so that they can be read out. N�char[]�bio�refrG c S s t �| �S �N)�_lib�BIO_free)rL rM rD rD rE �free� � z_new_mem_buf.<locals>.free) rO �BIO_new� BIO_s_memrP �_ffi�new�BIO_new_mem_buf�lenr �_openssl_assert�NULL�gc)rJ rL rQ �datarD rD rE � _new_mem_buf� s r] rL c C s. t �d�}t�| |�}t �|d |�dd� S )zO Copy the contents of an OpenSSL BIO object into a Python byte string. zchar**r N)rU rV rO �BIO_get_mem_datarJ )rL � result_buffer� buffer_lengthrD rD rE �_bio_to_string� s ra �boundary�whenc C s@ t |t�s td��t| tjk� t�| |�}|dkr td��dS )a� The the time value of an ASN1 time object. @param boundary: An ASN1_TIME pointer (or an object safely castable to that type) which will have its value set. @param when: A string representation of the desired time value. @raise TypeError: If C{when} is not a L{bytes} string. @raise ValueError: If C{when} does not represent a time in the required format. @raise RuntimeError: If the time value cannot be set for some other (unspecified) reason. zwhen must be a byte stringr zInvalid stringN) � isinstance�bytes� TypeErrorrY rU rZ rO �ASN1_TIME_set_string� ValueError)rb rc � set_resultrD rD rE �_set_asn1_time� s �rj c C s2 t �� }t|tjk� t�|t j�}t|| � |S )a� Behaves like _set_asn1_time but returns a new ASN1_TIME object. @param when: A string representation of the desired time value. @raise TypeError: If C{when} is not a L{bytes} string. @raise ValueError: If C{when} does not represent a time in the required format. @raise RuntimeError: If the time value cannot be set for some other (unspecified) reason. )rO � ASN1_TIME_newrY rU rZ r[ �ASN1_TIME_freerj )rc �retrD rD rE �_new_asn1_time� s rn � timestampc C s� t �d| �}t�|�dkrdS t�|�tjkr t �t�|��S t �d�}t� | |� |d t j kr7t d� dS t �d|d �}t�|�}t �|�}t� |d � |S )a] Retrieve the time value of an ASN1 time object. @param timestamp: An ASN1_GENERALIZEDTIME* (or an object safely castable to that type) from which the time value will be retrieved. @return: The time value from C{timestamp} as a L{bytes} string in a certain format. Or C{None} if the object contains no time value. � ASN1_STRING*r NzASN1_GENERALIZEDTIME**� ASN1_TIME_to_generalizedtime) rU �castrO �ASN1_STRING_length�ASN1_STRING_type�V_ASN1_GENERALIZEDTIME�string�ASN1_STRING_get0_datarV rq rZ rI �ASN1_GENERALIZEDTIME_free)ro �string_timestamp�generalized_timestamp� string_data� string_resultrD rD rE �_get_asn1_time� s � r} c @ s* e Zd Zd dd�Zd dd�Zd d d �ZdS ) �_X509NameInvalidatorrG Nc C s g | _ d S rN )�_names��selfrD rD rE �__init__ rR z _X509NameInvalidator.__init__�namer( c C s | j �|� d S rN )r �append�r� r� rD rD rE �add s z_X509NameInvalidator.addc C s | j D ]}|`qd S rN )r �_namer� rD rD rE �clear s �z_X509NameInvalidator.clear�rG N�r� r( rG N)r@ rA rB r� r� r� rD rD rD rE r~ s r~ c @ s� e Zd ZdZdZdZddd�Zdefdd �Ze d edd fd d ��Z d e de ddfdd�Z de fdd�Zde fdd�Zde fdd�ZdS )r% zD A class representing an DSA or RSA public key or key pair. FTrG Nc C s" t �� }t�|t j�| _d| _d S )NF)rO � EVP_PKEY_newrU r[ � EVP_PKEY_free�_pkey� _initialized�r� �pkeyrD rD rE r� s z PKey.__init__c C s< ddl m}m} | jrtt| �}||�S tt| �}||d�S )a Export as a ``cryptography`` key. :rtype: One of ``cryptography``'s `key interfaces`_. .. _key interfaces: https://cryptography.io/en/latest/hazmat/ primitives/asymmetric/rsa/#key-interfaces .. versionadded:: 16.1.0 r )�load_der_private_key�load_der_public_keyN)�,cryptography.hazmat.primitives.serializationr� r� � _only_publicr2 r r3 )r� r� r� �derrD rD rE �to_cryptography_key s zPKey.to_cryptography_key� crypto_keyc C s� t |tjtjtjtjtjtj t j t j t jt jf �s td��ddlm}m}m}m} t |tjtjtj t j t jf�rCtt|�|j|j��S |�|j|j |� �}t t|�S )z� Construct based on a ``cryptography`` *crypto_key*. :param crypto_key: A ``cryptography`` key. :type crypto_key: One of ``cryptography``'s `key interfaces`_. :rtype: PKey .. versionadded:: 16.1.0 zUnsupported key typer )�Encoding� NoEncryption� PrivateFormat� PublicFormat) rd r � DSAPrivateKey� DSAPublicKeyr �EllipticCurvePrivateKey�EllipticCurvePublicKeyr �Ed25519PrivateKey�Ed25519PublicKeyr �Ed448PrivateKey�Ed448PublicKeyr � RSAPrivateKey� RSAPublicKeyrf r� r� r� r� r� r6 r � public_bytes�DER�SubjectPublicKeyInfo� private_bytes�PKCS8r7 )�clsr� r� r� r� r� r� rD rD rE �from_cryptography_key3 sF ���� �� � zPKey.from_cryptography_key�type�bitsc C s4 t |t�s td��t |t�std��|tkrQ|dkr td��t�� }t�|tj �}t� |tj � t� � }t� |||tj�}t|dk� t�| j|�}t|dk� nD|tkr�t�� }t|tjk� t�|tj�}t�||tjdtjtjtj�}t|dk� tt�|�dk� tt�| j|�dk� ntd��d| _dS ) a3 Generate a key pair of the given type, with the given number of bits. This generates a key "into" the this object. :param type: The key type. :type type: :py:data:`TYPE_RSA` or :py:data:`TYPE_DSA` :param bits: The number of bits. :type bits: :py:data:`int` ``>= 0`` :raises TypeError: If :py:data:`type` or :py:data:`bits` isn't of the appropriate type. :raises ValueError: If the number of bits isn't an integer of the appropriate size. :return: ``None`` �type must be an integerzbits must be an integerr zInvalid number of bits� zNo such key typeTN)rd �intrf r" rh rO �BN_newrU r[ �BN_free� BN_set_word�RSA_F4�RSA_new�RSA_generate_key_exrZ rY �EVP_PKEY_assign_RSAr� r# �DSA_new�DSA_free�DSA_generate_parameters_ex�DSA_generate_key�EVP_PKEY_set1_DSAr$ r� )r� r� r� �exponentr �resultr �resrD rD rE � generate_keym s6 � zPKey.generate_keyc C sd | j rtd��t�| �� �tjkrtd��t�| j�}t� |tj �}t� |�}|dkr-dS t � dS )ax Check the consistency of an RSA private key. This is the Python equivalent of OpenSSL's ``RSA_check_key``. :return: ``True`` if key is consistent. :raise OpenSSL.crypto.Error: if the key is inconsistent. :raise TypeError: if the key is of a type which cannot be checked. Only RSA keys can currently be checked. zpublic key onlyz'Only RSA keys can currently be checked.r� TN) r� rf rO � EVP_PKEY_typer� � EVP_PKEY_RSA�EVP_PKEY_get1_RSAr� rU r[ �RSA_free� RSA_check_key�_raise_current_error)r� r r� rD rD rE �check� s z PKey.checkc C � t �| j�S )zT Returns the type of the key :return: The type of the key. )rO � EVP_PKEY_idr� r� rD rD rE r� � � z PKey.typec C r� )zh Returns the number of bits of the key :return: The number of bits of the key. )rO � EVP_PKEY_bitsr� r� rD rD rE r� � r� z PKey.bitsr� )r@ rA rB rC r� r� r� �_Keyr� � classmethodr� r� r� �boolr� r� r� rD rD rD rE r% s 98r% c s� e Zd ZdZdZdedef� fdd� Zedede d fdd ��Z edede d fd d ��Z eded e dd fd d��Z ded e deddfdd�Zdefdd�Zdefdd�Z� ZS )�_EllipticCurveaZ A representation of a supported elliptic curve. @cvar _curves: :py:obj:`None` until an attempt is made to load the curves. Thereafter, a :py:type:`set` containing :py:type:`_EllipticCurve` instances each of which represents one curve supported by the system. @type _curves: :py:type:`NoneType` or :py:type:`set` N�otherrG c s t |t�r t� �|�S tS )z� Implement cooperation with the right-hand side argument of ``!=``. Python 3 seems to have dropped this cooperation in this very narrow circumstance. )rd r� �super�__ne__�NotImplemented�r� r� �� __class__rD rE r� � s z_EllipticCurve.__ne__r c s> �� tjd�}t�d|�}�� ||� t� �fdd�|D ��S )z� Get the curves supported by OpenSSL. :param lib: The OpenSSL library binding object. :return: A :py:type:`set` of ``cls`` instances giving the names of the elliptic curves the underlying library supports. r zEC_builtin_curve[]c 3 s � | ] }� � �|j�V qd S rN )�from_nid�nid)�.0�c�r� r rD rE � <genexpr>� s � z7_EllipticCurve._load_elliptic_curves.<locals>.<genexpr>)�EC_get_builtin_curvesrU rZ rV �set)r� r � num_curves�builtin_curvesrD r� rE �_load_elliptic_curves� s z$_EllipticCurve._load_elliptic_curvesc C s | j du r | �|�| _ | j S )a Get, cache, and return the curves supported by OpenSSL. :param lib: The OpenSSL library binding object. :return: A :py:type:`set` of ``cls`` instances giving the names of the elliptic curves the underlying library supports. N)�_curvesr� r� rD rD rE �_get_elliptic_curves� s z#_EllipticCurve._get_elliptic_curvesr� c C s | ||t �|�|���d��S )a� Instantiate a new :py:class:`_EllipticCurve` associated with the given OpenSSL NID. :param lib: The OpenSSL library binding object. :param nid: The OpenSSL NID the resulting curve object will represent. This must be a curve NID (and not, for example, a hash NID) or subsequent operations will fail in unpredictable ways. :type nid: :py:class:`int` :return: The curve object. �ascii)rU rv � OBJ_nid2sn�decode)r� r r� rD rD rE r� s z_EllipticCurve.from_nidr� c C s || _ || _|| _dS )a� :param _lib: The :py:mod:`cryptography` binding instance used to interface with OpenSSL. :param _nid: The OpenSSL NID identifying the curve this object represents. :type _nid: :py:class:`int` :param name: The OpenSSL short name identifying the curve this object represents. :type name: :py:class:`unicode` N)rO �_nidr� )r� r r� r� rD rD rE r� s z_EllipticCurve.__init__c C s d| j �d�S )Nz<Curve �>�r� r� rD rD rE �__repr__) � z_EllipticCurve.__repr__c C s | j �| j�}t�|t j�S )z� Create a new OpenSSL EC_KEY structure initialized to use this curve. The structure is automatically garbage collected when the Python object is garbage collected. )rO �EC_KEY_new_by_curve_namer� rU r[ � EC_KEY_free)r� �keyrD rD rE � _to_EC_KEY, s z_EllipticCurve._to_EC_KEY)r@ rA rB rC r� r r� r� r� r r� r� r� r� �strr� r� r� � __classcell__rD rD r� rE r� � s r� c C s t �t�S )a� Return a set of objects representing the elliptic curves supported in the OpenSSL build in use. The curve objects have a :py:class:`unicode` ``name`` attribute by which they identify themselves. The curve objects are useful as values for the argument accepted by :py:meth:`Context.set_tmp_ecdh` to specify which elliptical curve should be used for ECDHE key exchange. )r� r� rO rD rD rD rE r& 7 s r& r� c C s( t � D ] }|j| kr| S qtd| ��)aT Return a single curve object selected by name. See :py:func:`get_elliptic_curves` for information about curve objects. :param name: The OpenSSL short name identifying the curve object to retrieve. :type name: :py:class:`unicode` If the named curve is not supported then :py:class:`ValueError` is raised. zunknown curve name)r& r� rh )r� �curverD rD rE r' F s � r' c s� e Zd ZdZddd�Zdededdf� fdd � Zdedee fd d �Z d ede fd d�Z d ede fdd�Z defdd�Z defdd�Zdefdd�Zdeeeef fdd�Z� ZS )r( a An X.509 Distinguished Name. :ivar countryName: The country of the entity. :ivar C: Alias for :py:attr:`countryName`. :ivar stateOrProvinceName: The state or province of the entity. :ivar ST: Alias for :py:attr:`stateOrProvinceName`. :ivar localityName: The locality of the entity. :ivar L: Alias for :py:attr:`localityName`. :ivar organizationName: The organization name of the entity. :ivar O: Alias for :py:attr:`organizationName`. :ivar organizationalUnitName: The organizational unit of the entity. :ivar OU: Alias for :py:attr:`organizationalUnitName` :ivar commonName: The common name of the entity. :ivar CN: Alias for :py:attr:`commonName`. :ivar emailAddress: The e-mail address of the entity. r� rG Nc C s t �|j�}t�|t j�| _dS )z� Create a new X509Name, copying the given X509Name instance. :param name: The name to copy. :type name: :py:class:`X509Name` N)rO � X509_NAME_dupr� rU r[ �X509_NAME_freer� rD rD rE r� r s zX509Name.__init__�valuec s |� d�r t� �||�S t|�tur tdt|�jd�d���t�t |��}|tj kr?zt � W t d�� t y> Y t d��w tt�| j��D ]%}t�| j|�}t�|�}t�|�}||krlt�| j|�}t�|� nqGt|t�rw|�d�}t�| j|tj|ddd�}|s�t � d S d S ) N�_z$attribute name must be string, not 'z.200�'�No such attribute�utf-8���r )� startswithr� � __setattr__r� r� rf r@ rO � OBJ_txt2nid� _byte_string� NID_undefr� r$ �AttributeError�range�X509_NAME_entry_countr� �X509_NAME_get_entry�X509_NAME_ENTRY_get_object� OBJ_obj2nid�X509_NAME_delete_entry�X509_NAME_ENTRY_freerd �encode�X509_NAME_add_entry_by_NID� MBSTRING_UTF8) r� r� r� r� �i�ent�ent_obj�ent_nid� add_resultr� rD rE r� | sD �� �� � � �zX509Name.__setattr__c C s� t �t|��}|t jkr!zt� W td�� ty Y td��w t �| j|d�}|dkr/dS t � | j|�}t � |�}t � d�}t � ||�}t|dk� zt �|d |�dd� �d�}W t �|d � |S t �|d � w )a Find attribute. An X509Name object has the following attributes: countryName (alias C), stateOrProvince (alias ST), locality (alias L), organization (alias O), organizationalUnit (alias OU), commonName (alias CN) and more... r� r� N�unsigned char**r r� )rO r� r� r r� r$ r �X509_NAME_get_index_by_NIDr� r �X509_NAME_ENTRY_get_datarU rV �ASN1_STRING_to_UTF8rY rJ r� � OPENSSL_free) r� r� r� � entry_index�entryr\ r_ � data_lengthr� rD rD rE � __getattr__� s0 �� ��zX509Name.__getattr__r� c C s" t |t�stS t�| j|j�dkS �Nr �rd r( r� rO � X509_NAME_cmpr� r� rD rD rE �__eq__� � zX509Name.__eq__c C s" t |t�stS t�| j|j�dk S r r r� rD rD rE �__lt__� r zX509Name.__lt__c C sD t �dd�}t�| j|t|��}t|t jk� d�t � |�� d��S )z6 String representation of an X509Name rK i z<X509Name object '{}'>r� ) rU rV rO �X509_NAME_oneliner� rX rY rZ �formatrv r� )r� r_ � format_resultrD rD rE r� � s ��zX509Name.__repr__c C r� )a& Return an integer representation of the first four bytes of the MD5 digest of the DER representation of the name. This is the Python equivalent of OpenSSL's ``X509_NAME_hash``. :return: The (integer) hash of this name. :rtype: :py:class:`int` )rO �X509_NAME_hashr� r� rD rD rE �hash� � z X509Name.hashc C sN t �d�}t�| j|�}t|dk� t �|d |�dd� }t�|d � |S )z� Return the DER encoding of this name. :return: The DER encoded form of this name. :rtype: :py:class:`bytes` r r N)rU rV rO � i2d_X509_NAMEr� rY rJ r )r� r_ � encode_resultr| rD rD rE r� � s z X509Name.derc C s� g }t t�| j��D ]7}t�| j|�}t�|�}t�|�}t�|�}t�|�}t � t� |�t� |��dd� }|� t �|�|f� q |S )z� Returns the components of this name, as a sequence of 2-tuples. :return: The components of this name. :rtype: :py:class:`list` of ``name, value`` tuples. N)r rO r r� r r r r r� rU rJ rw rs r� rv ) r� r� r r �fname�fvalr� r� r� rD rD rE �get_components s ��zX509Name.get_componentsr� )r@ rA rB rC r� r� r r� r r r� r r r� r� r$ re r� r r r* r� rD rD r� rE r( X s '( "r( c @ s� e Zd ZU dZ d dedededed ded d df d d �Zed e fd d ��Z e j de j de jdiZejejeef ed< d efdd�Zd efdd�Zd efdd�Zd efdd�Zd efdd�ZdS ) r) z, An X.509 v3 certificate extension. N� type_name�criticalr� �subjectr+ �issuerrG c C s� t �d�}t�|t jt jt jt jd� t�|� |dur)t|t�s%td��|j |_ |dur:t|t�s6td��|j |_ |r@d| }t� t j|||�}|t jkrQt � t �|tj�| _dS )a� Initializes an X509 extension. :param type_name: The name of the type of extension_ to create. :type type_name: :py:data:`bytes` :param bool critical: A flag indicating whether this is a critical extension. :param value: The OpenSSL textual representation of the extension's value. :type value: :py:data:`bytes` :param subject: Optional X509 certificate to use as subject. :type subject: :py:class:`X509` :param issuer: Optional X509 certificate to use as issuer. :type issuer: :py:class:`X509` .. _extension: https://www.openssl.org/docs/manmaster/man5/ x509v3_config.html#STANDARD-EXTENSIONS z X509V3_CTX*r Nz issuer must be an X509 instancez subject must be an X509 instances critical,)rU rV rO �X509V3_set_ctxrZ �X509V3_set_ctx_nodbrd r+ rf �_x509� issuer_cert� subject_cert�X509V3_EXT_nconfr� r[ �X509_EXTENSION_free� _extension)r� r+ r, r� r- r. �ctx� extensionrD rD rE r� s" zX509Extension.__init__c C s t �t �| j��S rN )rO r �X509_EXTENSION_get_objectr6 r� rD rD rE r� e s �zX509Extension._nid�email�DNS�URI� _prefixesc C s� t �dt�| j��}t �|tj�}g }tt�|��D ]I}t� ||�}z| j |j }W n t yF t � }t�||� |�t|��d�� Y qw t �|jjj|jjj�d d � �d�}|�|d | � qd�|�S )NzGENERAL_NAMES*r� �:z, )rU rr rO �X509V3_EXT_d2ir6 r[ �GENERAL_NAMES_freer �sk_GENERAL_NAME_num�sk_GENERAL_NAME_valuer= r� �KeyErrorr] �GENERAL_NAME_printr� ra r� rJ �d�ia5r\ �length�join)r� �names�partsr r� �labelrL r� rD rD rE �_subjectAltNameStringq s* � ��� z#X509Extension._subjectAltNameStringc C sF t j| jkr | �� S t� }t �|| jdd�}t|dk� t|�� d�S )zF :return: a nice text representation of the extension r r� ) rO �NID_subject_alt_namer� rL r] �X509V3_EXT_printr6 rY ra r� )r� rL � print_resultrD rD rE �__str__� s zX509Extension.__str__c C r� )zk Returns the critical field of this X.509 extension. :return: The critical field. )rO �X509_EXTENSION_get_criticalr6 r� rD rD rE � get_critical� r� zX509Extension.get_criticalc C s8 t �| j�}t �|�}t �|�}|tjkrt�|�S dS )z� Returns the short type name of this X.509 extension. The result is a byte string such as :py:const:`b"basicConstraints"`. :return: The short type name. :rtype: :py:data:`bytes` .. versionadded:: 0.12 s UNDEF)rO r9 r6 r r� rU rZ rv )r� �objr� �bufrD rD rE �get_short_name� s z X509Extension.get_short_namec C s@ t �| j�}t�d|�}t �|�}t �|�}t�||�dd� S )z� Returns the data of the X509 extension, encoded as ASN.1. :return: The ASN.1 encoded data of this X509 extension. :rtype: :py:data:`bytes` .. versionadded:: 0.12 rp N)rO �X509_EXTENSION_get_datar6 rU rr rw rs rJ )r� � octet_resultr| � char_result� result_lengthrD rD rE �get_data� s zX509Extension.get_data�NN)r@ rA rB rC re r� r r� �propertyr r� rO � GEN_EMAIL�GEN_DNS�GEN_URIr= �typing�ClassVar�Dictr� r� �__annotations__rL rP rR rU rZ rD rD rD rE r) s8 ������ �E � r) zZX509Extension support in pyOpenSSL is deprecated. You should use the APIs in cryptography.r� c @ s� e Zd ZdZd!dd�Zdejfdd�Zedejdd fd d ��Z d e ddfd d �Z de fdd�Z de ddfdd�Zde fdd�Zdefdd�Zdee ddfdd�Zdee fdd�Zd e d eddfd d �Zd e defd d �ZdS )"r* z0 An X.509 certificate signing requests. rG Nc C s& t �� }t�|t j�| _| �d� d S r )rO � X509_REQ_newrU r[ � X509_REQ_free�_req� set_version)r� �reqrD rD rE r� � s zX509Req.__init__c C � ddl m} tt| �}||�S )z� Export as a ``cryptography`` certificate signing request. :rtype: ``cryptography.x509.CertificateSigningRequest`` .. versionadded:: 17.1.0 r )�load_der_x509_csr)�cryptography.x509rj �"_dump_certificate_request_internalr )r� rj r� rD rD rE �to_cryptography� s zX509Req.to_cryptography� crypto_reqc C �6 t |tj�s td��ddlm} |�|j�}tt |�S )a Construct based on a ``cryptography`` *crypto_req*. :param crypto_req: A ``cryptography`` X.509 certificate signing request :type crypto_req: ``cryptography.x509.CertificateSigningRequest`` :rtype: X509Req .. versionadded:: 17.1.0 z%Must be a certificate signing requestr �r� ) rd r �CertificateSigningRequestrf r� r� r� r� �"_load_certificate_request_internalr )r� rn r� r� rD rD rE �from_cryptography� � zX509Req.from_cryptographyr� c C s t �| j|j�}t|dk� dS )z� Set the public key of the certificate signing request. :param pkey: The public key to use. :type pkey: :py:class:`PKey` :return: ``None`` r� N)rO �X509_REQ_set_pubkeyrf r� rY �r� r� ri rD rD rE � set_pubkey� s zX509Req.set_pubkeyc C sD t �t �}t�| j�|_t|jtjk� t� |jtj �|_d|_ |S )z� Get the public key of the certificate signing request. :return: The public key. :rtype: :py:class:`PKey` T) r% �__new__rO �X509_REQ_get_pubkeyrf r� rY rU rZ r[ r� r� r� rD rD rE � get_pubkey s zX509Req.get_pubkey�versionc C s@ t |t�s td��|dkrtd��t�| j|�}t|dk� dS )z� Set the version subfield (RFC 2986, section 4.1) of the certificate request. :param int version: The version number. :return: ``None`` zversion must be an intr z9Invalid version. The only valid version for X509Req is 0.r� N)rd r� rf rh rO �X509_REQ_set_versionrf rY )r� r{ ri rD rD rE rg s �zX509Req.set_versionc C r� )z� Get the version subfield (RFC 2459, section 4.1.2.1) of the certificate request. :return: The value of the version subfield. :rtype: :py:class:`int` )rO �X509_REQ_get_versionrf r� rD rD rE � get_version) s zX509Req.get_versionc C s2 t �t �}t�| j�|_t|jtjk� | |_ |S )a� Return the subject of this certificate signing request. This creates a new :class:`X509Name` that wraps the underlying subject name field on the certificate signing request. Modifying it will modify the underlying signing request, and will have the effect of modifying any other :class:`X509Name` that refers to this subject. :return: The subject of this certificate signing request. :rtype: :class:`X509Name` ) r( rx rO �X509_REQ_get_subject_namerf r� rY rU rZ �_ownerr� rD rD rE � get_subject3 s zX509Req.get_subject� extensionsc C sl t �� }t|tjk� t�|t j�}|D ]}t|t�s t d��t � ||j � qt � | j |�}t|dk� dS )z� Add extensions to the certificate signing request. :param extensions: The X.509 extensions to add. :type extensions: iterable of :py:class:`X509Extension` :return: ``None`` �+One of the elements is not an X509Extensionr� N)rO �sk_X509_EXTENSION_new_nullrY rU rZ r[ �sk_X509_EXTENSION_freerd �_X509ExtensionInternalrh �sk_X509_EXTENSION_pushr6 �X509_REQ_add_extensionsrf )r� r� �stack�extr rD rD rE �add_extensionsI s zX509Req.add_extensionsc C sn g }t �| j�}t�|dd� �}tt �|��D ] }t�t�}t � t � ||��}t�|t j �|_ |� |� q|S )z� Get X.509 extensions in the certificate signing request. :return: The X.509 extensions in this request. :rtype: :py:class:`list` of :py:class:`X509Extension` objects. .. versionadded:: 0.15 c S s t �| t�t jd��S )Nr5 )rO �sk_X509_EXTENSION_pop_freerU � addressof� _original_lib)�xrD rD rE �<lambda>o s �z(X509Req.get_extensions.<locals>.<lambda>)rO �X509_REQ_get_extensionsrf rU r[ r �sk_X509_EXTENSION_numr� rx �X509_EXTENSION_dup�sk_X509_EXTENSION_valuer5 r6 r� )r� �exts�native_exts_objr r� r8 rD rD rE �get_extensionsb s � � zX509Req.get_extensions�digestc C s^ |j rtd��|jstd��t�t|��}|tjkr td��t�| j |j |�}t |dk� dS )aa Sign the certificate signing request with this key and digest type. :param pkey: The key pair to sign with. :type pkey: :py:class:`PKey` :param digest: The name of the message digest to use for the signature, e.g. :py:data:`"sha256"`. :type digest: :py:class:`str` :return: ``None`` zKey has only public part�Key is uninitialized�No such digest methodr N) r� rh r� rO �EVP_get_digestbynamer� rU rZ � X509_REQ_signrf r� rY )r� r� r� � digest_obj� sign_resultrD rD rE r: ~ s z X509Req.signc C s4 t |t�s td��t�| j|j�}|dkrt� |S )a@ Verifies the signature on this certificate signing request. :param PKey key: A public key. :return: ``True`` if the signature is correct. :rtype: bool :raises OpenSSL.crypto.Error: If the signature is invalid or there is a problem verifying the signature. � pkey must be a PKey instancer )rd r% rf rO �X509_REQ_verifyrf r� r� )r� r� r� rD rD rE r; � s zX509Req.verifyr� )r@ rA rB rC r� r rq rm r� rs r% rw rz r� rg r~ r( r� r r� r� r r� r� r: r� r; rD rD rD rE r* � s. � � � � r* zPCSR support in pyOpenSSL is deprecated. You should use the APIs in cryptography.c @ sH e Zd ZdZdTdd�Zededd fdd��Zdej fd d �Z ed ej dd fd d ��Z de ddfdd�Z de fdd�Zdefdd�Zdeddfdd�Zdededdfdd�Zdefdd �Zd edefd d �Zdefd d!�Zd"e ddfd#d$�Zde fd%d&�Zd'e ddfd(d)�Zd'e ddfd*d+�Zde fd,d-�Z d.ede e fd/d0�Z de e fd1d2�Z d.e!d3ef d4eddfd5d6�Z"d4eddfd7d8�Z#de e fd9d:�Z$d4eddfd;d<�Z%d.ede&fd=d>�Z'd.ed?e&ddfd@dA�Z(de&fdBdC�Z)dDe&ddfdEdF�Z*de&fdGdH�Z+dIe&ddfdJdK�Z,de fdLdM�Z-dNe.e/ ddfdOdP�Z0dQe de/fdRdS�Z1dS )Ur+ z An X.509 certificate. rG Nc C s: t �� }t|tjk� t�|t j�| _t� | _ t� | _ d S rN ) rO �X509_newrY rU rZ r[ � X509_freer1 r~ �_issuer_invalidator�_subject_invalidator)r� r rD rD rE r� � s z X509.__init__r c C s. | � | �}t�|tj�|_t� |_t� |_|S rN ) rx rU r[ rO r� r1 r~ r� r� )r� r �certrD rD rE �_from_raw_x509_ptr� s zX509._from_raw_x509_ptrc C ri )z� Export as a ``cryptography`` certificate. :rtype: ``cryptography.x509.Certificate`` .. versionadded:: 17.1.0 r )�load_der_x509_certificate)rk r� r1 r )r� r� r� rD rD rE rm � � zX509.to_cryptography� crypto_certc C ro )z� Construct based on a ``cryptography`` *crypto_cert*. :param crypto_key: A ``cryptography`` X.509 certificate. :type crypto_key: ``cryptography.x509.Certificate`` :rtype: X509 .. versionadded:: 17.1.0 zMust be a certificater rp ) rd r � Certificaterf r� r� r� r� r0 r )r� r� r� r� rD rD rE rs � s zX509.from_cryptographyr{ c C s, t |t�s td��tt�| j|�dk� dS )a Set the version number of the certificate. Note that the version value is zero-based, eg. a value of 0 is V1. :param version: The version number of the certificate. :type version: :py:class:`int` :return: ``None`` zversion must be an integerr� N)rd r� rf rY rO �X509_set_versionr1 �r� r{ rD rD rE rg � s zX509.set_versionc C r� )z� Return the version number of the certificate. :return: The version number of the certificate. :rtype: :py:class:`int` )rO �X509_get_versionr1 r� rD rD rE r~ � � zX509.get_versionc C sF t �t �}t�| j�|_|jtjkrt� t� |jtj �|_d|_ |S )z{ Get the public key of the certificate. :return: The public key. :rtype: :py:class:`PKey` T) r% rx rO �X509_get_pubkeyr1 r� rU rZ r� r[ r� r� r� rD rD rE rz s zX509.get_pubkeyr� c C s2 t |t�s td��t�| j|j�}t|dk� dS )z� Set the public key of the certificate. :param pkey: The public key. :type pkey: :py:class:`PKey` :return: :py:data:`None` r� r� N)rd r% rf rO �X509_set_pubkeyr1 r� rY rv rD rD rE rw s zX509.set_pubkeyr� c C sp t |t�s td��|jrtd��|jstd��t�t|��}|t j kr'td��t� | j |j |�}t|dk� dS )a Sign the certificate with this key and digest type. :param pkey: The key to sign with. :type pkey: :py:class:`PKey` :param digest: The name of the message digest to use. :type digest: :py:class:`str` :return: :py:data:`None` r� zKey only has public partr� r� r N)rd r% rf r� rh r� rO r� r� rU rZ � X509_signr1 r� rY )r� r� r� �evp_mdr� rD rD rE r: & s z X509.signc C sZ t �| j�}t�d�}t �|tjtj|� t �|d �}|t jkr%t d��t� t � |��S )z� Return the signature algorithm used in the certificate. :return: The name of the algorithm. :rtype: :py:class:`bytes` :raises ValueError: If the signature algorithm is undefined. .. versionadded:: 0.13 zASN1_OBJECT **r z Undefined signature algorithm) rO �X509_get0_tbs_sigalgr1 rU rV �X509_ALGOR_get0rZ r r rh rv � OBJ_nid2ln)r� �sig_alg�algr� rD rD rE �get_signature_algorithmB s z X509.get_signature_algorithm� digest_namec C s� t �t|��}|tjkrtd��t�dt j�}t�dd�}t|�|d< t � | j |||�}t |dk� d� dd� t� ||d �D ��S ) a5 Return the digest of the X509 object. :param digest_name: The name of the digest algorithm to use. :type digest_name: :py:class:`str` :return: The digest of the object, formatted as :py:const:`b":"`-delimited hex pairs. :rtype: :py:class:`bytes` r� �unsigned char[]zunsigned int[]r� r � :c S s g | ]}t |��� �qS rD )r �upper)r� �chrD rD rE � <listcomp>n s ��z X509.digest.<locals>.<listcomp>)rO r� r� rU rZ rh rV �EVP_MAX_MD_SIZErX � X509_digestr1 rY rH rJ )r� r� r� r_ rY � digest_resultrD rD rE r� U s � ��z X509.digestc C r� )z� Return the hash of the X509 subject. :return: The hash of the subject. :rtype: :py:class:`bytes` )rO �X509_subject_name_hashr1 r� rD rD rE �subject_name_hasht r� zX509.subject_name_hash�serialc C s� t |t�s td��t|�dd� }|�d�}t�d�}t�||�}|d tj kr;t� t� | j �|�}|r9t � dS dS t�|d tj �}t�|d � |tj krSt � t�|tj�}t�| j |�}t|dk� dS )z� Set the serial number of the certificate. :param serial: The new serial number. :type serial: :py:class:`int` :return: :py:data`None` zserial must be an integer� Nr� �BIGNUM**r r� )rd r� rf �hexr rU rV rO � BN_hex2bnrZ �ASN1_INTEGER_set�X509_get_serialNumberr1 r� �BN_to_ASN1_INTEGERr� r[ �ASN1_INTEGER_free�X509_set_serialNumberrY )r� r� � hex_serial�hex_serial_bytes� bignum_serial� small_serialri � asn1_serialrD rD rE �set_serial_number} s( � � zX509.set_serial_numberc C sp t �| j�}t �|tj�}z$t �|�}zt�|�}t|d�}|W t � |� W t � |� S t � |� w t � |� w )zx Return the serial number of this certificate. :return: The serial number. :rtype: int � ) rO r� r1 �ASN1_INTEGER_to_BNrU rZ � BN_bn2hexrv r� r r� )r� r� r� r� �hexstring_serialr� rD rD rE �get_serial_number� s � zX509.get_serial_number�amountc C �. t |t�s td��t�| j�}t�||� dS )z� Adjust the time stamp on which the certificate stops being valid. :param int amount: The number of seconds by which to adjust the timestamp. :return: ``None`` �amount must be an integerN)rd r� rf rO �X509_getm_notAfterr1 �X509_gmtime_adj)r� r� �notAfterrD rD rE �gmtime_adj_notAfter� s zX509.gmtime_adj_notAfterc C r� )z� Adjust the timestamp on which the certificate starts being valid. :param amount: The number of seconds by which to adjust the timestamp. :return: ``None`` r� N)rd r� rf rO �X509_getm_notBeforer1 r� )r� r� � notBeforerD rD rE �gmtime_adj_notBefore� s zX509.gmtime_adj_notBeforec C sT | � � }|du r td��|�d�}tj�|d�}tjj}tj�|�jdd�}||k S )z� Check whether the certificate has expired. :return: ``True`` if the certificate has expired, ``False`` otherwise. :rtype: bool Nz Unable to determine notAfterr� z %Y%m%d%H%M%SZ)�tzinfo) � get_notAfterrh r� �datetime�strptime�timezone�utc�now�replace)r� � time_bytes� time_string� not_after�UTC�utcnowrD rD rE � has_expired� s zX509.has_expired�whichc C s t || j��S rN )r} r1 )r� r� rD rD rE �_get_boundary_time� r� zX509._get_boundary_timec C � | � tj�S )a Get the timestamp at which the certificate starts being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :return: A timestamp string, or ``None`` if there is none. :rtype: bytes or NoneType )r� rO r� r� rD rD rE � get_notBefore� � zX509.get_notBefore.rc c C s t || j�|�S rN )rj r1 )r� r� rc rD rD rE �_set_boundary_time� s zX509._set_boundary_timec C � | � tj|�S )z� Set the timestamp at which the certificate starts being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :param bytes when: A timestamp string. :return: ``None`` )r� rO r� �r� rc rD rD rE � set_notBefore� � zX509.set_notBeforec C r� )a Get the timestamp at which the certificate stops being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :return: A timestamp string, or ``None`` if there is none. :rtype: bytes or NoneType )r� rO r� r� rD rD rE r� r� zX509.get_notAfterc C r� )z� Set the timestamp at which the certificate stops being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :param bytes when: A timestamp string. :return: ``None`` )r� rO r� r� rD rD rE � set_notAfter r� zX509.set_notAfterc C s0 t �t �}|| j�|_t|jtjk� | |_|S rN )r( rx r1 r� rY rU rZ r� )r� r� r� rD rD rE � _get_name s zX509._get_namer� c C s0 t |t�s td��|| j|j�}t|dk� d S )Nzname must be an X509Namer� )rd r( rf r1 r� rY )r� r� r� ri rD rD rE � _set_name+ s zX509._set_namec C � | � tj�}| j�|� |S )a� Return the issuer of this certificate. This creates a new :class:`X509Name` that wraps the underlying issuer name field on the certificate. Modifying it will modify the underlying certificate, and will have the effect of modifying any other :class:`X509Name` that refers to this issuer. :return: The issuer of this certificate. :rtype: :class:`X509Name` )r� rO �X509_get_issuer_namer� r� r� rD rD rE � get_issuer1 � zX509.get_issuerr. c C � | � tj|� | j�� dS )z� Set the issuer of this certificate. :param issuer: The issuer. :type issuer: :py:class:`X509Name` :return: ``None`` N)r� rO �X509_set_issuer_namer� r� )r� r. rD rD rE � set_issuerA � zX509.set_issuerc C r� )a� Return the subject of this certificate. This creates a new :class:`X509Name` that wraps the underlying subject name field on the certificate. Modifying it will modify the underlying certificate, and will have the effect of modifying any other :class:`X509Name` that refers to this subject. :return: The subject of this certificate. :rtype: :class:`X509Name` )r� rO �X509_get_subject_namer� r� r� rD rD rE r� M r zX509.get_subjectr- c C r )z� Set the subject of this certificate. :param subject: The subject. :type subject: :py:class:`X509Name` :return: ``None`` N)r� rO �X509_set_subject_namer� r� )r� r- rD rD rE � set_subject] r zX509.set_subjectc C r� )z� Get the number of extensions on this certificate. :return: The number of extensions. :rtype: :py:class:`int` .. versionadded:: 0.12 )rO �X509_get_ext_countr1 r� rD rD rE �get_extension_counti s zX509.get_extension_countr� c C s< |D ]}t |t�s td��t�| j|jd�}|st� qdS )z� Add extensions to the certificate. :param extensions: The extensions to add. :type extensions: An iterable of :py:class:`X509Extension` objects. :return: ``None`` r� r� N)rd r� rh rO � X509_add_extr1 r6 r� )r� r� r� r rD rD rE r� t s ��zX509.add_extensions�indexc C sN t �t �}t�| j|�|_|jtjkrtd��t� |j�}t� |tj �|_|S )a� Get a specific extension of the certificate by index. Extensions on a certificate are kept in order. The index parameter selects which extension will be returned. :param int index: The index of the extension to retrieve. :return: The extension at the specified index. :rtype: :py:class:`X509Extension` :raises IndexError: If the extension index was out of bounds. .. versionadded:: 0.12 z extension index out of bounds) r� rx rO � X509_get_extr1 r6 rU rZ � IndexErrorr� r[ r5 )r� r r� r8 rD rD rE � get_extension� s zX509.get_extensionr� )2r@ rA rB rC r� r� r r� r r� rm rs r� rg r~ r% rz rw r� r: re r� r� r� r� r� r� r� r� r� r r� r� r r� r� r� r� r( r� r� r r r� r r r r� r� r rD rD rD rE r+ � s\ ' �� � � �r+ c @ s� e Zd ZU dZejZeed< ej Z eed< ej Z eed< ej Zeed< ejZeed< ejZeed< ejZeed< ejZeed < ejZeed < ejZeed < d S ) r, a Flags for X509 verification, used to change the behavior of :class:`X509Store`. See `OpenSSL Verification Flags`_ for details. .. _OpenSSL Verification Flags: https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_flags.html � CRL_CHECK� CRL_CHECK_ALL�IGNORE_CRITICAL� X509_STRICT�ALLOW_PROXY_CERTS� POLICY_CHECK�EXPLICIT_POLICY� INHIBIT_MAP�CHECK_SS_SIGNATURE� PARTIAL_CHAINN)r@ rA rB rC rO �X509_V_FLAG_CRL_CHECKr r� rc �X509_V_FLAG_CRL_CHECK_ALLr �X509_V_FLAG_IGNORE_CRITICALr �X509_V_FLAG_X509_STRICTr � X509_V_FLAG_ALLOW_PROXY_CERTSr �X509_V_FLAG_POLICY_CHECKr �X509_V_FLAG_EXPLICIT_POLICYr �X509_V_FLAG_INHIBIT_MAPr � X509_V_FLAG_CHECK_SS_SIGNATUREr �X509_V_FLAG_PARTIAL_CHAINr rD rD rD rE r, � s r, c @ s� e Zd ZdZddd�Zdeddfdd�Zd ed ej f ddfd d �Z d e ddfdd�Z de j ddfdd�Z ddedee ddfdd�ZdS )r- a� An X.509 store. An X.509 store is used to describe a context in which to verify a certificate. A description of a context may include a set of certificates to trust, a set of certificate revocation lists, verification flags and more. An X.509 store, being only a description, cannot be used by itself to verify a certificate. To carry out the actual verification process, see :class:`X509StoreContext`. rG Nc C � t �� }t�|t j�| _d S rN )rO �X509_STORE_newrU r[ �X509_STORE_free�_store�r� �storerD rD rE r� � � zX509Store.__init__r� c C s0 t |t�st� �t�| j|j�}t|dk� dS )a� Adds a trusted certificate to this store. Adding a certificate with this method adds this certificate as a *trusted* certificate. :param X509 cert: The certificate to add to this store. :raises TypeError: If the certificate is not an :class:`X509`. :raises OpenSSL.crypto.Error: If OpenSSL was unhappy with your certificate. :return: ``None`` if the certificate was added successfully. r� N)rd r+ rf rO �X509_STORE_add_certr' r1 rY )r� r� r� rD rD rE �add_cert� s zX509Store.add_cert�crl� _CRLInternalc C s� t |tj�r+ddlm} t|�|j��}t� |t j �}|t j kr#t � t � |tj�}n t |t�r4|j}ntd��tt�| j|�dk� dS )a Add a certificate revocation list to this store. The certificate revocation lists added to a store will only be used if the associated flags are configured to check certificate revocation lists. .. versionadded:: 16.1.0 :param crl: The certificate revocation list to add to this store. :type crl: ``Union[CRL, cryptography.x509.CertificateRevocationList]`` :return: ``None`` if the certificate revocation list was added successfully. r rp zUCRL must be of type OpenSSL.crypto.CRL or cryptography.x509.CertificateRevocationListN)rd r �CertificateRevocationListr� r� r] r� r� rO �d2i_X509_CRL_biorU rZ r� r[ � X509_CRL_freer. �_crlrf rY �X509_STORE_add_crlr' )r� r- r� rL � openssl_crlrD rD rE �add_crl� s �zX509Store.add_crl�flagsc C � t t�| j|�dk� dS )a� Set verification flags to this store. Verification flags can be combined by oring them together. .. note:: Setting a verification flag sometimes requires clients to add additional information to the store, otherwise a suitable error will be raised. For example, in setting flags to enable CRL checking a suitable CRL must be added to the store otherwise an error will be raised. .. versionadded:: 16.1.0 :param int flags: The verification flags to set on this store. See :class:`X509StoreFlags` for available constants. :return: ``None`` if the verification flags were successfully set. r N)rY rO �X509_STORE_set_flagsr' )r� r6 rD rD rE � set_flags s zX509Store.set_flags�vfy_timec C sF t �� }t�|t j�}t �|t�|�� �� t t � | j |�dk� dS )a� Set the time against which the certificates are verified. Normally the current time is used. .. note:: For example, you can determine if a certificate was valid at a given time. .. versionadded:: 17.0.0 :param datetime vfy_time: The verification time to set on this store. :return: ``None`` if the verification time was successfully set. r N) rO �X509_VERIFY_PARAM_newrU r[ �X509_VERIFY_PARAM_free�X509_VERIFY_PARAM_set_time�calendar�timegm� timetuplerY �X509_STORE_set1_paramr' )r� r: �paramrD rD rE �set_time s �zX509Store.set_time�cafile�capathc C sR |du rt j}nt|�}|du rt j}nt|�}t�| j||�}|s't� dS dS )a� Let X509Store 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 *cafile* or *capath* may be ``None``. .. note:: Both *cafile* and *capath* may be set simultaneously. Call this method multiple times to add more than one location. For example, CA certificates, and certificate revocation list bundles may be passed in *cafile* in subsequent calls to this method. .. versionadded:: 20.0 :param cafile: In which file we can find the certificates (``bytes`` or ``unicode``). :param capath: In which directory we can find the certificates (``bytes`` or ``unicode``). :return: ``None`` if the locations were set successfully. :raises OpenSSL.crypto.Error: If both *cafile* and *capath* is ``None`` or the locations could not be set for any reason. N)rU rZ � _path_bytesrO �X509_STORE_load_locationsr' r� )r� rD rE � load_resultrD rD rE �load_locations1 s !� �zX509Store.load_locationsr� rN )r@ rA rB rC r� r+ r, r r r/ r5 r� r9 r� rC �StrOrBytesPathr rI rD rD rD rE r- � s& � �$����r- c s6 e Zd ZdZdedee deddf� fdd� Z� Z S ) r. z� An exception raised when an error occurred while verifying a certificate using `OpenSSL.X509StoreContext.verify_certificate`. :ivar certificate: The certificate which caused verificate failure. :type certificate: :class:`X509` �message�errors� certificaterG Nc s t � �|� || _|| _d S rN )r� r� rL rM )r� rK rL rM r� rD rE r� l s z X509StoreContextError.__init__) r@ rA rB rC r� r r r+ r� r� rD rD r� rE r. c s ����r. c @ s� e Zd ZdZ ddededeee ddfdd�Ze d eee ddfd d ��Z e d e de fd d��Z de fdd�Zdeddfdd�Zddd�Zdee fdd�ZdS )r/ a9 An X.509 store context. An X.509 store context is used to carry out the actual verification process of a certificate in a described context. For describing such a context, see :class:`X509Store`. :param X509Store store: The certificates which will be trusted for the purposes of any verifications. :param X509 certificate: The certificate to be verified. :param chain: List of untrusted certificates that may be used for building the certificate chain. May be ``None``. :type chain: :class:`list` of :class:`X509` Nr) rM �chainrG c C s || _ || _| �|�| _d S rN )r' �_cert�_build_certificate_stack�_chain)r� r) rM rN rD rD rE r� � s zX509StoreContext.__init__� certificatesc C s� dt dd fdd�}| d u st| �dkrtjS t�� }t|tjk� t�||�}| D ]'}t|t �s4t d��tt� |j �dk� t� ||j �dkrPt�|j � t� q)|S )N�srG c S s8 t t�| ��D ] }t�| |�}t�|� qt�| � d S rN )r rO � sk_X509_num� sk_X509_valuer� � sk_X509_free)rS r r� rD rD rE �cleanup� s z:X509StoreContext._build_certificate_stack.<locals>.cleanupr z+One of the elements is not an X509 instance)r rX rU rZ rO �sk_X509_new_nullrY r[ rd r+ rf � X509_up_refr1 � sk_X509_pushr� r� )rR rW r� r� rD rD rE rP � s �z)X509StoreContext._build_certificate_stack� store_ctxc C s\ t �t�t�| ����d�}t�| �t�| �|g}t�| �}t�|�}t � |�}t |||�S )z� Convert an OpenSSL native context error failure into a Python exception. When a call to native OpenSSL X509_verify_cert fails, additional information about the failure can be obtained from the store context. r� ) rU rv rO � X509_verify_cert_error_string�X509_STORE_CTX_get_errorr� � X509_STORE_CTX_get_error_depth� X509_STORE_CTX_get_current_cert�X509_dupr+ r� r. )r[ rK rL r1 rO �pycertrD rD rE �_exception_from_context� s ���� z(X509StoreContext._exception_from_contextc C sj t �� }t|tjk� t�|t j�}t �|| jj| j j | j �}t|dk� t � |�}|dkr3| � |��|S )a3 Verifies the certificate and runs an X509_STORE_CTX containing the results. :raises X509StoreContextError: If an error occurred when validating a certificate in the context. Sets ``certificate`` attribute to indicate which certificate caused the error. r� r )rO �X509_STORE_CTX_newrY rU rZ r[ �X509_STORE_CTX_free�X509_STORE_CTX_initr' rO r1 rQ �X509_verify_certrb )r� r[ rm rD rD rE �_verify_certificate� s � z$X509StoreContext._verify_certificatec C s || _ dS )z� Set the context's X.509 store. .. versionadded:: 0.15 :param X509Store store: The store description which will be used for the purposes of any *future* verifications. N)r' r( rD rD rE � set_store� s zX509StoreContext.set_storec C s | � � dS )a" Verify a certificate in a context. .. versionadded:: 0.15 :raises X509StoreContextError: If an error occurred when validating a certificate in the context. Sets ``certificate`` attribute to indicate which certificate caused the error. N)rg r� rD rD rE �verify_certificate� r% z#X509StoreContext.verify_certificatec C st | � � }t�|�}t|tjk� g }tt�|��D ]}t�||�}t|tjk� t � |�}|� |� qt� |� |S )aR Verify a certificate in a context and return the complete validated chain. :raises X509StoreContextError: If an error occurred when validating a certificate in the context. Sets ``certificate`` attribute to indicate which certificate caused the error. .. versionadded:: 20.0 ) rg rO �X509_STORE_CTX_get1_chainrY rU rZ r rT rU r+ r� r� rV )r� r[ � cert_stackr� r r� ra rD rD rE �get_verified_chain� s z#X509StoreContext.get_verified_chainrN r� )r@ rA rB rC r- r+ r r r� � staticmethodrP r r. rb rg rh ri r rl rD rD rD rE r/ t s0 ��� � � � � r/ r� c C sv t |t�r |�d�}t|�}| tkr t�|tjtjtj�}n| t kr*t� |tj�}nt d��|tjkr6t � t �|�S )a Load a certificate (X509) from the string *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param bytes buffer: The buffer the certificate is stored in :return: The X509 object r� �3type argument must be FILETYPE_PEM or FILETYPE_ASN1)rd r� r r] r rO �PEM_read_bio_X509rU rZ r � d2i_X509_biorh r� r+ r� )r� rJ rL r rD rD rE r0 s r0 r� c C sn t � }| tkrt�||j�}n | tkrt�||j�}n| tkr)t�||jdd�}nt d��t |dk� t |�S )a Dump the certificate *cert* into a buffer string encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1, or FILETYPE_TEXT) :param cert: The certificate to dump :return: The buffer with the dumped certificate in r �Ctype argument must be FILETYPE_PEM, FILETYPE_ASN1, or FILETYPE_TEXTr� ) r] r rO �PEM_write_bio_X509r1 r � i2d_X509_bior! � X509_print_exrh rY ra )r� r� rL � result_coderD rD rE r1 / s � r1 r� c C sP t � }| tkr tj}n | tkrtj}ntd��|||j�}|dkr$t� t |�S )z� Dump a public key to a buffer. :param type: The file type (one of :data:`FILETYPE_PEM` or :data:`FILETYPE_ASN1`). :param PKey pkey: The public key to dump :return: The buffer with the dumped key in it. :rtype: bytes rn r� ) r] r rO �PEM_write_bio_PUBKEYr �i2d_PUBKEY_biorh r� r� ra )r� r� rL � write_bioru rD rD rE r2 K s r2 �cipher� passphrasec C s t � }t|t�s td��|dur)|du rtd��t�t|��}|tjkr(t d��ntj}t | |�}| t krIt� ||j |tjd|j|j�}|�� n4| tkrUt�||j �}n(| tkryt�|j �tjkrftd��t�t�|j �tj�}t�||d�}nt d��t|dk� t|�S )a� Dump the private key *pkey* into a buffer string encoded with the type *type*. Optionally (if *type* is :const:`FILETYPE_PEM`) encrypting it using *cipher* and *passphrase*. :param type: The file type (one of :const:`FILETYPE_PEM`, :const:`FILETYPE_ASN1`, or :const:`FILETYPE_TEXT`) :param PKey pkey: The PKey to dump :param cipher: (optional) if encrypted PEM format, the cipher to use :param passphrase: (optional) if encrypted PEM format, this can be either the passphrase to use, or a callback for providing the passphrase. :return: The buffer with the dumped key in :rtype: bytes zpkey must be a PKeyNzDif a value is given for cipher one must also be given for passphrasezInvalid cipher namer z-Only RSA keys are supported for FILETYPE_TEXTrq ) r] rd r% rf rO �EVP_get_cipherbynamer� rU rZ rh �_PassphraseHelperr �PEM_write_bio_PrivateKeyr� �callback� callback_args�raise_if_problemr �i2d_PrivateKey_bior! r� r� r[ r� r� � RSA_printrY ra ) r� r� ry rz rL � cipher_obj�helperru r rD rD rE r3 d sJ � � � � r3 c @ s� e Zd ZU dZg d�Zejeje e d< ddd�Z deddfd d �Z defd d �Z dd d�Z dee ddfdd�Zdee fdd�Zdee fdd�Zdeddfdd�Zdee fdd�ZdS ) r4 z# A certificate revocation. )s unspecifieds keyCompromises CACompromises affiliationChangeds supersededs cessationOfOperations certificateHold� _crl_reasonsrG Nc C r$ rN )rO �X509_REVOKED_newrU r[ �X509_REVOKED_free�_revoked)r� �revokedrD rD rE r� � r* zRevoked.__init__�hex_strc C sf t �t�� tj�}t �d�}||d< t�||�}|s td��t �t�|t j �tj �}t� | j |� dS )z� Set the serial number. The serial number is formatted as a hexadecimal number encoded in ASCII. :param bytes hex_str: The new serial number. :return: ``None`` r� r zbad hex stringN) rU r[ rO r� r� rV r� rh r� rZ r� � X509_REVOKED_set_serialNumberr� )r� r� r� � bignum_ptr� bn_resultr� rD rD rE � set_serial� s �zRevoked.set_serialc C s@ t � }t�| j�}t|tjk� t�||�}t|dk� t|�S )z� Get the serial number. The serial number is formatted as a hexadecimal number encoded in ASCII. :return: The serial number. :rtype: bytes r ) r] rO � X509_REVOKED_get0_serialNumberr� rY rU rZ �i2a_ASN1_INTEGERra )r� rL �asn1_intr� rD rD rE � get_serial� s zRevoked.get_serialc C s` t t�| j��D ]%}t�| j|�}t�|�}t�|�tjkr-t�|� t� | j|� d S qd S rN ) r rO �X509_REVOKED_get_ext_countr� �X509_REVOKED_get_extr9 r �NID_crl_reasonr5 �X509_REVOKED_delete_ext)r� r r� rS rD rD rE �_delete_reason� s ��zRevoked._delete_reason�reasonc C s� |du r | � � dS t|t�std��|�� �dd�}dd� | jD ��|�}t� � }t |t j k� t � |tj�}t�||�}t |t j k� | � � t�| jtj|dd�}t |dk� dS ) a� Set the reason of this revocation. If :data:`reason` is ``None``, delete the reason instead. :param reason: The reason string. :type reason: :class:`bytes` or :class:`NoneType` :return: ``None`` .. seealso:: :meth:`all_reasons`, which gives you a list of all supported reasons which you might pass to this method. Nz$reason must be None or a byte string� � c S s g | ]}|� � �qS rD )�lower)r� �rrD rD rE r� s z&Revoked.set_reason.<locals>.<listcomp>r r� )r� rd re rf r� r� r� r rO �ASN1_ENUMERATED_newrY rU rZ r[ �ASN1_ENUMERATED_free�ASN1_ENUMERATED_set�X509_REVOKED_add1_ext_i2dr� r� )r� r� � reason_code�new_reason_extri r rD rD rE � set_reason� s �zRevoked.set_reasonc C s� t t�| j��D ]8}t�| j|�}t�|�}t�|�tjkr@t� }t� ||dd�}|s:t� |t� |��}t |dk� t |� S qdS )a Get the reason of this revocation. :return: The reason, or ``None`` if there is none. :rtype: bytes or NoneType .. seealso:: :meth:`all_reasons`, which gives you a list of all supported reasons this method might return. r N)r rO r� r� r� r9 r r� r] rN �M_ASN1_OCTET_STRING_printrV rY ra )r� r r� rS rL rO rD rD rE � get_reason s � � zRevoked.get_reasonc C s | j dd� S )a Return a list of all the supported reason strings. This list is a copy; modifying it does not change the supported reason strings. :return: A list of reason strings. :rtype: :class:`list` of :class:`bytes` N)r� r� rD rD rE � all_reasons5 s zRevoked.all_reasonsrc c C �& t |�}t�| j|�}t|dk� dS )z� Set the revocation timestamp. :param bytes when: The timestamp of the revocation, as ASN.1 TIME. :return: ``None`` r� N)rn rO � X509_REVOKED_set_revocationDater� rY )r� rc �revocationDaterm rD rD rE � set_rev_dateA s �zRevoked.set_rev_datec C s t �| j�}t|�S )z� Get the revocation timestamp. :return: The timestamp of the revocation, as ASN.1 TIME. :rtype: bytes )rO � X509_REVOKED_get0_revocationDater� r} )r� �dtrD rD rE � get_rev_dateO s zRevoked.get_rev_dater� )r@ rA rB rC r� r` ra r re rc r� r� r� r� r r� r� r� r� r� rD rD rD rE r4 � s % r4 zPCRL support in pyOpenSSL is deprecated. You should use the APIs in cryptography.c @ s� e Zd ZdZd(dd�Zdejfdd�Zedejdd fd d ��Z de e e d f fd d�Z de ddfdd�Zdefdd�Zdeddfdd�Zdeddfdd�Zdeddfdd�Zd ed ed eddfd d �Zed!efd"ed#ed$ed%ed edef d&d'�ZdS ))r5 z( A certificate revocation list. rG Nc C r$ rN )rO � X509_CRL_newrU r[ r1 r2 )r� r- rD rD rE r� l r* z CRL.__init__c C ri )z� Export as a ``cryptography`` CRL. :rtype: ``cryptography.x509.CertificateRevocationList`` .. versionadded:: 17.1.0 r )�load_der_x509_crl)rk r� �_dump_crl_internalr )r� r� r� rD rD rE rm p r� zCRL.to_cryptography� crypto_crlr. c C ro )a Construct based on a ``cryptography`` *crypto_crl*. :param crypto_crl: A ``cryptography`` certificate revocation list :type crypto_crl: ``cryptography.x509.CertificateRevocationList`` :rtype: CRL .. versionadded:: 17.1.0 z%Must be a certificate revocation listr rp ) rd r r/ rf r� r� r� r� �_load_crl_internalr )r� r� r� r� rD rD rE rs } rt zCRL.from_cryptography.c C sn g }t �| j�}tt �|��D ] }t �||�}t �|�}t�t�}t � |t j �|_ |� |� q|r5t|�S dS )aA Return the revocations in this certificate revocation list. These revocations will be provided by value, not by reference. That means it's okay to mutate them: it won't affect this CRL. :return: The revocations in this CRL. :rtype: :class:`tuple` of :class:`Revocation` N)rO �X509_CRL_get_REVOKEDr2 r �sk_X509_REVOKED_num�sk_X509_REVOKED_value�X509_REVOKED_dup�_RevokedInternalrx rU r[ r� r� r� �tuple)r� �results� revoked_stackr r� � revoked_copy�pyrevrD rD rE � get_revoked� s zCRL.get_revokedr� c C s8 t �|j�}t|tjk� t �| j|�}t|dk� dS )a9 Add a revoked (by value not reference) to the CRL structure This revocation will be added by value, not by reference. That means it's okay to mutate it after adding: it won't affect this CRL. :param Revoked revoked: The new revocation. :return: ``None`` r N)rO r� r� rY rU rZ �X509_CRL_add0_revokedr2 )r� r� �copyr rD rD rE � add_revoked� s zCRL.add_revokedc C sB t �t �| j��}t|tjk� t�|t j�}t � t �}||_ |S )zc Get the CRL's issuer. .. versionadded:: 16.1.0 :rtype: X509Name ) rO r� �X509_CRL_get_issuerr2 rY rU rZ r[ r� r( rx r� )r� �_issuerr. rD rD rE r � s zCRL.get_issuerr{ c C r7 )z� Set the CRL version. .. versionadded:: 16.1.0 :param int version: The version of the CRL. :return: ``None`` r N)rY rO �X509_CRL_set_versionr2 r� rD rD rE rg � s zCRL.set_versionrc c C r� )z� Set when the CRL was last updated. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ .. versionadded:: 16.1.0 :param bytes when: A timestamp string. :return: ``None`` r� N)rn rO �X509_CRL_set1_lastUpdater2 rY )r� rc � lastUpdaterm rD rD rE �set_lastUpdate� � zCRL.set_lastUpdatec C r� )z� Set when the CRL will next be updated. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ .. versionadded:: 16.1.0 :param bytes when: A timestamp string. :return: ``None`` r� N)rn rO �X509_CRL_set1_nextUpdater2 rY )r� rc � nextUpdaterm rD rD rE �set_nextUpdate� r� zCRL.set_nextUpdater2 � issuer_keyr� c C s\ t �|�}t|tjk� t �| jt �|j�� t � | j� t � | j|j |�}t|dk� dS )a; Sign the CRL. Signing a CRL enables clients to associate the CRL itself with an issuer. Before a CRL is meaningful to other OpenSSL functions, it must be signed by an issuer. This method implicitly sets the issuer's name based on the issuer certificate and private key used to sign the CRL. .. versionadded:: 16.1.0 :param X509 issuer_cert: The issuer's certificate. :param PKey issuer_key: The issuer's private key. :param bytes digest: The digest method to sign the CRL with. r N) rO r� rY rU rZ �X509_CRL_set_issuer_namer2 r r1 � X509_CRL_sort� X509_CRL_signr� )r� r2 r� r� r� r� rD rD rE r: � s � zCRL.sign�d r� r� r� �daysc C sB t |t�s td��t |t�std��t |t�std��|tu r#td��t�|�}|tj kr1t d��t� � }t |tj k� t� |tj�}t�|d�}t |tj k� t�| j|�}t |dk� t�||d d d �}t |tj k� t�| j|�}t |dk� t�| jt�|j��}t |dk� t�| j|j|�} | s�t� t|| �S ) a� Export the CRL as a string. :param X509 cert: The certificate used to sign the CRL. :param PKey key: The key used to sign the CRL. :param int type: The export format, either :data:`FILETYPE_PEM`, :data:`FILETYPE_ASN1`, or :data:`FILETYPE_TEXT`. :param int days: The number of days until the next update of this CRL. :param bytes digest: The name of the message digest to use (eg ``b"sha256"``). :rtype: bytes z cert must be an X509 instancezkey must be a PKey instancer� zdigest must be providedr� r r� � �< )rd r+ rf r% r� � _UNSPECIFIEDrO r� rU rZ rh rk rY r[ rl r� r� r2 r� r� r r1 r� r� r� r� ) r� r� r� r� r� r� r� �sometimerm r� rD rD rE �export s< � z CRL.exportr� ) r@ rA rB rC r� r r/ rm r� rs r r r� r� r� r( r r� rg re r� r� r+ r% r: r r� r� rD rD rD rE r5 g sB � � �������r5 c @ s� e Zd Z ddedee dededdf dd �Zede fd d ��Z ede fd d ��Z e fde e ddfdd�Zde dede de def dd�ZdS )r| Fr� rz � more_args�truncaterG Nc C s4 |t kr |d ur td��|| _|| _|| _g | _d S )Nz0only FILETYPE_PEM key format supports encryption)r rh � _passphrase� _more_args� _truncate� _problems)r� r� rz r� r� rD rD rE r� ] s � z_PassphraseHelper.__init__c C s< | j d u rtjS t| j t�st| j �rt�d| j�S td��)N�pem_password_cb�2Last argument must be a byte string or a callable.) r� rU rZ rd re �callabler~ �_read_passphraserf r� rD rD rE r~ m s �z_PassphraseHelper.callbackc C s4 | j d u rtjS t| j t�st| j �rtjS td��)Nr� )r� rU rZ rd re r� rf r� rD rD rE r x s �z _PassphraseHelper.callback_args� exceptionTypec C s6 | j rzt|� W n |y Y nw | j �d��d S r )r� �_exception_from_error_queue�pop)r� r� rD rD rE r� � s � �z"_PassphraseHelper.raise_if_problemrT �size�rwflag�userdatac C s� zUt | j�r| jr| �|||�}n| �|�}n | jd us J �| j}t|t�s*td��t|�|kr>| jr:|d |� }ntd��tt|��D ] }|||d � ||< qDt|�W S t yn } z | j � |� W Y d }~dS d }~ww )NzBytes expectedz+passphrase returned by callback is too longr� r ) r� r� r� rd re rh rX r� r � Exceptionr� r� )r� rT r� r� r� r� r �erD rD rE r� � s. � ��z"_PassphraseHelper._read_passphrase)FF)r@ rA rB r� r �PassphraseCallableTr� r� r\ r r~ r r$ r r� r� r� rD rD rD rE r| \ s< ����� � �����r| c C s� t |t�r |�d�}t|�}| tkr t�|tjtjtj�}n| t kr*t� |tj�}nt d��|tjkr6t � t �t �}t�|tj�|_d|_|S )a< Load a public key from a buffer. :param type: The file type (one of :data:`FILETYPE_PEM`, :data:`FILETYPE_ASN1`). :param buffer: The buffer the key is stored in. :type buffer: A Python string object, either unicode or bytestring. :return: The PKey object. :rtype: :class:`PKey` r� rn T)rd r� r r] r rO �PEM_read_bio_PUBKEYrU rZ r �d2i_PUBKEY_biorh r� r% rx r[ r� r� r� )r� rJ rL �evp_pkeyr� rD rD rE r6 � s � r6 c C s� t |t�r |�d�}t|�}t| |�}| tkr't�|tj |j |j �}|� � n| t kr3t�|tj �}ntd��|tj kr?t� t�t�}t�|tj�|_|S )a� Load a private key (PKey) from the string *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param buffer: The buffer the key is stored in :param passphrase: (optional) if encrypted PEM format, this can be either the passphrase to use, or a callback for providing the passphrase. :return: The PKey object r� rn )rd r� r r] r| r rO �PEM_read_bio_PrivateKeyrU rZ r~ r r� r �d2i_PrivateKey_biorh r� r% rx r[ r� r� )r� rJ rz rL r� r� r� rD rD rE r7 � s" � r7 rh c C sn t � }| tkrt�||j�}n | tkrt�||j�}n| tkr)t�||jdd�}nt d��t |dk� t |�S )a Dump the certificate request *req* into a buffer string encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param req: The certificate request to dump :return: The buffer with the dumped certificate request in r rq ) r] r rO �PEM_write_bio_X509_REQrf r �i2d_X509_REQ_bior! �X509_REQ_print_exrh rY ra )r� rh rL ru rD rD rE r8 � s � r8 c C s� t |t�r |�d�}t|�}| tkr t�|tjtjtj�}n| t kr*t� |tj�}nt d��t |tjk� t �t �}t�|tj�|_|S )a Load a certificate request (X509Req) from the string *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param buffer: The buffer the certificate request is stored in :return: The X509Req object r� rn )rd r� r r] r rO �PEM_read_bio_X509_REQrU rZ r �d2i_X509_REQ_biorh rY �_X509ReqInternalrx r[ re rf )r� rJ rL rh �x509reqrD rD rE r9 s r9 r\ r� c C s� t d|�}t�t|��}|tjkrtd��t�� }t�|tj �}t� ||� t� ||t |�� t� | j�}t|dk� t�d|�}t�d�}t�|||| j�}t|dk� t�||d �dd� S )z� Sign a data string using the given key and message digest. :param pkey: PKey to sign with :param data: data to be signed :param digest: message digest to use :return: signature .. versionadded:: 0.11 r\ r� r r� zunsigned int *r� N)�_text_to_bytes_and_warnrO r� r� rU rZ rh �EVP_MD_CTX_newr[ �EVP_MD_CTX_free� EVP_SignInit�EVP_SignUpdaterX � EVP_PKEY_sizer� rY rV � EVP_SignFinalrJ ) r� r\ r� r� �md_ctxrG �signature_buffer�signature_length� final_resultrD rD rE r: I s" � r: z>sign() is deprecated. Use the equivalent APIs in cryptography.� signaturec C s� t d|�}t�t|��}|tjkrtd��t�| j�}t |tjk� t� |tj �}t� � }t� |tj �}t�||� t�||t|�� t�||t|�|�}|dkrVt� dS dS )a� Verify the signature for a data string. :param cert: signing certificate (X509 object) corresponding to the private key which generated the signature. :param signature: signature returned by sign function :param data: data to be verified :param digest: message digest to use :return: ``None`` if the signature is correct, raise exception otherwise. .. versionadded:: 0.11 r\ r� r� N)r� rO r� r� rU rZ rh r� r1 rY r[ r� r� r� �EVP_VerifyInit�EVP_VerifyUpdaterX �EVP_VerifyFinalr� )r� r r\ r� r� r� r� � verify_resultrD rD rE r; u s" � �r; z@verify() is deprecated. Use the equivalent APIs in cryptography.r- c C sj t � }| tkrt�||j�}n | tkrt�||j�}n| tkr't�||j�}nt d��t |dk� t |�S )a Dump a certificate revocation list to a buffer. :param type: The file type (one of ``FILETYPE_PEM``, ``FILETYPE_ASN1``, or ``FILETYPE_TEXT``). :param CRL crl: The CRL to dump. :return: The buffer with the CRL. :rtype: bytes rq r� ) r] r rO �PEM_write_bio_X509_CRLr2 r �i2d_X509_CRL_bior! �X509_CRL_printrh rY ra )r� r- rL rm rD rD rE r< � s � r< c C s� t |t�r |�d�}t|�}| tkr t�|tjtjtj�}n| t kr*t� |tj�}nt d��|tjkr6t � t �t �}t�|tj�|_|S )a Load Certificate Revocation List (CRL) data from a string *buffer*. *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param buffer: The buffer the CRL is stored in :return: The CRL object r� rn )rd r� r r] r rO �PEM_read_bio_X509_CRLrU rZ r r0 rh r� r. rx r[ r1 r2 )r� rJ rL r- r� rD rD rE r= � s r= rN r[ )r> r� � functoolsr` �base64r r �osr r r r r r r r r r r r � cryptographyr r �)cryptography.hazmat.primitives.asymmetricr r r r r � OpenSSL._utilr r� r r� r r� r rU r rO r � _make_assertr rF r r� �__all__r� r� r� r� r� r� r� r� r� r� r� r� re rJ r� �SSL_FILETYPE_PEMr r� rc �SSL_FILETYPE_ASN1r r! r� r" � EVP_PKEY_DSAr# � EVP_PKEY_DHr> � EVP_PKEY_ECr? r� r$ r� rY rI r] ra rj rn r} r~ r% r� r& r' �total_orderingr( r) r� � deprecatedr@ �DeprecationWarningr* r� r+ r, r- r. r/ r0 r1 r2 r3 r4 r� r5 r. r| r6 r7 r8 rl r9 rr r: r; r< r� r= r� rD rD rD rE �<module> s� 4 #�� ) Bg C (� ^� g / ����� �E 2� i� N%�� �� �) � �" #� �� �� �&� � � __pycache__/_util.cpython-310.pyc 0000644 00000007122 15030415060 0012565 0 ustar 00 o �h� � @ s� d dl Z d dlZd dlZd dlmZmZmZmZmZ d dl m Z ee e e j f Ze � ZejZejZejdd�Zdede fdd �Zd ee defd d �Zd ee deegef fdd�Zdede fdd�Zde de fdd�Ze� Z dZ de dedefdd�Z dS )� N)�Any�Callable�NoReturn�Type�Union)�BindingF)�should_clear_after_alloc�charp�returnc C s | sdS t �| ��d�S )z� Get a native string type representing of the given CFFI ``char*`` object. :param charp: A C-style string represented using CFFI. :return: :class:`str` � �utf-8)�ffi�string�decode)r � r �C/usr/local/CyberPanel/lib/python3.10/site-packages/OpenSSL/_util.py�text s r �exception_typec C sP g } t �� }|dkr | |��|�tt �|��tt �|��tt �|��f� q)ac Convert an OpenSSL library failure into a Python exception. When a call to the native OpenSSL library fails, this is usually signalled by the return value, and an error code is stored in an error queue associated with the current thread. The err library provides functions to obtain these error codes and textual error messages. Tr )�lib� ERR_get_error�appendr �ERR_lib_error_string�ERR_func_error_string�ERR_reason_error_string)r �errors�errorr r r �exception_from_error_queue" s � ���r r c s dt ddf� fdd� }|S )z~ Create an assert function that uses :func:`exception_from_error_queue` to raise an exception wrapped by *error*. �okr Nc s | dur t � � dS dS )zT If *ok* is not True, retrieve the error from OpenSSL and raise it. TN)r )r �r r r �openssl_assertB s �z#make_assert.<locals>.openssl_assert)�bool)r r r r r � make_assert< s r! �sc C s& t �| �}t|t�r|�t�� �S |S )z� Convert a Python path to a :py:class:`bytes` for the path which can be passed into an OpenSSL API accepting a filename. :param s: A path (valid for os.fspath). :return: An instance of :py:class:`bytes`. )�os�fspath� isinstance�str�encode�sys�getfilesystemencoding)r" �br r r � path_bytesL s r+ c C s | � d�S )N�charmap)r' )r" r r r � byte_string] s r- z,str for {0} is no longer accepted, use bytes�label�objc C s. t |t�rtjt�| �tdd� |�d�S |S )a� If ``obj`` is text, emit a warning that it should be bytes instead and try to convert it to bytes automatically. :param str label: The name of the parameter from which ``obj`` was taken (so a developer can easily find the source of the problem and correct it). :return: If ``obj`` is the text string type, a ``bytes`` object giving the UTF-8 encoding of that text is returned. Otherwise, ``obj`` itself is returned. � )�category� stacklevelr )r% r& �warnings�warn� _TEXT_WARNING�format�DeprecationWarningr' )r. r/ r r r �text_to_bytes_and_warnh s � r8 ) r# r( r3 �typingr r r r r �,cryptography.hazmat.bindings.openssl.bindingr r& �bytes�PathLike�StrOrBytesPath�bindingr r � new_allocator�no_zero_allocatorr � Exceptionr r r! r+ r- �object� UNSPECIFIEDr5 r8 r r r r �<module> s$ _util.py 0000644 00000006723 15030415060 0006234 0 ustar 00 import os import sys import warnings from typing import Any, Callable, NoReturn, Type, Union from cryptography.hazmat.bindings.openssl.binding import Binding StrOrBytesPath = Union[str, bytes, os.PathLike] binding = Binding() ffi = binding.ffi lib = binding.lib # This is a special CFFI allocator that does not bother to zero its memory # after allocation. This has vastly better performance on large allocations and # so should be used whenever we don't need the memory zeroed out. no_zero_allocator = ffi.new_allocator(should_clear_after_alloc=False) def text(charp: Any) -> str: """ Get a native string type representing of the given CFFI ``char*`` object. :param charp: A C-style string represented using CFFI. :return: :class:`str` """ if not charp: return "" return ffi.string(charp).decode("utf-8") def exception_from_error_queue(exception_type: Type[Exception]) -> NoReturn: """ Convert an OpenSSL library failure into a Python exception. When a call to the native OpenSSL library fails, this is usually signalled by the return value, and an error code is stored in an error queue associated with the current thread. The err library provides functions to obtain these error codes and textual error messages. """ errors = [] while True: error = lib.ERR_get_error() if error == 0: break errors.append( ( text(lib.ERR_lib_error_string(error)), text(lib.ERR_func_error_string(error)), text(lib.ERR_reason_error_string(error)), ) ) raise exception_type(errors) def make_assert(error: Type[Exception]) -> Callable[[bool], Any]: """ Create an assert function that uses :func:`exception_from_error_queue` to raise an exception wrapped by *error*. """ def openssl_assert(ok: bool) -> None: """ If *ok* is not True, retrieve the error from OpenSSL and raise it. """ if ok is not True: exception_from_error_queue(error) return openssl_assert def path_bytes(s: StrOrBytesPath) -> bytes: """ Convert a Python path to a :py:class:`bytes` for the path which can be passed into an OpenSSL API accepting a filename. :param s: A path (valid for os.fspath). :return: An instance of :py:class:`bytes`. """ b = os.fspath(s) if isinstance(b, str): return b.encode(sys.getfilesystemencoding()) else: return b def byte_string(s: str) -> bytes: return s.encode("charmap") # A marker object to observe whether some optional arguments are passed any # value or not. UNSPECIFIED = object() _TEXT_WARNING = "str for {0} is no longer accepted, use bytes" def text_to_bytes_and_warn(label: str, obj: Any) -> Any: """ If ``obj`` is text, emit a warning that it should be bytes instead and try to convert it to bytes automatically. :param str label: The name of the parameter from which ``obj`` was taken (so a developer can easily find the source of the problem and correct it). :return: If ``obj`` is the text string type, a ``bytes`` object giving the UTF-8 encoding of that text is returned. Otherwise, ``obj`` itself is returned. """ if isinstance(obj, str): warnings.warn( _TEXT_WARNING.format(label), category=DeprecationWarning, stacklevel=3, ) return obj.encode("utf-8") return obj rand.py 0000644 00000002055 15030415060 0006036 0 ustar 00 """ PRNG management routines, thin wrappers. """ from OpenSSL._util import lib as _lib def add(buffer: bytes, entropy: int) -> None: """ Mix bytes from *string* into the PRNG state. The *entropy* argument is (the lower bound of) an estimate of how much randomness is contained in *string*, measured in bytes. For more information, see e.g. :rfc:`1750`. This function is only relevant if you are forking Python processes and need to reseed the CSPRNG after fork. :param buffer: Buffer with random data. :param entropy: The entropy (in bytes) measurement of the buffer. :return: :obj:`None` """ if not isinstance(buffer, bytes): raise TypeError("buffer must be a byte string") if not isinstance(entropy, int): raise TypeError("entropy must be an integer") _lib.RAND_add(buffer, len(buffer), entropy) def status() -> int: """ Check whether the PRNG has been seeded with enough data. :return: 1 if the PRNG is seeded enough, 0 otherwise. """ return _lib.RAND_status() py.typed 0000644 00000000000 15030415060 0006223 0 ustar 00 version.py 0000644 00000001201 15030415060 0006567 0 ustar 00 # Copyright (C) AB Strakt # Copyright (C) Jean-Paul Calderone # See LICENSE for details. """ pyOpenSSL - A simple wrapper around the OpenSSL library """ __all__ = [ "__author__", "__copyright__", "__email__", "__license__", "__summary__", "__title__", "__uri__", "__version__", ] __version__ = "24.2.1" __title__ = "pyOpenSSL" __uri__ = "https://pyopenssl.org/" __summary__ = "Python wrapper module around the OpenSSL library" __author__ = "The pyOpenSSL developers" __email__ = "cryptography-dev@python.org" __license__ = "Apache License, Version 2.0" __copyright__ = f"Copyright 2001-2024 {__author__}" debug.py 0000644 00000001760 15030415060 0006202 0 ustar 00 import ssl import sys import cffi import cryptography import OpenSSL.SSL from . import version _env_info = """\ pyOpenSSL: {pyopenssl} cryptography: {cryptography} cffi: {cffi} cryptography's compiled against OpenSSL: {crypto_openssl_compile} cryptography's linked OpenSSL: {crypto_openssl_link} Python's OpenSSL: {python_openssl} Python executable: {python} Python version: {python_version} Platform: {platform} sys.path: {sys_path}""".format( pyopenssl=version.__version__, crypto_openssl_compile=OpenSSL._util.ffi.string( OpenSSL._util.lib.OPENSSL_VERSION_TEXT, ).decode("ascii"), crypto_openssl_link=OpenSSL.SSL.SSLeay_version( OpenSSL.SSL.SSLEAY_VERSION ).decode("ascii"), python_openssl=getattr(ssl, "OPENSSL_VERSION", "n/a"), cryptography=cryptography.__version__, cffi=cffi.__version__, python=sys.executable, python_version=sys.version, platform=sys.platform, sys_path=sys.path, ) if __name__ == "__main__": print(_env_info) SSL.py 0000644 00000320550 15030415060 0005556 0 ustar 00 import os import socket import typing from errno import errorcode from functools import partial, wraps from itertools import chain, count from sys import platform from typing import Any, Callable, List, Optional, Sequence, Tuple, TypeVar from weakref import WeakValueDictionary from OpenSSL._util import ( StrOrBytesPath as _StrOrBytesPath, ) from OpenSSL._util import ( exception_from_error_queue as _exception_from_error_queue, ) from OpenSSL._util import ( ffi as _ffi, ) from OpenSSL._util import ( lib as _lib, ) from OpenSSL._util import ( make_assert as _make_assert, ) from OpenSSL._util import ( no_zero_allocator as _no_zero_allocator, ) from OpenSSL._util import ( path_bytes as _path_bytes, ) from OpenSSL._util import ( text_to_bytes_and_warn as _text_to_bytes_and_warn, ) from OpenSSL.crypto import ( FILETYPE_PEM, X509, PKey, X509Name, X509Store, _EllipticCurve, _PassphraseHelper, ) __all__ = [ "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", "X509VerificationCodes", ] OPENSSL_VERSION_NUMBER: int = _lib.OPENSSL_VERSION_NUMBER OPENSSL_VERSION: int = _lib.OPENSSL_VERSION OPENSSL_CFLAGS: int = _lib.OPENSSL_CFLAGS OPENSSL_PLATFORM: int = _lib.OPENSSL_PLATFORM OPENSSL_DIR: int = _lib.OPENSSL_DIR OPENSSL_BUILT_ON: int = _lib.OPENSSL_BUILT_ON SSLEAY_VERSION = OPENSSL_VERSION SSLEAY_CFLAGS = OPENSSL_CFLAGS SSLEAY_PLATFORM = OPENSSL_PLATFORM SSLEAY_DIR = OPENSSL_DIR SSLEAY_BUILT_ON = OPENSSL_BUILT_ON SENT_SHUTDOWN = _lib.SSL_SENT_SHUTDOWN RECEIVED_SHUTDOWN = _lib.SSL_RECEIVED_SHUTDOWN SSLv23_METHOD = 3 TLSv1_METHOD = 4 TLSv1_1_METHOD = 5 TLSv1_2_METHOD = 6 TLS_METHOD = 7 TLS_SERVER_METHOD = 8 TLS_CLIENT_METHOD = 9 DTLS_METHOD = 10 DTLS_SERVER_METHOD = 11 DTLS_CLIENT_METHOD = 12 SSL3_VERSION: int = _lib.SSL3_VERSION TLS1_VERSION: int = _lib.TLS1_VERSION TLS1_1_VERSION: int = _lib.TLS1_1_VERSION TLS1_2_VERSION: int = _lib.TLS1_2_VERSION TLS1_3_VERSION: int = _lib.TLS1_3_VERSION OP_NO_SSLv2: int = _lib.SSL_OP_NO_SSLv2 OP_NO_SSLv3: int = _lib.SSL_OP_NO_SSLv3 OP_NO_TLSv1: int = _lib.SSL_OP_NO_TLSv1 OP_NO_TLSv1_1: int = _lib.SSL_OP_NO_TLSv1_1 OP_NO_TLSv1_2: int = _lib.SSL_OP_NO_TLSv1_2 try: OP_NO_TLSv1_3: int = _lib.SSL_OP_NO_TLSv1_3 __all__.append("OP_NO_TLSv1_3") except AttributeError: pass MODE_RELEASE_BUFFERS: int = _lib.SSL_MODE_RELEASE_BUFFERS OP_SINGLE_DH_USE: int = _lib.SSL_OP_SINGLE_DH_USE OP_SINGLE_ECDH_USE: int = _lib.SSL_OP_SINGLE_ECDH_USE OP_EPHEMERAL_RSA: int = _lib.SSL_OP_EPHEMERAL_RSA OP_MICROSOFT_SESS_ID_BUG: int = _lib.SSL_OP_MICROSOFT_SESS_ID_BUG OP_NETSCAPE_CHALLENGE_BUG: int = _lib.SSL_OP_NETSCAPE_CHALLENGE_BUG OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: int = ( _lib.SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG ) OP_SSLREF2_REUSE_CERT_TYPE_BUG: int = _lib.SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG OP_MICROSOFT_BIG_SSLV3_BUFFER: int = _lib.SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER OP_MSIE_SSLV2_RSA_PADDING: int = _lib.SSL_OP_MSIE_SSLV2_RSA_PADDING OP_SSLEAY_080_CLIENT_DH_BUG: int = _lib.SSL_OP_SSLEAY_080_CLIENT_DH_BUG OP_TLS_D5_BUG: int = _lib.SSL_OP_TLS_D5_BUG OP_TLS_BLOCK_PADDING_BUG: int = _lib.SSL_OP_TLS_BLOCK_PADDING_BUG OP_DONT_INSERT_EMPTY_FRAGMENTS: int = _lib.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS OP_CIPHER_SERVER_PREFERENCE: int = _lib.SSL_OP_CIPHER_SERVER_PREFERENCE OP_TLS_ROLLBACK_BUG: int = _lib.SSL_OP_TLS_ROLLBACK_BUG OP_PKCS1_CHECK_1 = _lib.SSL_OP_PKCS1_CHECK_1 OP_PKCS1_CHECK_2: int = _lib.SSL_OP_PKCS1_CHECK_2 OP_NETSCAPE_CA_DN_BUG: int = _lib.SSL_OP_NETSCAPE_CA_DN_BUG OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: int = ( _lib.SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG ) OP_NO_COMPRESSION: int = _lib.SSL_OP_NO_COMPRESSION OP_NO_QUERY_MTU: int = _lib.SSL_OP_NO_QUERY_MTU OP_COOKIE_EXCHANGE: int = _lib.SSL_OP_COOKIE_EXCHANGE OP_NO_TICKET: int = _lib.SSL_OP_NO_TICKET try: OP_NO_RENEGOTIATION: int = _lib.SSL_OP_NO_RENEGOTIATION __all__.append("OP_NO_RENEGOTIATION") except AttributeError: pass try: OP_IGNORE_UNEXPECTED_EOF: int = _lib.SSL_OP_IGNORE_UNEXPECTED_EOF __all__.append("OP_IGNORE_UNEXPECTED_EOF") except AttributeError: pass try: OP_LEGACY_SERVER_CONNECT: int = _lib.SSL_OP_LEGACY_SERVER_CONNECT __all__.append("OP_LEGACY_SERVER_CONNECT") except AttributeError: pass OP_ALL: int = _lib.SSL_OP_ALL VERIFY_PEER: int = _lib.SSL_VERIFY_PEER VERIFY_FAIL_IF_NO_PEER_CERT: int = _lib.SSL_VERIFY_FAIL_IF_NO_PEER_CERT VERIFY_CLIENT_ONCE: int = _lib.SSL_VERIFY_CLIENT_ONCE VERIFY_NONE: int = _lib.SSL_VERIFY_NONE SESS_CACHE_OFF: int = _lib.SSL_SESS_CACHE_OFF SESS_CACHE_CLIENT: int = _lib.SSL_SESS_CACHE_CLIENT SESS_CACHE_SERVER: int = _lib.SSL_SESS_CACHE_SERVER SESS_CACHE_BOTH: int = _lib.SSL_SESS_CACHE_BOTH SESS_CACHE_NO_AUTO_CLEAR: int = _lib.SSL_SESS_CACHE_NO_AUTO_CLEAR SESS_CACHE_NO_INTERNAL_LOOKUP: int = _lib.SSL_SESS_CACHE_NO_INTERNAL_LOOKUP SESS_CACHE_NO_INTERNAL_STORE: int = _lib.SSL_SESS_CACHE_NO_INTERNAL_STORE SESS_CACHE_NO_INTERNAL: int = _lib.SSL_SESS_CACHE_NO_INTERNAL SSL_ST_CONNECT: int = _lib.SSL_ST_CONNECT SSL_ST_ACCEPT: int = _lib.SSL_ST_ACCEPT SSL_ST_MASK: int = _lib.SSL_ST_MASK SSL_CB_LOOP: int = _lib.SSL_CB_LOOP SSL_CB_EXIT: int = _lib.SSL_CB_EXIT SSL_CB_READ: int = _lib.SSL_CB_READ SSL_CB_WRITE: int = _lib.SSL_CB_WRITE SSL_CB_ALERT: int = _lib.SSL_CB_ALERT SSL_CB_READ_ALERT: int = _lib.SSL_CB_READ_ALERT SSL_CB_WRITE_ALERT: int = _lib.SSL_CB_WRITE_ALERT SSL_CB_ACCEPT_LOOP: int = _lib.SSL_CB_ACCEPT_LOOP SSL_CB_ACCEPT_EXIT: int = _lib.SSL_CB_ACCEPT_EXIT SSL_CB_CONNECT_LOOP: int = _lib.SSL_CB_CONNECT_LOOP SSL_CB_CONNECT_EXIT: int = _lib.SSL_CB_CONNECT_EXIT SSL_CB_HANDSHAKE_START: int = _lib.SSL_CB_HANDSHAKE_START SSL_CB_HANDSHAKE_DONE: int = _lib.SSL_CB_HANDSHAKE_DONE _T = TypeVar("_T") class _NoOverlappingProtocols: pass NO_OVERLAPPING_PROTOCOLS = _NoOverlappingProtocols() # Callback types. _ALPNSelectCallback = Callable[ [ "Connection", typing.Union[List[bytes], _NoOverlappingProtocols], ], None, ] _CookieGenerateCallback = Callable[["Connection"], bytes] _CookieVerifyCallback = Callable[["Connection", bytes], bool] _OCSPClientCallback = Callable[["Connection", bytes, Optional[_T]], bool] _OCSPServerCallback = Callable[["Connection", Optional[_T]], bytes] _PassphraseCallback = Callable[[int, bool, Optional[_T]], bytes] _VerifyCallback = Callable[["Connection", X509, int, int, int], bool] class X509VerificationCodes: """ 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. """ OK = _lib.X509_V_OK ERR_UNABLE_TO_GET_ISSUER_CERT = _lib.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT ERR_UNABLE_TO_GET_CRL = _lib.X509_V_ERR_UNABLE_TO_GET_CRL ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE = ( _lib.X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE ) ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE = ( _lib.X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE ) ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY = ( _lib.X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY ) ERR_CERT_SIGNATURE_FAILURE = _lib.X509_V_ERR_CERT_SIGNATURE_FAILURE ERR_CRL_SIGNATURE_FAILURE = _lib.X509_V_ERR_CRL_SIGNATURE_FAILURE ERR_CERT_NOT_YET_VALID = _lib.X509_V_ERR_CERT_NOT_YET_VALID ERR_CERT_HAS_EXPIRED = _lib.X509_V_ERR_CERT_HAS_EXPIRED ERR_CRL_NOT_YET_VALID = _lib.X509_V_ERR_CRL_NOT_YET_VALID ERR_CRL_HAS_EXPIRED = _lib.X509_V_ERR_CRL_HAS_EXPIRED ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD = ( _lib.X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD ) ERR_ERROR_IN_CERT_NOT_AFTER_FIELD = ( _lib.X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD ) ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD = ( _lib.X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD ) ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD = ( _lib.X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD ) ERR_OUT_OF_MEM = _lib.X509_V_ERR_OUT_OF_MEM ERR_DEPTH_ZERO_SELF_SIGNED_CERT = ( _lib.X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT ) ERR_SELF_SIGNED_CERT_IN_CHAIN = _lib.X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = ( _lib.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY ) ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE = ( _lib.X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE ) ERR_CERT_CHAIN_TOO_LONG = _lib.X509_V_ERR_CERT_CHAIN_TOO_LONG ERR_CERT_REVOKED = _lib.X509_V_ERR_CERT_REVOKED ERR_INVALID_CA = _lib.X509_V_ERR_INVALID_CA ERR_PATH_LENGTH_EXCEEDED = _lib.X509_V_ERR_PATH_LENGTH_EXCEEDED ERR_INVALID_PURPOSE = _lib.X509_V_ERR_INVALID_PURPOSE ERR_CERT_UNTRUSTED = _lib.X509_V_ERR_CERT_UNTRUSTED ERR_CERT_REJECTED = _lib.X509_V_ERR_CERT_REJECTED ERR_SUBJECT_ISSUER_MISMATCH = _lib.X509_V_ERR_SUBJECT_ISSUER_MISMATCH ERR_AKID_SKID_MISMATCH = _lib.X509_V_ERR_AKID_SKID_MISMATCH ERR_AKID_ISSUER_SERIAL_MISMATCH = ( _lib.X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH ) ERR_KEYUSAGE_NO_CERTSIGN = _lib.X509_V_ERR_KEYUSAGE_NO_CERTSIGN ERR_UNABLE_TO_GET_CRL_ISSUER = _lib.X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER ERR_UNHANDLED_CRITICAL_EXTENSION = ( _lib.X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION ) ERR_KEYUSAGE_NO_CRL_SIGN = _lib.X509_V_ERR_KEYUSAGE_NO_CRL_SIGN ERR_UNHANDLED_CRITICAL_CRL_EXTENSION = ( _lib.X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION ) ERR_INVALID_NON_CA = _lib.X509_V_ERR_INVALID_NON_CA ERR_PROXY_PATH_LENGTH_EXCEEDED = _lib.X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = ( _lib.X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE ) ERR_PROXY_CERTIFICATES_NOT_ALLOWED = ( _lib.X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED ) ERR_INVALID_EXTENSION = _lib.X509_V_ERR_INVALID_EXTENSION ERR_INVALID_POLICY_EXTENSION = _lib.X509_V_ERR_INVALID_POLICY_EXTENSION ERR_NO_EXPLICIT_POLICY = _lib.X509_V_ERR_NO_EXPLICIT_POLICY ERR_DIFFERENT_CRL_SCOPE = _lib.X509_V_ERR_DIFFERENT_CRL_SCOPE ERR_UNSUPPORTED_EXTENSION_FEATURE = ( _lib.X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE ) ERR_UNNESTED_RESOURCE = _lib.X509_V_ERR_UNNESTED_RESOURCE ERR_PERMITTED_VIOLATION = _lib.X509_V_ERR_PERMITTED_VIOLATION ERR_EXCLUDED_VIOLATION = _lib.X509_V_ERR_EXCLUDED_VIOLATION ERR_SUBTREE_MINMAX = _lib.X509_V_ERR_SUBTREE_MINMAX ERR_UNSUPPORTED_CONSTRAINT_TYPE = ( _lib.X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE ) ERR_UNSUPPORTED_CONSTRAINT_SYNTAX = ( _lib.X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX ) ERR_UNSUPPORTED_NAME_SYNTAX = _lib.X509_V_ERR_UNSUPPORTED_NAME_SYNTAX ERR_CRL_PATH_VALIDATION_ERROR = _lib.X509_V_ERR_CRL_PATH_VALIDATION_ERROR ERR_HOSTNAME_MISMATCH = _lib.X509_V_ERR_HOSTNAME_MISMATCH ERR_EMAIL_MISMATCH = _lib.X509_V_ERR_EMAIL_MISMATCH ERR_IP_ADDRESS_MISMATCH = _lib.X509_V_ERR_IP_ADDRESS_MISMATCH ERR_APPLICATION_VERIFICATION = _lib.X509_V_ERR_APPLICATION_VERIFICATION # Taken from https://golang.org/src/crypto/x509/root_linux.go _CERTIFICATE_FILE_LOCATIONS = [ "/etc/ssl/certs/ca-certificates.crt", # Debian/Ubuntu/Gentoo etc. "/etc/pki/tls/certs/ca-bundle.crt", # Fedora/RHEL 6 "/etc/ssl/ca-bundle.pem", # OpenSUSE "/etc/pki/tls/cacert.pem", # OpenELEC "/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem", # CentOS/RHEL 7 ] _CERTIFICATE_PATH_LOCATIONS = [ "/etc/ssl/certs", # SLES10/SLES11 ] # These values are compared to output from cffi's ffi.string so they must be # byte strings. _CRYPTOGRAPHY_MANYLINUX_CA_DIR = b"/opt/pyca/cryptography/openssl/certs" _CRYPTOGRAPHY_MANYLINUX_CA_FILE = b"/opt/pyca/cryptography/openssl/cert.pem" class Error(Exception): """ An error occurred in an `OpenSSL.SSL` API. """ _raise_current_error = partial(_exception_from_error_queue, Error) _openssl_assert = _make_assert(Error) class WantReadError(Error): pass class WantWriteError(Error): pass class WantX509LookupError(Error): pass class ZeroReturnError(Error): pass class SysCallError(Error): pass class _CallbackExceptionHelper: """ 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. """ def __init__(self) -> None: self._problems: List[Exception] = [] def raise_if_problem(self) -> None: """ Raise an exception from the OpenSSL error queue or that was previously captured whe running a callback. """ if self._problems: try: _raise_current_error() except Error: pass raise self._problems.pop(0) class _VerifyHelper(_CallbackExceptionHelper): """ Wrap a callback such that it can be used as a certificate verification callback. """ def __init__(self, callback: _VerifyCallback) -> None: _CallbackExceptionHelper.__init__(self) @wraps(callback) def wrapper(ok, store_ctx): # type: ignore[no-untyped-def] x509 = _lib.X509_STORE_CTX_get_current_cert(store_ctx) _lib.X509_up_ref(x509) cert = X509._from_raw_x509_ptr(x509) error_number = _lib.X509_STORE_CTX_get_error(store_ctx) error_depth = _lib.X509_STORE_CTX_get_error_depth(store_ctx) index = _lib.SSL_get_ex_data_X509_STORE_CTX_idx() ssl = _lib.X509_STORE_CTX_get_ex_data(store_ctx, index) connection = Connection._reverse_mapping[ssl] try: result = callback( connection, cert, error_number, error_depth, ok ) except Exception as e: self._problems.append(e) return 0 else: if result: _lib.X509_STORE_CTX_set_error(store_ctx, _lib.X509_V_OK) return 1 else: return 0 self.callback = _ffi.callback( "int (*)(int, X509_STORE_CTX *)", wrapper ) class _ALPNSelectHelper(_CallbackExceptionHelper): """ Wrap a callback such that it can be used as an ALPN selection callback. """ def __init__(self, callback: _ALPNSelectCallback) -> None: _CallbackExceptionHelper.__init__(self) @wraps(callback) def wrapper(ssl, out, outlen, in_, inlen, arg): # type: ignore[no-untyped-def] try: conn = Connection._reverse_mapping[ssl] # The string passed to us is made up of multiple # length-prefixed bytestrings. We need to split that into a # list. instr = _ffi.buffer(in_, inlen)[:] protolist = [] while instr: encoded_len = instr[0] proto = instr[1 : encoded_len + 1] protolist.append(proto) instr = instr[encoded_len + 1 :] # Call the callback outbytes = callback(conn, protolist) any_accepted = True if outbytes is NO_OVERLAPPING_PROTOCOLS: outbytes = b"" any_accepted = False elif not isinstance(outbytes, bytes): raise TypeError( "ALPN callback must return a bytestring or the " "special NO_OVERLAPPING_PROTOCOLS sentinel value." ) # Save our callback arguments on the connection object to make # sure that they don't get freed before OpenSSL can use them. # Then, return them in the appropriate output parameters. conn._alpn_select_callback_args = [ _ffi.new("unsigned char *", len(outbytes)), _ffi.new("unsigned char[]", outbytes), ] outlen[0] = conn._alpn_select_callback_args[0][0] out[0] = conn._alpn_select_callback_args[1] if not any_accepted: return _lib.SSL_TLSEXT_ERR_NOACK return _lib.SSL_TLSEXT_ERR_OK except Exception as e: self._problems.append(e) return _lib.SSL_TLSEXT_ERR_ALERT_FATAL self.callback = _ffi.callback( ( "int (*)(SSL *, unsigned char **, unsigned char *, " "const unsigned char *, unsigned int, void *)" ), wrapper, ) class _OCSPServerCallbackHelper(_CallbackExceptionHelper): """ 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. """ def __init__(self, callback: _OCSPServerCallback[Any]) -> None: _CallbackExceptionHelper.__init__(self) @wraps(callback) def wrapper(ssl, cdata): # type: ignore[no-untyped-def] try: conn = Connection._reverse_mapping[ssl] # Extract the data if any was provided. if cdata != _ffi.NULL: data = _ffi.from_handle(cdata) else: data = None # Call the callback. ocsp_data = callback(conn, data) if not isinstance(ocsp_data, bytes): raise TypeError("OCSP callback must return a bytestring.") # If the OCSP data was provided, we will pass it to OpenSSL. # However, we have an early exit here: if no OCSP data was # provided we will just exit out and tell OpenSSL that there # is nothing to do. if not ocsp_data: return 3 # SSL_TLSEXT_ERR_NOACK # OpenSSL takes ownership of this data and expects it to have # been allocated by OPENSSL_malloc. ocsp_data_length = len(ocsp_data) data_ptr = _lib.OPENSSL_malloc(ocsp_data_length) _ffi.buffer(data_ptr, ocsp_data_length)[:] = ocsp_data _lib.SSL_set_tlsext_status_ocsp_resp( ssl, data_ptr, ocsp_data_length ) return 0 except Exception as e: self._problems.append(e) return 2 # SSL_TLSEXT_ERR_ALERT_FATAL self.callback = _ffi.callback("int (*)(SSL *, void *)", wrapper) class _OCSPClientCallbackHelper(_CallbackExceptionHelper): """ 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. """ def __init__(self, callback: _OCSPClientCallback[Any]) -> None: _CallbackExceptionHelper.__init__(self) @wraps(callback) def wrapper(ssl, cdata): # type: ignore[no-untyped-def] try: conn = Connection._reverse_mapping[ssl] # Extract the data if any was provided. if cdata != _ffi.NULL: data = _ffi.from_handle(cdata) else: data = None # Get the OCSP data. ocsp_ptr = _ffi.new("unsigned char **") ocsp_len = _lib.SSL_get_tlsext_status_ocsp_resp(ssl, ocsp_ptr) if ocsp_len < 0: # No OCSP data. ocsp_data = b"" else: # Copy the OCSP data, then pass it to the callback. ocsp_data = _ffi.buffer(ocsp_ptr[0], ocsp_len)[:] valid = callback(conn, ocsp_data, data) # Return 1 on success or 0 on error. return int(bool(valid)) except Exception as e: self._problems.append(e) # Return negative value if an exception is hit. return -1 self.callback = _ffi.callback("int (*)(SSL *, void *)", wrapper) class _CookieGenerateCallbackHelper(_CallbackExceptionHelper): def __init__(self, callback: _CookieGenerateCallback) -> None: _CallbackExceptionHelper.__init__(self) @wraps(callback) def wrapper(ssl, out, outlen): # type: ignore[no-untyped-def] try: conn = Connection._reverse_mapping[ssl] cookie = callback(conn) out[0 : len(cookie)] = cookie outlen[0] = len(cookie) return 1 except Exception as e: self._problems.append(e) # "a zero return value can be used to abort the handshake" return 0 self.callback = _ffi.callback( "int (*)(SSL *, unsigned char *, unsigned int *)", wrapper, ) class _CookieVerifyCallbackHelper(_CallbackExceptionHelper): def __init__(self, callback: _CookieVerifyCallback) -> None: _CallbackExceptionHelper.__init__(self) @wraps(callback) def wrapper(ssl, c_cookie, cookie_len): # type: ignore[no-untyped-def] try: conn = Connection._reverse_mapping[ssl] return callback(conn, bytes(c_cookie[0:cookie_len])) except Exception as e: self._problems.append(e) return 0 self.callback = _ffi.callback( "int (*)(SSL *, unsigned char *, unsigned int)", wrapper, ) def _asFileDescriptor(obj: Any) -> int: fd = None if not isinstance(obj, int): meth = getattr(obj, "fileno", None) if meth is not None: obj = meth() if isinstance(obj, int): fd = obj if not isinstance(fd, int): raise TypeError("argument must be an int, or have a fileno() method.") elif fd < 0: raise ValueError( "file descriptor cannot be a negative integer (%i)" % (fd,) ) return fd def OpenSSL_version(type: int) -> bytes: """ Return a string describing the version of OpenSSL in use. :param type: One of the :const:`OPENSSL_` constants defined in this module. """ return _ffi.string(_lib.OpenSSL_version(type)) SSLeay_version = OpenSSL_version def _make_requires(flag: int, error: str) -> Callable[[_T], _T]: """ 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. """ def _requires_decorator(func): # type: ignore[no-untyped-def] if not flag: @wraps(func) def explode(*args, **kwargs): # type: ignore[no-untyped-def] raise NotImplementedError(error) return explode else: return func return _requires_decorator _requires_alpn = _make_requires( _lib.Cryptography_HAS_ALPN, "ALPN not available" ) _requires_keylog = _make_requires( getattr(_lib, "Cryptography_HAS_KEYLOG", 0), "Key logging not available" ) class Session: """ 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 """ _session: Any class Context: """ :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. """ _methods: typing.ClassVar[ typing.Dict[int, typing.Tuple[Callable[[], Any], Optional[int]]] ] = { SSLv23_METHOD: (_lib.TLS_method, None), TLSv1_METHOD: (_lib.TLS_method, TLS1_VERSION), TLSv1_1_METHOD: (_lib.TLS_method, TLS1_1_VERSION), TLSv1_2_METHOD: (_lib.TLS_method, TLS1_2_VERSION), TLS_METHOD: (_lib.TLS_method, None), TLS_SERVER_METHOD: (_lib.TLS_server_method, None), TLS_CLIENT_METHOD: (_lib.TLS_client_method, None), DTLS_METHOD: (_lib.DTLS_method, None), DTLS_SERVER_METHOD: (_lib.DTLS_server_method, None), DTLS_CLIENT_METHOD: (_lib.DTLS_client_method, None), } def __init__(self, method: int) -> None: if not isinstance(method, int): raise TypeError("method must be an integer") try: method_func, version = self._methods[method] except KeyError: raise ValueError("No such protocol") method_obj = method_func() _openssl_assert(method_obj != _ffi.NULL) context = _lib.SSL_CTX_new(method_obj) _openssl_assert(context != _ffi.NULL) context = _ffi.gc(context, _lib.SSL_CTX_free) self._context = context self._passphrase_helper: Optional[_PassphraseHelper] = None self._passphrase_callback: Optional[_PassphraseCallback[Any]] = None self._passphrase_userdata: Optional[Any] = None self._verify_helper: Optional[_VerifyHelper] = None self._verify_callback: Optional[_VerifyCallback] = None self._info_callback = None self._keylog_callback = None self._tlsext_servername_callback = None self._app_data = None self._alpn_select_helper: Optional[_ALPNSelectHelper] = None self._alpn_select_callback: Optional[_ALPNSelectCallback] = None self._ocsp_helper: typing.Union[ _OCSPClientCallbackHelper, _OCSPServerCallbackHelper, None ] = None self._ocsp_callback: typing.Union[ _OCSPClientCallback[Any], _OCSPServerCallback[Any], None ] = None self._ocsp_data: Optional[Any] = None self._cookie_generate_helper: Optional[ _CookieGenerateCallbackHelper ] = None self._cookie_verify_helper: Optional[_CookieVerifyCallbackHelper] = ( None ) self.set_mode(_lib.SSL_MODE_ENABLE_PARTIAL_WRITE) if version is not None: self.set_min_proto_version(version) self.set_max_proto_version(version) def set_min_proto_version(self, version: int) -> None: """ 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. """ _openssl_assert( _lib.SSL_CTX_set_min_proto_version(self._context, version) == 1 ) def set_max_proto_version(self, version: int) -> None: """ 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. """ _openssl_assert( _lib.SSL_CTX_set_max_proto_version(self._context, version) == 1 ) def load_verify_locations( self, cafile: Optional[_StrOrBytesPath], capath: Optional[_StrOrBytesPath] = None, ) -> None: """ 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 """ if cafile is None: cafile = _ffi.NULL else: cafile = _path_bytes(cafile) if capath is None: capath = _ffi.NULL else: capath = _path_bytes(capath) load_result = _lib.SSL_CTX_load_verify_locations( self._context, cafile, capath ) if not load_result: _raise_current_error() def _wrap_callback( self, callback: _PassphraseCallback[_T] ) -> _PassphraseHelper: @wraps(callback) def wrapper(size: int, verify: bool, userdata: Any) -> bytes: return callback(size, verify, self._passphrase_userdata) return _PassphraseHelper( FILETYPE_PEM, wrapper, more_args=True, truncate=True ) def set_passwd_cb( self, callback: _PassphraseCallback[_T], userdata: Optional[_T] = None, ) -> None: """ 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 """ if not callable(callback): raise TypeError("callback must be callable") self._passphrase_helper = self._wrap_callback(callback) self._passphrase_callback = self._passphrase_helper.callback _lib.SSL_CTX_set_default_passwd_cb( self._context, self._passphrase_callback ) self._passphrase_userdata = userdata def set_default_verify_paths(self) -> None: """ 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 """ # SSL_CTX_set_default_verify_paths will attempt to load certs from # both a cafile and capath that are set at compile time. However, # it will first check environment variables and, if present, load # those paths instead set_result = _lib.SSL_CTX_set_default_verify_paths(self._context) _openssl_assert(set_result == 1) # After attempting to set default_verify_paths we need to know whether # to go down the fallback path. # First we'll check to see if any env vars have been set. If so, # we won't try to do anything else because the user has set the path # themselves. dir_env_var = _ffi.string(_lib.X509_get_default_cert_dir_env()).decode( "ascii" ) file_env_var = _ffi.string( _lib.X509_get_default_cert_file_env() ).decode("ascii") if not self._check_env_vars_set(dir_env_var, file_env_var): default_dir = _ffi.string(_lib.X509_get_default_cert_dir()) default_file = _ffi.string(_lib.X509_get_default_cert_file()) # Now we check to see if the default_dir and default_file are set # to the exact values we use in our manylinux builds. If they are # then we know to load the fallbacks if ( default_dir == _CRYPTOGRAPHY_MANYLINUX_CA_DIR and default_file == _CRYPTOGRAPHY_MANYLINUX_CA_FILE ): # This is manylinux, let's load our fallback paths self._fallback_default_verify_paths( _CERTIFICATE_FILE_LOCATIONS, _CERTIFICATE_PATH_LOCATIONS ) def _check_env_vars_set(self, dir_env_var: str, file_env_var: str) -> bool: """ Check to see if the default cert dir/file environment vars are present. :return: bool """ return ( os.environ.get(file_env_var) is not None or os.environ.get(dir_env_var) is not None ) def _fallback_default_verify_paths( self, file_path: List[str], dir_path: List[str] ) -> None: """ 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 """ for cafile in file_path: if os.path.isfile(cafile): self.load_verify_locations(cafile) break for capath in dir_path: if os.path.isdir(capath): self.load_verify_locations(None, capath) break def use_certificate_chain_file(self, certfile: _StrOrBytesPath) -> None: """ 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 """ certfile = _path_bytes(certfile) result = _lib.SSL_CTX_use_certificate_chain_file( self._context, certfile ) if not result: _raise_current_error() def use_certificate_file( self, certfile: _StrOrBytesPath, filetype: int = FILETYPE_PEM ) -> None: """ 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 """ certfile = _path_bytes(certfile) if not isinstance(filetype, int): raise TypeError("filetype must be an integer") use_result = _lib.SSL_CTX_use_certificate_file( self._context, certfile, filetype ) if not use_result: _raise_current_error() def use_certificate(self, cert: X509) -> None: """ Load a certificate from a X509 object :param cert: The X509 object :return: None """ # Mirrored at Connection.use_certificate if not isinstance(cert, X509): raise TypeError("cert must be an X509 instance") use_result = _lib.SSL_CTX_use_certificate(self._context, cert._x509) if not use_result: _raise_current_error() def add_extra_chain_cert(self, certobj: X509) -> None: """ Add certificate to chain :param certobj: The X509 certificate object to add to the chain :return: None """ if not isinstance(certobj, X509): raise TypeError("certobj must be an X509 instance") copy = _lib.X509_dup(certobj._x509) add_result = _lib.SSL_CTX_add_extra_chain_cert(self._context, copy) if not add_result: # TODO: This is untested. _lib.X509_free(copy) _raise_current_error() def _raise_passphrase_exception(self) -> None: if self._passphrase_helper is not None: self._passphrase_helper.raise_if_problem(Error) _raise_current_error() def use_privatekey_file( self, keyfile: _StrOrBytesPath, filetype: int = FILETYPE_PEM ) -> None: """ 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 """ keyfile = _path_bytes(keyfile) if not isinstance(filetype, int): raise TypeError("filetype must be an integer") use_result = _lib.SSL_CTX_use_PrivateKey_file( self._context, keyfile, filetype ) if not use_result: self._raise_passphrase_exception() def use_privatekey(self, pkey: PKey) -> None: """ Load a private key from a PKey object :param pkey: The PKey object :return: None """ # Mirrored at Connection.use_privatekey if not isinstance(pkey, PKey): raise TypeError("pkey must be a PKey instance") use_result = _lib.SSL_CTX_use_PrivateKey(self._context, pkey._pkey) if not use_result: self._raise_passphrase_exception() def check_privatekey(self) -> None: """ 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) """ if not _lib.SSL_CTX_check_private_key(self._context): _raise_current_error() def load_client_ca(self, cafile: bytes) -> None: """ 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 """ ca_list = _lib.SSL_load_client_CA_file( _text_to_bytes_and_warn("cafile", cafile) ) _openssl_assert(ca_list != _ffi.NULL) _lib.SSL_CTX_set_client_CA_list(self._context, ca_list) def set_session_id(self, buf: bytes) -> None: """ 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 """ buf = _text_to_bytes_and_warn("buf", buf) _openssl_assert( _lib.SSL_CTX_set_session_id_context(self._context, buf, len(buf)) == 1 ) def set_session_cache_mode(self, mode: int) -> None: """ 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 """ if not isinstance(mode, int): raise TypeError("mode must be an integer") return _lib.SSL_CTX_set_session_cache_mode(self._context, mode) def get_session_cache_mode(self) -> int: """ Get the current session cache mode. :returns: The currently used cache mode. .. versionadded:: 0.14 """ return _lib.SSL_CTX_get_session_cache_mode(self._context) def set_verify( self, mode: int, callback: Optional[_VerifyCallback] = None ) -> None: """ 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. """ if not isinstance(mode, int): raise TypeError("mode must be an integer") if callback is None: self._verify_helper = None self._verify_callback = None _lib.SSL_CTX_set_verify(self._context, mode, _ffi.NULL) else: if not callable(callback): raise TypeError("callback must be callable") self._verify_helper = _VerifyHelper(callback) self._verify_callback = self._verify_helper.callback _lib.SSL_CTX_set_verify(self._context, mode, self._verify_callback) def set_verify_depth(self, depth: int) -> None: """ 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 """ if not isinstance(depth, int): raise TypeError("depth must be an integer") _lib.SSL_CTX_set_verify_depth(self._context, depth) def get_verify_mode(self) -> int: """ Retrieve the Context object's verify mode, as set by :meth:`set_verify`. :return: The verify mode """ return _lib.SSL_CTX_get_verify_mode(self._context) def get_verify_depth(self) -> int: """ Retrieve the Context object's verify depth, as set by :meth:`set_verify_depth`. :return: The verify depth """ return _lib.SSL_CTX_get_verify_depth(self._context) def load_tmp_dh(self, dhfile: _StrOrBytesPath) -> None: """ Load parameters for Ephemeral Diffie-Hellman :param dhfile: The file to load EDH parameters from (``bytes`` or ``str``). :return: None """ dhfile = _path_bytes(dhfile) bio = _lib.BIO_new_file(dhfile, b"r") if bio == _ffi.NULL: _raise_current_error() bio = _ffi.gc(bio, _lib.BIO_free) dh = _lib.PEM_read_bio_DHparams(bio, _ffi.NULL, _ffi.NULL, _ffi.NULL) dh = _ffi.gc(dh, _lib.DH_free) res = _lib.SSL_CTX_set_tmp_dh(self._context, dh) _openssl_assert(res == 1) def set_tmp_ecdh(self, curve: _EllipticCurve) -> None: """ 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 """ _lib.SSL_CTX_set_tmp_ecdh(self._context, curve._to_EC_KEY()) def set_cipher_list(self, cipher_list: bytes) -> None: """ 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 """ cipher_list = _text_to_bytes_and_warn("cipher_list", cipher_list) if not isinstance(cipher_list, bytes): raise TypeError("cipher_list must be a byte string.") _openssl_assert( _lib.SSL_CTX_set_cipher_list(self._context, cipher_list) == 1 ) # In OpenSSL 1.1.1 setting the cipher list will always return TLS 1.3 # ciphers even if you pass an invalid cipher. Applications (like # Twisted) have tests that depend on an error being raised if an # invalid cipher string is passed, but without the following check # for the TLS 1.3 specific cipher suites it would never error. tmpconn = Connection(self, None) if tmpconn.get_cipher_list() == [ "TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256", "TLS_AES_128_GCM_SHA256", ]: raise Error( [ ( "SSL routines", "SSL_CTX_set_cipher_list", "no cipher match", ), ], ) def set_client_ca_list( self, certificate_authorities: Sequence[X509Name] ) -> None: """ 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 """ name_stack = _lib.sk_X509_NAME_new_null() _openssl_assert(name_stack != _ffi.NULL) try: for ca_name in certificate_authorities: if not isinstance(ca_name, X509Name): raise TypeError( f"client CAs must be X509Name objects, not " f"{type(ca_name).__name__} objects" ) copy = _lib.X509_NAME_dup(ca_name._name) _openssl_assert(copy != _ffi.NULL) push_result = _lib.sk_X509_NAME_push(name_stack, copy) if not push_result: _lib.X509_NAME_free(copy) _raise_current_error() except Exception: _lib.sk_X509_NAME_free(name_stack) raise _lib.SSL_CTX_set_client_CA_list(self._context, name_stack) def add_client_ca(self, certificate_authority: X509) -> None: """ 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 """ if not isinstance(certificate_authority, X509): raise TypeError("certificate_authority must be an X509 instance") add_result = _lib.SSL_CTX_add_client_CA( self._context, certificate_authority._x509 ) _openssl_assert(add_result == 1) def set_timeout(self, timeout: int) -> None: """ 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 """ if not isinstance(timeout, int): raise TypeError("timeout must be an integer") return _lib.SSL_CTX_set_timeout(self._context, timeout) def get_timeout(self) -> int: """ Retrieve session timeout, as set by :meth:`set_timeout`. The default is 300 seconds. :return: The session timeout """ return _lib.SSL_CTX_get_timeout(self._context) def set_info_callback( self, callback: Callable[["Connection", int, int], None] ) -> None: """ 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 """ @wraps(callback) def wrapper(ssl, where, return_code): # type: ignore[no-untyped-def] callback(Connection._reverse_mapping[ssl], where, return_code) self._info_callback = _ffi.callback( "void (*)(const SSL *, int, int)", wrapper ) _lib.SSL_CTX_set_info_callback(self._context, self._info_callback) @_requires_keylog def set_keylog_callback( self, callback: Callable[["Connection", bytes], None] ) -> None: """ 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 """ @wraps(callback) def wrapper(ssl, line): # type: ignore[no-untyped-def] line = _ffi.string(line) callback(Connection._reverse_mapping[ssl], line) self._keylog_callback = _ffi.callback( "void (*)(const SSL *, const char *)", wrapper ) _lib.SSL_CTX_set_keylog_callback(self._context, self._keylog_callback) def get_app_data(self) -> Any: """ Get the application data (supplied via :meth:`set_app_data()`) :return: The application data """ return self._app_data def set_app_data(self, data: Any) -> None: """ Set the application data (will be returned from get_app_data()) :param data: Any Python object :return: None """ self._app_data = data def get_cert_store(self) -> Optional[X509Store]: """ 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. """ store = _lib.SSL_CTX_get_cert_store(self._context) if store == _ffi.NULL: # TODO: This is untested. return None pystore = X509Store.__new__(X509Store) pystore._store = store return pystore def set_options(self, options: int) -> None: """ 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. """ if not isinstance(options, int): raise TypeError("options must be an integer") return _lib.SSL_CTX_set_options(self._context, options) def set_mode(self, mode: int) -> None: """ 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. """ if not isinstance(mode, int): raise TypeError("mode must be an integer") return _lib.SSL_CTX_set_mode(self._context, mode) def set_tlsext_servername_callback( self, callback: Callable[["Connection"], None] ) -> None: """ 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 """ @wraps(callback) def wrapper(ssl, alert, arg): # type: ignore[no-untyped-def] callback(Connection._reverse_mapping[ssl]) return 0 self._tlsext_servername_callback = _ffi.callback( "int (*)(SSL *, int *, void *)", wrapper ) _lib.SSL_CTX_set_tlsext_servername_callback( self._context, self._tlsext_servername_callback ) def set_tlsext_use_srtp(self, profiles: bytes) -> None: """ 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 """ if not isinstance(profiles, bytes): raise TypeError("profiles must be a byte string.") _openssl_assert( _lib.SSL_CTX_set_tlsext_use_srtp(self._context, profiles) == 0 ) @_requires_alpn def set_alpn_protos(self, protos: List[bytes]) -> None: """ 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']``. """ # Different versions of OpenSSL are inconsistent about how they handle # empty proto lists (see #1043), so we avoid the problem entirely by # rejecting them ourselves. if not protos: raise ValueError("at least one protocol must be specified") # Take the list of protocols and join them together, prefixing them # with their lengths. protostr = b"".join( chain.from_iterable((bytes((len(p),)), p) for p in protos) ) # Build a C string from the list. We don't need to save this off # because OpenSSL immediately copies the data out. input_str = _ffi.new("unsigned char[]", protostr) # https://www.openssl.org/docs/man1.1.0/man3/SSL_CTX_set_alpn_protos.html: # SSL_CTX_set_alpn_protos() and SSL_set_alpn_protos() # return 0 on success, and non-0 on failure. # WARNING: these functions reverse the return value convention. _openssl_assert( _lib.SSL_CTX_set_alpn_protos( self._context, input_str, len(protostr) ) == 0 ) @_requires_alpn def set_alpn_select_callback(self, callback: _ALPNSelectCallback) -> None: """ 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. """ self._alpn_select_helper = _ALPNSelectHelper(callback) self._alpn_select_callback = self._alpn_select_helper.callback _lib.SSL_CTX_set_alpn_select_cb( self._context, self._alpn_select_callback, _ffi.NULL ) def _set_ocsp_callback( self, helper: typing.Union[ _OCSPClientCallbackHelper, _OCSPServerCallbackHelper ], data: Optional[Any], ) -> None: """ This internal helper does the common work for ``set_ocsp_server_callback`` and ``set_ocsp_client_callback``, which is almost all of it. """ self._ocsp_helper = helper self._ocsp_callback = helper.callback if data is None: self._ocsp_data = _ffi.NULL else: self._ocsp_data = _ffi.new_handle(data) rc = _lib.SSL_CTX_set_tlsext_status_cb( self._context, self._ocsp_callback ) _openssl_assert(rc == 1) rc = _lib.SSL_CTX_set_tlsext_status_arg(self._context, self._ocsp_data) _openssl_assert(rc == 1) def set_ocsp_server_callback( self, callback: _OCSPServerCallback[_T], data: Optional[_T] = None, ) -> None: """ 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. """ helper = _OCSPServerCallbackHelper(callback) self._set_ocsp_callback(helper, data) def set_ocsp_client_callback( self, callback: _OCSPClientCallback[_T], data: Optional[_T] = None, ) -> None: """ 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. """ helper = _OCSPClientCallbackHelper(callback) self._set_ocsp_callback(helper, data) def set_cookie_generate_callback( self, callback: _CookieGenerateCallback ) -> None: self._cookie_generate_helper = _CookieGenerateCallbackHelper(callback) _lib.SSL_CTX_set_cookie_generate_cb( self._context, self._cookie_generate_helper.callback, ) def set_cookie_verify_callback( self, callback: _CookieVerifyCallback ) -> None: self._cookie_verify_helper = _CookieVerifyCallbackHelper(callback) _lib.SSL_CTX_set_cookie_verify_cb( self._context, self._cookie_verify_helper.callback, ) class Connection: _reverse_mapping: typing.MutableMapping[Any, "Connection"] = ( WeakValueDictionary() ) def __init__( self, context: Context, socket: Optional[socket.socket] = None ) -> None: """ 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 """ if not isinstance(context, Context): raise TypeError("context must be a Context instance") ssl = _lib.SSL_new(context._context) self._ssl = _ffi.gc(ssl, _lib.SSL_free) # We set SSL_MODE_AUTO_RETRY to handle situations where OpenSSL returns # an SSL_ERROR_WANT_READ when processing a non-application data packet # even though there is still data on the underlying transport. # See https://github.com/openssl/openssl/issues/6234 for more details. _lib.SSL_set_mode(self._ssl, _lib.SSL_MODE_AUTO_RETRY) self._context = context self._app_data = None # References to strings used for Application Layer Protocol # Negotiation. These strings get copied at some point but it's well # after the callback returns, so we have to hang them somewhere to # avoid them getting freed. self._alpn_select_callback_args = None # Reference the verify_callback of the Context. This ensures that if # set_verify is called again after the SSL object has been created we # do not point to a dangling reference self._verify_helper = context._verify_helper self._verify_callback = context._verify_callback # And likewise for the cookie callbacks self._cookie_generate_helper = context._cookie_generate_helper self._cookie_verify_helper = context._cookie_verify_helper self._reverse_mapping[self._ssl] = self if socket is None: self._socket = None # Don't set up any gc for these, SSL_free will take care of them. self._into_ssl = _lib.BIO_new(_lib.BIO_s_mem()) _openssl_assert(self._into_ssl != _ffi.NULL) self._from_ssl = _lib.BIO_new(_lib.BIO_s_mem()) _openssl_assert(self._from_ssl != _ffi.NULL) _lib.SSL_set_bio(self._ssl, self._into_ssl, self._from_ssl) else: self._into_ssl = None self._from_ssl = None self._socket = socket set_result = _lib.SSL_set_fd( self._ssl, _asFileDescriptor(self._socket) ) _openssl_assert(set_result == 1) def __getattr__(self, name: str) -> Any: """ Look up attributes on the wrapped socket object if they are not found on the Connection object. """ if self._socket is None: raise AttributeError( f"'{self.__class__.__name__}' object has no attribute '{name}'" ) else: return getattr(self._socket, name) def _raise_ssl_error(self, ssl: Any, result: int) -> None: if self._context._verify_helper is not None: self._context._verify_helper.raise_if_problem() if self._context._alpn_select_helper is not None: self._context._alpn_select_helper.raise_if_problem() if self._context._ocsp_helper is not None: self._context._ocsp_helper.raise_if_problem() error = _lib.SSL_get_error(ssl, result) if error == _lib.SSL_ERROR_WANT_READ: raise WantReadError() elif error == _lib.SSL_ERROR_WANT_WRITE: raise WantWriteError() elif error == _lib.SSL_ERROR_ZERO_RETURN: raise ZeroReturnError() elif error == _lib.SSL_ERROR_WANT_X509_LOOKUP: # TODO: This is untested. raise WantX509LookupError() elif error == _lib.SSL_ERROR_SYSCALL: if _lib.ERR_peek_error() == 0: if result < 0: if platform == "win32": errno = _ffi.getwinerror()[0] else: errno = _ffi.errno if errno != 0: raise SysCallError(errno, errorcode.get(errno)) raise SysCallError(-1, "Unexpected EOF") else: # TODO: This is untested. _raise_current_error() elif error == _lib.SSL_ERROR_SSL and _lib.ERR_peek_error() != 0: # In 3.0.x an unexpected EOF no longer triggers syscall error # but we want to maintain compatibility so we check here and # raise syscall if it is an EOF. Since we're not actually sure # what else could raise SSL_ERROR_SSL we check for the presence # of the OpenSSL 3 constant SSL_R_UNEXPECTED_EOF_WHILE_READING # and if it's not present we just raise an error, which matches # the behavior before we added this elif section peeked_error = _lib.ERR_peek_error() reason = _lib.ERR_GET_REASON(peeked_error) if _lib.Cryptography_HAS_UNEXPECTED_EOF_WHILE_READING: _openssl_assert( reason == _lib.SSL_R_UNEXPECTED_EOF_WHILE_READING ) _lib.ERR_clear_error() raise SysCallError(-1, "Unexpected EOF") else: _raise_current_error() elif error == _lib.SSL_ERROR_NONE: pass else: _raise_current_error() def get_context(self) -> Context: """ Retrieve the :class:`Context` object associated with this :class:`Connection`. """ return self._context def set_context(self, context: Context) -> None: """ Switch this connection to a new session context. :param context: A :class:`Context` instance giving the new session context to use. """ if not isinstance(context, Context): raise TypeError("context must be a Context instance") _lib.SSL_set_SSL_CTX(self._ssl, context._context) self._context = context def get_servername(self) -> Optional[bytes]: """ 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 """ name = _lib.SSL_get_servername( self._ssl, _lib.TLSEXT_NAMETYPE_host_name ) if name == _ffi.NULL: return None return _ffi.string(name) def set_verify( self, mode: int, callback: Optional[_VerifyCallback] = None ) -> None: """ Override the Context object's verification flags for this specific connection. See :py:meth:`Context.set_verify` for details. """ if not isinstance(mode, int): raise TypeError("mode must be an integer") if callback is None: self._verify_helper = None self._verify_callback = None _lib.SSL_set_verify(self._ssl, mode, _ffi.NULL) else: if not callable(callback): raise TypeError("callback must be callable") self._verify_helper = _VerifyHelper(callback) self._verify_callback = self._verify_helper.callback _lib.SSL_set_verify(self._ssl, mode, self._verify_callback) def get_verify_mode(self) -> int: """ Retrieve the Connection object's verify mode, as set by :meth:`set_verify`. :return: The verify mode """ return _lib.SSL_get_verify_mode(self._ssl) def use_certificate(self, cert: X509) -> None: """ Load a certificate from a X509 object :param cert: The X509 object :return: None """ # Mirrored from Context.use_certificate if not isinstance(cert, X509): raise TypeError("cert must be an X509 instance") use_result = _lib.SSL_use_certificate(self._ssl, cert._x509) if not use_result: _raise_current_error() def use_privatekey(self, pkey: PKey) -> None: """ Load a private key from a PKey object :param pkey: The PKey object :return: None """ # Mirrored from Context.use_privatekey if not isinstance(pkey, PKey): raise TypeError("pkey must be a PKey instance") use_result = _lib.SSL_use_PrivateKey(self._ssl, pkey._pkey) if not use_result: self._context._raise_passphrase_exception() def set_ciphertext_mtu(self, mtu: int) -> None: """ 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 """ _lib.SSL_set_mtu(self._ssl, mtu) def get_cleartext_mtu(self) -> int: """ 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 """ if not hasattr(_lib, "DTLS_get_data_mtu"): raise NotImplementedError("requires OpenSSL 1.1.1 or better") return _lib.DTLS_get_data_mtu(self._ssl) def set_tlsext_host_name(self, name: bytes) -> None: """ Set the value of the servername extension to send in the client hello. :param name: A byte string giving the name. .. versionadded:: 0.13 """ if not isinstance(name, bytes): raise TypeError("name must be a byte string") elif b"\0" in name: raise TypeError("name must not contain NUL byte") # XXX I guess this can fail sometimes? _lib.SSL_set_tlsext_host_name(self._ssl, name) def pending(self) -> int: """ 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. """ return _lib.SSL_pending(self._ssl) def send(self, buf: bytes, flags: int = 0) -> int: """ 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 """ # Backward compatibility buf = _text_to_bytes_and_warn("buf", buf) with _ffi.from_buffer(buf) as data: # check len(buf) instead of len(data) for testability if len(buf) > 2147483647: raise ValueError( "Cannot send more than 2**31-1 bytes at once." ) result = _lib.SSL_write(self._ssl, data, len(data)) self._raise_ssl_error(self._ssl, result) return result write = send def sendall(self, buf: bytes, flags: int = 0) -> int: """ 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 """ buf = _text_to_bytes_and_warn("buf", buf) with _ffi.from_buffer(buf) as data: left_to_send = len(buf) total_sent = 0 while left_to_send: # SSL_write's num arg is an int, # so we cannot send more than 2**31-1 bytes at once. result = _lib.SSL_write( self._ssl, data + total_sent, min(left_to_send, 2147483647) ) self._raise_ssl_error(self._ssl, result) total_sent += result left_to_send -= result return total_sent def recv(self, bufsiz: int, flags: Optional[int] = None) -> bytes: """ 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 """ buf = _no_zero_allocator("char[]", bufsiz) if flags is not None and flags & socket.MSG_PEEK: result = _lib.SSL_peek(self._ssl, buf, bufsiz) else: result = _lib.SSL_read(self._ssl, buf, bufsiz) self._raise_ssl_error(self._ssl, result) return _ffi.buffer(buf, result)[:] read = recv def recv_into( self, buffer: Any, # collections.abc.Buffer once we use Python 3.12+ nbytes: Optional[int] = None, flags: Optional[int] = None, ) -> int: """ 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. """ if nbytes is None: nbytes = len(buffer) else: nbytes = min(nbytes, len(buffer)) # We need to create a temporary buffer. This is annoying, it would be # better if we could pass memoryviews straight into the SSL_read call, # but right now we can't. Revisit this if CFFI gets that ability. buf = _no_zero_allocator("char[]", nbytes) if flags is not None and flags & socket.MSG_PEEK: result = _lib.SSL_peek(self._ssl, buf, nbytes) else: result = _lib.SSL_read(self._ssl, buf, nbytes) self._raise_ssl_error(self._ssl, result) # This strange line is all to avoid a memory copy. The buffer protocol # should allow us to assign a CFFI buffer to the LHS of this line, but # on CPython 3.3+ that segfaults. As a workaround, we can temporarily # wrap it in a memoryview. buffer[:result] = memoryview(_ffi.buffer(buf, result)) return result def _handle_bio_errors(self, bio: Any, result: int) -> typing.NoReturn: if _lib.BIO_should_retry(bio): if _lib.BIO_should_read(bio): raise WantReadError() elif _lib.BIO_should_write(bio): # TODO: This is untested. raise WantWriteError() elif _lib.BIO_should_io_special(bio): # TODO: This is untested. I think io_special means the socket # BIO has a not-yet connected socket. raise ValueError("BIO_should_io_special") else: # TODO: This is untested. raise ValueError("unknown bio failure") else: # TODO: This is untested. _raise_current_error() def bio_read(self, bufsiz: int) -> bytes: """ 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. """ if self._from_ssl is None: raise TypeError("Connection sock was not None") if not isinstance(bufsiz, int): raise TypeError("bufsiz must be an integer") buf = _no_zero_allocator("char[]", bufsiz) result = _lib.BIO_read(self._from_ssl, buf, bufsiz) if result <= 0: self._handle_bio_errors(self._from_ssl, result) return _ffi.buffer(buf, result)[:] def bio_write(self, buf: bytes) -> int: """ 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 """ buf = _text_to_bytes_and_warn("buf", buf) if self._into_ssl is None: raise TypeError("Connection sock was not None") with _ffi.from_buffer(buf) as data: result = _lib.BIO_write(self._into_ssl, data, len(data)) if result <= 0: self._handle_bio_errors(self._into_ssl, result) return result def renegotiate(self) -> bool: """ Renegotiate the session. :return: True if the renegotiation can be started, False otherwise """ if not self.renegotiate_pending(): _openssl_assert(_lib.SSL_renegotiate(self._ssl) == 1) return True return False def do_handshake(self) -> None: """ 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. """ result = _lib.SSL_do_handshake(self._ssl) self._raise_ssl_error(self._ssl, result) def renegotiate_pending(self) -> bool: """ 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 """ return _lib.SSL_renegotiate_pending(self._ssl) == 1 def total_renegotiations(self) -> int: """ Find out the total number of renegotiations. :return: The number of renegotiations. """ return _lib.SSL_total_renegotiations(self._ssl) def connect(self, addr: Any) -> None: """ 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 """ _lib.SSL_set_connect_state(self._ssl) return self._socket.connect(addr) # type: ignore[return-value, union-attr] def connect_ex(self, addr: Any) -> int: """ 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 """ connect_ex = self._socket.connect_ex # type: ignore[union-attr] self.set_connect_state() return connect_ex(addr) def accept(self) -> Tuple["Connection", Any]: """ 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`. """ client, addr = self._socket.accept() # type: ignore[union-attr] conn = Connection(self._context, client) conn.set_accept_state() return (conn, addr) def DTLSv1_listen(self) -> None: """ Call the OpenSSL function DTLSv1_listen on this connection. See the OpenSSL manual for more details. :return: None """ # Possible future extension: return the BIO_ADDR in some form. bio_addr = _lib.BIO_ADDR_new() try: result = _lib.DTLSv1_listen(self._ssl, bio_addr) finally: _lib.BIO_ADDR_free(bio_addr) # DTLSv1_listen is weird. A zero return value means 'didn't find a # ClientHello with valid cookie, but keep trying'. So basically # WantReadError. But it doesn't work correctly with _raise_ssl_error. # So we raise it manually instead. if self._cookie_generate_helper is not None: self._cookie_generate_helper.raise_if_problem() if self._cookie_verify_helper is not None: self._cookie_verify_helper.raise_if_problem() if result == 0: raise WantReadError() if result < 0: self._raise_ssl_error(self._ssl, result) def DTLSv1_get_timeout(self) -> Optional[int]: """ 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. """ ptv_sec = _ffi.new("time_t *") ptv_usec = _ffi.new("long *") if _lib.Cryptography_DTLSv1_get_timeout(self._ssl, ptv_sec, ptv_usec): return ptv_sec[0] + (ptv_usec[0] / 1000000) else: return None def DTLSv1_handle_timeout(self) -> bool: """ Handles any timeout events which have become pending on a DTLS SSL object. :return: `True` if there was a pending timeout, `False` otherwise. """ result = _lib.DTLSv1_handle_timeout(self._ssl) if result < 0: self._raise_ssl_error(self._ssl, result) assert False, "unreachable" else: return bool(result) def bio_shutdown(self) -> None: """ 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 """ if self._from_ssl is None: raise TypeError("Connection sock was not None") _lib.BIO_set_mem_eof_return(self._into_ssl, 0) def shutdown(self) -> bool: """ 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). """ result = _lib.SSL_shutdown(self._ssl) if result < 0: self._raise_ssl_error(self._ssl, result) assert False, "unreachable" elif result > 0: return True else: return False def get_cipher_list(self) -> List[str]: """ Retrieve the list of ciphers used by the Connection object. :return: A list of native cipher strings. """ ciphers = [] for i in count(): result = _lib.SSL_get_cipher_list(self._ssl, i) if result == _ffi.NULL: break ciphers.append(_ffi.string(result).decode("utf-8")) return ciphers def get_client_ca_list(self) -> List[X509Name]: """ 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 """ ca_names = _lib.SSL_get_client_CA_list(self._ssl) if ca_names == _ffi.NULL: # TODO: This is untested. return [] result = [] for i in range(_lib.sk_X509_NAME_num(ca_names)): name = _lib.sk_X509_NAME_value(ca_names, i) copy = _lib.X509_NAME_dup(name) _openssl_assert(copy != _ffi.NULL) pyname = X509Name.__new__(X509Name) pyname._name = _ffi.gc(copy, _lib.X509_NAME_free) result.append(pyname) return result def makefile(self, *args: Any, **kwargs: Any) -> typing.NoReturn: """ The makefile() method is not implemented, since there is no dup semantics for SSL connections :raise: NotImplementedError """ raise NotImplementedError( "Cannot make file object of OpenSSL.SSL.Connection" ) def get_app_data(self) -> Any: """ Retrieve application data as set by :meth:`set_app_data`. :return: The application data """ return self._app_data def set_app_data(self, data: Any) -> None: """ Set application data :param data: The application data :return: None """ self._app_data = data def get_shutdown(self) -> int: """ Get the shutdown state of the Connection. :return: The shutdown state, a bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN. """ return _lib.SSL_get_shutdown(self._ssl) def set_shutdown(self, state: int) -> None: """ Set the shutdown state of the Connection. :param state: bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN. :return: None """ if not isinstance(state, int): raise TypeError("state must be an integer") _lib.SSL_set_shutdown(self._ssl, state) def get_state_string(self) -> bytes: """ Retrieve a verbose string detailing the state of the Connection. :return: A string representing the state """ return _ffi.string(_lib.SSL_state_string_long(self._ssl)) def server_random(self) -> Optional[bytes]: """ Retrieve the random value used with the server hello message. :return: A string representing the state """ session = _lib.SSL_get_session(self._ssl) if session == _ffi.NULL: return None length = _lib.SSL_get_server_random(self._ssl, _ffi.NULL, 0) _openssl_assert(length > 0) outp = _no_zero_allocator("unsigned char[]", length) _lib.SSL_get_server_random(self._ssl, outp, length) return _ffi.buffer(outp, length)[:] def client_random(self) -> Optional[bytes]: """ Retrieve the random value used with the client hello message. :return: A string representing the state """ session = _lib.SSL_get_session(self._ssl) if session == _ffi.NULL: return None length = _lib.SSL_get_client_random(self._ssl, _ffi.NULL, 0) _openssl_assert(length > 0) outp = _no_zero_allocator("unsigned char[]", length) _lib.SSL_get_client_random(self._ssl, outp, length) return _ffi.buffer(outp, length)[:] def master_key(self) -> Optional[bytes]: """ Retrieve the value of the master key for this session. :return: A string representing the state """ session = _lib.SSL_get_session(self._ssl) if session == _ffi.NULL: return None length = _lib.SSL_SESSION_get_master_key(session, _ffi.NULL, 0) _openssl_assert(length > 0) outp = _no_zero_allocator("unsigned char[]", length) _lib.SSL_SESSION_get_master_key(session, outp, length) return _ffi.buffer(outp, length)[:] def export_keying_material( self, label: bytes, olen: int, context: Optional[bytes] = None ) -> bytes: """ 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 """ outp = _no_zero_allocator("unsigned char[]", olen) context_buf = _ffi.NULL context_len = 0 use_context = 0 if context is not None: context_buf = context context_len = len(context) use_context = 1 success = _lib.SSL_export_keying_material( self._ssl, outp, olen, label, len(label), context_buf, context_len, use_context, ) _openssl_assert(success == 1) return _ffi.buffer(outp, olen)[:] def sock_shutdown(self, *args: Any, **kwargs: Any) -> None: """ Call the :meth:`shutdown` method of the underlying socket. See :manpage:`shutdown(2)`. :return: What the socket's shutdown() method returns """ return self._socket.shutdown(*args, **kwargs) # type: ignore[return-value, union-attr] def get_certificate(self) -> Optional[X509]: """ Retrieve the local certificate (if any) :return: The local certificate """ cert = _lib.SSL_get_certificate(self._ssl) if cert != _ffi.NULL: _lib.X509_up_ref(cert) return X509._from_raw_x509_ptr(cert) return None def get_peer_certificate(self) -> Optional[X509]: """ Retrieve the other side's certificate (if any) :return: The peer's certificate """ cert = _lib.SSL_get_peer_certificate(self._ssl) if cert != _ffi.NULL: return X509._from_raw_x509_ptr(cert) return None @staticmethod def _cert_stack_to_list(cert_stack: Any) -> List[X509]: """ Internal helper to convert a STACK_OF(X509) to a list of X509 instances. """ result = [] for i in range(_lib.sk_X509_num(cert_stack)): cert = _lib.sk_X509_value(cert_stack, i) _openssl_assert(cert != _ffi.NULL) res = _lib.X509_up_ref(cert) _openssl_assert(res >= 1) pycert = X509._from_raw_x509_ptr(cert) result.append(pycert) return result def get_peer_cert_chain(self) -> Optional[List[X509]]: """ 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. """ cert_stack = _lib.SSL_get_peer_cert_chain(self._ssl) if cert_stack == _ffi.NULL: return None return self._cert_stack_to_list(cert_stack) def get_verified_chain(self) -> Optional[List[X509]]: """ 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 """ # OpenSSL 1.1+ cert_stack = _lib.SSL_get0_verified_chain(self._ssl) if cert_stack == _ffi.NULL: return None return self._cert_stack_to_list(cert_stack) def want_read(self) -> bool: """ 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 """ return _lib.SSL_want_read(self._ssl) def want_write(self) -> bool: """ Checks if there is data to write to the transport layer to complete an operation. :return: True iff there is data to write """ return _lib.SSL_want_write(self._ssl) def set_accept_state(self) -> None: """ Set the connection to work in server mode. The handshake will be handled automatically by read/write. :return: None """ _lib.SSL_set_accept_state(self._ssl) def set_connect_state(self) -> None: """ Set the connection to work in client mode. The handshake will be handled automatically by read/write. :return: None """ _lib.SSL_set_connect_state(self._ssl) def get_session(self) -> Optional[Session]: """ Returns the Session currently used. :return: An instance of :class:`OpenSSL.SSL.Session` or :obj:`None` if no session exists. .. versionadded:: 0.14 """ session = _lib.SSL_get1_session(self._ssl) if session == _ffi.NULL: return None pysession = Session.__new__(Session) pysession._session = _ffi.gc(session, _lib.SSL_SESSION_free) return pysession def set_session(self, session: Session) -> None: """ 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 """ if not isinstance(session, Session): raise TypeError("session must be a Session instance") result = _lib.SSL_set_session(self._ssl, session._session) _openssl_assert(result == 1) def _get_finished_message( self, function: Callable[[Any, Any, int], int] ) -> Optional[bytes]: """ 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. """ # The OpenSSL documentation says nothing about what might happen if the # count argument given is zero. Specifically, it doesn't say whether # the output buffer may be NULL in that case or not. Inspection of the # implementation reveals that it calls memcpy() unconditionally. # Section 7.1.4, paragraph 1 of the C standard suggests that # memcpy(NULL, source, 0) is not guaranteed to produce defined (let # alone desirable) behavior (though it probably does on just about # every implementation...) # # Allocate a tiny buffer to pass in (instead of just passing NULL as # one might expect) for the initial call so as to be safe against this # potentially undefined behavior. empty = _ffi.new("char[]", 0) size = function(self._ssl, empty, 0) if size == 0: # No Finished message so far. return None buf = _no_zero_allocator("char[]", size) function(self._ssl, buf, size) return _ffi.buffer(buf, size)[:] def get_finished(self) -> Optional[bytes]: """ 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 """ return self._get_finished_message(_lib.SSL_get_finished) def get_peer_finished(self) -> Optional[bytes]: """ 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 """ return self._get_finished_message(_lib.SSL_get_peer_finished) def get_cipher_name(self) -> Optional[str]: """ 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 """ cipher = _lib.SSL_get_current_cipher(self._ssl) if cipher == _ffi.NULL: return None else: name = _ffi.string(_lib.SSL_CIPHER_get_name(cipher)) return name.decode("utf-8") def get_cipher_bits(self) -> Optional[int]: """ 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 """ cipher = _lib.SSL_get_current_cipher(self._ssl) if cipher == _ffi.NULL: return None else: return _lib.SSL_CIPHER_get_bits(cipher, _ffi.NULL) def get_cipher_version(self) -> Optional[str]: """ 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 """ cipher = _lib.SSL_get_current_cipher(self._ssl) if cipher == _ffi.NULL: return None else: version = _ffi.string(_lib.SSL_CIPHER_get_version(cipher)) return version.decode("utf-8") def get_protocol_version_name(self) -> str: """ 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. """ version = _ffi.string(_lib.SSL_get_version(self._ssl)) return version.decode("utf-8") def get_protocol_version(self) -> int: """ 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. """ version = _lib.SSL_version(self._ssl) return version @_requires_alpn def set_alpn_protos(self, protos: List[bytes]) -> None: """ 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']``. """ # Different versions of OpenSSL are inconsistent about how they handle # empty proto lists (see #1043), so we avoid the problem entirely by # rejecting them ourselves. if not protos: raise ValueError("at least one protocol must be specified") # Take the list of protocols and join them together, prefixing them # with their lengths. protostr = b"".join( chain.from_iterable((bytes((len(p),)), p) for p in protos) ) # Build a C string from the list. We don't need to save this off # because OpenSSL immediately copies the data out. input_str = _ffi.new("unsigned char[]", protostr) # https://www.openssl.org/docs/man1.1.0/man3/SSL_CTX_set_alpn_protos.html: # SSL_CTX_set_alpn_protos() and SSL_set_alpn_protos() # return 0 on success, and non-0 on failure. # WARNING: these functions reverse the return value convention. _openssl_assert( _lib.SSL_set_alpn_protos(self._ssl, input_str, len(protostr)) == 0 ) @_requires_alpn def get_alpn_proto_negotiated(self) -> bytes: """ 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. """ data = _ffi.new("unsigned char **") data_len = _ffi.new("unsigned int *") _lib.SSL_get0_alpn_selected(self._ssl, data, data_len) if not data_len: return b"" return _ffi.buffer(data[0], data_len[0])[:] def get_selected_srtp_profile(self) -> bytes: """ 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. """ profile = _lib.SSL_get_selected_srtp_profile(self._ssl) if not profile: return b"" return _ffi.string(profile.name) def request_ocsp(self) -> None: """ 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`. """ rc = _lib.SSL_set_tlsext_status_type( self._ssl, _lib.TLSEXT_STATUSTYPE_ocsp ) _openssl_assert(rc == 1) crypto.py 0000644 00000300353 15030415060 0006434 0 ustar 00 import calendar import datetime import functools import typing from base64 import b16encode from functools import partial from os import PathLike from typing import ( Any, Callable, Iterable, List, NoReturn, Optional, Sequence, Set, Tuple, Type, Union, ) from cryptography import utils, x509 from cryptography.hazmat.primitives.asymmetric import ( dsa, ec, ed448, ed25519, rsa, ) from OpenSSL._util import ( UNSPECIFIED as _UNSPECIFIED, ) from OpenSSL._util import ( byte_string as _byte_string, ) from OpenSSL._util import ( exception_from_error_queue as _exception_from_error_queue, ) from OpenSSL._util import ( ffi as _ffi, ) from OpenSSL._util import ( lib as _lib, ) from OpenSSL._util import ( make_assert as _make_assert, ) from OpenSSL._util import ( path_bytes as _path_bytes, ) from OpenSSL._util import ( text_to_bytes_and_warn as _text_to_bytes_and_warn, ) __all__ = [ "FILETYPE_PEM", "FILETYPE_ASN1", "FILETYPE_TEXT", "TYPE_RSA", "TYPE_DSA", "Error", "PKey", "get_elliptic_curves", "get_elliptic_curve", "X509Name", "X509Extension", "X509Req", "X509", "X509StoreFlags", "X509Store", "X509StoreContextError", "X509StoreContext", "load_certificate", "dump_certificate", "dump_publickey", "dump_privatekey", "Revoked", "CRL", "load_publickey", "load_privatekey", "dump_certificate_request", "load_certificate_request", "sign", "verify", "dump_crl", "load_crl", ] _Key = Union[ dsa.DSAPrivateKey, dsa.DSAPublicKey, ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey, ed25519.Ed25519PrivateKey, ed25519.Ed25519PublicKey, ed448.Ed448PrivateKey, ed448.Ed448PublicKey, rsa.RSAPrivateKey, rsa.RSAPublicKey, ] StrOrBytesPath = Union[str, bytes, PathLike] PassphraseCallableT = Union[bytes, Callable[..., bytes]] FILETYPE_PEM: int = _lib.SSL_FILETYPE_PEM FILETYPE_ASN1: int = _lib.SSL_FILETYPE_ASN1 # TODO This was an API mistake. OpenSSL has no such constant. FILETYPE_TEXT = 2**16 - 1 TYPE_RSA: int = _lib.EVP_PKEY_RSA TYPE_DSA: int = _lib.EVP_PKEY_DSA TYPE_DH: int = _lib.EVP_PKEY_DH TYPE_EC: int = _lib.EVP_PKEY_EC class Error(Exception): """ An error occurred in an `OpenSSL.crypto` API. """ _raise_current_error = partial(_exception_from_error_queue, Error) _openssl_assert = _make_assert(Error) def _untested_error(where: str) -> NoReturn: """ An OpenSSL API failed somehow. Additionally, the failure which was encountered isn't one that's exercised by the test suite so future behavior of pyOpenSSL is now somewhat less predictable. """ raise RuntimeError(f"Unknown {where} failure") def _new_mem_buf(buffer: Optional[bytes] = None) -> Any: """ Allocate a new OpenSSL memory BIO. Arrange for the garbage collector to clean it up automatically. :param buffer: None or some bytes to use to put into the BIO so that they can be read out. """ if buffer is None: bio = _lib.BIO_new(_lib.BIO_s_mem()) free = _lib.BIO_free else: data = _ffi.new("char[]", buffer) bio = _lib.BIO_new_mem_buf(data, len(buffer)) # Keep the memory alive as long as the bio is alive! def free(bio: Any, ref: Any = data) -> Any: return _lib.BIO_free(bio) _openssl_assert(bio != _ffi.NULL) bio = _ffi.gc(bio, free) return bio def _bio_to_string(bio: Any) -> bytes: """ Copy the contents of an OpenSSL BIO object into a Python byte string. """ result_buffer = _ffi.new("char**") buffer_length = _lib.BIO_get_mem_data(bio, result_buffer) return _ffi.buffer(result_buffer[0], buffer_length)[:] def _set_asn1_time(boundary: Any, when: bytes) -> None: """ The the time value of an ASN1 time object. @param boundary: An ASN1_TIME pointer (or an object safely castable to that type) which will have its value set. @param when: A string representation of the desired time value. @raise TypeError: If C{when} is not a L{bytes} string. @raise ValueError: If C{when} does not represent a time in the required format. @raise RuntimeError: If the time value cannot be set for some other (unspecified) reason. """ if not isinstance(when, bytes): raise TypeError("when must be a byte string") # ASN1_TIME_set_string validates the string without writing anything # when the destination is NULL. _openssl_assert(boundary != _ffi.NULL) set_result = _lib.ASN1_TIME_set_string(boundary, when) if set_result == 0: raise ValueError("Invalid string") def _new_asn1_time(when: bytes) -> Any: """ Behaves like _set_asn1_time but returns a new ASN1_TIME object. @param when: A string representation of the desired time value. @raise TypeError: If C{when} is not a L{bytes} string. @raise ValueError: If C{when} does not represent a time in the required format. @raise RuntimeError: If the time value cannot be set for some other (unspecified) reason. """ ret = _lib.ASN1_TIME_new() _openssl_assert(ret != _ffi.NULL) ret = _ffi.gc(ret, _lib.ASN1_TIME_free) _set_asn1_time(ret, when) return ret def _get_asn1_time(timestamp: Any) -> Optional[bytes]: """ Retrieve the time value of an ASN1 time object. @param timestamp: An ASN1_GENERALIZEDTIME* (or an object safely castable to that type) from which the time value will be retrieved. @return: The time value from C{timestamp} as a L{bytes} string in a certain format. Or C{None} if the object contains no time value. """ string_timestamp = _ffi.cast("ASN1_STRING*", timestamp) if _lib.ASN1_STRING_length(string_timestamp) == 0: return None elif ( _lib.ASN1_STRING_type(string_timestamp) == _lib.V_ASN1_GENERALIZEDTIME ): return _ffi.string(_lib.ASN1_STRING_get0_data(string_timestamp)) else: generalized_timestamp = _ffi.new("ASN1_GENERALIZEDTIME**") _lib.ASN1_TIME_to_generalizedtime(timestamp, generalized_timestamp) if generalized_timestamp[0] == _ffi.NULL: # This may happen: # - if timestamp was not an ASN1_TIME # - if allocating memory for the ASN1_GENERALIZEDTIME failed # - if a copy of the time data from timestamp cannot be made for # the newly allocated ASN1_GENERALIZEDTIME # # These are difficult to test. cffi enforces the ASN1_TIME type. # Memory allocation failures are a pain to trigger # deterministically. _untested_error("ASN1_TIME_to_generalizedtime") else: string_timestamp = _ffi.cast( "ASN1_STRING*", generalized_timestamp[0] ) string_data = _lib.ASN1_STRING_get0_data(string_timestamp) string_result = _ffi.string(string_data) _lib.ASN1_GENERALIZEDTIME_free(generalized_timestamp[0]) return string_result class _X509NameInvalidator: def __init__(self) -> None: self._names: List[X509Name] = [] def add(self, name: "X509Name") -> None: self._names.append(name) def clear(self) -> None: for name in self._names: # Breaks the object, but also prevents UAF! del name._name class PKey: """ A class representing an DSA or RSA public key or key pair. """ _only_public = False _initialized = True def __init__(self) -> None: pkey = _lib.EVP_PKEY_new() self._pkey = _ffi.gc(pkey, _lib.EVP_PKEY_free) self._initialized = False def to_cryptography_key(self) -> _Key: """ Export as a ``cryptography`` key. :rtype: One of ``cryptography``'s `key interfaces`_. .. _key interfaces: https://cryptography.io/en/latest/hazmat/\ primitives/asymmetric/rsa/#key-interfaces .. versionadded:: 16.1.0 """ from cryptography.hazmat.primitives.serialization import ( load_der_private_key, load_der_public_key, ) if self._only_public: der = dump_publickey(FILETYPE_ASN1, self) return load_der_public_key(der) else: der = dump_privatekey(FILETYPE_ASN1, self) return load_der_private_key(der, None) @classmethod def from_cryptography_key(cls, crypto_key: _Key) -> "PKey": """ Construct based on a ``cryptography`` *crypto_key*. :param crypto_key: A ``cryptography`` key. :type crypto_key: One of ``cryptography``'s `key interfaces`_. :rtype: PKey .. versionadded:: 16.1.0 """ if not isinstance( crypto_key, ( dsa.DSAPrivateKey, dsa.DSAPublicKey, ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey, ed25519.Ed25519PrivateKey, ed25519.Ed25519PublicKey, ed448.Ed448PrivateKey, ed448.Ed448PublicKey, rsa.RSAPrivateKey, rsa.RSAPublicKey, ), ): raise TypeError("Unsupported key type") from cryptography.hazmat.primitives.serialization import ( Encoding, NoEncryption, PrivateFormat, PublicFormat, ) if isinstance( crypto_key, ( dsa.DSAPublicKey, ec.EllipticCurvePublicKey, ed25519.Ed25519PublicKey, ed448.Ed448PublicKey, rsa.RSAPublicKey, ), ): return load_publickey( FILETYPE_ASN1, crypto_key.public_bytes( Encoding.DER, PublicFormat.SubjectPublicKeyInfo ), ) else: der = crypto_key.private_bytes( Encoding.DER, PrivateFormat.PKCS8, NoEncryption() ) return load_privatekey(FILETYPE_ASN1, der) def generate_key(self, type: int, bits: int) -> None: """ Generate a key pair of the given type, with the given number of bits. This generates a key "into" the this object. :param type: The key type. :type type: :py:data:`TYPE_RSA` or :py:data:`TYPE_DSA` :param bits: The number of bits. :type bits: :py:data:`int` ``>= 0`` :raises TypeError: If :py:data:`type` or :py:data:`bits` isn't of the appropriate type. :raises ValueError: If the number of bits isn't an integer of the appropriate size. :return: ``None`` """ if not isinstance(type, int): raise TypeError("type must be an integer") if not isinstance(bits, int): raise TypeError("bits must be an integer") if type == TYPE_RSA: if bits <= 0: raise ValueError("Invalid number of bits") # TODO Check error return exponent = _lib.BN_new() exponent = _ffi.gc(exponent, _lib.BN_free) _lib.BN_set_word(exponent, _lib.RSA_F4) rsa = _lib.RSA_new() result = _lib.RSA_generate_key_ex(rsa, bits, exponent, _ffi.NULL) _openssl_assert(result == 1) result = _lib.EVP_PKEY_assign_RSA(self._pkey, rsa) _openssl_assert(result == 1) elif type == TYPE_DSA: dsa = _lib.DSA_new() _openssl_assert(dsa != _ffi.NULL) dsa = _ffi.gc(dsa, _lib.DSA_free) res = _lib.DSA_generate_parameters_ex( dsa, bits, _ffi.NULL, 0, _ffi.NULL, _ffi.NULL, _ffi.NULL ) _openssl_assert(res == 1) _openssl_assert(_lib.DSA_generate_key(dsa) == 1) _openssl_assert(_lib.EVP_PKEY_set1_DSA(self._pkey, dsa) == 1) else: raise Error("No such key type") self._initialized = True def check(self) -> bool: """ Check the consistency of an RSA private key. This is the Python equivalent of OpenSSL's ``RSA_check_key``. :return: ``True`` if key is consistent. :raise OpenSSL.crypto.Error: if the key is inconsistent. :raise TypeError: if the key is of a type which cannot be checked. Only RSA keys can currently be checked. """ if self._only_public: raise TypeError("public key only") if _lib.EVP_PKEY_type(self.type()) != _lib.EVP_PKEY_RSA: raise TypeError("Only RSA keys can currently be checked.") rsa = _lib.EVP_PKEY_get1_RSA(self._pkey) rsa = _ffi.gc(rsa, _lib.RSA_free) result = _lib.RSA_check_key(rsa) if result == 1: return True _raise_current_error() def type(self) -> int: """ Returns the type of the key :return: The type of the key. """ return _lib.EVP_PKEY_id(self._pkey) def bits(self) -> int: """ Returns the number of bits of the key :return: The number of bits of the key. """ return _lib.EVP_PKEY_bits(self._pkey) class _EllipticCurve: """ A representation of a supported elliptic curve. @cvar _curves: :py:obj:`None` until an attempt is made to load the curves. Thereafter, a :py:type:`set` containing :py:type:`_EllipticCurve` instances each of which represents one curve supported by the system. @type _curves: :py:type:`NoneType` or :py:type:`set` """ _curves = None def __ne__(self, other: Any) -> bool: """ Implement cooperation with the right-hand side argument of ``!=``. Python 3 seems to have dropped this cooperation in this very narrow circumstance. """ if isinstance(other, _EllipticCurve): return super().__ne__(other) return NotImplemented @classmethod def _load_elliptic_curves(cls, lib: Any) -> Set["_EllipticCurve"]: """ Get the curves supported by OpenSSL. :param lib: The OpenSSL library binding object. :return: A :py:type:`set` of ``cls`` instances giving the names of the elliptic curves the underlying library supports. """ num_curves = lib.EC_get_builtin_curves(_ffi.NULL, 0) builtin_curves = _ffi.new("EC_builtin_curve[]", num_curves) # The return value on this call should be num_curves again. We # could check it to make sure but if it *isn't* then.. what could # we do? Abort the whole process, I suppose...? -exarkun lib.EC_get_builtin_curves(builtin_curves, num_curves) return set(cls.from_nid(lib, c.nid) for c in builtin_curves) @classmethod def _get_elliptic_curves(cls, lib: Any) -> Set["_EllipticCurve"]: """ Get, cache, and return the curves supported by OpenSSL. :param lib: The OpenSSL library binding object. :return: A :py:type:`set` of ``cls`` instances giving the names of the elliptic curves the underlying library supports. """ if cls._curves is None: cls._curves = cls._load_elliptic_curves(lib) return cls._curves @classmethod def from_nid(cls, lib: Any, nid: int) -> "_EllipticCurve": """ Instantiate a new :py:class:`_EllipticCurve` associated with the given OpenSSL NID. :param lib: The OpenSSL library binding object. :param nid: The OpenSSL NID the resulting curve object will represent. This must be a curve NID (and not, for example, a hash NID) or subsequent operations will fail in unpredictable ways. :type nid: :py:class:`int` :return: The curve object. """ return cls(lib, nid, _ffi.string(lib.OBJ_nid2sn(nid)).decode("ascii")) def __init__(self, lib: Any, nid: int, name: str) -> None: """ :param _lib: The :py:mod:`cryptography` binding instance used to interface with OpenSSL. :param _nid: The OpenSSL NID identifying the curve this object represents. :type _nid: :py:class:`int` :param name: The OpenSSL short name identifying the curve this object represents. :type name: :py:class:`unicode` """ self._lib = lib self._nid = nid self.name = name def __repr__(self) -> str: return f"<Curve {self.name!r}>" def _to_EC_KEY(self) -> Any: """ Create a new OpenSSL EC_KEY structure initialized to use this curve. The structure is automatically garbage collected when the Python object is garbage collected. """ key = self._lib.EC_KEY_new_by_curve_name(self._nid) return _ffi.gc(key, _lib.EC_KEY_free) def get_elliptic_curves() -> Set["_EllipticCurve"]: """ Return a set of objects representing the elliptic curves supported in the OpenSSL build in use. The curve objects have a :py:class:`unicode` ``name`` attribute by which they identify themselves. The curve objects are useful as values for the argument accepted by :py:meth:`Context.set_tmp_ecdh` to specify which elliptical curve should be used for ECDHE key exchange. """ return _EllipticCurve._get_elliptic_curves(_lib) def get_elliptic_curve(name: str) -> _EllipticCurve: """ Return a single curve object selected by name. See :py:func:`get_elliptic_curves` for information about curve objects. :param name: The OpenSSL short name identifying the curve object to retrieve. :type name: :py:class:`unicode` If the named curve is not supported then :py:class:`ValueError` is raised. """ for curve in get_elliptic_curves(): if curve.name == name: return curve raise ValueError("unknown curve name", name) @functools.total_ordering class X509Name: """ An X.509 Distinguished Name. :ivar countryName: The country of the entity. :ivar C: Alias for :py:attr:`countryName`. :ivar stateOrProvinceName: The state or province of the entity. :ivar ST: Alias for :py:attr:`stateOrProvinceName`. :ivar localityName: The locality of the entity. :ivar L: Alias for :py:attr:`localityName`. :ivar organizationName: The organization name of the entity. :ivar O: Alias for :py:attr:`organizationName`. :ivar organizationalUnitName: The organizational unit of the entity. :ivar OU: Alias for :py:attr:`organizationalUnitName` :ivar commonName: The common name of the entity. :ivar CN: Alias for :py:attr:`commonName`. :ivar emailAddress: The e-mail address of the entity. """ def __init__(self, name: "X509Name") -> None: """ Create a new X509Name, copying the given X509Name instance. :param name: The name to copy. :type name: :py:class:`X509Name` """ name = _lib.X509_NAME_dup(name._name) self._name: Any = _ffi.gc(name, _lib.X509_NAME_free) def __setattr__(self, name: str, value: Any) -> None: if name.startswith("_"): return super().__setattr__(name, value) # Note: we really do not want str subclasses here, so we do not use # isinstance. if type(name) is not str: raise TypeError( f"attribute name must be string, not " f"'{type(value).__name__:.200}'" ) nid = _lib.OBJ_txt2nid(_byte_string(name)) if nid == _lib.NID_undef: try: _raise_current_error() except Error: pass raise AttributeError("No such attribute") # If there's an old entry for this NID, remove it for i in range(_lib.X509_NAME_entry_count(self._name)): ent = _lib.X509_NAME_get_entry(self._name, i) ent_obj = _lib.X509_NAME_ENTRY_get_object(ent) ent_nid = _lib.OBJ_obj2nid(ent_obj) if nid == ent_nid: ent = _lib.X509_NAME_delete_entry(self._name, i) _lib.X509_NAME_ENTRY_free(ent) break if isinstance(value, str): value = value.encode("utf-8") add_result = _lib.X509_NAME_add_entry_by_NID( self._name, nid, _lib.MBSTRING_UTF8, value, -1, -1, 0 ) if not add_result: _raise_current_error() def __getattr__(self, name: str) -> Optional[str]: """ Find attribute. An X509Name object has the following attributes: countryName (alias C), stateOrProvince (alias ST), locality (alias L), organization (alias O), organizationalUnit (alias OU), commonName (alias CN) and more... """ nid = _lib.OBJ_txt2nid(_byte_string(name)) if nid == _lib.NID_undef: # This is a bit weird. OBJ_txt2nid indicated failure, but it seems # a lower level function, a2d_ASN1_OBJECT, also feels the need to # push something onto the error queue. If we don't clean that up # now, someone else will bump into it later and be quite confused. # See lp#314814. try: _raise_current_error() except Error: pass raise AttributeError("No such attribute") entry_index = _lib.X509_NAME_get_index_by_NID(self._name, nid, -1) if entry_index == -1: return None entry = _lib.X509_NAME_get_entry(self._name, entry_index) data = _lib.X509_NAME_ENTRY_get_data(entry) result_buffer = _ffi.new("unsigned char**") data_length = _lib.ASN1_STRING_to_UTF8(result_buffer, data) _openssl_assert(data_length >= 0) try: result = _ffi.buffer(result_buffer[0], data_length)[:].decode( "utf-8" ) finally: # XXX untested _lib.OPENSSL_free(result_buffer[0]) return result def __eq__(self, other: Any) -> bool: if not isinstance(other, X509Name): return NotImplemented return _lib.X509_NAME_cmp(self._name, other._name) == 0 def __lt__(self, other: Any) -> bool: if not isinstance(other, X509Name): return NotImplemented return _lib.X509_NAME_cmp(self._name, other._name) < 0 def __repr__(self) -> str: """ String representation of an X509Name """ result_buffer = _ffi.new("char[]", 512) format_result = _lib.X509_NAME_oneline( self._name, result_buffer, len(result_buffer) ) _openssl_assert(format_result != _ffi.NULL) return "<X509Name object '{}'>".format( _ffi.string(result_buffer).decode("utf-8"), ) def hash(self) -> int: """ Return an integer representation of the first four bytes of the MD5 digest of the DER representation of the name. This is the Python equivalent of OpenSSL's ``X509_NAME_hash``. :return: The (integer) hash of this name. :rtype: :py:class:`int` """ return _lib.X509_NAME_hash(self._name) def der(self) -> bytes: """ Return the DER encoding of this name. :return: The DER encoded form of this name. :rtype: :py:class:`bytes` """ result_buffer = _ffi.new("unsigned char**") encode_result = _lib.i2d_X509_NAME(self._name, result_buffer) _openssl_assert(encode_result >= 0) string_result = _ffi.buffer(result_buffer[0], encode_result)[:] _lib.OPENSSL_free(result_buffer[0]) return string_result def get_components(self) -> List[Tuple[bytes, bytes]]: """ Returns the components of this name, as a sequence of 2-tuples. :return: The components of this name. :rtype: :py:class:`list` of ``name, value`` tuples. """ result = [] for i in range(_lib.X509_NAME_entry_count(self._name)): ent = _lib.X509_NAME_get_entry(self._name, i) fname = _lib.X509_NAME_ENTRY_get_object(ent) fval = _lib.X509_NAME_ENTRY_get_data(ent) nid = _lib.OBJ_obj2nid(fname) name = _lib.OBJ_nid2sn(nid) # ffi.string does not handle strings containing NULL bytes # (which may have been generated by old, broken software) value = _ffi.buffer( _lib.ASN1_STRING_get0_data(fval), _lib.ASN1_STRING_length(fval) )[:] result.append((_ffi.string(name), value)) return result class X509Extension: """ An X.509 v3 certificate extension. """ def __init__( self, type_name: bytes, critical: bool, value: bytes, subject: Optional["X509"] = None, issuer: Optional["X509"] = None, ) -> None: """ Initializes an X509 extension. :param type_name: The name of the type of extension_ to create. :type type_name: :py:data:`bytes` :param bool critical: A flag indicating whether this is a critical extension. :param value: The OpenSSL textual representation of the extension's value. :type value: :py:data:`bytes` :param subject: Optional X509 certificate to use as subject. :type subject: :py:class:`X509` :param issuer: Optional X509 certificate to use as issuer. :type issuer: :py:class:`X509` .. _extension: https://www.openssl.org/docs/manmaster/man5/ x509v3_config.html#STANDARD-EXTENSIONS """ ctx = _ffi.new("X509V3_CTX*") # A context is necessary for any extension which uses the r2i # conversion method. That is, X509V3_EXT_nconf may segfault if passed # a NULL ctx. Start off by initializing most of the fields to NULL. _lib.X509V3_set_ctx(ctx, _ffi.NULL, _ffi.NULL, _ffi.NULL, _ffi.NULL, 0) # We have no configuration database - but perhaps we should (some # extensions may require it). _lib.X509V3_set_ctx_nodb(ctx) # Initialize the subject and issuer, if appropriate. ctx is a local, # and as far as I can tell none of the X509V3_* APIs invoked here steal # any references, so no need to mess with reference counts or # duplicates. if issuer is not None: if not isinstance(issuer, X509): raise TypeError("issuer must be an X509 instance") ctx.issuer_cert = issuer._x509 if subject is not None: if not isinstance(subject, X509): raise TypeError("subject must be an X509 instance") ctx.subject_cert = subject._x509 if critical: # There are other OpenSSL APIs which would let us pass in critical # separately, but they're harder to use, and since value is already # a pile of crappy junk smuggling a ton of utterly important # structured data, what's the point of trying to avoid nasty stuff # with strings? (However, X509V3_EXT_i2d in particular seems like # it would be a better API to invoke. I do not know where to get # the ext_struc it desires for its last parameter, though.) value = b"critical," + value extension = _lib.X509V3_EXT_nconf(_ffi.NULL, ctx, type_name, value) if extension == _ffi.NULL: _raise_current_error() self._extension = _ffi.gc(extension, _lib.X509_EXTENSION_free) @property def _nid(self) -> Any: return _lib.OBJ_obj2nid( _lib.X509_EXTENSION_get_object(self._extension) ) _prefixes: typing.ClassVar[typing.Dict[int, str]] = { _lib.GEN_EMAIL: "email", _lib.GEN_DNS: "DNS", _lib.GEN_URI: "URI", } def _subjectAltNameString(self) -> str: names = _ffi.cast( "GENERAL_NAMES*", _lib.X509V3_EXT_d2i(self._extension) ) names = _ffi.gc(names, _lib.GENERAL_NAMES_free) parts = [] for i in range(_lib.sk_GENERAL_NAME_num(names)): name = _lib.sk_GENERAL_NAME_value(names, i) try: label = self._prefixes[name.type] except KeyError: bio = _new_mem_buf() _lib.GENERAL_NAME_print(bio, name) parts.append(_bio_to_string(bio).decode("utf-8")) else: value = _ffi.buffer(name.d.ia5.data, name.d.ia5.length)[ : ].decode("utf-8") parts.append(label + ":" + value) return ", ".join(parts) def __str__(self) -> str: """ :return: a nice text representation of the extension """ if _lib.NID_subject_alt_name == self._nid: return self._subjectAltNameString() bio = _new_mem_buf() print_result = _lib.X509V3_EXT_print(bio, self._extension, 0, 0) _openssl_assert(print_result != 0) return _bio_to_string(bio).decode("utf-8") def get_critical(self) -> bool: """ Returns the critical field of this X.509 extension. :return: The critical field. """ return _lib.X509_EXTENSION_get_critical(self._extension) def get_short_name(self) -> bytes: """ Returns the short type name of this X.509 extension. The result is a byte string such as :py:const:`b"basicConstraints"`. :return: The short type name. :rtype: :py:data:`bytes` .. versionadded:: 0.12 """ obj = _lib.X509_EXTENSION_get_object(self._extension) nid = _lib.OBJ_obj2nid(obj) # OpenSSL 3.1.0 has a bug where nid2sn returns NULL for NIDs that # previously returned UNDEF. This is a workaround for that issue. # https://github.com/openssl/openssl/commit/908ba3ed9adbb3df90f76 buf = _lib.OBJ_nid2sn(nid) if buf != _ffi.NULL: return _ffi.string(buf) else: return b"UNDEF" def get_data(self) -> bytes: """ Returns the data of the X509 extension, encoded as ASN.1. :return: The ASN.1 encoded data of this X509 extension. :rtype: :py:data:`bytes` .. versionadded:: 0.12 """ octet_result = _lib.X509_EXTENSION_get_data(self._extension) string_result = _ffi.cast("ASN1_STRING*", octet_result) char_result = _lib.ASN1_STRING_get0_data(string_result) result_length = _lib.ASN1_STRING_length(string_result) return _ffi.buffer(char_result, result_length)[:] _X509ExtensionInternal = X509Extension utils.deprecated( X509Extension, __name__, ( "X509Extension support in pyOpenSSL is deprecated. You should use the " "APIs in cryptography." ), DeprecationWarning, name="X509Extension", ) class X509Req: """ An X.509 certificate signing requests. """ def __init__(self) -> None: req = _lib.X509_REQ_new() self._req = _ffi.gc(req, _lib.X509_REQ_free) # Default to version 0. self.set_version(0) def to_cryptography(self) -> x509.CertificateSigningRequest: """ Export as a ``cryptography`` certificate signing request. :rtype: ``cryptography.x509.CertificateSigningRequest`` .. versionadded:: 17.1.0 """ from cryptography.x509 import load_der_x509_csr der = _dump_certificate_request_internal(FILETYPE_ASN1, self) return load_der_x509_csr(der) @classmethod def from_cryptography( cls, crypto_req: x509.CertificateSigningRequest ) -> "X509Req": """ Construct based on a ``cryptography`` *crypto_req*. :param crypto_req: A ``cryptography`` X.509 certificate signing request :type crypto_req: ``cryptography.x509.CertificateSigningRequest`` :rtype: X509Req .. versionadded:: 17.1.0 """ if not isinstance(crypto_req, x509.CertificateSigningRequest): raise TypeError("Must be a certificate signing request") from cryptography.hazmat.primitives.serialization import Encoding der = crypto_req.public_bytes(Encoding.DER) return _load_certificate_request_internal(FILETYPE_ASN1, der) def set_pubkey(self, pkey: PKey) -> None: """ Set the public key of the certificate signing request. :param pkey: The public key to use. :type pkey: :py:class:`PKey` :return: ``None`` """ set_result = _lib.X509_REQ_set_pubkey(self._req, pkey._pkey) _openssl_assert(set_result == 1) def get_pubkey(self) -> PKey: """ Get the public key of the certificate signing request. :return: The public key. :rtype: :py:class:`PKey` """ pkey = PKey.__new__(PKey) pkey._pkey = _lib.X509_REQ_get_pubkey(self._req) _openssl_assert(pkey._pkey != _ffi.NULL) pkey._pkey = _ffi.gc(pkey._pkey, _lib.EVP_PKEY_free) pkey._only_public = True return pkey def set_version(self, version: int) -> None: """ Set the version subfield (RFC 2986, section 4.1) of the certificate request. :param int version: The version number. :return: ``None`` """ if not isinstance(version, int): raise TypeError("version must be an int") if version != 0: raise ValueError( "Invalid version. The only valid version for X509Req is 0." ) set_result = _lib.X509_REQ_set_version(self._req, version) _openssl_assert(set_result == 1) def get_version(self) -> int: """ Get the version subfield (RFC 2459, section 4.1.2.1) of the certificate request. :return: The value of the version subfield. :rtype: :py:class:`int` """ return _lib.X509_REQ_get_version(self._req) def get_subject(self) -> X509Name: """ Return the subject of this certificate signing request. This creates a new :class:`X509Name` that wraps the underlying subject name field on the certificate signing request. Modifying it will modify the underlying signing request, and will have the effect of modifying any other :class:`X509Name` that refers to this subject. :return: The subject of this certificate signing request. :rtype: :class:`X509Name` """ name = X509Name.__new__(X509Name) name._name = _lib.X509_REQ_get_subject_name(self._req) _openssl_assert(name._name != _ffi.NULL) # The name is owned by the X509Req structure. As long as the X509Name # Python object is alive, keep the X509Req Python object alive. name._owner = self return name def add_extensions( self, extensions: Iterable[_X509ExtensionInternal] ) -> None: """ Add extensions to the certificate signing request. :param extensions: The X.509 extensions to add. :type extensions: iterable of :py:class:`X509Extension` :return: ``None`` """ stack = _lib.sk_X509_EXTENSION_new_null() _openssl_assert(stack != _ffi.NULL) stack = _ffi.gc(stack, _lib.sk_X509_EXTENSION_free) for ext in extensions: if not isinstance(ext, _X509ExtensionInternal): raise ValueError("One of the elements is not an X509Extension") # TODO push can fail (here and elsewhere) _lib.sk_X509_EXTENSION_push(stack, ext._extension) add_result = _lib.X509_REQ_add_extensions(self._req, stack) _openssl_assert(add_result == 1) def get_extensions(self) -> List[_X509ExtensionInternal]: """ Get X.509 extensions in the certificate signing request. :return: The X.509 extensions in this request. :rtype: :py:class:`list` of :py:class:`X509Extension` objects. .. versionadded:: 0.15 """ exts = [] native_exts_obj = _lib.X509_REQ_get_extensions(self._req) native_exts_obj = _ffi.gc( native_exts_obj, lambda x: _lib.sk_X509_EXTENSION_pop_free( x, _ffi.addressof(_lib._original_lib, "X509_EXTENSION_free"), ), ) for i in range(_lib.sk_X509_EXTENSION_num(native_exts_obj)): ext = _X509ExtensionInternal.__new__(_X509ExtensionInternal) extension = _lib.X509_EXTENSION_dup( _lib.sk_X509_EXTENSION_value(native_exts_obj, i) ) ext._extension = _ffi.gc(extension, _lib.X509_EXTENSION_free) exts.append(ext) return exts def sign(self, pkey: PKey, digest: str) -> None: """ Sign the certificate signing request with this key and digest type. :param pkey: The key pair to sign with. :type pkey: :py:class:`PKey` :param digest: The name of the message digest to use for the signature, e.g. :py:data:`"sha256"`. :type digest: :py:class:`str` :return: ``None`` """ if pkey._only_public: raise ValueError("Key has only public part") if not pkey._initialized: raise ValueError("Key is uninitialized") digest_obj = _lib.EVP_get_digestbyname(_byte_string(digest)) if digest_obj == _ffi.NULL: raise ValueError("No such digest method") sign_result = _lib.X509_REQ_sign(self._req, pkey._pkey, digest_obj) _openssl_assert(sign_result > 0) def verify(self, pkey: PKey) -> bool: """ Verifies the signature on this certificate signing request. :param PKey key: A public key. :return: ``True`` if the signature is correct. :rtype: bool :raises OpenSSL.crypto.Error: If the signature is invalid or there is a problem verifying the signature. """ if not isinstance(pkey, PKey): raise TypeError("pkey must be a PKey instance") result = _lib.X509_REQ_verify(self._req, pkey._pkey) if result <= 0: _raise_current_error() return result _X509ReqInternal = X509Req utils.deprecated( X509Req, __name__, ( "CSR support in pyOpenSSL is deprecated. You should use the APIs " "in cryptography." ), DeprecationWarning, name="X509Req", ) class X509: """ An X.509 certificate. """ def __init__(self) -> None: x509 = _lib.X509_new() _openssl_assert(x509 != _ffi.NULL) self._x509 = _ffi.gc(x509, _lib.X509_free) self._issuer_invalidator = _X509NameInvalidator() self._subject_invalidator = _X509NameInvalidator() @classmethod def _from_raw_x509_ptr(cls, x509: Any) -> "X509": cert = cls.__new__(cls) cert._x509 = _ffi.gc(x509, _lib.X509_free) cert._issuer_invalidator = _X509NameInvalidator() cert._subject_invalidator = _X509NameInvalidator() return cert def to_cryptography(self) -> x509.Certificate: """ Export as a ``cryptography`` certificate. :rtype: ``cryptography.x509.Certificate`` .. versionadded:: 17.1.0 """ from cryptography.x509 import load_der_x509_certificate der = dump_certificate(FILETYPE_ASN1, self) return load_der_x509_certificate(der) @classmethod def from_cryptography(cls, crypto_cert: x509.Certificate) -> "X509": """ Construct based on a ``cryptography`` *crypto_cert*. :param crypto_key: A ``cryptography`` X.509 certificate. :type crypto_key: ``cryptography.x509.Certificate`` :rtype: X509 .. versionadded:: 17.1.0 """ if not isinstance(crypto_cert, x509.Certificate): raise TypeError("Must be a certificate") from cryptography.hazmat.primitives.serialization import Encoding der = crypto_cert.public_bytes(Encoding.DER) return load_certificate(FILETYPE_ASN1, der) def set_version(self, version: int) -> None: """ Set the version number of the certificate. Note that the version value is zero-based, eg. a value of 0 is V1. :param version: The version number of the certificate. :type version: :py:class:`int` :return: ``None`` """ if not isinstance(version, int): raise TypeError("version must be an integer") _openssl_assert(_lib.X509_set_version(self._x509, version) == 1) def get_version(self) -> int: """ Return the version number of the certificate. :return: The version number of the certificate. :rtype: :py:class:`int` """ return _lib.X509_get_version(self._x509) def get_pubkey(self) -> PKey: """ Get the public key of the certificate. :return: The public key. :rtype: :py:class:`PKey` """ pkey = PKey.__new__(PKey) pkey._pkey = _lib.X509_get_pubkey(self._x509) if pkey._pkey == _ffi.NULL: _raise_current_error() pkey._pkey = _ffi.gc(pkey._pkey, _lib.EVP_PKEY_free) pkey._only_public = True return pkey def set_pubkey(self, pkey: PKey) -> None: """ Set the public key of the certificate. :param pkey: The public key. :type pkey: :py:class:`PKey` :return: :py:data:`None` """ if not isinstance(pkey, PKey): raise TypeError("pkey must be a PKey instance") set_result = _lib.X509_set_pubkey(self._x509, pkey._pkey) _openssl_assert(set_result == 1) def sign(self, pkey: PKey, digest: str) -> None: """ Sign the certificate with this key and digest type. :param pkey: The key to sign with. :type pkey: :py:class:`PKey` :param digest: The name of the message digest to use. :type digest: :py:class:`str` :return: :py:data:`None` """ if not isinstance(pkey, PKey): raise TypeError("pkey must be a PKey instance") if pkey._only_public: raise ValueError("Key only has public part") if not pkey._initialized: raise ValueError("Key is uninitialized") evp_md = _lib.EVP_get_digestbyname(_byte_string(digest)) if evp_md == _ffi.NULL: raise ValueError("No such digest method") sign_result = _lib.X509_sign(self._x509, pkey._pkey, evp_md) _openssl_assert(sign_result > 0) def get_signature_algorithm(self) -> bytes: """ Return the signature algorithm used in the certificate. :return: The name of the algorithm. :rtype: :py:class:`bytes` :raises ValueError: If the signature algorithm is undefined. .. versionadded:: 0.13 """ sig_alg = _lib.X509_get0_tbs_sigalg(self._x509) alg = _ffi.new("ASN1_OBJECT **") _lib.X509_ALGOR_get0(alg, _ffi.NULL, _ffi.NULL, sig_alg) nid = _lib.OBJ_obj2nid(alg[0]) if nid == _lib.NID_undef: raise ValueError("Undefined signature algorithm") return _ffi.string(_lib.OBJ_nid2ln(nid)) def digest(self, digest_name: str) -> bytes: """ Return the digest of the X509 object. :param digest_name: The name of the digest algorithm to use. :type digest_name: :py:class:`str` :return: The digest of the object, formatted as :py:const:`b":"`-delimited hex pairs. :rtype: :py:class:`bytes` """ digest = _lib.EVP_get_digestbyname(_byte_string(digest_name)) if digest == _ffi.NULL: raise ValueError("No such digest method") result_buffer = _ffi.new("unsigned char[]", _lib.EVP_MAX_MD_SIZE) result_length = _ffi.new("unsigned int[]", 1) result_length[0] = len(result_buffer) digest_result = _lib.X509_digest( self._x509, digest, result_buffer, result_length ) _openssl_assert(digest_result == 1) return b":".join( [ b16encode(ch).upper() for ch in _ffi.buffer(result_buffer, result_length[0]) ] ) def subject_name_hash(self) -> bytes: """ Return the hash of the X509 subject. :return: The hash of the subject. :rtype: :py:class:`bytes` """ return _lib.X509_subject_name_hash(self._x509) def set_serial_number(self, serial: int) -> None: """ Set the serial number of the certificate. :param serial: The new serial number. :type serial: :py:class:`int` :return: :py:data`None` """ if not isinstance(serial, int): raise TypeError("serial must be an integer") hex_serial = hex(serial)[2:] hex_serial_bytes = hex_serial.encode("ascii") bignum_serial = _ffi.new("BIGNUM**") # BN_hex2bn stores the result in &bignum. Unless it doesn't feel like # it. If bignum is still NULL after this call, then the return value # is actually the result. I hope. -exarkun small_serial = _lib.BN_hex2bn(bignum_serial, hex_serial_bytes) if bignum_serial[0] == _ffi.NULL: set_result = _lib.ASN1_INTEGER_set( _lib.X509_get_serialNumber(self._x509), small_serial ) if set_result: # TODO Not tested _raise_current_error() else: asn1_serial = _lib.BN_to_ASN1_INTEGER(bignum_serial[0], _ffi.NULL) _lib.BN_free(bignum_serial[0]) if asn1_serial == _ffi.NULL: # TODO Not tested _raise_current_error() asn1_serial = _ffi.gc(asn1_serial, _lib.ASN1_INTEGER_free) set_result = _lib.X509_set_serialNumber(self._x509, asn1_serial) _openssl_assert(set_result == 1) def get_serial_number(self) -> int: """ Return the serial number of this certificate. :return: The serial number. :rtype: int """ asn1_serial = _lib.X509_get_serialNumber(self._x509) bignum_serial = _lib.ASN1_INTEGER_to_BN(asn1_serial, _ffi.NULL) try: hex_serial = _lib.BN_bn2hex(bignum_serial) try: hexstring_serial = _ffi.string(hex_serial) serial = int(hexstring_serial, 16) return serial finally: _lib.OPENSSL_free(hex_serial) finally: _lib.BN_free(bignum_serial) def gmtime_adj_notAfter(self, amount: int) -> None: """ Adjust the time stamp on which the certificate stops being valid. :param int amount: The number of seconds by which to adjust the timestamp. :return: ``None`` """ if not isinstance(amount, int): raise TypeError("amount must be an integer") notAfter = _lib.X509_getm_notAfter(self._x509) _lib.X509_gmtime_adj(notAfter, amount) def gmtime_adj_notBefore(self, amount: int) -> None: """ Adjust the timestamp on which the certificate starts being valid. :param amount: The number of seconds by which to adjust the timestamp. :return: ``None`` """ if not isinstance(amount, int): raise TypeError("amount must be an integer") notBefore = _lib.X509_getm_notBefore(self._x509) _lib.X509_gmtime_adj(notBefore, amount) def has_expired(self) -> bool: """ Check whether the certificate has expired. :return: ``True`` if the certificate has expired, ``False`` otherwise. :rtype: bool """ time_bytes = self.get_notAfter() if time_bytes is None: raise ValueError("Unable to determine notAfter") time_string = time_bytes.decode("utf-8") not_after = datetime.datetime.strptime(time_string, "%Y%m%d%H%M%SZ") UTC = datetime.timezone.utc utcnow = datetime.datetime.now(UTC).replace(tzinfo=None) return not_after < utcnow def _get_boundary_time(self, which: Any) -> Optional[bytes]: return _get_asn1_time(which(self._x509)) def get_notBefore(self) -> Optional[bytes]: """ Get the timestamp at which the certificate starts being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :return: A timestamp string, or ``None`` if there is none. :rtype: bytes or NoneType """ return self._get_boundary_time(_lib.X509_getm_notBefore) def _set_boundary_time( self, which: Callable[..., Any], when: bytes ) -> None: return _set_asn1_time(which(self._x509), when) def set_notBefore(self, when: bytes) -> None: """ Set the timestamp at which the certificate starts being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :param bytes when: A timestamp string. :return: ``None`` """ return self._set_boundary_time(_lib.X509_getm_notBefore, when) def get_notAfter(self) -> Optional[bytes]: """ Get the timestamp at which the certificate stops being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :return: A timestamp string, or ``None`` if there is none. :rtype: bytes or NoneType """ return self._get_boundary_time(_lib.X509_getm_notAfter) def set_notAfter(self, when: bytes) -> None: """ Set the timestamp at which the certificate stops being valid. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ :param bytes when: A timestamp string. :return: ``None`` """ return self._set_boundary_time(_lib.X509_getm_notAfter, when) def _get_name(self, which: Any) -> X509Name: name = X509Name.__new__(X509Name) name._name = which(self._x509) _openssl_assert(name._name != _ffi.NULL) # The name is owned by the X509 structure. As long as the X509Name # Python object is alive, keep the X509 Python object alive. name._owner = self return name def _set_name(self, which: Any, name: X509Name) -> None: if not isinstance(name, X509Name): raise TypeError("name must be an X509Name") set_result = which(self._x509, name._name) _openssl_assert(set_result == 1) def get_issuer(self) -> X509Name: """ Return the issuer of this certificate. This creates a new :class:`X509Name` that wraps the underlying issuer name field on the certificate. Modifying it will modify the underlying certificate, and will have the effect of modifying any other :class:`X509Name` that refers to this issuer. :return: The issuer of this certificate. :rtype: :class:`X509Name` """ name = self._get_name(_lib.X509_get_issuer_name) self._issuer_invalidator.add(name) return name def set_issuer(self, issuer: X509Name) -> None: """ Set the issuer of this certificate. :param issuer: The issuer. :type issuer: :py:class:`X509Name` :return: ``None`` """ self._set_name(_lib.X509_set_issuer_name, issuer) self._issuer_invalidator.clear() def get_subject(self) -> X509Name: """ Return the subject of this certificate. This creates a new :class:`X509Name` that wraps the underlying subject name field on the certificate. Modifying it will modify the underlying certificate, and will have the effect of modifying any other :class:`X509Name` that refers to this subject. :return: The subject of this certificate. :rtype: :class:`X509Name` """ name = self._get_name(_lib.X509_get_subject_name) self._subject_invalidator.add(name) return name def set_subject(self, subject: X509Name) -> None: """ Set the subject of this certificate. :param subject: The subject. :type subject: :py:class:`X509Name` :return: ``None`` """ self._set_name(_lib.X509_set_subject_name, subject) self._subject_invalidator.clear() def get_extension_count(self) -> int: """ Get the number of extensions on this certificate. :return: The number of extensions. :rtype: :py:class:`int` .. versionadded:: 0.12 """ return _lib.X509_get_ext_count(self._x509) def add_extensions( self, extensions: Iterable[_X509ExtensionInternal] ) -> None: """ Add extensions to the certificate. :param extensions: The extensions to add. :type extensions: An iterable of :py:class:`X509Extension` objects. :return: ``None`` """ for ext in extensions: if not isinstance(ext, _X509ExtensionInternal): raise ValueError("One of the elements is not an X509Extension") add_result = _lib.X509_add_ext(self._x509, ext._extension, -1) if not add_result: _raise_current_error() def get_extension(self, index: int) -> _X509ExtensionInternal: """ Get a specific extension of the certificate by index. Extensions on a certificate are kept in order. The index parameter selects which extension will be returned. :param int index: The index of the extension to retrieve. :return: The extension at the specified index. :rtype: :py:class:`X509Extension` :raises IndexError: If the extension index was out of bounds. .. versionadded:: 0.12 """ ext = _X509ExtensionInternal.__new__(_X509ExtensionInternal) ext._extension = _lib.X509_get_ext(self._x509, index) if ext._extension == _ffi.NULL: raise IndexError("extension index out of bounds") extension = _lib.X509_EXTENSION_dup(ext._extension) ext._extension = _ffi.gc(extension, _lib.X509_EXTENSION_free) return ext class X509StoreFlags: """ Flags for X509 verification, used to change the behavior of :class:`X509Store`. See `OpenSSL Verification Flags`_ for details. .. _OpenSSL Verification Flags: https://www.openssl.org/docs/manmaster/man3/X509_VERIFY_PARAM_set_flags.html """ CRL_CHECK: int = _lib.X509_V_FLAG_CRL_CHECK CRL_CHECK_ALL: int = _lib.X509_V_FLAG_CRL_CHECK_ALL IGNORE_CRITICAL: int = _lib.X509_V_FLAG_IGNORE_CRITICAL X509_STRICT: int = _lib.X509_V_FLAG_X509_STRICT ALLOW_PROXY_CERTS: int = _lib.X509_V_FLAG_ALLOW_PROXY_CERTS POLICY_CHECK: int = _lib.X509_V_FLAG_POLICY_CHECK EXPLICIT_POLICY: int = _lib.X509_V_FLAG_EXPLICIT_POLICY INHIBIT_MAP: int = _lib.X509_V_FLAG_INHIBIT_MAP CHECK_SS_SIGNATURE: int = _lib.X509_V_FLAG_CHECK_SS_SIGNATURE PARTIAL_CHAIN: int = _lib.X509_V_FLAG_PARTIAL_CHAIN class X509Store: """ An X.509 store. An X.509 store is used to describe a context in which to verify a certificate. A description of a context may include a set of certificates to trust, a set of certificate revocation lists, verification flags and more. An X.509 store, being only a description, cannot be used by itself to verify a certificate. To carry out the actual verification process, see :class:`X509StoreContext`. """ def __init__(self) -> None: store = _lib.X509_STORE_new() self._store = _ffi.gc(store, _lib.X509_STORE_free) def add_cert(self, cert: X509) -> None: """ Adds a trusted certificate to this store. Adding a certificate with this method adds this certificate as a *trusted* certificate. :param X509 cert: The certificate to add to this store. :raises TypeError: If the certificate is not an :class:`X509`. :raises OpenSSL.crypto.Error: If OpenSSL was unhappy with your certificate. :return: ``None`` if the certificate was added successfully. """ if not isinstance(cert, X509): raise TypeError() res = _lib.X509_STORE_add_cert(self._store, cert._x509) _openssl_assert(res == 1) def add_crl( self, crl: Union["_CRLInternal", x509.CertificateRevocationList] ) -> None: """ Add a certificate revocation list to this store. The certificate revocation lists added to a store will only be used if the associated flags are configured to check certificate revocation lists. .. versionadded:: 16.1.0 :param crl: The certificate revocation list to add to this store. :type crl: ``Union[CRL, cryptography.x509.CertificateRevocationList]`` :return: ``None`` if the certificate revocation list was added successfully. """ if isinstance(crl, x509.CertificateRevocationList): from cryptography.hazmat.primitives.serialization import Encoding bio = _new_mem_buf(crl.public_bytes(Encoding.DER)) openssl_crl = _lib.d2i_X509_CRL_bio(bio, _ffi.NULL) if openssl_crl == _ffi.NULL: _raise_current_error() crl = _ffi.gc(openssl_crl, _lib.X509_CRL_free) elif isinstance(crl, _CRLInternal): crl = crl._crl else: raise TypeError( "CRL must be of type OpenSSL.crypto.CRL or " "cryptography.x509.CertificateRevocationList" ) _openssl_assert(_lib.X509_STORE_add_crl(self._store, crl) != 0) def set_flags(self, flags: int) -> None: """ Set verification flags to this store. Verification flags can be combined by oring them together. .. note:: Setting a verification flag sometimes requires clients to add additional information to the store, otherwise a suitable error will be raised. For example, in setting flags to enable CRL checking a suitable CRL must be added to the store otherwise an error will be raised. .. versionadded:: 16.1.0 :param int flags: The verification flags to set on this store. See :class:`X509StoreFlags` for available constants. :return: ``None`` if the verification flags were successfully set. """ _openssl_assert(_lib.X509_STORE_set_flags(self._store, flags) != 0) def set_time(self, vfy_time: datetime.datetime) -> None: """ Set the time against which the certificates are verified. Normally the current time is used. .. note:: For example, you can determine if a certificate was valid at a given time. .. versionadded:: 17.0.0 :param datetime vfy_time: The verification time to set on this store. :return: ``None`` if the verification time was successfully set. """ param = _lib.X509_VERIFY_PARAM_new() param = _ffi.gc(param, _lib.X509_VERIFY_PARAM_free) _lib.X509_VERIFY_PARAM_set_time( param, calendar.timegm(vfy_time.timetuple()) ) _openssl_assert(_lib.X509_STORE_set1_param(self._store, param) != 0) def load_locations( self, cafile: StrOrBytesPath, capath: Optional[StrOrBytesPath] = None ) -> None: """ Let X509Store 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 *cafile* or *capath* may be ``None``. .. note:: Both *cafile* and *capath* may be set simultaneously. Call this method multiple times to add more than one location. For example, CA certificates, and certificate revocation list bundles may be passed in *cafile* in subsequent calls to this method. .. versionadded:: 20.0 :param cafile: In which file we can find the certificates (``bytes`` or ``unicode``). :param capath: In which directory we can find the certificates (``bytes`` or ``unicode``). :return: ``None`` if the locations were set successfully. :raises OpenSSL.crypto.Error: If both *cafile* and *capath* is ``None`` or the locations could not be set for any reason. """ if cafile is None: cafile = _ffi.NULL else: cafile = _path_bytes(cafile) if capath is None: capath = _ffi.NULL else: capath = _path_bytes(capath) load_result = _lib.X509_STORE_load_locations( self._store, cafile, capath ) if not load_result: _raise_current_error() class X509StoreContextError(Exception): """ An exception raised when an error occurred while verifying a certificate using `OpenSSL.X509StoreContext.verify_certificate`. :ivar certificate: The certificate which caused verificate failure. :type certificate: :class:`X509` """ def __init__( self, message: str, errors: List[Any], certificate: X509 ) -> None: super().__init__(message) self.errors = errors self.certificate = certificate class X509StoreContext: """ An X.509 store context. An X.509 store context is used to carry out the actual verification process of a certificate in a described context. For describing such a context, see :class:`X509Store`. :param X509Store store: The certificates which will be trusted for the purposes of any verifications. :param X509 certificate: The certificate to be verified. :param chain: List of untrusted certificates that may be used for building the certificate chain. May be ``None``. :type chain: :class:`list` of :class:`X509` """ def __init__( self, store: X509Store, certificate: X509, chain: Optional[Sequence[X509]] = None, ) -> None: self._store = store self._cert = certificate self._chain = self._build_certificate_stack(chain) @staticmethod def _build_certificate_stack( certificates: Optional[Sequence[X509]], ) -> None: def cleanup(s: Any) -> None: # Equivalent to sk_X509_pop_free, but we don't # currently have a CFFI binding for that available for i in range(_lib.sk_X509_num(s)): x = _lib.sk_X509_value(s, i) _lib.X509_free(x) _lib.sk_X509_free(s) if certificates is None or len(certificates) == 0: return _ffi.NULL stack = _lib.sk_X509_new_null() _openssl_assert(stack != _ffi.NULL) stack = _ffi.gc(stack, cleanup) for cert in certificates: if not isinstance(cert, X509): raise TypeError("One of the elements is not an X509 instance") _openssl_assert(_lib.X509_up_ref(cert._x509) > 0) if _lib.sk_X509_push(stack, cert._x509) <= 0: _lib.X509_free(cert._x509) _raise_current_error() return stack @staticmethod def _exception_from_context(store_ctx: Any) -> X509StoreContextError: """ Convert an OpenSSL native context error failure into a Python exception. When a call to native OpenSSL X509_verify_cert fails, additional information about the failure can be obtained from the store context. """ message = _ffi.string( _lib.X509_verify_cert_error_string( _lib.X509_STORE_CTX_get_error(store_ctx) ) ).decode("utf-8") errors = [ _lib.X509_STORE_CTX_get_error(store_ctx), _lib.X509_STORE_CTX_get_error_depth(store_ctx), message, ] # A context error should always be associated with a certificate, so we # expect this call to never return :class:`None`. _x509 = _lib.X509_STORE_CTX_get_current_cert(store_ctx) _cert = _lib.X509_dup(_x509) pycert = X509._from_raw_x509_ptr(_cert) return X509StoreContextError(message, errors, pycert) def _verify_certificate(self) -> Any: """ Verifies the certificate and runs an X509_STORE_CTX containing the results. :raises X509StoreContextError: If an error occurred when validating a certificate in the context. Sets ``certificate`` attribute to indicate which certificate caused the error. """ store_ctx = _lib.X509_STORE_CTX_new() _openssl_assert(store_ctx != _ffi.NULL) store_ctx = _ffi.gc(store_ctx, _lib.X509_STORE_CTX_free) ret = _lib.X509_STORE_CTX_init( store_ctx, self._store._store, self._cert._x509, self._chain ) _openssl_assert(ret == 1) ret = _lib.X509_verify_cert(store_ctx) if ret <= 0: raise self._exception_from_context(store_ctx) return store_ctx def set_store(self, store: X509Store) -> None: """ Set the context's X.509 store. .. versionadded:: 0.15 :param X509Store store: The store description which will be used for the purposes of any *future* verifications. """ self._store = store def verify_certificate(self) -> None: """ Verify a certificate in a context. .. versionadded:: 0.15 :raises X509StoreContextError: If an error occurred when validating a certificate in the context. Sets ``certificate`` attribute to indicate which certificate caused the error. """ self._verify_certificate() def get_verified_chain(self) -> List[X509]: """ Verify a certificate in a context and return the complete validated chain. :raises X509StoreContextError: If an error occurred when validating a certificate in the context. Sets ``certificate`` attribute to indicate which certificate caused the error. .. versionadded:: 20.0 """ store_ctx = self._verify_certificate() # Note: X509_STORE_CTX_get1_chain returns a deep copy of the chain. cert_stack = _lib.X509_STORE_CTX_get1_chain(store_ctx) _openssl_assert(cert_stack != _ffi.NULL) result = [] for i in range(_lib.sk_X509_num(cert_stack)): cert = _lib.sk_X509_value(cert_stack, i) _openssl_assert(cert != _ffi.NULL) pycert = X509._from_raw_x509_ptr(cert) result.append(pycert) # Free the stack but not the members which are freed by the X509 class. _lib.sk_X509_free(cert_stack) return result def load_certificate(type: int, buffer: bytes) -> X509: """ Load a certificate (X509) from the string *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param bytes buffer: The buffer the certificate is stored in :return: The X509 object """ if isinstance(buffer, str): buffer = buffer.encode("ascii") bio = _new_mem_buf(buffer) if type == FILETYPE_PEM: x509 = _lib.PEM_read_bio_X509(bio, _ffi.NULL, _ffi.NULL, _ffi.NULL) elif type == FILETYPE_ASN1: x509 = _lib.d2i_X509_bio(bio, _ffi.NULL) else: raise ValueError("type argument must be FILETYPE_PEM or FILETYPE_ASN1") if x509 == _ffi.NULL: _raise_current_error() return X509._from_raw_x509_ptr(x509) def dump_certificate(type: int, cert: X509) -> bytes: """ Dump the certificate *cert* into a buffer string encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1, or FILETYPE_TEXT) :param cert: The certificate to dump :return: The buffer with the dumped certificate in """ bio = _new_mem_buf() if type == FILETYPE_PEM: result_code = _lib.PEM_write_bio_X509(bio, cert._x509) elif type == FILETYPE_ASN1: result_code = _lib.i2d_X509_bio(bio, cert._x509) elif type == FILETYPE_TEXT: result_code = _lib.X509_print_ex(bio, cert._x509, 0, 0) else: raise ValueError( "type argument must be FILETYPE_PEM, FILETYPE_ASN1, or " "FILETYPE_TEXT" ) _openssl_assert(result_code == 1) return _bio_to_string(bio) def dump_publickey(type: int, pkey: PKey) -> bytes: """ Dump a public key to a buffer. :param type: The file type (one of :data:`FILETYPE_PEM` or :data:`FILETYPE_ASN1`). :param PKey pkey: The public key to dump :return: The buffer with the dumped key in it. :rtype: bytes """ bio = _new_mem_buf() if type == FILETYPE_PEM: write_bio = _lib.PEM_write_bio_PUBKEY elif type == FILETYPE_ASN1: write_bio = _lib.i2d_PUBKEY_bio else: raise ValueError("type argument must be FILETYPE_PEM or FILETYPE_ASN1") result_code = write_bio(bio, pkey._pkey) if result_code != 1: # pragma: no cover _raise_current_error() return _bio_to_string(bio) def dump_privatekey( type: int, pkey: PKey, cipher: Optional[str] = None, passphrase: Optional[PassphraseCallableT] = None, ) -> bytes: """ Dump the private key *pkey* into a buffer string encoded with the type *type*. Optionally (if *type* is :const:`FILETYPE_PEM`) encrypting it using *cipher* and *passphrase*. :param type: The file type (one of :const:`FILETYPE_PEM`, :const:`FILETYPE_ASN1`, or :const:`FILETYPE_TEXT`) :param PKey pkey: The PKey to dump :param cipher: (optional) if encrypted PEM format, the cipher to use :param passphrase: (optional) if encrypted PEM format, this can be either the passphrase to use, or a callback for providing the passphrase. :return: The buffer with the dumped key in :rtype: bytes """ bio = _new_mem_buf() if not isinstance(pkey, PKey): raise TypeError("pkey must be a PKey") if cipher is not None: if passphrase is None: raise TypeError( "if a value is given for cipher " "one must also be given for passphrase" ) cipher_obj = _lib.EVP_get_cipherbyname(_byte_string(cipher)) if cipher_obj == _ffi.NULL: raise ValueError("Invalid cipher name") else: cipher_obj = _ffi.NULL helper = _PassphraseHelper(type, passphrase) if type == FILETYPE_PEM: result_code = _lib.PEM_write_bio_PrivateKey( bio, pkey._pkey, cipher_obj, _ffi.NULL, 0, helper.callback, helper.callback_args, ) helper.raise_if_problem() elif type == FILETYPE_ASN1: result_code = _lib.i2d_PrivateKey_bio(bio, pkey._pkey) elif type == FILETYPE_TEXT: if _lib.EVP_PKEY_id(pkey._pkey) != _lib.EVP_PKEY_RSA: raise TypeError("Only RSA keys are supported for FILETYPE_TEXT") rsa = _ffi.gc(_lib.EVP_PKEY_get1_RSA(pkey._pkey), _lib.RSA_free) result_code = _lib.RSA_print(bio, rsa, 0) else: raise ValueError( "type argument must be FILETYPE_PEM, FILETYPE_ASN1, or " "FILETYPE_TEXT" ) _openssl_assert(result_code != 0) return _bio_to_string(bio) class Revoked: """ A certificate revocation. """ # https://www.openssl.org/docs/manmaster/man5/x509v3_config.html#CRL-distribution-points # which differs from crl_reasons of crypto/x509v3/v3_enum.c that matches # OCSP_crl_reason_str. We use the latter, just like the command line # program. _crl_reasons: typing.ClassVar[typing.List[bytes]] = [ b"unspecified", b"keyCompromise", b"CACompromise", b"affiliationChanged", b"superseded", b"cessationOfOperation", b"certificateHold", # b"removeFromCRL", ] def __init__(self) -> None: revoked = _lib.X509_REVOKED_new() self._revoked = _ffi.gc(revoked, _lib.X509_REVOKED_free) def set_serial(self, hex_str: bytes) -> None: """ Set the serial number. The serial number is formatted as a hexadecimal number encoded in ASCII. :param bytes hex_str: The new serial number. :return: ``None`` """ bignum_serial = _ffi.gc(_lib.BN_new(), _lib.BN_free) bignum_ptr = _ffi.new("BIGNUM**") bignum_ptr[0] = bignum_serial bn_result = _lib.BN_hex2bn(bignum_ptr, hex_str) if not bn_result: raise ValueError("bad hex string") asn1_serial = _ffi.gc( _lib.BN_to_ASN1_INTEGER(bignum_serial, _ffi.NULL), _lib.ASN1_INTEGER_free, ) _lib.X509_REVOKED_set_serialNumber(self._revoked, asn1_serial) def get_serial(self) -> bytes: """ Get the serial number. The serial number is formatted as a hexadecimal number encoded in ASCII. :return: The serial number. :rtype: bytes """ bio = _new_mem_buf() asn1_int = _lib.X509_REVOKED_get0_serialNumber(self._revoked) _openssl_assert(asn1_int != _ffi.NULL) result = _lib.i2a_ASN1_INTEGER(bio, asn1_int) _openssl_assert(result >= 0) return _bio_to_string(bio) def _delete_reason(self) -> None: for i in range(_lib.X509_REVOKED_get_ext_count(self._revoked)): ext = _lib.X509_REVOKED_get_ext(self._revoked, i) obj = _lib.X509_EXTENSION_get_object(ext) if _lib.OBJ_obj2nid(obj) == _lib.NID_crl_reason: _lib.X509_EXTENSION_free(ext) _lib.X509_REVOKED_delete_ext(self._revoked, i) break def set_reason(self, reason: Optional[bytes]) -> None: """ Set the reason of this revocation. If :data:`reason` is ``None``, delete the reason instead. :param reason: The reason string. :type reason: :class:`bytes` or :class:`NoneType` :return: ``None`` .. seealso:: :meth:`all_reasons`, which gives you a list of all supported reasons which you might pass to this method. """ if reason is None: self._delete_reason() elif not isinstance(reason, bytes): raise TypeError("reason must be None or a byte string") else: reason = reason.lower().replace(b" ", b"") reason_code = [r.lower() for r in self._crl_reasons].index(reason) new_reason_ext = _lib.ASN1_ENUMERATED_new() _openssl_assert(new_reason_ext != _ffi.NULL) new_reason_ext = _ffi.gc(new_reason_ext, _lib.ASN1_ENUMERATED_free) set_result = _lib.ASN1_ENUMERATED_set(new_reason_ext, reason_code) _openssl_assert(set_result != _ffi.NULL) self._delete_reason() add_result = _lib.X509_REVOKED_add1_ext_i2d( self._revoked, _lib.NID_crl_reason, new_reason_ext, 0, 0 ) _openssl_assert(add_result == 1) def get_reason(self) -> Optional[bytes]: """ Get the reason of this revocation. :return: The reason, or ``None`` if there is none. :rtype: bytes or NoneType .. seealso:: :meth:`all_reasons`, which gives you a list of all supported reasons this method might return. """ for i in range(_lib.X509_REVOKED_get_ext_count(self._revoked)): ext = _lib.X509_REVOKED_get_ext(self._revoked, i) obj = _lib.X509_EXTENSION_get_object(ext) if _lib.OBJ_obj2nid(obj) == _lib.NID_crl_reason: bio = _new_mem_buf() print_result = _lib.X509V3_EXT_print(bio, ext, 0, 0) if not print_result: print_result = _lib.M_ASN1_OCTET_STRING_print( bio, _lib.X509_EXTENSION_get_data(ext) ) _openssl_assert(print_result != 0) return _bio_to_string(bio) return None def all_reasons(self) -> List[bytes]: """ Return a list of all the supported reason strings. This list is a copy; modifying it does not change the supported reason strings. :return: A list of reason strings. :rtype: :class:`list` of :class:`bytes` """ return self._crl_reasons[:] def set_rev_date(self, when: bytes) -> None: """ Set the revocation timestamp. :param bytes when: The timestamp of the revocation, as ASN.1 TIME. :return: ``None`` """ revocationDate = _new_asn1_time(when) ret = _lib.X509_REVOKED_set_revocationDate( self._revoked, revocationDate ) _openssl_assert(ret == 1) def get_rev_date(self) -> Optional[bytes]: """ Get the revocation timestamp. :return: The timestamp of the revocation, as ASN.1 TIME. :rtype: bytes """ dt = _lib.X509_REVOKED_get0_revocationDate(self._revoked) return _get_asn1_time(dt) _RevokedInternal = Revoked utils.deprecated( Revoked, __name__, ( "CRL support in pyOpenSSL is deprecated. You should use the APIs " "in cryptography." ), DeprecationWarning, name="Revoked", ) class CRL: """ A certificate revocation list. """ def __init__(self) -> None: crl = _lib.X509_CRL_new() self._crl = _ffi.gc(crl, _lib.X509_CRL_free) def to_cryptography(self) -> x509.CertificateRevocationList: """ Export as a ``cryptography`` CRL. :rtype: ``cryptography.x509.CertificateRevocationList`` .. versionadded:: 17.1.0 """ from cryptography.x509 import load_der_x509_crl der = _dump_crl_internal(FILETYPE_ASN1, self) return load_der_x509_crl(der) @classmethod def from_cryptography( cls, crypto_crl: x509.CertificateRevocationList ) -> "_CRLInternal": """ Construct based on a ``cryptography`` *crypto_crl*. :param crypto_crl: A ``cryptography`` certificate revocation list :type crypto_crl: ``cryptography.x509.CertificateRevocationList`` :rtype: CRL .. versionadded:: 17.1.0 """ if not isinstance(crypto_crl, x509.CertificateRevocationList): raise TypeError("Must be a certificate revocation list") from cryptography.hazmat.primitives.serialization import Encoding der = crypto_crl.public_bytes(Encoding.DER) return _load_crl_internal(FILETYPE_ASN1, der) def get_revoked(self) -> Optional[Tuple[_RevokedInternal, ...]]: """ Return the revocations in this certificate revocation list. These revocations will be provided by value, not by reference. That means it's okay to mutate them: it won't affect this CRL. :return: The revocations in this CRL. :rtype: :class:`tuple` of :class:`Revocation` """ results = [] revoked_stack = _lib.X509_CRL_get_REVOKED(self._crl) for i in range(_lib.sk_X509_REVOKED_num(revoked_stack)): revoked = _lib.sk_X509_REVOKED_value(revoked_stack, i) revoked_copy = _lib.X509_REVOKED_dup(revoked) pyrev = _RevokedInternal.__new__(_RevokedInternal) pyrev._revoked = _ffi.gc(revoked_copy, _lib.X509_REVOKED_free) results.append(pyrev) if results: return tuple(results) return None def add_revoked(self, revoked: _RevokedInternal) -> None: """ Add a revoked (by value not reference) to the CRL structure This revocation will be added by value, not by reference. That means it's okay to mutate it after adding: it won't affect this CRL. :param Revoked revoked: The new revocation. :return: ``None`` """ copy = _lib.X509_REVOKED_dup(revoked._revoked) _openssl_assert(copy != _ffi.NULL) add_result = _lib.X509_CRL_add0_revoked(self._crl, copy) _openssl_assert(add_result != 0) def get_issuer(self) -> X509Name: """ Get the CRL's issuer. .. versionadded:: 16.1.0 :rtype: X509Name """ _issuer = _lib.X509_NAME_dup(_lib.X509_CRL_get_issuer(self._crl)) _openssl_assert(_issuer != _ffi.NULL) _issuer = _ffi.gc(_issuer, _lib.X509_NAME_free) issuer = X509Name.__new__(X509Name) issuer._name = _issuer return issuer def set_version(self, version: int) -> None: """ Set the CRL version. .. versionadded:: 16.1.0 :param int version: The version of the CRL. :return: ``None`` """ _openssl_assert(_lib.X509_CRL_set_version(self._crl, version) != 0) def set_lastUpdate(self, when: bytes) -> None: """ Set when the CRL was last updated. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ .. versionadded:: 16.1.0 :param bytes when: A timestamp string. :return: ``None`` """ lastUpdate = _new_asn1_time(when) ret = _lib.X509_CRL_set1_lastUpdate(self._crl, lastUpdate) _openssl_assert(ret == 1) def set_nextUpdate(self, when: bytes) -> None: """ Set when the CRL will next be updated. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ .. versionadded:: 16.1.0 :param bytes when: A timestamp string. :return: ``None`` """ nextUpdate = _new_asn1_time(when) ret = _lib.X509_CRL_set1_nextUpdate(self._crl, nextUpdate) _openssl_assert(ret == 1) def sign(self, issuer_cert: X509, issuer_key: PKey, digest: bytes) -> None: """ Sign the CRL. Signing a CRL enables clients to associate the CRL itself with an issuer. Before a CRL is meaningful to other OpenSSL functions, it must be signed by an issuer. This method implicitly sets the issuer's name based on the issuer certificate and private key used to sign the CRL. .. versionadded:: 16.1.0 :param X509 issuer_cert: The issuer's certificate. :param PKey issuer_key: The issuer's private key. :param bytes digest: The digest method to sign the CRL with. """ digest_obj = _lib.EVP_get_digestbyname(digest) _openssl_assert(digest_obj != _ffi.NULL) _lib.X509_CRL_set_issuer_name( self._crl, _lib.X509_get_subject_name(issuer_cert._x509) ) _lib.X509_CRL_sort(self._crl) result = _lib.X509_CRL_sign(self._crl, issuer_key._pkey, digest_obj) _openssl_assert(result != 0) def export( self, cert: X509, key: PKey, type: int = FILETYPE_PEM, days: int = 100, digest: bytes = _UNSPECIFIED, # type: ignore ) -> bytes: """ Export the CRL as a string. :param X509 cert: The certificate used to sign the CRL. :param PKey key: The key used to sign the CRL. :param int type: The export format, either :data:`FILETYPE_PEM`, :data:`FILETYPE_ASN1`, or :data:`FILETYPE_TEXT`. :param int days: The number of days until the next update of this CRL. :param bytes digest: The name of the message digest to use (eg ``b"sha256"``). :rtype: bytes """ if not isinstance(cert, X509): raise TypeError("cert must be an X509 instance") if not isinstance(key, PKey): raise TypeError("key must be a PKey instance") if not isinstance(type, int): raise TypeError("type must be an integer") if digest is _UNSPECIFIED: raise TypeError("digest must be provided") digest_obj = _lib.EVP_get_digestbyname(digest) if digest_obj == _ffi.NULL: raise ValueError("No such digest method") # A scratch time object to give different values to different CRL # fields sometime = _lib.ASN1_TIME_new() _openssl_assert(sometime != _ffi.NULL) sometime = _ffi.gc(sometime, _lib.ASN1_TIME_free) ret = _lib.X509_gmtime_adj(sometime, 0) _openssl_assert(ret != _ffi.NULL) ret = _lib.X509_CRL_set1_lastUpdate(self._crl, sometime) _openssl_assert(ret == 1) ret = _lib.X509_gmtime_adj(sometime, days * 24 * 60 * 60) _openssl_assert(ret != _ffi.NULL) ret = _lib.X509_CRL_set1_nextUpdate(self._crl, sometime) _openssl_assert(ret == 1) ret = _lib.X509_CRL_set_issuer_name( self._crl, _lib.X509_get_subject_name(cert._x509) ) _openssl_assert(ret == 1) sign_result = _lib.X509_CRL_sign(self._crl, key._pkey, digest_obj) if not sign_result: _raise_current_error() return _dump_crl_internal(type, self) _CRLInternal = CRL utils.deprecated( CRL, __name__, ( "CRL support in pyOpenSSL is deprecated. You should use the APIs " "in cryptography." ), DeprecationWarning, name="CRL", ) class _PassphraseHelper: def __init__( self, type: int, passphrase: Optional[PassphraseCallableT], more_args: bool = False, truncate: bool = False, ) -> None: if type != FILETYPE_PEM and passphrase is not None: raise ValueError( "only FILETYPE_PEM key format supports encryption" ) self._passphrase = passphrase self._more_args = more_args self._truncate = truncate self._problems: List[Exception] = [] @property def callback(self) -> Any: if self._passphrase is None: return _ffi.NULL elif isinstance(self._passphrase, bytes) or callable(self._passphrase): return _ffi.callback("pem_password_cb", self._read_passphrase) else: raise TypeError( "Last argument must be a byte string or a callable." ) @property def callback_args(self) -> Any: if self._passphrase is None: return _ffi.NULL elif isinstance(self._passphrase, bytes) or callable(self._passphrase): return _ffi.NULL else: raise TypeError( "Last argument must be a byte string or a callable." ) def raise_if_problem(self, exceptionType: Type[Exception] = Error) -> None: if self._problems: # Flush the OpenSSL error queue try: _exception_from_error_queue(exceptionType) except exceptionType: pass raise self._problems.pop(0) def _read_passphrase( self, buf: Any, size: int, rwflag: Any, userdata: Any ) -> int: try: if callable(self._passphrase): if self._more_args: result = self._passphrase(size, rwflag, userdata) else: result = self._passphrase(rwflag) else: assert self._passphrase is not None result = self._passphrase if not isinstance(result, bytes): raise ValueError("Bytes expected") if len(result) > size: if self._truncate: result = result[:size] else: raise ValueError( "passphrase returned by callback is too long" ) for i in range(len(result)): buf[i] = result[i : i + 1] return len(result) except Exception as e: self._problems.append(e) return 0 def load_publickey(type: int, buffer: Union[str, bytes]) -> PKey: """ Load a public key from a buffer. :param type: The file type (one of :data:`FILETYPE_PEM`, :data:`FILETYPE_ASN1`). :param buffer: The buffer the key is stored in. :type buffer: A Python string object, either unicode or bytestring. :return: The PKey object. :rtype: :class:`PKey` """ if isinstance(buffer, str): buffer = buffer.encode("ascii") bio = _new_mem_buf(buffer) if type == FILETYPE_PEM: evp_pkey = _lib.PEM_read_bio_PUBKEY( bio, _ffi.NULL, _ffi.NULL, _ffi.NULL ) elif type == FILETYPE_ASN1: evp_pkey = _lib.d2i_PUBKEY_bio(bio, _ffi.NULL) else: raise ValueError("type argument must be FILETYPE_PEM or FILETYPE_ASN1") if evp_pkey == _ffi.NULL: _raise_current_error() pkey = PKey.__new__(PKey) pkey._pkey = _ffi.gc(evp_pkey, _lib.EVP_PKEY_free) pkey._only_public = True return pkey def load_privatekey( type: int, buffer: Union[str, bytes], passphrase: Optional[PassphraseCallableT] = None, ) -> PKey: """ Load a private key (PKey) from the string *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param buffer: The buffer the key is stored in :param passphrase: (optional) if encrypted PEM format, this can be either the passphrase to use, or a callback for providing the passphrase. :return: The PKey object """ if isinstance(buffer, str): buffer = buffer.encode("ascii") bio = _new_mem_buf(buffer) helper = _PassphraseHelper(type, passphrase) if type == FILETYPE_PEM: evp_pkey = _lib.PEM_read_bio_PrivateKey( bio, _ffi.NULL, helper.callback, helper.callback_args ) helper.raise_if_problem() elif type == FILETYPE_ASN1: evp_pkey = _lib.d2i_PrivateKey_bio(bio, _ffi.NULL) else: raise ValueError("type argument must be FILETYPE_PEM or FILETYPE_ASN1") if evp_pkey == _ffi.NULL: _raise_current_error() pkey = PKey.__new__(PKey) pkey._pkey = _ffi.gc(evp_pkey, _lib.EVP_PKEY_free) return pkey def dump_certificate_request(type: int, req: X509Req) -> bytes: """ Dump the certificate request *req* into a buffer string encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param req: The certificate request to dump :return: The buffer with the dumped certificate request in """ bio = _new_mem_buf() if type == FILETYPE_PEM: result_code = _lib.PEM_write_bio_X509_REQ(bio, req._req) elif type == FILETYPE_ASN1: result_code = _lib.i2d_X509_REQ_bio(bio, req._req) elif type == FILETYPE_TEXT: result_code = _lib.X509_REQ_print_ex(bio, req._req, 0, 0) else: raise ValueError( "type argument must be FILETYPE_PEM, FILETYPE_ASN1, or " "FILETYPE_TEXT" ) _openssl_assert(result_code != 0) return _bio_to_string(bio) _dump_certificate_request_internal = dump_certificate_request utils.deprecated( dump_certificate_request, __name__, ( "CSR support in pyOpenSSL is deprecated. You should use the APIs " "in cryptography." ), DeprecationWarning, name="dump_certificate_request", ) def load_certificate_request(type: int, buffer: bytes) -> X509Req: """ Load a certificate request (X509Req) from the string *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param buffer: The buffer the certificate request is stored in :return: The X509Req object """ if isinstance(buffer, str): buffer = buffer.encode("ascii") bio = _new_mem_buf(buffer) if type == FILETYPE_PEM: req = _lib.PEM_read_bio_X509_REQ(bio, _ffi.NULL, _ffi.NULL, _ffi.NULL) elif type == FILETYPE_ASN1: req = _lib.d2i_X509_REQ_bio(bio, _ffi.NULL) else: raise ValueError("type argument must be FILETYPE_PEM or FILETYPE_ASN1") _openssl_assert(req != _ffi.NULL) x509req = _X509ReqInternal.__new__(_X509ReqInternal) x509req._req = _ffi.gc(req, _lib.X509_REQ_free) return x509req _load_certificate_request_internal = load_certificate_request utils.deprecated( load_certificate_request, __name__, ( "CSR support in pyOpenSSL is deprecated. You should use the APIs " "in cryptography." ), DeprecationWarning, name="load_certificate_request", ) def sign(pkey: PKey, data: Union[str, bytes], digest: str) -> bytes: """ Sign a data string using the given key and message digest. :param pkey: PKey to sign with :param data: data to be signed :param digest: message digest to use :return: signature .. versionadded:: 0.11 """ data = _text_to_bytes_and_warn("data", data) digest_obj = _lib.EVP_get_digestbyname(_byte_string(digest)) if digest_obj == _ffi.NULL: raise ValueError("No such digest method") md_ctx = _lib.EVP_MD_CTX_new() md_ctx = _ffi.gc(md_ctx, _lib.EVP_MD_CTX_free) _lib.EVP_SignInit(md_ctx, digest_obj) _lib.EVP_SignUpdate(md_ctx, data, len(data)) length = _lib.EVP_PKEY_size(pkey._pkey) _openssl_assert(length > 0) signature_buffer = _ffi.new("unsigned char[]", length) signature_length = _ffi.new("unsigned int *") final_result = _lib.EVP_SignFinal( md_ctx, signature_buffer, signature_length, pkey._pkey ) _openssl_assert(final_result == 1) return _ffi.buffer(signature_buffer, signature_length[0])[:] utils.deprecated( sign, __name__, "sign() is deprecated. Use the equivalent APIs in cryptography.", DeprecationWarning, name="sign", ) def verify( cert: X509, signature: bytes, data: Union[str, bytes], digest: str ) -> None: """ Verify the signature for a data string. :param cert: signing certificate (X509 object) corresponding to the private key which generated the signature. :param signature: signature returned by sign function :param data: data to be verified :param digest: message digest to use :return: ``None`` if the signature is correct, raise exception otherwise. .. versionadded:: 0.11 """ data = _text_to_bytes_and_warn("data", data) digest_obj = _lib.EVP_get_digestbyname(_byte_string(digest)) if digest_obj == _ffi.NULL: raise ValueError("No such digest method") pkey = _lib.X509_get_pubkey(cert._x509) _openssl_assert(pkey != _ffi.NULL) pkey = _ffi.gc(pkey, _lib.EVP_PKEY_free) md_ctx = _lib.EVP_MD_CTX_new() md_ctx = _ffi.gc(md_ctx, _lib.EVP_MD_CTX_free) _lib.EVP_VerifyInit(md_ctx, digest_obj) _lib.EVP_VerifyUpdate(md_ctx, data, len(data)) verify_result = _lib.EVP_VerifyFinal( md_ctx, signature, len(signature), pkey ) if verify_result != 1: _raise_current_error() utils.deprecated( verify, __name__, "verify() is deprecated. Use the equivalent APIs in cryptography.", DeprecationWarning, name="verify", ) def dump_crl(type: int, crl: _CRLInternal) -> bytes: """ Dump a certificate revocation list to a buffer. :param type: The file type (one of ``FILETYPE_PEM``, ``FILETYPE_ASN1``, or ``FILETYPE_TEXT``). :param CRL crl: The CRL to dump. :return: The buffer with the CRL. :rtype: bytes """ bio = _new_mem_buf() if type == FILETYPE_PEM: ret = _lib.PEM_write_bio_X509_CRL(bio, crl._crl) elif type == FILETYPE_ASN1: ret = _lib.i2d_X509_CRL_bio(bio, crl._crl) elif type == FILETYPE_TEXT: ret = _lib.X509_CRL_print(bio, crl._crl) else: raise ValueError( "type argument must be FILETYPE_PEM, FILETYPE_ASN1, or " "FILETYPE_TEXT" ) _openssl_assert(ret == 1) return _bio_to_string(bio) _dump_crl_internal = dump_crl utils.deprecated( dump_crl, __name__, ( "CRL support in pyOpenSSL is deprecated. You should use the APIs " "in cryptography." ), DeprecationWarning, name="dump_crl", ) def load_crl(type: int, buffer: Union[str, bytes]) -> _CRLInternal: """ Load Certificate Revocation List (CRL) data from a string *buffer*. *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1) :param buffer: The buffer the CRL is stored in :return: The CRL object """ if isinstance(buffer, str): buffer = buffer.encode("ascii") bio = _new_mem_buf(buffer) if type == FILETYPE_PEM: crl = _lib.PEM_read_bio_X509_CRL(bio, _ffi.NULL, _ffi.NULL, _ffi.NULL) elif type == FILETYPE_ASN1: crl = _lib.d2i_X509_CRL_bio(bio, _ffi.NULL) else: raise ValueError("type argument must be FILETYPE_PEM or FILETYPE_ASN1") if crl == _ffi.NULL: _raise_current_error() result = _CRLInternal.__new__(_CRLInternal) result._crl = _ffi.gc(crl, _lib.X509_CRL_free) return result _load_crl_internal = load_crl utils.deprecated( load_crl, __name__, ( "CRL support in pyOpenSSL is deprecated. You should use the APIs " "in cryptography." ), DeprecationWarning, name="load_crl", ) __init__.py 0000644 00000000761 15030415060 0006653 0 ustar 00 # Copyright (C) AB Strakt # See LICENSE for details. """ pyOpenSSL - A simple wrapper around the OpenSSL library """ from OpenSSL import SSL, crypto from OpenSSL.version import ( __author__, __copyright__, __email__, __license__, __summary__, __title__, __uri__, __version__, ) __all__ = [ "SSL", "crypto", "__author__", "__copyright__", "__email__", "__license__", "__summary__", "__title__", "__uri__", "__version__", ]
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.03 |
proxy
|
phpinfo
|
Settings