3
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/dnZ0e j1Z2e j3Z4e j5Z6e j7Z8G d1d de9Z:ee e:Z;e*e:Zdod6d7Z?d8d9 Z@d:d; ZAdd? d?eCZDG d@d deCZEeeEeFdAeGZHG dBdC dCeCZIdDd ZJdEd ZKG dFd deCZLeeLeFdGeGZMG dHd deCZNeeNeFdIeGZOG dJd deCZPeePeFdKeGZQG dLd deCZReeReFdMeGZSG dNd deCZTG dOd deCZUeeUeFdPeGZVG dQd de9ZWG dRd deCZXdSd ZYdTd ZZdUd Z[dpdVd Z\G dWd d eCZ]G dXd d eCZ^ee^eFdYeGZ_G dZd! d!eCZ`ee`eFd[eGZaG d\d" d"eCZbeebeFd]eGZcG d^d# d#eCZdeedeFd_eGZeG d`da daeCZfdbd$ Zgdqdcd%Zhddd& Zided' Zjdfd( Zkdgd) Zldhd* Zmdid+ Zndjd, Zodrdkd-Zpe jq e jr e jsdl dS )s N) b16encode)partial)__eq____ne____lt____le____gt____ge__)
integer_types text_typePY3)x509)dsarsa)
deprecated)ffilibexception_from_error_queue byte_stringnative UNSPECIFIEDtext_to_bytes_and_warn make_assert FILETYPE_PEM
FILETYPE_ASN1
FILETYPE_TEXTTYPE_RSATYPE_DSAErrorPKeyget_elliptic_curvesget_elliptic_curveX509Name
X509ExtensionX509ReqX509X509StoreFlags X509StoreX509StoreContextErrorX509StoreContextload_certificatedump_certificatedump_publickeydump_privatekeyRevokedCRLPKCS7PKCS12 NetscapeSPKIload_publickeyload_privatekeydump_certificate_requestload_certificate_requestsignverifydump_crlload_crlload_pkcs7_data load_pkcs12 c @ s e Zd ZdZdS )r z7
An error occurred in an `OpenSSL.crypto` API.
N)__name__
__module__ __qualname____doc__ rD rD /usr/lib/python3.6/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.backendrF )rF rD rD rE _get_backendX s rG 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)whererD rD rE _untested_errord s rJ c C sd | dkr t jt j }t j}n(tjd| }t j|t| }|fdd}t|tj k tj
||}|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.
Nzchar[]c S s
t j| S )N)_libBIO_free)biorefrD rD rE free~ s z_new_mem_buf..free) rK BIO_new BIO_s_memrL _ffinewZBIO_new_mem_buflen_openssl_assertNULLgc)bufferrM rO datarD rD rE _new_mem_bufm s rZ c C s. t jd}tj| |}t j|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_lengthrD rD rE _bio_to_string s
r\ c C s2 t |tstdtj| |}|dkr.tddS )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)
isinstancebytes TypeErrorrK ZASN1_TIME_set_string
ValueError)boundarywhen
set_resultrD rD rE _set_asn1_time s
rd c C s t jd| }tj|dkr dS tj|tjkr>t jtj|S t jd}tj | | |d t j
krlt d n6t jd|d }tj|}t j|}tj |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.
z ASN1_STRING*r NzASN1_GENERALIZEDTIME** ASN1_TIME_to_generalizedtime)
rR castrK ASN1_STRING_lengthZASN1_STRING_typeZV_ASN1_GENERALIZEDTIMEstringASN1_STRING_datarS re rV rJ ZASN1_GENERALIZEDTIME_free)Z timestampZstring_timestampZgeneralized_timestampZ string_data
string_resultrD rD rE _get_asn1_time s
rk c @ s$ e Zd Zdd Zdd Zdd ZdS )_X509NameInvalidatorc C s
g | _ d S )N)_names)selfrD rD rE __init__ s z _X509NameInvalidator.__init__c C s | j j| d S )N)rm append)rn namerD rD rE add s z_X509NameInvalidator.addc C s x| j D ]}|`qW d S )N)rm _name)rn rq rD rD rE clear s z_X509NameInvalidator.clearN)r@ rA rB ro rr rt rD rD rD rE rl s rl 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 j }tj|t j| _d| _d S )NF)rK Z EVP_PKEY_newrR rW
EVP_PKEY_free_pkey _initialized)rn pkeyrD rD rE ro s z
PKey.__init__c C s( t }| jr|j| jS |j| jS 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)rG _only_publicZ_evp_pkey_to_public_keyrv Z_evp_pkey_to_private_key)rn rF rD rD rE to_cryptography_key s zPKey.to_cryptography_keyc C sR | }t |tjtjtjtjfs(td|j|_ t |tjtjfrHd|_
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_pkeyrv ry rw )clsZ
crypto_keyrx rD rD rE from_cryptography_key s zPKey.from_cryptography_keyc C s6 t |tstdt |ts$td|tkr|dkr= 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``
ztype must be an integerzbits must be an integerr zInvalid number of bitsr? 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_RSArv r ZDSA_newZDSA_freeZDSA_generate_parameters_exZDSA_generate_keyZEVP_PKEY_set1_DSAr rw )rn typebitsZexponentr resultr resrD rD rE generate_key s4
zPKey.generate_keyc C s` | j rtdtj| j tjkr*tdtj| j}tj |tj
}tj |}|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)
ry r_ rK Z
EVP_PKEY_typer EVP_PKEY_RSAEVP_PKEY_get1_RSArv rR rW RSA_freeZ
RSA_check_key_raise_current_error)rn r r rD rD rE checkG s
z
PKey.checkc C s t j| jS )zT
Returns the type of the key
:return: The type of the key.
)rK EVP_PKEY_idrv )rn rD rD rE r a s z PKey.typec C s t j| jS )zh
Returns the number of bits of the key
:return: The number of bits of the key.
)rK Z
EVP_PKEY_bitsrv )rn rD rD rE r i s z PKey.bitsN)r@ rA rB rC ry rw ro rz classmethodr| r r r r rD rD rD rE r s 8z.PKeyType has been deprecated, use PKey insteadc sd e Zd ZdZdZer fddZedd 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 |trtt| j|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)rn other) __class__rD rE r s
z_EllipticCurve.__ne__c s> j tjd}tjd|}j || 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 |jV qd S )N)from_nidnid).0c)r{ r rD rE s z7_EllipticCurve._load_elliptic_curves..)ZEC_get_builtin_curvesrR rV rS set)r{ r Z
num_curvesZbuiltin_curvesrD )r{ r rE _load_elliptic_curves s
z$_EllipticCurve._load_elliptic_curvesc C s | j dkr| j|| _ | 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{ r rD rD rE _get_elliptic_curves s
z#_EllipticCurve._get_elliptic_curvesc C s | ||t j|j|jdS )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 rh
OBJ_nid2sndecode)r{ r r rD rD rE 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 _nidrq )rn r r rq rD rD rE ro s
z_EllipticCurve.__init__c C s d| j f S )Nz
)rq )rn rD rD rE __repr__ s z_EllipticCurve.__repr__c C s | j j| j}tj|t jS )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)rn keyrD rD rE
_to_EC_KEY s z_EllipticCurve._to_EC_KEY)r@ rA rB rC r _PY3r r r r r ro r r
__classcell__rD rD )r rE r y s r c C s
t jtS )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 rD rD rD rE r s c C s, x t D ]}|j| kr|S qW td| 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 rq r` )rq ZcurverD rD rE r! s
c s e Zd ZdZdd Z fddZ fddZdd ZeeZee 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|j}tj|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_duprs rR rW X509_NAME_free)rn rq rD rD rE ro s zX509Name.__init__c s |j dr tt| j||S t|tk r.frD )r r rD )r rE _cmps s z
X509Name._cmpc C sB t jdd}tj| j|t|}t|t jk dtt j |f S )z6
String representation of an X509Name
zchar[]i z)
rR rS rK ZX509_NAME_oneliners rT rU rV _nativerh )rn r[ Z
format_resultrD rD rE r s zX509Name.__repr__c C s t j| jS )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_hashrs )rn rD rD rE hash s
z
X509Name.hashc C sN t jd}tj| j|}t|dk t j|d |dd }tj|d |S )z
Return the DER encoding of this name.
:return: The DER encoded form of this name.
:rtype: :py:class:`bytes`
zunsigned char**r N)rR rS rK Z
i2d_X509_NAMErs rU rX r )rn r[ Z
encode_resultrj rD rD rE der s
z X509Name.derc C s g }xt tj| jD ]n}tj| j|}tj|}tj|}tj|}tj|}t j
tj |tj |dd }|j
t j||f qW |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 rs r r r r r rR rX ri rg rp rh ) rn r r r ZfnameZfvalr rq r rD rD rE get_components s
zX509Name.get_components)r@ rA rB rC ro r r r r r r r r r r r r r r rD rD )r rE r" s
$ ( z6X509NameType has been deprecated, use X509Name insteadc @ sd e Zd ZdZdddZedd 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 jd}tj|t jt jt jt jd tj| |dk rRt|tsJtd|j |_
|dk rtt|tsltd|j |_ |rd| }tj t j|||}|t jkrt
t j|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)rn Z type_nameZcriticalr subjectissuerZctx extensionrD rD rE ro s"
zX509Extension.__init__c C s t jt j| jS )N)rK r X509_EXTENSION_get_objectr )rn rD rD rE r s zX509Extension._nidZemailZDNSZURIc
C s t jdtj| j}t j|tj}g }xttj|D ]}tj ||}y| j
|j }W n8 t k
r t
}tj|| |jtt| Y q6X tt j|jjj|jjjd d }|j|d | q6W dj|S )NzGENERAL_NAMES*:z, )rR rf rK ZX509V3_EXT_d2ir rW ZGENERAL_NAMES_freer Zsk_GENERAL_NAME_numZsk_GENERAL_NAME_value _prefixesr KeyErrorrZ ZGENERAL_NAME_printrp r r\ rX dZia5rY lengthjoin)rn namespartsr rq ZlabelrM r rD rD rE _subjectAltNameString s "z#X509Extension._subjectAltNameStringc C sD t j| jkr| j S t }t j|| 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\ )rn rM print_resultrD rD rE __str__/ s zX509Extension.__str__c C s t j| jS )zk
Returns the critical field of this X.509 extension.
:return: The critical field.
)rK ZX509_EXTENSION_get_criticalr )rn rD rD rE get_critical< s zX509Extension.get_criticalc C s& t j| j}t j|}tjt j|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 rh r )rn objr rD rD rE get_short_nameD s
z X509Extension.get_short_namec C s@ t j| j}tjd|}t j|}t j|}tj||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
z ASN1_STRING*N)rK X509_EXTENSION_get_datar rR rf ri rg rX )rn Z octet_resultrj Z char_result
result_lengthrD rD rE get_dataS s
zX509Extension.get_data)NN)r@ rA rB rC ro propertyr rK Z GEN_EMAILZGEN_DNSZGEN_URIr r r r r r rD rD rD rE 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 j }tj|t j| _| jd d S )Nr )rK Z X509_REQ_newrR rW
X509_REQ_free_req set_version)rn reqrD rD rE ro o s zX509Req.__init__c C s ddl m} t }||| jS )z
Export as a ``cryptography`` certificate signing request.
:rtype: ``cryptography.x509.CertificateSigningRequest``
.. versionadded:: 17.1.0
r )_CertificateSigningRequest))cryptography.hazmat.backends.openssl.x509r rG r )rn r rF rD rD rE to_cryptographyu s zX509Req.to_cryptographyc C s& t |tjstd| }|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 rD rD rE from_cryptography s
zX509Req.from_cryptographyc C s t j| 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 rv rU )rn rx rc rD rD rE
set_pubkey s zX509Req.set_pubkeyc C sD t jt }tj| j|_t|jtjk tj |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 rv rU rR rV rW ru ry )rn rx rD rD rE
get_pubkey s
zX509Req.get_pubkeyc C s t j| 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 )rn versionrc rD rD rE r s zX509Req.set_versionc C s t j| jS )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 )rn rD rD rE get_version s zX509Req.get_versionc C s2 t jt }tj| 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 rs rU rR rV _owner)rn rq rD rD rE get_subject s
zX509Req.get_subjectc C sp t j }t|tjk tj|t j}x,|D ]$}t|ts@t dt j
||j q*W t j | 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``
z+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 )rn
extensionsstackextr rD rD rE add_extensions s
zX509Req.add_extensionsc C sN g }t j| j}x8tt j|D ]&}tjt}t j|||_|j | q W |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 rp )rn ZextsZnative_exts_objr r rD rD rE get_extensions s
zX509Req.get_extensionsc C s^ |j rtd|js tdtjt|}|tjkrd? Z#d@dA Z$dBS )Cr% z
An X.509 certificate.
c C s: t j }t|tjk tj|t j| _t | _ t | _
d S )N) rK ZX509_newrU rR rV rW X509_freer rl _issuer_invalidator_subject_invalidator)rn r
rD rD rE ro < s
z
X509.__init__c C s. | j | }tj|tj|_t |_t |_|S )N) r rR rW rK r r rl r r )r{ r
certrD rD rE _from_raw_x509_ptrD s
zX509._from_raw_x509_ptrc C s ddl m} t }||| jS )z
Export as a ``cryptography`` certificate.
:rtype: ``cryptography.x509.Certificate``
.. versionadded:: 17.1.0
r ) _Certificate)r r rG r )rn r rF rD rD rE r L s zX509.to_cryptographyc C s& t |tjstd| }|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 rD rD rE r X s
zX509.from_cryptographyc C s$ t |tstdtj| 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 )rn r rD rD rE r k s
zX509.set_versionc C s t j| jS )z
Return the version number of the certificate.
:return: The version number of the certificate.
:rtype: :py:class:`int`
)rK ZX509_get_versionr )rn rD rD rE r z s zX509.get_versionc C sF t jt }tj| j|_|jtjkr*t tj |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 rv rR rV r rW ru ry )rn rx rD rD rE r s
zX509.get_pubkeyc C s2 t |tstdtj| 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`
z pkey must be a PKey instancer? N)r] r r_ rK ZX509_set_pubkeyr rv rU )rn rx rc rD rD rE r s
zX509.set_pubkeyc C sp t |tstd|jr td|js.tdtjt|}|t j
krNtdtj | 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`
z pkey must be a PKey instancezKey only has public partzKey is uninitializedzNo such digest methodr N)r] r r_ ry r` rw rK r r rR rV Z X509_signr rv rU )rn rx r Zevp_mdr rD rD rE r7 s
z X509.signc C s: t j| j}t j|j}|t jkr*tdtjt j |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 rh Z
OBJ_nid2ln)rn Zalgorr rD rD rE get_signature_algorithm s
z X509.get_signature_algorithmc C s t jt|}|tjkr tdtjdt j}tjdd}t||d< t j | j
|||}t |dk dj dd tj
||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`
zNo such digest methodzunsigned char[]zunsigned int[]r? r :c S s g | ]}t |j qS rD )r upper)r ZchrD rD rE
s z X509.digest..)rK r r rR rV r` rS ZEVP_MAX_MD_SIZErT Z X509_digestr rU r rX )rn Z digest_namer r[ r Z
digest_resultrD rD rE r s
z X509.digestc C s t j| jS )z
Return the hash of the X509 subject.
:return: The hash of the subject.
:rtype: :py:class:`bytes`
)rK ZX509_subject_name_hashr )rn rD rD rE subject_name_hash s zX509.subject_name_hashc C s t |tstdt|dd }t |ts6|jd}tjd}tj ||}|d tj
krztj tj | j
|}|rt nXtj|d tj
}tj|d |tj
krt tj|tj}tj| 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 integerr= Nr zBIGNUM**r r? )r] _integer_typesr_ hexr^ r rR rS rK BN_hex2bnrV ZASN1_INTEGER_setX509_get_serialNumberr r BN_to_ASN1_INTEGERr rW ASN1_INTEGER_freeZX509_set_serialNumberrU )rn serial
hex_serial
bignum_serialZ small_serialrc asn1_serialrD rD rE set_serial_number s&
zX509.set_serial_numberc C s` t j| j}t j|tj}z4t j|}ztj|}t|d}|S t j | X W dt j
| X dS )zx
Return the serial number of this certificate.
:return: The serial number.
:rtype: int
r> N) rK r r ZASN1_INTEGER_to_BNrR rV Z BN_bn2hexrh r} r r )rn r
r r Zhexstring_serialr
rD rD rE get_serial_number s
zX509.get_serial_numberc C s. t |tstdtj| j}tj|| 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``
zamount must be an integerN)r] r} r_ rK X509_get_notAfterr X509_gmtime_adj)rn amountZnotAfterrD rD rE gmtime_adj_notAfter- s
zX509.gmtime_adj_notAfterc C s. t |tstdtj| j}tj|| 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``
zamount must be an integerN)r] r} r_ rK X509_get_notBeforer r )rn r Z notBeforerD rD rE gmtime_adj_notBefore; s
zX509.gmtime_adj_notBeforec C s( t | j }tjj|d}|tjj 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_notAfterdatetimeZstrptimeZutcnow)rn Z time_stringZ not_afterrD rD rE has_expiredH s zX509.has_expiredc C s t || jS )N)rk r )rn whichrD rD rE _get_boundary_timeT s zX509._get_boundary_timec C s | j tjS )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 rK r )rn rD rD rE
get_notBeforeW s zX509.get_notBeforec C s t || j|S )N)rd r )rn r rb rD rD rE _set_boundary_timed s zX509._set_boundary_timec C s | j 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 rK r )rn rb rD rD rE
set_notBeforeg s zX509.set_notBeforec C s | j tjS )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 rK r )rn rD rD rE r t s zX509.get_notAfterc C s | j 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``
)r rK r )rn rb rD rD rE set_notAfter s zX509.set_notAfterc C s0 t jt }|| j|_t|jtjk | |_|S )N)r" r r rs rU rR rV r )rn r rq rD rD rE _get_name s
zX509._get_namec C s0 t |tstd|| j|j}t|dk d S )Nzname must be an X509Namer? )r] r" r_ r rs rU )rn r rq rc rD rD rE _set_name s
zX509._set_namec C s | j tj}| jj| |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 rr )rn rq rD rD rE
get_issuer s zX509.get_issuerc C s | j tj| | jj 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 rt )rn r rD rD rE
set_issuer s zX509.set_issuerc C s | j tj}| jj| |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 rr )rn rq rD rD rE r s zX509.get_subjectc C s | j tj| | jj 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 rt )rn r rD rD rE set_subject s zX509.set_subjectc C s t j| jS )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 )rn rD rD rE get_extension_count s zX509.get_extension_countc C s@ x:|D ]2}t |ts tdtj| j|jd}|st qW dS )z
Add extensions to the certificate.
:param extensions: The extensions to add.
:type extensions: An iterable of :py:class:`X509Extension` objects.
:return: ``None``
z+One of the elements is not an X509Extensionr? Nr )r] r# r` rK Z X509_add_extr r r )rn r r r rD rD rE r s
zX509.add_extensionsc C sN t jt }tj| j||_|jtjkr.tdtj |j}tj
|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 )rn indexr r rD rD rE
get_extension s
zX509.get_extensionN)%r@ rA rB rC ro r r r r r r r r r7 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% 8 sB '
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@ rA rB rC 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_CHECKrD rD rD rE 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 j }tj|t j| _d S )N)rK ZX509_STORE_newrR rW ZX509_STORE_free_store)rn storerD rD rE ro 6 s zX509Store.__init__c C sP t |tst tj| j|jdkrLtj }tj|}t |tj
k tj 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_certr) r ZERR_peek_errorZERR_GET_REASONrU Z!X509_R_CERT_ALREADY_IN_HASH_TABLEZERR_clear_error)rn r codeZ
err_reasonrD rD rE add_cert: s
zX509Store.add_certc C s t tj| j|jdk 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_crlr) _crl)rn crlrD rD rE add_crlX s zX509Store.add_crlc C s t tj| 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_flagsr) )rn flagsrD rD rE set_flagsh s zX509Store.set_flagsc C sF t j }tj|t j}t j|t|jd tt j | 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} ZstrftimerU ZX509_STORE_set1_paramr) )rn Zvfy_timeZparamrD rD rE set_time s zX509Store.set_timeN) r@ rA rB rC ro r, r/ r1 r2 rD rD rD rE r' ( s z8X509StoreType has been deprecated, use X509Store insteadc s e Zd ZdZ fddZ 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| j| || _d S )N)r r( ro certificate)rn messager3 )r rD rE ro s z X509StoreContextError.__init__)r@ rA rB rC ro r rD rD )r rE 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 j }tj|t j| _|| _|| _| j d S )N) rK ZX509_STORE_CTX_newrR rW ZX509_STORE_CTX_free
_store_ctxr) _cert_init)rn r* r3 Z store_ctxrD rD rE ro s
zX509StoreContext.__init__c C s. t j| 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_initr5 r) r6 r rR rV r )rn retrD rD rE r7 s zX509StoreContext._initc C s t j| 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_cleanupr5 )rn rD rD rE _cleanup s zX509StoreContext._cleanupc C s\ t j| jt j| jttjt jt j| jg}t j| j}t j |}t
j |}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_errorr5 Z X509_STORE_CTX_get_error_depthr rR rh Z X509_verify_cert_error_stringZ X509_STORE_CTX_get_current_certZX509_dupr% r r( )rn errorsr r6 pycertrD rD rE _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)r) )rn r* rD rD rE set_store s zX509StoreContext.set_storec C s8 | j | j tj| j}| j |dkr4| j 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)r9 r7 rK ZX509_verify_certr5 r< )rn r8 rD rD rE verify_certificate s z#X509StoreContext.verify_certificateN)
r@ rA rB rC ro r7 r9 r< r= r> rD rD rD rE r) s
c C sv t |tr|jd}t|}| tkr.r r? )rN r] r^ r_ rQ replace _crl_reasonsr' rK ZASN1_ENUMERATED_newrU rR rV rW ZASN1_ENUMERATED_freeZASN1_ENUMERATED_setZX509_REVOKED_add1_ext_i2drG rM )rn reasonZ reason_codeZnew_reason_extrc r rD rD rE
set_reason s
zRevoked.set_reasonc C s xt tj| jD ]l}tj| j|}tj|}tj|tjkrt }tj ||dd}|svtj
|tj |}t |dk t
|S qW dS )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 rK rG rL r r rM rZ r ZM_ASN1_OCTET_STRING_printr rU r\ )rn r r r rM r 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)rT )rn rD rD rE all_reasons) s
zRevoked.all_reasonsc C s t j| 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_revocationDaterG rd )rn rb dtrD rD rE set_rev_date5 s zRevoked.set_rev_datec C s t j| j}t|S )z
Get the revocation timestamp.
:return: The timestamp of the revocation, as ASN.1 TIME.
:rtype: bytes
)rK rY rG rk )rn rZ rD rD rE get_rev_date@ s zRevoked.get_rev_dateN)r@ rA rB rC rT ro rI rJ rN rV rW rX r[ r\ rD rD rD rE r. s" $ c @ s| e Zd ZdZdd Zdd Zedd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd Zdd ZedefddZdS ) r/ z(
A certificate revocation list.
c C s t j }tj|t j| _d S )N)rK Z X509_CRL_newrR rW
X509_CRL_freer- )rn r. rD rD rE ro P s z CRL.__init__c C s ddl m} t }||| jS )z
Export as a ``cryptography`` CRL.
:rtype: ``cryptography.x509.CertificateRevocationList``
.. versionadded:: 17.1.0
r )_CertificateRevocationList)r r^ rG r- )rn r^ rF rD rD rE r T s zCRL.to_cryptographyc C s& t |tjstd| }|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_crlr- )r{ Z
crypto_crlr. rD rD rE r b s
zCRL.from_cryptographyc C sr g }t j| j}xPtt j|D ]>}t j||}t j|}tjt}t j
|t j |_ |j
| q W |rnt|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_REVOKEDr- r Zsk_X509_REVOKED_numZsk_X509_REVOKED_value Cryptography_X509_REVOKED_dupr. r rR rW rF rG rp tuple)rn resultsZ
revoked_stackr rH Z revoked_copyZpyrevrD rD rE get_revokedu s
zCRL.get_revokedc C s8 t j|j}t|tjk t j| 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_ rG rU rR rV ZX509_CRL_add0_revokedr- )rn rH copyr rD rD rE add_revoked s zCRL.add_revokedc C sB t jt j| j}t|tjk tj|t j}t j
t }||_ |S )zc
Get the CRL's issuer.
.. versionadded:: 16.1.0
:rtype: X509Name
) rK r ZX509_CRL_get_issuerr- rU rR rV rW r r" r rs )rn Z_issuerr rD rD rE r! s
zCRL.get_issuerc C s t tj| 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_versionr- )rn r rD rD rE r s zCRL.set_versionc C s t || j|S )N)rd r- )rn r rb rD rD rE r s zCRL._set_boundary_timec C s | j 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``
)r rK ZX509_CRL_get_lastUpdate)rn rb rD rD rE set_lastUpdate s
zCRL.set_lastUpdatec C s | j 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``
)r rK ZX509_CRL_get_nextUpdate)rn rb rD rD rE set_nextUpdate s
zCRL.set_nextUpdatec C s\ t j|}t|tjk t j| jt j|j t j | j t j
| 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_namer- r# r Z
X509_CRL_sort
X509_CRL_signrv )rn r Z
issuer_keyr r r rD rD rE r7 s
zCRL.signd c
C s t |tstdt |ts$tdt |ts6td|tkrFtdtj|}|tj krbt
dtj tj }t
|tj k tj }t
|tj k tj|d tj| j| tj||d d d tj| j| tj| jtj|j tj| 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
z cert must be an X509 instancezkey must be a PKey instanceztype must be an integerzdigest must be providedzNo such digest methodr < )r] r% r_ r r} _UNSPECIFIEDrK r rR rV r` rP rQ rU Z
ASN1_TIME_newr ZX509_CRL_set_lastUpdater- ZX509_CRL_set_nextUpdaterg r# r rh rv r r9 )
rn r r r Zdaysr r rM Zsometimer rD rD rE export s2
z
CRL.exportN)r@ rA rB rC ro r r r rb rd r! r r re rf r7 r rl rm rD rD rD rE 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 tj| jS )zm
Check if this NID_pkcs7_signed object
:return: True if the PKCS7 is of type signed
)boolrK ZPKCS7_type_is_signed_pkcs7)rn rD rD rE type_is_signed- s zPKCS7.type_is_signedc C s t tj| jS )zt
Check if this NID_pkcs7_enveloped object
:returns: True if the PKCS7 is of type enveloped
)rn rK ZPKCS7_type_is_envelopedro )rn rD rD rE type_is_enveloped5 s zPKCS7.type_is_envelopedc C s t tj| jS )z
Check if this NID_pkcs7_signedAndEnveloped object
:returns: True if the PKCS7 is of type signedAndEnveloped
)rn rK Z PKCS7_type_is_signedAndEnvelopedro )rn rD rD rE type_is_signedAndEnveloped= s z PKCS7.type_is_signedAndEnvelopedc C s t tj| jS )zi
Check if this NID_pkcs7_data object
:return: True if the PKCS7 is of type data
)rn rK ZPKCS7_type_is_dataro )rn rD rD rE type_is_dataE s zPKCS7.type_is_datac C s" t j| jj}t j|}tj|S )zk
Returns the type name of the PKCS7 structure
:return: A string with the typename
)rK r ro r r rR rh )rn r Z string_typerD rD rE
get_type_nameM s
zPKCS7.get_type_nameN)r@ rA rB rp rq rr rs rt rD rD rD rE 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 dddZ
dS )r1 z
A PKCS #12 archive.
c C s d | _ d | _d | _d | _d S )N)rv r6 _cacerts
_friendlyname)rn rD rD rE ro 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`
)r6 )rn rD rD rE get_certificatej s zPKCS12.get_certificatec C s t |tstd|| _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``
z cert must be an X509 instanceN)r] r% r_ r6 )rn r rD rD rE 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`
)rv )rn rD rD rE get_privatekey s zPKCS12.get_privatekeyc C s t |tstd|| _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``
z pkey must be a PKey instanceN)r] r r_ rv )rn rx rD rD rE 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)ru r` )rn rD rD rE get_ca_certificates s
zPKCS12.get_ca_certificatesc C sB |dkrd| _ n.t|}x |D ]}t|ts tdq W || _ 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)ru listr] r% r_ )rn cacertsr rD rD rE set_ca_certificates s
zPKCS12.set_ca_certificatesc C s2 |dkrd| _ nt|ts(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))rv r] r^ r_ )rn rq rD rD rE 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`
)rv )rn rD rD rE get_friendlyname s zPKCS12.get_friendlynameN r? c
C s t d|}| jdkr tj}n4tj }tj|tj}x | jD ]}tj||j q:W |dkr^tj}| j
}|dkrrtj}| j dkrtj}n| j j }| j dkrtj}n| j j }tj
|||||tjtj||d
}|tjkrt tj|tj}t } tj| | 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:
rD Nr )_text_to_bytes_and_warnru rR rV rK Zsk_X509_new_nullrW sk_X509_freeZ sk_X509_pushr rv rv r6 Z
PKCS12_createZ&NID_pbe_WithSHA1And3_Key_TripleDES_CBCr PKCS12_freerZ Zi2d_PKCS12_bior\ )
rn rD iterZmaciterr} r friendlynamerx pkcs12rM rD rD rE rm s:
z
PKCS12.export)Nr r? )r@ rA rB rC ro rw rx ry rz r{ r~ r r rm rD rD rD rE 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 j }tj|t j| _d S )N)rK ZNETSCAPE_SPKI_newrR rW ZNETSCAPE_SPKI_free_spki)rn ZspkirD rD rE ro
s zNetscapeSPKI.__init__c C s^ |j rtd|js tdtjt|}|tjkrNetscapeSPKIType has been deprecated, use NetscapeSPKI insteadc @ sB e Zd Zd
ddZedd Zedd Zefdd Zd
d Z d S )r@ 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)rn r rD Z more_argstruncaterD rD rE ro v
s z_PassphraseHelper.__init__c C sF | j d krtjS t| j tr"tjS t| j r:tjd| jS tdd S )NZpem_password_cbz2Last argument must be a byte string or a callable.) r rR rV r] r^ callablerA _read_passphraser_ )rn rD rD rE rA
s
z_PassphraseHelper.callbackc C s> | j d krtjS t| j tr"| j S t| j r2tjS tdd S )Nz2Last argument must be a byte string or a callable.)r rR rV r] r^ r r_ )rn rD rD rE rB
s
z _PassphraseHelper.callback_argsc C s8 | j r4y t| W n |k
r& Y nX | j jdd S )Nr )r _exception_from_error_queuepop)rn Z
exceptionTyperD rD rE rC
s z"_PassphraseHelper.raise_if_problemc C s y| j r| j|||}n
| j|}t|ts4tdt||kr\| jrT|d | }ntdx(tt|D ]}|||d ||< qjW t|S tk
r } z| j j
| dS d }~X nX d S )NzString expectedz+passphrase returned by callback is too longr? r ) r r r] r^ r` rT r r Exceptionr rp )rn ZbufsizeZrwflagZuserdatar r erD rD rE r
s"
z"_PassphraseHelper._read_passphraseN)FF)
r@ rA rB ro r rA rB r rC r rD rD rD rE r@ u
s
r@ c C s t |tr|jd}t|}| tkr s$ (
(
j B H Uoh
; + [, /ZG!
$ "$
`