← Back
Editing: crypto.cpython-38.pyc
U �F\�� � $ @ s� d dl Z d dlmZ d dlmZ d dlmZmZmZm Z m Z m Z d dl m ZmZmZ d dlmZ d dlmZmZ d dlmZ d d lmZ m Z m Z m!Z"m#Z$m%Z&m'Z(m)Z* d d d d ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-g$Z+e j,Z-e j.Z/d.Z0e j1Z2e j3Z4e j5Z6e j7Z8G d/d� de9�Z:ee e:�Z;e*e:�Z<d0d1� Z=d2d3� Z>dkd4d5�Z?d6d7� Z@d8d9� ZAd:d;� ZBG d<d=� d=eC�ZDG d>d� deC�ZEeeEeFd?eG�ZHG d@dA� dAeC�ZIdBd� ZJdCd� ZKG dDd� deC�ZLeeLeFdEeG�ZMG dFd� deC�ZNeeNeFdGeG�ZOG dHd� deC�ZPeePeFdIeG�ZQG dJd� deC�ZReeReFdKeG�ZSG dLd� deC�ZTG dMd� deC�ZUeeUeFdNeG�ZVG dOd� de9�ZWG dPd� deC�ZXdQd� ZYdRd � ZZdSd � Z[dldTd �Z\G dUd � d eC�Z]G dVd � d eC�Z^ee^eFdWeG�Z_G dXd!� d!eC�Z`ee`eFdYeG�ZaG dZd"� d"eC�ZbeebeFd[eG�ZcG d\d#� d#eC�ZdeedeFd]eG�ZeG d^d_� d_eC�Zfd`d$� Zgdmdad%�Zhdbd&� Zidcd'� Zjddd(� Zkded)� Zldfd*� Zmdgd+� Zndhd,� Zodndid-�Zpe �q� e �r� e �sdj� dS )o� N)� b16encode)�partial)�__eq__�__ne__�__lt__�__le__�__gt__�__ge__)� integer_types� text_type�PY3)�x509)�dsa�rsa)� deprecated)�ffi�lib�exception_from_error_queue� byte_string�native� UNSPECIFIED�text_to_bytes_and_warn� make_assert� 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�PKCS7�PKCS12� NetscapeSPKI�load_publickey�load_privatekey�dump_certificate_request�load_certificate_request�sign�verify�dump_crl�load_crl�load_pkcs7_data� load_pkcs12i�� c @ s e Zd ZdZdS )r z7 An error occurred in an `OpenSSL.crypto` API. N)�__name__� __module__� __qualname__�__doc__� rA rA �0/usr/lib/python3/dist-packages/OpenSSL/crypto.pyr N s c C s ddl m} | S )ap Importing the backend from cryptography has the side effect of activating the osrandom engine. This mutates the global state of OpenSSL in the process and causes issues for various programs that use subinterpreters or embed Python. By putting the import in this function we can avoid triggering this side effect unless _get_backend is called. r ��backend)Z,cryptography.hazmat.backends.openssl.backendrD rC rA rA rB � _get_backendX s rE c C s t d| f ��dS )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 %s failureN)� RuntimeError)�whererA rA rB �_untested_errord s rH c C sd | dkr t �t �� �}t j}n(t�d| �}t �|t| ��}|fdd�}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[]c S s t �| �S �N)�_lib�BIO_free)�bio�refrA rA rB �free~ s z_new_mem_buf.<locals>.free) rK �BIO_new� BIO_s_memrL �_ffi�newZBIO_new_mem_buf�len�_openssl_assert�NULL�gc)�bufferrM rO �datarA rA rB � _new_mem_bufm s rZ 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)rR rS rK ZBIO_get_mem_datarX )rM � result_bufferZ buffer_lengthrA rA rB �_bio_to_string� s r\ c C s2 t |t�std��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� TypeErrorrK ZASN1_TIME_set_string� ValueError)�boundary�when� set_resultrA rA rB �_set_asn1_time� s rd c C s� t �d| �}t�|�dkr dS t�|�tjkr>t �t�|��S t �d�}t� | |� |d t j krlt d� n6t �d|d �}t�|�}t �|�}t� |d � |S dS )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) rR �castrK �ASN1_STRING_lengthZASN1_STRING_typeZV_ASN1_GENERALIZEDTIME�string�ASN1_STRING_datarS rf rV rH ZASN1_GENERALIZEDTIME_free)Z timestampZstring_timestampZgeneralized_timestampZ string_data� string_resultrA rA rB �_get_asn1_time� s$ � � rl c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�_X509NameInvalidatorc C s g | _ d S rJ )�_names��selfrA rA rB �__init__� s z _X509NameInvalidator.__init__c C s | j �|� d S rJ )rn �append�rp �namerA rA rB �add� s z_X509NameInvalidator.addc C s | j D ]}|`qd S rJ )rn �_namers rA rA rB �clear� s z_X509NameInvalidator.clearN)r= r> r? rq ru rw rA rA rA rB rm � s rm c @ sT e Zd ZdZdZdZdd� Zdd� Zedd � �Z d d � Z d d � Z dd� Z dd� Z dS )r zD A class representing an DSA or RSA public key or key pair. FTc C s" t �� }t�|t j�| _d| _d S )NF)rK Z EVP_PKEY_newrR rW � EVP_PKEY_free�_pkey� _initialized�rp �pkeyrA rA rB rq � s z PKey.__init__c C s( t � }| jr|�| j�S |�| j�S dS )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 N)rE � _only_publicZ_evp_pkey_to_public_keyry Z_evp_pkey_to_private_key)rp rD rA rA rB �to_cryptography_key� s zPKey.to_cryptography_keyc C sR | � }t |tjtjtjtjf�s(td��|j|_ t |tjtjf�rHd|_ d|_ |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 typeT) r] r Z RSAPublicKeyZ RSAPrivateKeyr Z DSAPublicKeyZ DSAPrivateKeyr_ Z _evp_pkeyry r} rz )�clsZ crypto_keyr| rA rA rB �from_cryptography_key� s �zPKey.from_cryptography_keyc C s6 t |t�std��t |t�s$td��|tkr�|dkr<td��t�� }t�|tj �}t� |tj � t� � }t� |||tj�}t|dk� t�| j|�}t|dk� n�|tk�r$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)r] �intr_ r r` rK �BN_newrR rW �BN_freeZ BN_set_wordZRSA_F4ZRSA_newZRSA_generate_key_exrV rU ZEVP_PKEY_assign_RSAry r ZDSA_newZDSA_freeZDSA_generate_parameters_exZDSA_generate_keyZEVP_PKEY_set1_DSAr rz )rp �type�bitsZexponentr �resultr �resrA rA rB � generate_key sB � zPKey.generate_keyc C s` | j rtd��t�| �� �tjkr*td��t�| j�}t� |tj �}t� |�}|rVdS 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 onlyzkey type unsupportedTN) r} r_ rK Z EVP_PKEY_typer� � EVP_PKEY_RSA�EVP_PKEY_get1_RSAry rR rW �RSA_freeZ RSA_check_key�_raise_current_error)rp r r� rA rA rB �checkG s z PKey.checkc C s t �| j�S )zT Returns the type of the key :return: The type of the key. )rK � EVP_PKEY_idry ro rA rA rB r� a s z PKey.typec C s t �| j�S )zh Returns the number of bits of the key :return: The number of bits of the key. )rK Z EVP_PKEY_bitsry ro rA rA rB r� i s z PKey.bitsN)r= r> r? r@ r} rz rq r~ � classmethodr� r� r� r� r� rA rA rA rB r � s 8z.PKeyType has been deprecated, use PKey insteadc sd e Zd ZdZdZer � fdd�Zedd� �Zedd� �Z ed d � �Z d d � Z d d� Z dd� 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` Nc s t |t�rtt| ��|�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. )r] r� �superr �NotImplemented)rp �other�� __class__rA rB r � s z_EllipticCurve.__ne__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 rJ )�from_nid�nid)�.0�c�r r rA rB � <genexpr>� s �z7_EllipticCurve._load_elliptic_curves.<locals>.<genexpr>)ZEC_get_builtin_curvesrR rV rS �set)r r Z num_curvesZbuiltin_curvesrA r� rB �_load_elliptic_curves� s �z$_EllipticCurve._load_elliptic_curvesc C s | j dkr| �|�| _ | 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� rA rA rB �_get_elliptic_curves� s z#_EllipticCurve._get_elliptic_curvesc 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)rR ri � OBJ_nid2sn�decode)r r r� rA rA rB r� � s z_EllipticCurve.from_nidc 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)rK �_nidrt )rp r r� rt rA rA rB rq � s z_EllipticCurve.__init__c C s d| j f S )Nz <Curve %r>)rt ro rA rA rB �__repr__� s 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. )rK ZEC_KEY_new_by_curve_namer� rR rW Z EC_KEY_free)rp �keyrA rA rB � _to_EC_KEY� s z_EllipticCurve._to_EC_KEY)r= r> r? r@ r� �_PY3r r� r� r� r� rq r� r� � __classcell__rA rA r� rB r� y 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� rK rA rA rA rB r � s c C s, t � D ]}|j| kr| S qtd| ��dS )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 nameN)r rt r` )rt ZcurverA rA rB r! � s c s� e Zd ZdZdd� Z� fdd�Z� fdd�Zdd � Zee�Zee �Z ee �Z ee �Z ee �Z ee �Z d d � Zd d � Zdd� Zdd� 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. c 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)rK � X509_NAME_duprv rR rW �X509_NAME_freers rA rA rB rq s zX509Name.__init__c s |� d�r tt| ��||�S t|�tk r<tdt|�jf ��t� t |��}|tj kr|z t � W n t k rr Y nX td��tt�| j��D ]J}t�| j|�}t�|�}t�|�}||kr�t�| j|�}t�|� q�q�t|t�r�|�d�}t�| j|tj|ddd�}|�st � d S )N�_z+attribute name must be string, not '%.200s'zNo such attribute�utf-8���r ) � startswithr� r" � __setattr__r� �strr_ r= rK � OBJ_txt2nid� _byte_string� NID_undefr� r �AttributeError�range�X509_NAME_entry_countrv �X509_NAME_get_entry�X509_NAME_ENTRY_get_object� OBJ_obj2nidZX509_NAME_delete_entryZX509_NAME_ENTRY_freer] � _text_type�encodeZX509_NAME_add_entry_by_NIDZ MBSTRING_UTF8) rp rt �valuer� �i�entZent_objZent_nid� add_resultr� rA rB r� ' sD � �zX509Name.__setattr__c s� t �t|��}|t jkrHz t� W n tk r6 Y nX tt| ��|�S t � | j |d�}|dkrddS t � | j |�}t � |�}t �d�}t �||�}t|dk� z"t �|d |�dd� �d�}W 5 t �|d � X |S )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� N�unsigned char**r r� )rK r� r� r� r� r r� r" � __getattr__ZX509_NAME_get_index_by_NIDrv r� �X509_NAME_ENTRY_get_datarR rS ZASN1_STRING_to_UTF8rU � OPENSSL_freerX r� ) rp rt r� Z entry_index�entryrY r[ Z data_lengthr� r� rA rB r� K s0 � �zX509Name.__getattr__c s � fdd�}|S )Nc s( t |t�stS t�| j|j�}� |d�S �Nr )r] r" r� rK Z X509_NAME_cmprv )rp r� r� ��oprA rB �ft s zX509Name._cmp.<locals>.frA )r� r� rA r� rB �_cmps s z X509Name._cmpc C sB t �dd�}t�| j|t|��}t|t jk� dtt � |��f S )z6 String representation of an X509Name rI i z<X509Name object '%s'>) rR rS rK ZX509_NAME_onelinerv rT rU rV �_nativeri )rp r[ Z format_resultrA rA rB r� � s � �zX509Name.__repr__c C s t �| j�S )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` )rK ZX509_NAME_hashrv ro rA rA rB �hash� s 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)rR rS rK Z i2d_X509_NAMErv rU rX r� )rp r[ Z encode_resultrk rA rA rB �der� s z X509Name.derc C s� g }t t�| j��D ]n}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� rK r� rv r� r� r� r� r� rR rX rj rh rr ri ) rp r� r� r� �fnameZfvalr� rt r� rA rA rB �get_components� s � zX509Name.get_components)r= r> r? r@ rq r� r� r� r r r r r r r� r� r� r� r� rA rA r� rB r" s $ ( z6X509NameType has been deprecated, use X509Name insteadc @ sd e Zd ZdZddd�Zedd� �Zejdej dej d iZ d d � Z d d � Z dd� Zdd� Zdd� ZdS )r# z, An X.509 v3 certificate extension. Nc C s� t �d�}t�|t jt jt jt jd� t�|� |dk rRt|t�sJtd��|j |_ |dk rtt|t�sltd��|j |_ |r�d| }t� t j|||�}|t jkr�t � 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 value of the extension. :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,)rR rS rK ZX509V3_set_ctxrV ZX509V3_set_ctx_nodbr] r% r_ �_x509� issuer_certZ subject_certZX509V3_EXT_nconfr� rW �X509_EXTENSION_free� _extension)rp Z type_nameZcriticalr� �subject�issuerZctx� extensionrA rA rB rq � s" zX509Extension.__init__c C s t �t �| j��S rJ )rK r� �X509_EXTENSION_get_objectr� ro rA rA rB r� s �zX509Extension._nidZemailZDNSZURIc C s� t �dt�| j��}t �|tj�}g }tt�|��D ]�}t� ||�}z| j |j }W n8 t k r� t � }t�||� |�tt|��� Y q4X tt �|jjj|jjj�d d � �}|�|d | � q4d�|�S )NzGENERAL_NAMES*�:z, )rR rg rK ZX509V3_EXT_d2ir� rW ZGENERAL_NAMES_freer� Zsk_GENERAL_NAME_numZsk_GENERAL_NAME_value� _prefixesr� �KeyErrorrZ ZGENERAL_NAME_printrr r� r\ rX �dZia5rY �length�join)rp �names�partsr� rt ZlabelrM r� rA rA rB �_subjectAltNameString s& � �z#X509Extension._subjectAltNameStringc C sD t j| jkr| �� S t� }t �|| jdd�}t|dk� tt |��S )zF :return: a nice text representation of the extension r ) rK ZNID_subject_alt_namer� r� rZ �X509V3_EXT_printr� rU r� r\ )rp rM � print_resultrA rA rB �__str__/ s zX509Extension.__str__c C s t �| j�S )zk Returns the critical field of this X.509 extension. :return: The critical field. )rK ZX509_EXTENSION_get_criticalr� ro rA rA rB � get_critical< s zX509Extension.get_criticalc C s& t �| j�}t �|�}t�t �|��S )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 )rK r� r� r� rR ri r� )rp �objr� rA rA rB �get_short_nameD 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 re N)rK �X509_EXTENSION_get_datar� rR rg rj rh rX )rp Z octet_resultrk Z char_result� result_lengthrA rA rB �get_dataS s zX509Extension.get_data)NN)r= r> r? r@ rq �propertyr� rK Z GEN_EMAILZGEN_DNSZGEN_URIr� r� r� r� r� r� rA rA rA rB r# � s = � z@X509ExtensionType has been deprecated, use X509Extension insteadc @ st e Zd ZdZdd� Zdd� Zedd� �Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� ZdS )r$ z0 An X.509 certificate signing requests. c C s& t �� }t�|t j�| _| �d� d S r� )rK Z X509_REQ_newrR rW � X509_REQ_free�_req� set_version)rp �reqrA rA rB rq o s zX509Req.__init__c C s ddl m} t� }||| j�S )z� Export as a ``cryptography`` certificate signing request. :rtype: ``cryptography.x509.CertificateSigningRequest`` .. versionadded:: 17.1.0 r )�_CertificateSigningRequest)�)cryptography.hazmat.backends.openssl.x509r� rE r� )rp r� rD rA rA rB �to_cryptographyu s zX509Req.to_cryptographyc C s& t |tj�std��| � }|j|_|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 request)r] r ZCertificateSigningRequestr_ Z _x509_reqr� )r Z crypto_reqr� rA rA rB �from_cryptography� s zX509Req.from_cryptographyc 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)rK ZX509_REQ_set_pubkeyr� ry rU �rp r| rc rA rA rB � 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__rK ZX509_REQ_get_pubkeyr� ry rU rR rV rW rx r} r{ rA rA rB � get_pubkey� s zX509Req.get_pubkeyc C s t �| j|�}t|dk� dS )z� Set the version subfield (RFC 2459, section 4.1.2.1) of the certificate request. :param int version: The version number. :return: ``None`` r� N)rK ZX509_REQ_set_versionr� rU )rp �versionrc rA rA rB r� � s zX509Req.set_versionc C s t �| j�S )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` )rK ZX509_REQ_get_versionr� ro rA rA rB � 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" r� rK ZX509_REQ_get_subject_namer� rv rU rR rV �_ownerrs rA rA rB � get_subject� s zX509Req.get_subjectc C sl t �� }t|tjk� t�|t j�}|D ]$}t|t�s>t d��t � ||j � q(t � | 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)rK Zsk_X509_EXTENSION_new_nullrU rR rV rW Zsk_X509_EXTENSION_freer] r# r` Zsk_X509_EXTENSION_pushr� ZX509_REQ_add_extensionsr� )rp � extensions�stack�extr� rA rA rB �add_extensions� s zX509Req.add_extensionsc C sJ g }t �| j�}tt �|��D ]&}t�t�}t �||�|_|� |� 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 ) rK ZX509_REQ_get_extensionsr� r� Zsk_X509_EXTENSION_numr# r� Zsk_X509_EXTENSION_valuer� rr )rp ZextsZnative_exts_objr� r� rA rA rB �get_extensions� s zX509Req.get_extensionsc C s^ |j rtd��|js td��t�t|��}|tjkr<td��t�| j |j |�}t |dk� dS )ad 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:`b"sha256"`. :type digest: :py:class:`bytes` :return: ``None`` �Key has only public part�Key is uninitialized�No such digest methodr N) r} r` rz rK �EVP_get_digestbynamer� rR rV Z X509_REQ_signr� ry rU �rp r| �digest� digest_obj� sign_resultrA rA rB r7 s z X509Req.signc C s4 t |t�std��t�| j|j�}|dkr0t� |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 )r] r r_ rK ZX509_REQ_verifyr� ry r� )rp r| r� rA rA rB r8 s zX509Req.verifyN)r= r> r? r@ rq r� r� r� r� r� r� r� r� r r r7 r8 rA rA rA rB r$ j s z4X509ReqType has been deprecated, use X509Req insteadc @ s e Zd ZdZdd� Zedd� �Zdd� Zedd � �Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Z d2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z!d<d=� Z"d>d?� Z#d@dA� Z$dBS )Cr% z An X.509 certificate. c C s: t �� }t|tjk� t�|t j�| _t� | _ t� | _ d S rJ ) rK ZX509_newrU rR rV rW � X509_freer� rm �_issuer_invalidator�_subject_invalidator)rp r rA rA rB rq < s z X509.__init__c C s. | � | �}t�|tj�|_t� |_t� |_|S rJ ) r� rR rW rK r r� rm r r )r r �certrA rA rB �_from_raw_x509_ptrD s zX509._from_raw_x509_ptrc C s ddl m} t� }||| j�S )z� Export as a ``cryptography`` certificate. :rtype: ``cryptography.x509.Certificate`` .. versionadded:: 17.1.0 r )� _Certificate)r� r rE r� )rp r rD rA rA rB r� L s zX509.to_cryptographyc C s& t |tj�std��| � }|j|_|S )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 certificate)r] r Z Certificater_ r� )r Z crypto_certr rA rA rB r� X s zX509.from_cryptographyc C s$ t |t�std��t�| j|� 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 integerN)r] r� r_ rK ZX509_set_versionr� �rp r� rA rA rB r� k s zX509.set_versionc C s t �| j�S )z� Return the version number of the certificate. :return: The version number of the certificate. :rtype: :py:class:`int` )rK ZX509_get_versionr� ro rA rA rB r� z s zX509.get_versionc C sF t �t �}t�| j�|_|jtjkr*t� t� |jtj �|_d|_ |S )z{ Get the public key of the certificate. :return: The public key. :rtype: :py:class:`PKey` T) r r� rK �X509_get_pubkeyr� ry rR rV r� rW rx r} r{ rA rA rB r� � s zX509.get_pubkeyc C s2 t |t�std��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)r] r r_ rK ZX509_set_pubkeyr� ry rU r� rA rA rB r� � s zX509.set_pubkeyc C sp t |t�std��|jr td��|js.td��t�t|��}|t j krNtd��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:`bytes` :return: :py:data:`None` r zKey only has public partr r r N)r] r r_ r} r` rz rK r r� rR rV Z X509_signr� ry rU )rp r| r Zevp_mdr rA rA rB r7 � s z X509.signc C s: t �| j�}t �|j�}|t jkr*td��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 z Undefined signature algorithm) rK ZX509_get0_tbs_sigalgr� r� � algorithmr� r` rR ri Z OBJ_nid2ln)rp Zalgorr� rA rA rB �get_signature_algorithm� s z X509.get_signature_algorithmc C s� t �t|��}|tjkr td��t�dt j�}t�dd�}t|�|d< t � | j |||�}t |dk� d� dd� t� ||d �D ��S ) a7 Return the digest of the X509 object. :param digest_name: The name of the digest algorithm to use. :type digest_name: :py:class:`bytes` :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 rA )r �upper)r� ZchrA rA rB � <listcomp>� s z X509.digest.<locals>.<listcomp>)rK r r� rR rV r` rS ZEVP_MAX_MD_SIZErT Z X509_digestr� rU r� rX )rp Z digest_namer r[ r� Z digest_resultrA rA rB r � s � �z X509.digestc C s t �| j�S )z� Return the hash of the X509 subject. :return: The hash of the subject. :rtype: :py:class:`bytes` )rK ZX509_subject_name_hashr� ro rA rA rB �subject_name_hash� s zX509.subject_name_hashc C s� t |t�std��t|�dd� }t |t�s6|�d�}t�d�}t� ||�}|d tj krzt� t� | j �|�}|r�t� nXt�|d tj �}t�|d � |tj kr�t� 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� )r] �_integer_typesr_ �hexr^ r� rR rS rK � BN_hex2bnrV ZASN1_INTEGER_set�X509_get_serialNumberr� r� �BN_to_ASN1_INTEGERr� rW �ASN1_INTEGER_freeZX509_set_serialNumberrU )rp �serial� hex_serial� bignum_serialZ small_serialrc � asn1_serialrA rA rB �set_serial_number� s* � zX509.set_serial_numberc C sh t �| j�}t �|tj�}z<t �|�}z t� |�}t |d�}|W �W �S t �|� X W 5 t �|� X dS )zx Return the serial number of this certificate. :return: The serial number. :rtype: int � N) rK r r� ZASN1_INTEGER_to_BNrR rV r� Z BN_bn2hexr� ri r� )rp r% r$ r# Zhexstring_serialr" rA rA rB �get_serial_number s zX509.get_serial_numberc C s. t |t�std��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)r] r� r_ rK �X509_get_notAfterr� �X509_gmtime_adj)rp �amountZnotAfterrA rA rB �gmtime_adj_notAfter- s zX509.gmtime_adj_notAfterc C s. t |t�std��t�| j�}t�||� dS )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)r] r� r_ rK �X509_get_notBeforer� r+ )rp r, Z notBeforerA rA rB �gmtime_adj_notBefore; s zX509.gmtime_adj_notBeforec C s( t | �� �}tj�|d�}|tj�� k S )z� Check whether the certificate has expired. :return: ``True`` if the certificate has expired, ``False`` otherwise. :rtype: bool z %Y%m%d%H%M%SZ)r� � get_notAfter�datetime�strptimeZutcnow)rp Z time_stringZ not_afterrA rA rB � has_expiredH s zX509.has_expiredc C s t || j��S rJ )rl r� )rp �whichrA rA rB �_get_boundary_timeT s zX509._get_boundary_timec C s | � 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 )r5 rK r. ro rA rA rB � get_notBeforeW s zX509.get_notBeforec C s t || j�|�S rJ )rd r� �rp r4 rb rA rA rB �_set_boundary_timed s zX509._set_boundary_timec C s | � 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`` )r8 rK r. �rp rb rA rA rB � set_notBeforeg s zX509.set_notBeforec C s | � tj�S )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 )r5 rK r* ro rA rA rB r0 t s zX509.get_notAfterc C s | � tj|�S )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`` )r8 rK r* r9 rA rA rB � set_notAfter� s zX509.set_notAfterc C s0 t �t �}|| j�|_t|jtjk� | |_|S rJ )r" r� r� rv rU rR rV r� )rp r4 rt rA rA rB � _get_name� s zX509._get_namec C s0 t |t�std��|| j|j�}t|dk� d S )Nzname must be an X509Namer� )r] r" r_ r� rv rU )rp r4 rt rc rA rA rB � _set_name� s zX509._set_namec C s | � 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< rK ZX509_get_issuer_namer ru rs rA rA rB � get_issuer� s zX509.get_issuerc C s | � tj|� | j�� dS )z� Set the issuer of this certificate. :param issuer: The issuer. :type issuer: :py:class:`X509Name` :return: ``None`` N)r= rK ZX509_set_issuer_namer rw )rp r� rA rA rB � set_issuer� s zX509.set_issuerc C s | � tj�}| j�|� |S )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< rK �X509_get_subject_namer ru rs rA rA rB r� � s zX509.get_subjectc C s | � tj|� | j�� dS )z� Set the subject of this certificate. :param subject: The subject. :type subject: :py:class:`X509Name` :return: ``None`` N)r= rK ZX509_set_subject_namer rw )rp r� rA rA rB � set_subject� s zX509.set_subjectc C s t �| j�S )z� Get the number of extensions on this certificate. :return: The number of extensions. :rtype: :py:class:`int` .. versionadded:: 0.12 )rK ZX509_get_ext_countr� ro rA rA rB �get_extension_count� s zX509.get_extension_countc C s< |D ]2}t |t�std��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)r] r# r` rK Z X509_add_extr� r� r� )rp r� r� r� rA rA rB r � s zX509.add_extensionsc C sN t �t �}t�| j|�|_|jtjkr.td��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# r� rK Z X509_get_extr� r� rR rV � IndexErrorZX509_EXTENSION_duprW r� )rp �indexr� r� rA rA rB � get_extension� s zX509.get_extensionN)%r= r> r? r@ rq r� r r� r� r� r� r� r� r7 r r r r& r( r- r/ r3 r5 r6 r8 r: r0 r; r< r= r> r? r� rA rB r rE rA rA rA rB r% 8 sF ' z.X509Type has been deprecated, use X509 insteadc @ sR e Zd ZdZejZejZej Z ej Z ej ZejZejZejZejZejZejZdS )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 N)r= r> r? r@ rK ZX509_V_FLAG_CRL_CHECKZ CRL_CHECKZX509_V_FLAG_CRL_CHECK_ALLZ CRL_CHECK_ALLZX509_V_FLAG_IGNORE_CRITICALZIGNORE_CRITICALZX509_V_FLAG_X509_STRICTZ X509_STRICTZ X509_V_FLAG_ALLOW_PROXY_CERTSZALLOW_PROXY_CERTSZX509_V_FLAG_POLICY_CHECKZ POLICY_CHECKZX509_V_FLAG_EXPLICIT_POLICYZEXPLICIT_POLICYZX509_V_FLAG_INHIBIT_MAPZ INHIBIT_MAPZX509_V_FLAG_NOTIFY_POLICYZ NOTIFY_POLICYZ X509_V_FLAG_CHECK_SS_SIGNATUREZCHECK_SS_SIGNATUREZX509_V_FLAG_CB_ISSUER_CHECKZCB_ISSUER_CHECKrA rA rA rB r& s c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) 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`. c C s t �� }t�|t j�| _d S rJ )rK ZX509_STORE_newrR rW ZX509_STORE_free�_store�rp �storerA rA rB rq 6 s zX509Store.__init__c C sP t |t�st� �t�| j|j�dkrLt�� }t�|�}t |tj k� t� � 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) r] r% r_ rK ZX509_STORE_add_certrF r� ZERR_peek_errorZERR_GET_REASONrU Z!X509_R_CERT_ALREADY_IN_HASH_TABLEZERR_clear_error)rp r �codeZ err_reasonrA rA rB �add_cert: s �zX509Store.add_certc C s t t�| j|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 crl: The certificate revocation list to add to this store. :return: ``None`` if the certificate revocation list was added successfully. r N)rU rK ZX509_STORE_add_crlrF �_crl�rp �crlrA rA rB �add_crlX s zX509Store.add_crlc C s 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)rU rK ZX509_STORE_set_flagsrF )rp �flagsrA rA rB � set_flagsh s zX509Store.set_flagsc C sF t �� }t�|t j�}t �|t|�d��� tt � | 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. z%sr N) rK ZX509_VERIFY_PARAM_newrR rW ZX509_VERIFY_PARAM_freeZX509_VERIFY_PARAM_set_timer� �strftimerU ZX509_STORE_set1_paramrF )rp Zvfy_timeZparamrA rA rB �set_time� s zX509Store.set_timeN) r= r> r? r@ rq rJ rN rP rR rA rA rA rB r' ( s z8X509StoreType has been deprecated, use X509Store insteadc s e Zd ZdZ� fdd�Z� ZS )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` c s t t| ��|� || _d S rJ )r� r( rq � certificate)rp �messagerS r� rA rB rq � s z X509StoreContextError.__init__)r= r> r? r@ rq r� rA rA r� rB r( � s c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )r) a� 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`. :ivar _store_ctx: The underlying X509_STORE_CTX structure used by this instance. It is dynamically allocated and automatically garbage collected. :ivar _store: See the ``store`` ``__init__`` parameter. :ivar _cert: See the ``certificate`` ``__init__`` parameter. :param X509Store store: The certificates which will be trusted for the purposes of any verifications. :param X509 certificate: The certificate to be verified. c C s0 t �� }t�|t j�| _|| _|| _| �� d S rJ ) rK ZX509_STORE_CTX_newrR rW ZX509_STORE_CTX_free� _store_ctxrF �_cert�_init)rp rH rS Z store_ctxrA rA rB rq � s zX509StoreContext.__init__c C s. t �| j| jj| jjtj�}|dkr*t� dS )z� Set up the store context for a subsequent verification operation. Calling this method more than once without first calling :meth:`_cleanup` will leak memory. r N) rK ZX509_STORE_CTX_initrU rF rV r� rR rV r� �rp �retrA rA rB rW � s �zX509StoreContext._initc C s t �| j� dS )z� Internally cleans up the store context. The store context can then be reused with a new call to :meth:`_init`. N)rK ZX509_STORE_CTX_cleanuprU ro rA rA rB �_cleanup� s zX509StoreContext._cleanupc C s\ t �| j�t �| j�tt�t �t �| j����g}t �| j�}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. ) rK ZX509_STORE_CTX_get_errorrU Z X509_STORE_CTX_get_error_depthr� rR ri Z X509_verify_cert_error_stringZ X509_STORE_CTX_get_current_certZX509_dupr% r r( )rp �errorsr� rV �pycertrA rA rB �_exception_from_context� s �� z(X509StoreContext._exception_from_contextc 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)rF rG rA rA rB � set_store� s zX509StoreContext.set_storec C s8 | � � | �� t�| j�}| � � |dkr4| �� �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. r N)rZ rW rK ZX509_verify_certrU r] rX rA rA rB �verify_certificate� s z#X509StoreContext.verify_certificateN) r= r> r? r@ rq rW rZ r] r^ r_ rA rA rA rB r) � s c C sv t |t�r|�d�}t|�}| tkr<t�|tjtjtj�}n | t krTt� |tj�}nt d��|tjkrlt � 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)r] r� r� rZ r rK ZPEM_read_bio_X509rR rV r Z d2i_X509_bior` r� r% r )r� rX rM r rA rA rB r* s � c C sn t � }| tkr t�||j�}n<| tkr6t�||j�}n$| tkrRt�||jdd�}nt d��|dksft �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� ) rZ r rK ZPEM_write_bio_X509r� r Z i2d_X509_bior Z X509_print_exr` �AssertionErrorr\ )r� r rM � result_coderA rA rB r+ 2 s � c C sP t � }| tkrtj}n| tkr&tj}ntd��|||j�}|dkrHt� 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 r` r� ) rZ r rK ZPEM_write_bio_PUBKEYr Zi2d_PUBKEY_bior` ry r� r\ )r� r| rM Z write_biorc rA rA rB r, M s c C s t � }t|t�std��|dk rR|dkr0td��t�t|��}|tjkrXt d��ntj}t | |�}| t kr�t� ||j |tjd|j|j�}|�� nh| tkr�t�||j �}nP| tkr�t�|j �tjkr�td��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_TEXTra ) rZ r] r r_ rK ZEVP_get_cipherbynamer� rR rV r` �_PassphraseHelperr ZPEM_write_bio_PrivateKeyry �callback� callback_args�raise_if_problemr Zi2d_PrivateKey_bior r� r� rW r� r� Z RSA_printrU r\ ) r� r| Zcipher� passphraserM Z cipher_obj�helperrc r rA rA rB r- f sN � � �� c @ sj e Zd ZdZdddddddgZd d � Zd d � Zd d� Zdd� Zdd� Z dd� Z dd� Z dd� Z dd� Z dS ) r. z# A certificate revocation. s unspecifieds keyCompromises CACompromises affiliationChangeds supersededs cessationOfOperations certificateHoldc C s t �� }t�|t j�| _d S rJ )rK ZX509_REVOKED_newrR rW �X509_REVOKED_free�_revoked)rp �revokedrA rA rB rq � s zRevoked.__init__c 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) rR rW rK r� r� rS r r` r rV r! Z X509_REVOKED_set_serialNumberrk )rp Zhex_strr$ Z bignum_ptrZ bn_resultr% rA rA rB � 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 ) rZ rK Z X509_REVOKED_get0_serialNumberrk rU rR rV Zi2a_ASN1_INTEGERr\ )rp rM Zasn1_intr� rA rA rB � get_serial� s zRevoked.get_serialc C s^ t t�| j��D ]H}t�| j|�}t�|�}t�|�tjkrt�|� t� | j|� qZqd S rJ ) r� rK �X509_REVOKED_get_ext_countrk �X509_REVOKED_get_extr� r� �NID_crl_reasonr� ZX509_REVOKED_delete_ext)rp r� r� r� rA rA rB �_delete_reason� s zRevoked._delete_reasonc C s� |dkr| � � n�t|t�s&td��n�|�� �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 rA )�lower)r� �rrA rA rB r s z&Revoked.set_reason.<locals>.<listcomp>r r� )rr r] r^ r_ ru �replace� _crl_reasonsrD rK ZASN1_ENUMERATED_newrU rR rV rW ZASN1_ENUMERATED_freeZASN1_ENUMERATED_setZX509_REVOKED_add1_ext_i2drk rq )rp �reasonZ reason_codeZnew_reason_extrc r� rA rA rB � set_reason� s( �zRevoked.set_reasonc C s� t t�| j��D ]p}t�| j|�}t�|�}t�|�tjkrt� }t� ||dd�}|stt� |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� rK ro rk rp r� r� rq rZ r� ZM_ASN1_OCTET_STRING_printr� rU r\ )rp r� r� r� rM r� rA rA rB � 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)rx ro rA rA rB � all_reasons) s zRevoked.all_reasonsc C s t �| j�}t||�S )z� Set the revocation timestamp. :param bytes when: The timestamp of the revocation, as ASN.1 TIME. :return: ``None`` )rK � X509_REVOKED_get0_revocationDaterk rd )rp rb �dtrA rA rB � set_rev_date5 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 )rK r} rk rl )rp r~ rA rA rB � get_rev_date@ s zRevoked.get_rev_dateN)r= r> r? r@ rx rq rm rn rr rz r{ r| r r� rA rA rA rB r. � s$ � $ c @ s| e Zd ZdZdd� Zdd� Zedd� �Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zedefdd�ZdS ) r/ z( A certificate revocation list. c C s t �� }t�|t j�| _d S rJ )rK Z X509_CRL_newrR rW � X509_CRL_freerK rL rA rA rB rq P s z CRL.__init__c C s ddl m} t� }||| j�S )z� Export as a ``cryptography`` CRL. :rtype: ``cryptography.x509.CertificateRevocationList`` .. versionadded:: 17.1.0 r )�_CertificateRevocationList)r� r� rE rK )rp r� rD rA rA rB r� T s zCRL.to_cryptographyc C s& t |tj�std��| � }|j|_|S )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 list)r] r ZCertificateRevocationListr_ Z _x509_crlrK )r Z crypto_crlrM rA rA rB r� b s zCRL.from_cryptographyc C sn g }t �| j�}tt �|��D ]>}t �||�}t �|�}t�t�}t � |t j �|_ |� |� q |rjt|�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)rK ZX509_CRL_get_REVOKEDrK r� Zsk_X509_REVOKED_numZsk_X509_REVOKED_value� Cryptography_X509_REVOKED_dupr. r� rR rW rj rk rr �tuple)rp ZresultsZ revoked_stackr� rl Z revoked_copyZpyrevrA rA rB � get_revokedu s zCRL.get_revokedc 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)rK r� rk rU rR rV ZX509_CRL_add0_revokedrK )rp rl �copyr� rA rA rB � 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 ) rK r� ZX509_CRL_get_issuerrK rU rR rV rW r� r" r� rv )rp Z_issuerr� rA rA rB r> � s zCRL.get_issuerc C s t t�| j|�dk� dS )z� Set the CRL version. .. versionadded:: 16.1.0 :param int version: The version of the CRL. :return: ``None`` r N)rU rK ZX509_CRL_set_versionrK r rA rA rB r� � s zCRL.set_versionc C s t || j�|�S rJ )rd rK r7 rA rA rB r8 � s zCRL._set_boundary_timec C s | � tj|�S )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`` )r8 rK ZX509_CRL_get_lastUpdater9 rA rA rB �set_lastUpdate� s zCRL.set_lastUpdatec C s | � tj|�S )z� Set when the CRL will next be udpated. The timestamp is formatted as an ASN.1 TIME:: YYYYMMDDhhmmssZ .. versionadded:: 16.1.0 :param bytes when: A timestamp string. :return: ``None`` )r8 rK ZX509_CRL_get_nextUpdater9 rA rA rB �set_nextUpdate� s zCRL.set_nextUpdatec 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) rK r rU rR rV �X509_CRL_set_issuer_namerK r@ r� Z X509_CRL_sort� X509_CRL_signry )rp r� Z issuer_keyr r r� rA rA rB r7 � s � zCRL.sign�d c C s t |t�std��t |t�s$td��t |t�s6td��|tkrFtd��t�|�}|tj krbt d��t� t� � �}t |tj k� t�� }t |tj k� t�|d� t�| j|� t�||d d d � t�| j|� t�| jt�|j�� t�| j|j|�} | �st� 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"sha2566"``). :rtype: bytes � cert must be an X509 instancezkey must be a PKey instancer� zdigest must be providedr r � �< )r] r% r_ r r� � _UNSPECIFIEDrK r rR rV r` rP rQ rU Z ASN1_TIME_newr+ ZX509_CRL_set_lastUpdaterK ZX509_CRL_set_nextUpdater� r@ r� r� ry r� r9 ) rp r r� r� Zdaysr r rM Zsometimer rA rA rB �export� s6 �z CRL.exportN)r= r> r? r@ rq r� r� r� r� r� r> r� r8 r� r� r7 r r� r� rA rA rA rB r/ K s �z,CRLType has been deprecated, use CRL insteadc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) r0 c C s t t�| j��S )zm Check if this NID_pkcs7_signed object :return: True if the PKCS7 is of type signed )�boolrK ZPKCS7_type_is_signed�_pkcs7ro rA rA rB �type_is_signed- s zPKCS7.type_is_signedc C s t t�| j��S )zt Check if this NID_pkcs7_enveloped object :returns: True if the PKCS7 is of type enveloped )r� rK ZPKCS7_type_is_envelopedr� ro rA rA rB �type_is_enveloped5 s zPKCS7.type_is_envelopedc C s t t�| j��S )z� Check if this NID_pkcs7_signedAndEnveloped object :returns: True if the PKCS7 is of type signedAndEnveloped )r� rK Z PKCS7_type_is_signedAndEnvelopedr� ro rA rA rB �type_is_signedAndEnveloped= s z PKCS7.type_is_signedAndEnvelopedc C s t t�| j��S )zi Check if this NID_pkcs7_data object :return: True if the PKCS7 is of type data )r� rK ZPKCS7_type_is_datar� ro rA rA rB � type_is_dataE s zPKCS7.type_is_datac C s" t �| jj�}t �|�}t�|�S )zk Returns the type name of the PKCS7 structure :return: A string with the typename )rK r� r� r� r� rR ri )rp r� Z string_typerA rA rB � get_type_nameM s zPKCS7.get_type_nameN)r= r> r? r� r� r� r� r� rA rA rA rB r0 , s z0PKCS7Type has been deprecated, use PKCS7 insteadc @ sb e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z ddd�Z dS )r1 z A PKCS #12 archive. c C s d | _ d | _d | _d | _d S rJ )ry rV �_cacerts� _friendlynamero rA rA rB rq d s zPKCS12.__init__c C s | j S )z� Get the certificate in the PKCS #12 structure. :return: The certificate, or :py:const:`None` if there is none. :rtype: :py:class:`X509` or :py:const:`None` )rV ro rA rA rB �get_certificatej s zPKCS12.get_certificatec C s t |t�std��|| _dS )z� Set the certificate in the PKCS #12 structure. :param cert: The new certificate, or :py:const:`None` to unset it. :type cert: :py:class:`X509` or :py:const:`None` :return: ``None`` r� N)r] r% r_ rV )rp r rA rA rB �set_certificates s zPKCS12.set_certificatec C s | j S )z� Get the private key in the PKCS #12 structure. :return: The private key, or :py:const:`None` if there is none. :rtype: :py:class:`PKey` )ry ro rA rA rB �get_privatekey� s zPKCS12.get_privatekeyc C s t |t�std��|| _dS )z� Set the certificate portion of the PKCS #12 structure. :param pkey: The new private key, or :py:const:`None` to unset it. :type pkey: :py:class:`PKey` or :py:const:`None` :return: ``None`` r N)r] r r_ ry r{ rA rA rB �set_privatekey� s zPKCS12.set_privatekeyc C s | j dk rt| j �S dS )a Get the CA certificates in the PKCS #12 structure. :return: A tuple with the CA certificates in the chain, or :py:const:`None` if there are none. :rtype: :py:class:`tuple` of :py:class:`X509` or :py:const:`None` N)r� r� ro rA rA rB �get_ca_certificates� s zPKCS12.get_ca_certificatesc C s> |dkrd| _ n*t|�}|D ]}t|t�s td��q || _ dS )a Replace or set the CA certificates within the PKCS12 object. :param cacerts: The new CA certificates, or :py:const:`None` to unset them. :type cacerts: An iterable of :py:class:`X509` or :py:const:`None` :return: ``None`` Nz)iterable must only contain X509 instances)r� �listr] r% r_ )rp �cacertsr rA rA rB �set_ca_certificates� s �zPKCS12.set_ca_certificatesc C s2 |dkrd| _ nt|t�s(td|f ��|| _ dS )z� Set the friendly name in the PKCS #12 structure. :param name: The new friendly name, or :py:const:`None` to unset. :type name: :py:class:`bytes` or :py:const:`None` :return: ``None`` Nz+name must be a byte string or None (not %r))r� r] r^ r_ rs rA rA rB �set_friendlyname� s �zPKCS12.set_friendlynamec C s | j S )z� Get the friendly name in the PKCS# 12 structure. :returns: The friendly name, or :py:const:`None` if there is none. :rtype: :py:class:`bytes` or :py:const:`None` )r� ro rA rA rB �get_friendlyname� s zPKCS12.get_friendlynameN� r� c C s� t d|�}| jdkr tj}n0t�� }t�|tj�}| jD ]}t�||j � q8|dkrZtj}| j }|dkrntj}| j dkr�tj}n| j j }| j dkr�tj}n| j j }t� |||||tjtj||d� }|tjkr�t� t�|tj�}t� } t�| |� t| �S )a� Dump a PKCS12 object as a string. For more information, see the :c:func:`PKCS12_create` man page. :param passphrase: The passphrase used to encrypt the structure. Unlike some other passphrase arguments, this *must* be a string, not a callback. :type passphrase: :py:data:`bytes` :param iter: Number of times to repeat the encryption step. :type iter: :py:data:`int` :param maciter: Number of times to repeat the MAC step. :type maciter: :py:data:`int` :return: The string representation of the PKCS #12 structure. :rtype: rh Nr )�_text_to_bytes_and_warnr� rR rV rK Zsk_X509_new_nullrW � sk_X509_freeZ sk_X509_pushr� r� ry rV Z PKCS12_createZ&NID_pbe_WithSHA1And3_Key_TripleDES_CBCr� � PKCS12_freerZ Zi2d_PKCS12_bior\ ) rp rh �iterZmaciterr� r � friendlynamer| �pkcs12rM rA rA rB r� � sH � z PKCS12.export)Nr� r� )r= r> r? r@ rq r� r� r� r� r� r� r� r� r� rA rA rA rB r1 _ s z2PKCS12Type has been deprecated, use PKCS12 insteadc @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )r2 z! A Netscape SPKI object. c C s t �� }t�|t j�| _d S rJ )rK ZNETSCAPE_SPKI_newrR rW ZNETSCAPE_SPKI_free�_spki)rp ZspkirA rA rB rq s zNetscapeSPKI.__init__c C s^ |j rtd��|js td��t�t|��}|tjkr<td��t�| j |j |�}t |dk� dS )a Sign the certificate request with this key and digest type. :param pkey: The private key to sign with. :type pkey: :py:class:`PKey` :param digest: The message digest to use. :type digest: :py:class:`bytes` :return: ``None`` r r r r N) r} r` rz rK r r� rR rV ZNETSCAPE_SPKI_signr� ry rU r rA rA rB r7 s �zNetscapeSPKI.signc C s" t �| j|j�}|dkr t� dS )aY Verifies a signature on a certificate request. :param PKey key: The public key that signature is supposedly from. :return: ``True`` if the signature is correct. :rtype: bool :raises OpenSSL.crypto.Error: If the signature is invalid, or there was a problem verifying the signature. r T)rK ZNETSCAPE_SPKI_verifyr� ry r� )rp r� ZanswerrA rA rB r8 8 s zNetscapeSPKI.verifyc C s$ t �| j�}t�|�}t �|� |S )z� Generate a base64 encoded representation of this SPKI object. :return: The base64 encoded string. :rtype: :py:class:`bytes` )rK ZNETSCAPE_SPKI_b64_encoder� rR ri r� )rp Zencodedr� rA rA rB � b64_encodeI s zNetscapeSPKI.b64_encodec C sD t �t �}t�| j�|_t|jtjk� t� |jtj �|_d|_ |S )z| Get the public key of this certificate. :return: The public key. :rtype: :py:class:`PKey` T) r r� rK ZNETSCAPE_SPKI_get_pubkeyr� ry rU rR rV rW rx r} r{ rA rA rB r� U s zNetscapeSPKI.get_pubkeyc C s t �| j|j�}t|dk� dS )zv Set the public key of the certificate :param pkey: The public key :return: ``None`` r� N)rK ZNETSCAPE_SPKI_set_pubkeyr� ry rU r� rA rA rB r� c s zNetscapeSPKI.set_pubkeyN) r= r> r? r@ rq r7 r8 r� r� r� rA rA rA rB r2 s z>NetscapeSPKIType has been deprecated, use NetscapeSPKI insteadc @ sB e Zd Zd dd�Zedd� �Zedd� �Zefdd �Zd d � Z d S )rd Fc C s4 |t kr|d k rtd��|| _|| _|| _g | _d S )Nz0only FILETYPE_PEM key format supports encryption)r r` � _passphrase� _more_args� _truncate� _problems)rp r� rh Z more_args�truncaterA rA rB rq v s �z_PassphraseHelper.__init__c C sF | j d krtjS t| j t�r"tjS t| j �r:t�d| j�S td��d S )NZpem_password_cb�2Last argument must be a byte string or a callable.) r� rR rV r] r^ �callablere �_read_passphraser_ ro rA rA rB re � s �z_PassphraseHelper.callbackc C s> | j d krtjS t| j t�r"| j S t| j �r2tjS td��d S )Nr� )r� rR rV r] r^ r� r_ ro rA rA rB rf � s �z _PassphraseHelper.callback_argsc C s8 | j r4z t|� W n |k r& Y nX | j �d��d S r� )r� �_exception_from_error_queue�pop)rp Z exceptionTyperA rA rB rg � s z"_PassphraseHelper.raise_if_problemc C s� z�| j r| �|||�}n | �|�}t|t�s4td��t|�|kr\| jrT|d |� }ntd��tt|��D ]}|||d � ||< qht|�W S tk r� } z| j � |� W Y �dS d }~X Y nX d S )NzString expectedz+passphrase returned by callback is too longr� r ) r� r� r] r^ r` rT r� r� � Exceptionr� rr )rp Zbuf�sizeZrwflagZuserdatar� r� �erA rA rB r� � s$ � z"_PassphraseHelper._read_passphraseN)FF) r= r> r? rq r� re rf r rg r� rA rA rA rB rd u s rd c C s� t |t�r|�d�}t|�}| tkr<t�|tjtjtj�}n | t krTt� |tj�}nt d��|tjkrlt � 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� r` T)r] r� r� rZ r rK ZPEM_read_bio_PUBKEYrR rV r Zd2i_PUBKEY_bior` r� r r� rW rx ry r} )r� rX rM �evp_pkeyr| rA rA rB r3 � s& � c C s� t |t�r|�d�}t|�}t| |�}| tkrNt�|tj |j |j �}|� � n | t krft�|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� r` )r] r� r� rZ rd r rK ZPEM_read_bio_PrivateKeyrR rV re rf rg r Zd2i_PrivateKey_bior` r� r r� rW rx ry )r� rX rh rM ri r� r| rA rA rB r4 � s( � c C sn t � }| tkr t�||j�}n<| tkr6t�||j�}n$| tkrRt�||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 ra ) rZ r rK ZPEM_write_bio_X509_REQr� r Zi2d_X509_REQ_bior ZX509_REQ_print_exr` rU r\ )r� r� rM rc rA rA rB r5 s � c C s� t |t�r|�d�}t|�}| tkr<t�|tjtjtj�}n | t krTt� |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� r` )r] r� r� rZ r rK ZPEM_read_bio_X509_REQrR rV r Zd2i_X509_REQ_bior` rU r$ r� rW r� r� )r� rX rM r� Zx509reqrA rA rB r6 s c C s� t d|�}t�t|��}|tjkr*td��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 rY r r r zunsigned int *r� N)r� rK r r� rR rV r` �Cryptography_EVP_MD_CTX_newrW � Cryptography_EVP_MD_CTX_freeZ EVP_SignInitZEVP_SignUpdaterT Z EVP_PKEY_sizery rU rS Z EVP_SignFinalrX ) r| rY r r �md_ctxr� Zsignature_bufferZsignature_lengthZ final_resultrA rA rB r7 9 s( � c C s� t d|�}t�t|��}|tjkr*td��t�| j�}t |tjk� t� |tj �}t� � }t� |tj �}t�||� t�||t|�� t�||t|�|�}|dkr�t� 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 rY r r� N)r� rK r r� rR rV r` r r� rU rW rx r� r� ZEVP_VerifyInitZEVP_VerifyUpdaterT ZEVP_VerifyFinalr� )r Z signaturerY r r r| r� Z verify_resultrA rA rB r8 [ s& �c C sj t � }| tkr t�||j�}n8| tkr6t�||j�}n | tkrNt�||j�}nt d��|dksbt �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 ra r� ) rZ r rK ZPEM_write_bio_X509_CRLrK r Zi2d_X509_CRL_bior ZX509_CRL_printr` rb r\ )r� rM rM rY rA rA rB r9 s � c C s� t |t�r|�d�}t|�}| tkr<t�|tjtjtj�}n | t krTt� |tj�}nt d��|tjkrlt � 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 PKey object r� r` )r] r� r� rZ r rK ZPEM_read_bio_X509_CRLrR rV r Zd2i_X509_CRL_bior` r� r/ r� rW r� rK )r� rX rM rM r� rA rA rB r: � s c C s� t |t�r|�d�}t|�}| tkr<t�|tjtjtj�}n | t krTt� |tj�}nt d��|tjkrlt � t �t �}t�|tj�|_|S )z� Load pkcs7 data from the string *buffer* encoded with the type *type*. :param type: The file type (one of FILETYPE_PEM or FILETYPE_ASN1) :param buffer: The buffer with the pkcs7 data. :return: The PKCS7 object r� r` )r] r� r� rZ r rK ZPEM_read_bio_PKCS7rR rV r Z d2i_PKCS7_bior` r� r0 r� rW Z PKCS7_freer� )r� rX rM Zpkcs7Zpypkcs7rA rA rB r; � s c C s� t d|�}t| t�r | �d�} t| �}|s0tj}t�|tj�}|tjkrNt � t� |tj �}t� d�}t� d�}t� d�}t� |||||�}|s�t � t� |d tj�}z t � W n tk r� Y nX |d tjkr�d}n t�t�}t� |d tj�|_|d tjk�rd} d} nPt�|d �} t� d�} t�|d | �} t�| | d �dd� } | tjk�rdd} g } tt�|��D ]&}t�||�}t�|�}| �|� �qv| �s�d} t �t �}||_| |_ | |_ | |_ |S ) a� Load pkcs12 data from the string *buffer*. If the pkcs12 structure is encrypted, a *passphrase* must be included. The MAC is always checked and thus required. See also the man page for the C function :py:func:`PKCS12_parse`. :param buffer: The buffer the certificate is stored in :param passphrase: (Optional) The password to decrypt the PKCS12 lump :returns: The PKCS12 object rh r� z EVP_PKEY**zX509**z Cryptography_STACK_OF_X509**r Nzint*) r� r] r� r� rZ rR rV rK Zd2i_PKCS12_bior� rW r� rS Z PKCS12_parser� r r r� rx ry r% r ZX509_alias_get0rX r� Z sk_X509_numZ sk_X509_valuerr r1 rV r� r� )rX rh rM Zp12r| r r� Z parse_resultZpykeyr\ r� Zfriendlyname_lengthZfriendlyname_bufferZ pycacertsr� r Zpycacertr� rA rA rB r< � sj � � s utf8only)N)NN)N)N)tr1 �base64r � functoolsr �operatorr r r r r r Zsixr r r r� r r� Z cryptographyr Z)cryptography.hazmat.primitives.asymmetricr r Zcryptography.utilsr Z OpenSSL._utilr rR r rK r r� r r� r r� r r� r r� r Z _make_assert�__all__ZSSL_FILETYPE_PEMr ZSSL_FILETYPE_ASN1r r r� r Z EVP_PKEY_DSAr Z EVP_PKEY_DHZTYPE_DHZ EVP_PKEY_ECZTYPE_ECr� r r� rU rE rH rZ r\ rd rl �objectrm r r= �DeprecationWarningZPKeyTyper� r r! r" Z X509NameTyper# ZX509ExtensionTyper$ Z X509ReqTyper% ZX509Typer& r' Z X509StoreTyper( r) r* r+ r, r- r. r/ ZCRLTyper0 Z PKCS7Typer1 Z PKCS12Typer2 ZNetscapeSPKITyperd r3 r4 r5 r6 r7 r8 r9 r: r; r< ZOpenSSL_add_all_algorithmsZSSL_load_error_stringsZ ASN1_STRING_set_default_mask_ascrA rA rA rB �<module> sN ( �' ( �j B � � H � U �o �h ; + [ �, � / �Z �G! $ "$ `
Save File
Cancel