Current File : //lib/python3/dist-packages/twisted/internet/__pycache__/_sslverify.cpython-312.pyc
�
Ϫ�f� � �$ � d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl m
Z
d dl m Z m
Z
d dlmZmZ d d lmZ d dlZd d
lmZmZmZmZ d d lmZ d d l m Z m Z d d
l m Z d dl!m"Z"m#Z# d dl$m%Z%m&Z&m'Z'm(Z( d dl)m*Z*m+Z+ d dl,m-Z- d dl.m/Z/m0Z0 d dl1m2Z2 d dl3m4Z4 ddl5m6Z6 G d� de� Z7e7jp ejr e7jt ejv e7jx ejz e7j| ej~ e7j� eAedd � iZBd� ZC G d� d eD� ZEd � ZFd � ZGd � ZHd � ZI eI� \ ZJZKZL G d!� d"e� ZMeMj� eMj� z eM_O d#� ZPd$d$d%d%d&d&d'd'd(d(d)d)d*d+�
ZQ G d,� d-e
eReSf � ZTeTZU G d.� d/� ZVd0� ZW G d1� d2eV� ZX G d3� d4eV� ZY G d5� d6eX� ZZ G d7� d8� Z[ G d9� d:e[� Z\ G d;� d<e � Z] e
e]� G d=� d>� � Z^d?� Z_ e
e]� G d@� dA� � Z`dB� ZadC� Zb e
e'� G dD� dE� � Zc d_ddF�dG�Zd e
e(� G dH� dI� � Ze e0 edJdKd d � dL� eej� � ee_f e0 edJdKd d � dL� eej� � ee_g e
e&� ej� dMdM�N� G dO� dP� � � Zi edQ�R� dS� � Zj edT�R� dU� � Zk e
e%� G dV� dW� � Zlelj� dX� ZndYZo G dZ� d[� Zp G d\� d]� Zqd^� Zry)`� )� annotationsN)�hexlify)� lru_cache��md5)�Dict)� Interface� implementer)�SSL�crypto)�lib)� FlagConstant�Flags�
NamedConstant�Names)�Version)� isIPAddress�
isIPv6Address)�Deferred)�CertificateError� VerifyError)�IAcceptableCiphers�ICipher� IOpenSSLClientConnectionCreator�IOpenSSLContextFactory)�log�util)� nativeString)�_mutuallyExclusiveArguments�
deprecated)�Failure)� secureRandom� )�
_idnaBytesc �V � e Zd ZdZ e� Z e� Z e� Z e� Z e� Z y)�
TLSVersionzD
TLS versions that we can negotiate with the client/server.
N)
�__name__�
__module__� __qualname__�__doc__r �SSLv3�TLSv1_0�TLSv1_1�TLSv1_2�TLSv1_3� � �=/usr/lib/python3/dist-packages/twisted/internet/_sslverify.pyr& r& ' s, � ��
�O�E��o�G��o�G��o�G��o�Gr1 r& �
OP_NO_TLSv1_3c � � t t j � � }|d|j | � D �cg c] }|�� }}|r1|j ||j |� d D �cg c] }|�� c}� |S c c}w c c}w )a�
Given a pair of L{TLSVersion} constants, figure out what versions we want
to disable (as OpenSSL is an exclusion based API).
@param oldest: The oldest L{TLSVersion} we want to allow.
@type oldest: L{TLSVersion} constant
@param newest: The newest L{TLSVersion} we want to allow, or L{None} for no
upper limit.
@type newest: L{TLSVersion} constant or L{None}
@return: The versions we want to disable.
@rtype: L{list} of L{TLSVersion} constants.
N)�listr& �
iterconstants�index�extend)�oldest�newest�versions�x�excludedVersionss r2 �_getExcludedTLSProtocolsr> ? s{ � � �J�,�,�.�/�H�#+�,D�h�n�n�V�.D�#E�F�a��F��F�
�� � �H�X�^�^�F�5K�5M�,N� O�q�� O�P� ��� G�� !Ps � A4�" A9c � � e Zd ZdZy)�SimpleVerificationErrorz/
Not a very useful verification error.
N)r' r( r) r* r0 r1 r2 r@ r@ W s � �r1 r@ c � � | j � j � j }||k7 r#t t |� dz t |� z � �y)a�
Check only the common name in the certificate presented by the peer and
only for an exact match.
This is to provide I{something} in the way of hostname verification to
users who haven't installed C{service_identity}. This check is overly
strict, relies on a deprecated TLS feature (you're supposed to ignore the
commonName if the subjectAlternativeName extensions are present, I
believe), and lots of valid certificates will fail.
@param connection: the OpenSSL connection to verify.
@type connection: L{OpenSSL.SSL.Connection}
@param hostname: The hostname expected by the user.
@type hostname: L{unicode}
@raise twisted.internet.ssl.VerificationError: if the common name and
hostname don't match.
z!=N)�get_peer_certificate� get_subject�
commonNamer@ �repr)�
connection�hostnamerD s r2 �simpleVerifyHostnamerH ] sL � �( �0�0�2�>�>�@�K�K�J��X� �%�d�:�&6��&=��X��&N�O�O� r1 c � � t d� �)a5
Always fails validation of IP addresses
@param connection: the OpenSSL connection to verify.
@type connection: L{OpenSSL.SSL.Connection}
@param hostname: The hostname expected by the user.
@type hostname: L{unicode}
@raise twisted.internet.ssl.VerificationError: Always raised
z&Cannot verify certificate IP addresses)r@ )rF rG s r2 �simpleVerifyIPAddressrJ v s � � "�"J�
K�Kr1 c �L � d� | j d� dd D � \ }}||fdk\ S )z�
Check pyOpenSSL version string whether we can use it for host verification.
@param version: A pyOpenSSL version string.
@type version: L{str}
@rtype: L{bool}
c 3 �2 K � | ] }t |� �� � y �w�N)�int)�.0�parts r2 � <genexpr>z#_usablePyOpenSSL.<locals>.<genexpr>� s � �� �A�$�C��I�A�� ��.N� )r � )�split)�version�major�minors r2 �_usablePyOpenSSLrZ � s2 � � B�'�-�-��*<�R�a�*@�A�L�E�5� �5�>�W� $�$r1 c �� � d} ddl m} ddlm}m} |||fS # t
$ r9}t
j dt |� z dz | z t dd�� Y d }~nd }~ww xY wt t t fS )
a
Determine if C{service_identity} is installed. If so, use it. If not, use
simplistic and incorrect checking as implemented in
L{simpleVerifyHostname}.
@return: 2-tuple of (C{verify_hostname}, C{VerificationError})
@rtype: L{tuple}
z�Without the service_identity module, Twisted can perform only rudimentary TLS client hostname verification. Many valid certificate/hostname mappings may be rejected.r )�VerificationError)�verify_hostname�verify_ip_addresszHYou do not have a working installation of the service_identity module: 'z�'. Please install it from <https://pypi.python.org/pypi/service_identity> and make sure all of its dependencies are satisfied. � )�category�filename�linenoN)
�service_identityr\ �service_identity.pyopensslr] r^ � ImportError�warnings�
warn_explicit�str� UserWarningrH rJ r@ )�
whatsWrongr\ r] r^ �es r2 �_selectVerifyImplementationrl � s� � � 9� �
�6�Q� � 1�3D�D�D�� �
�� � �
)�+.�q�6�
2�5<�
<� ?I�
I� !���
�
��
�� �!6�8O� O�Os � � A�/A�Ac �0 � e Zd ZdZ ed� Z ed� Zy)�ProtocolNegotiationSupporta�
L{ProtocolNegotiationSupport} defines flags which are used to indicate the
level of NPN/ALPN support provided by the TLS backend.
@cvar NOSUPPORT: There is no support for NPN or ALPN. This is exclusive
with both L{NPN} and L{ALPN}.
@cvar NPN: The implementation supports Next Protocol Negotiation.
@cvar ALPN: The implementation supports Application Layer Protocol
Negotiation.
r# rT N)r' r( r) r* r �NPN�ALPNr0 r1 r2 rn rn � s � � � �v�
�C� �� �Dr1 rn c �Z � t j } t j t j � } |j d� � | t j z } |j d� � | t j z } | S # t t f$ r Y �9w xY w# t t f$ r Y | S w xY w)ay
Checks whether your versions of PyOpenSSL and OpenSSL are recent enough to
support protocol negotiation, and if they are, what kind of protocol
negotiation is supported.
@return: A combination of flags from L{ProtocolNegotiationSupport} that
indicate which mechanisms for protocol negotiation are supported.
@rtype: L{constantly.FlagConstant}
c � � y rM r0 ��cs r2 �<lambda>z/protocolNegotiationMechanisms.<locals>.<lambda>� � � r1 c � � y rM r0 rs s r2 ru z/protocolNegotiationMechanisms.<locals>.<lambda>� rv r1 ) rn � NOSUPPORTr �Context�
SSLv23_METHOD�set_npn_advertise_callbackro �AttributeError�NotImplementedError�set_alpn_select_callbackrp )�support�ctxs r2 � protocolNegotiationMechanismsr� � s� � � )�2�2�G�
�+�+�c�'�'�
(�C�2� �&�&�~�6� �-�1�1�1��3� �$�$�^�4� �-�2�2�2�� �N��
� /� 0�
� �
��
� /� 0�
� � �N�
�s# �B �B �B�B�B*�)B*rD �organizationName�organizationalUnitName� localityName�stateOrProvinceName� countryName� emailAddress)
�CNrD �Or� �OUr� �Lr� �STr� �Cr� r� c �@ � e Zd ZdZdZd� Zd� Zd� Zd d�Zd� Z d� Z
d � Z y
) �DistinguishedNameag
Identify and describe an entity.
Distinguished names are used to provide a minimal amount of identifying
information about a certificate issuer or subject. They are commonly
created with one or more of the following fields::
commonName (CN)
organizationName (O)
organizationalUnitName (OU)
localityName (L)
stateOrProvinceName (ST)
countryName (C)
emailAddress
A L{DistinguishedName} should be constructed using keyword arguments whose
keys can be any of the field names above (as a native string), and the
values are either Unicode text which is encodable to ASCII, or L{bytes}
limited to the ASCII subset. Any fields passed to the constructor will be
set as attributes, accessible using both their extended name and their
shortened acronym. The attribute values will be the ASCII-encoded
bytes. For example::
>>> dn = DistinguishedName(commonName=b'www.example.com',
... C='US')
>>> dn.C
b'US'
>>> dn.countryName
b'US'
>>> hasattr(dn, "organizationName")
False
L{DistinguishedName} instances can also be used as dictionaries; the keys
are extended name of the fields::
>>> dn.keys()
['countryName', 'commonName']
>>> dn['countryName']
b'US'
r0 c �N � |j � D ] \ }}t | ||� � y rM )�items�setattr)�self�kw�k�vs r2 �__init__zDistinguishedName.__init__/ s' � ��H�H�J� �D�A�q� �D�!�Q� � r1 c �T � t D ] }t ||d � }|��t | ||� �! y rM )�
_x509names�getattrr� )r� �x509name�name�values r2 � _copyFromzDistinguishedName._copyFrom3 s1 � � � +�D��H�d�D�1�E�� ���d�E�*� +r1 c �` � | j � D ] \ }}t ||t |� � � y rM )r� r� r )r� r� r� r� s r2 � _copyIntozDistinguishedName._copyInto9 s+ � ��J�J�L� 2�D�A�q� �H�a� �a� � 1� 2r1 c �8 � dt j | � dd z S )Nz<DN %s>r# ���)�dict�__repr__�r� s r2 r� zDistinguishedName.__repr__= s � ��D�M�M�$� /��"� 5�6�6r1 c �L � | t | S # t $ r t |� �w xY wrM )r� �KeyErrorr| )r� �attrs r2 � __getattr__z DistinguishedName.__getattr__@ s1 � � '��
�4�(�)� )��� '� ��&� &� '�s � �#c � � |t vrt |� d�� �t | }t |t � s|j d� }|| |< y )Nz' is not a valid OpenSSL X509 name field�ascii)r� r| �
isinstance�bytes�encode)r� r� r� �realAttrs r2 � __setattr__z DistinguishedName.__setattr__F sH � � �z� !� �D�6�)P�!Q�R� R� �d�#���%��'��L�L��)�E� ��X�r1 c �| � g }d}d� }t |t � � D ]X }t j |� }t t |� |� }t
| |d� }|��=|j |t |� f� �Z |dz
}t |� D ]" \ }\ }}|j |� dz |z ||< �$ dj |� S )zh
Return a multi-line, human-readable representation of this DN.
@rtype: L{str}
r c �4 � t | j � � S rM )�set�values)�mappings r2 � uniqueValuesz/DistinguishedName.inspect.<locals>.uniqueValuesW s � ��w�~�~�'�(� (r1 NrT z: �
) �sortedr� r � nameToLabel�max�lenr� �appendr � enumerate�rjust�join) r� �l�lablenr� r� �labelr� �n�attribs r2 �inspectzDistinguishedName.inspectN s� � �
���� )� � �Z�0�1� 3�A��$�$�Q�'�E���U��V�,�F���a��&�A��}����%� �a� �1�2� 3� �!� ��"+�A�,� 7� �A���v��;�;�v�&��-��6�A�a�D� 7��y�y��|�r1 N��returnrh ) r' r( r) r* � __slots__r� r� r� r� r� r� r� r0 r1 r2 r� r� s2 � �(�T �I� �+� 2�7�'� � r1 r� c �( � e Zd ZdZd� Zd� Zd� Zd� Zy)�CertBasez�
Base class for public (certificate only) and private (certificate + key
pair) certificates.
@ivar original: The underlying OpenSSL certificate object.
@type original: L{OpenSSL.crypto.X509}
c � � || _ y rM ��original)r� r� s r2 r� zCertBase.__init__r s � � ��
r1 c �t � t � }|j t | j d|z � � � |S )N�get_)r� r� r� r� )r� �suffix�dns r2 � _copyNamezCertBase._copyNameu s0 � �
�
��
� � �<�W�T�]�]�F�V�O�<�>�?�� r1 c �$ � | j d� S )z�
Retrieve the subject of this certificate.
@return: A copy of the subject of this certificate.
@rtype: L{DistinguishedName}
�subject�r� r� s r2 �
getSubjectzCertBase.getSubjectz s � � �~�~�i�(�(r1 c �J � |t u rt | j g� S t S )aM
Convert this L{CertBase} into a provider of the given interface.
@param interface: The interface to conform to.
@type interface: L{zope.interface.interfaces.IInterface}
@return: an L{IOpenSSLTrustRoot} provider or L{NotImplemented}
@rtype: L{IOpenSSLTrustRoot} or L{NotImplemented}
)�IOpenSSLTrustRoot� OpenSSLCertificateAuthoritiesr� �NotImplemented)r� � interfaces r2 � __conform__zCertBase.__conform__� s$ � � �)� )�0�$�-�-� �A� A� � r1 N)r' r( r) r* r� r� r� r� r0 r1 r2 r� r� i s � ��!��
)� r1 r� c �� � t |j � d|� d�d� }|�t dj ||� � � |� }|�t dj ||� � � | |� S )a
(private) Helper for L{Certificate.peerFromTransport} and
L{Certificate.hostFromTransport} which checks for incompatible handle types
and null certificates and raises the appropriate exception or returns the
appropriate certificate object.
r� � _certificateNz2non-TLS transport {!r} did not have {} certificatez.TLS transport {!r} did not have {} certificate)r� � getHandler �format)�Class� transport�
methodName�method�certs r2 �_handleattrhelperr� � s� � � �Y�(�(�*�d�:�,�l�,K�T�
R�F�
�~� � @� G� G��:�
�
�
�
�8�D� �|� � <� C� C��:�
�
�
�
��;�r1 c �� � e Zd ZdZdd�Zdd�Zeej dfd�� Z e Z
d� Z ed� � Z ed� � Z
ed � � Zd
� Zej fdd �Zd � Zdd
�Zd� Zd� Zd� Zd� Zy)� Certificatez
An x509 certificate.
c � � dj | j j | j � j | j � j � S )Nz<{} Subject={} Issuer={}>)r� � __class__r' r� rD � getIssuerr� s r2 r� zCertificate.__repr__� sB � �*�1�1� �N�N� #� #� �O�O� � (� (� �N�N� � '� '�
�
r1 c �p � t |t � r!| j � |j � k( S t S rM )r� r� �dumpr� )r� �others r2 �__eq__zCertificate.__eq__� s) � � �e�[� )��9�9�;�%�*�*�,�.� .� � r1 r0 c �< � | t j ||� g|��� S )zc
Load a certificate from an ASN.1- or PEM-format string.
@rtype: C{Class}
)r �load_certificate)r� � requestDatar� �argss r2 �loadzCertificate.load� s! � � �V�,�,�V�[�A�I�D�I�Ir1 c �@ � | j t j � S )z\
Dump this certificate to a PEM-format data string.
@rtype: L{str}
)r� r � FILETYPE_PEMr� s r2 �dumpPEMzCertificate.dumpPEM� s � � �y�y��,�,�-�-r1 c �B � | j |t j � S )z]
Load a certificate from a PEM-format data string.
@rtype: C{Class}
)r� r r� �r� �datas r2 �loadPEMzCertificate.loadPEM� s � � �z�z�$�� 3� 3�4�4r1 c � � t | |d� S )a
Get the certificate for the remote end of the given transport.
@param transport: an L{ISystemHandle} provider
@rtype: C{Class}
@raise CertificateError: if the given transport does not have a peer
certificate.
�peer�r� �r� r� s r2 �peerFromTransportz Certificate.peerFromTransport� � � � !�� �6�:�:r1 c � � t | |d� S )a
Get the certificate for the local end of the given transport.
@param transport: an L{ISystemHandle} provider; the transport we will
@rtype: C{Class}
@raise CertificateError: if the given transport does not have a host
certificate.
�hostr� r� s r2 �hostFromTransportz Certificate.hostFromTransport� r r1 c �H � t | j j � � S )zX
Get the public key for this certificate.
@rtype: L{PublicKey}
)� PublicKeyr� �
get_pubkeyr� s r2 � getPublicKeyzCertificate.getPublicKey� s � � �� � �1�1�3�4�4r1 c �B � t j || j � S rM )r �dump_certificater� �r� r� s r2 r� zCertificate.dump� s � ��&�&�v�t�}�}�=�=r1 c �6 � | j j � S )zY
Retrieve the serial number of this certificate.
@rtype: L{int}
)r� �get_serial_numberr� s r2 � serialNumberzCertificate.serialNumber s � � �}�}�.�.�0�0r1 c �8 � | j j |� S )a
Return a digest hash of this certificate using the specified hash
algorithm.
@param method: One of C{'md5'} or C{'sha'}.
@return: The digest of the object, formatted as b":"-delimited hex
pairs
@rtype: L{bytes}
)r� �digest)r� r� s r2 r zCertificate.digest s � � �}�}�#�#�F�+�+r1 c � � dj d| j � j � d| j � j � d| j � z dt | j
� � z g� S )Nr� zCertificate For Subject:z
Issuer:z
Serial Number: %dz
Digest: %s)r� r� r� r� r r r r� s r2 �_inspectzCertificate._inspect sh � ��y�y�*����!�)�)�+����� �(�(�*�%��(9�(9�(;�;� �|�D�K�K�M� :�:�
�
�
r1 c �| � dj | j � | j � j � f� S )z�
Return a multi-line, human-readable representation of this
Certificate, including information about the subject, issuer, and
public key.
r� )r� r r r� r� s r2 r� zCertificate.inspect! s0 � � �y�y�$�-�-�/�4�+<�+<�+>�+F�+F�+H�I�J�Jr1 c �$ � | j d� S )z�
Retrieve the issuer of this certificate.
@rtype: L{DistinguishedName}
@return: A copy of the issuer of this certificate.
�issuerr� r� s r2 r� zCertificate.getIssuer) s � � �~�~�h�'�'r1 c � � t d� �)Nz'Possible, but doubtful we need this yet)r} )r� � authoritiess r2 �optionszCertificate.options2 s � �!�"K�L�Lr1 Nr� )r� �objectr� �bool)r� rN r� r� r )r' r( r) r* r� r� � classmethodr �
FILETYPE_ASN1r� �_loadr� r� r r r r� r r r r� r� r r0 r1 r2 r� r� � s� � ��
� �
�(.�(<�(<�2� J� �J�
�E�.� �5� �5� � ;� � ;� � ;� � ;�5� "(�!5�!5� >�1� ,�
�K�(�Mr1 r� c �V � e Zd ZdZeej fd�� Zej fd�Zy)�CertificateRequestz�
An x509 certificate request.
Certificate requests are given to certificate authorities to be signed and
returned resulting in an actual certificate.
c �� � t j ||� }t � }|j |j � � |j |j
� � st d|�d�� � | |� S )Nz Can't verify that request for z is self-signed.)r �load_certificate_requestr� r� rC �verifyr r )r� r� �
requestFormat�reqr� s r2 r� zCertificateRequest.load> sb � ��-�-�m�[�I��
�
��
� � �S�_�_�&�'��z�z�#�.�.�*�+� � >�r�f�DT� U�V� V��S�z�r1 c �B � t j || j � S rM )r �dump_certificate_requestr� r s r2 r� zCertificateRequest.dumpG s � ��.�.�v�t�}�}�E�Er1 N) r' r( r) r* r r r r� r� r0 r1 r2 r r 6 s5 � �� �/5�/C�/C� � �� !�.�.� Fr1 r c � � e Zd ZdZdd�Zd� Zej fd�Ze ej fd�� Z
d� Z d� Z e d� � Z
e d � � Zd
� Zej d fd �Zej ej fd
�Z dd�Zy)�PrivateCertificatez.
An x509 certificate and private key.
c �^ � t j | � dz t | j � z S )Nz with )r� r� rE �
privateKeyr� s r2 r� zPrivateCertificate.__repr__P s& � ��#�#�D�)�H�4�t�D�O�O�7L�L�Lr1 c �h � |j | j � � s t d� �|| _ | S )Nz1Certificate public and private keys do not match.)�matchesr r r* )r� r* s r2 �_setPrivateKeyz!PrivateCertificate._setPrivateKeyS s1 � ��!�!�$�"3�"3�"5�6� � Q�R� R�$���� r1 c �< � | j || j |� S )z}
Create a new L{PrivateCertificate} from the given certificate data and
this instance's private key.
)r� r* �r� � newCertDatar� s r2 �newCertificatez!PrivateCertificate.newCertificateY s � �
�y�y��d�o�o�v�>�>r1 c �D � | j ||� j |� S rM )r r- )r� r� r* r� s r2 r� zPrivateCertificate.load` s � ��{�{�4��(�7�7�
�C�Cr1 c �~ � dj t j | � | j j � g� S )Nr� )r� r� r r* r� r� s r2 r� zPrivateCertificate.inspectd s. � ��y�y�+�.�.�t�4�d�o�o�6M�6M�6O�P�Q�Qr1 c � � | j t j � | j j t j � z S )zi
Dump both public and private parts of a private certificate to
PEM-format data.
)r� r r� r* r� s r2 r� zPrivateCertificate.dumpPEMg s: � �
�y�y��,�,�-����0D�0D� � � �1
�
�
r1 c � � | j |t j |t j � t j � S )zv
Load both private and public parts of a private certificate from a
chunk of PEM-format data.
)r� �KeyPairr r� r� s r2 r� zPrivateCertificate.loadPEMp s3 � � �z�z� �'�,�,�t�V�%8�%8�9�6�;N�;N�
�
r1 c �H � | |j � }|j |� S rM )r� r- )r� �certificateInstancer* �privcerts r2 �fromCertificateAndKeyPairz,PrivateCertificate.fromCertificateAndKeyPairz s$ � ��,�5�5�6���&�&�z�2�2r1 c
�� � t | j j | j �� }|r<|j t t |D �cg c] }|j �� c}� �� � t di |��S c c}w )a$
Create a context factory using this L{PrivateCertificate}'s certificate
and private key.
@param authorities: A list of L{Certificate} object
@return: A context factory.
@rtype: L{CertificateOptions <twisted.internet.ssl.CertificateOptions>}
�r* � certificate)� trustRootr0 )r� r* r� �updater� �OpenSSLCertificateOptions)r� r r �auths r2 r zPrivateCertificate.options se � � �$�/�/�":�":��
�
�V�� � �N�N�� ;�3>�?�4�� � �?� ��
� )�3�7�3�3�� @s �A5�sha256c �X � | j j | j � ||� S rM )r* �certificateRequestr� )r� r� �digestAlgorithms r2 rD z%PrivateCertificate.certificateRequest� s' � ����1�1� �O�O� �v��
�
r1 c �b � | j � }| j j ||||||� S rM )r� r* �signCertificateRequest)r� r� �verifyDNCallbackr r# �certificateFormatr s r2 rG z)PrivateCertificate.signCertificateRequest� s9 � � � � �"�����5�5� � � � � � �
�
r1 c �\ � | j j | j � ||||� S rM )r* �signRequestObjectr� )r� rD r �secondsToExpiryrE s r2 rK z$PrivateCertificate.signRequestObject� s1 � � ���0�0� �O�O� � � � � �
�
r1 Nr� ��3�rB )r' r( r) r* r� r- r r r1 r r� r� r� r� r: r rD rG rK r0 r1 r2 r( r( K s� � ��M�� 28�1E�1E� ?� �-3�-A�-A� D� �D�R�
� �
� �
� �3� �3�4�* )/�(<�(<�h�
� �*�*� �.�.�
�, +� �
r1 r( c �0 � e Zd ZdZd� Zd� Zdd�Zd� Zd� Zy) r an
A L{PublicKey} is a representation of the public part of a key pair.
You can't do a whole lot with it aside from comparing it to other
L{PublicKey} objects.
@note: If constructing a L{PublicKey} manually, be sure to pass only a
L{OpenSSL.crypto.PKey} that does not contain a private key!
@ivar original: The original private key.
c � � || _ y)zv
@param osslpkey: The underlying pyOpenSSL key object.
@type osslpkey: L{OpenSSL.crypto.PKey}
Nr� )r� �osslpkeys r2 r� zPublicKey.__init__� s � �
!��
r1 c �D � | j � |j � k( S )a
Does this L{PublicKey} contain the same value as another L{PublicKey}?
@param otherKey: The key to compare C{self} to.
@type otherKey: L{PublicKey}
@return: L{True} if these keys match, L{False} if not.
@rtype: L{bool}
��keyHash)r� �otherKeys r2 r, zPublicKey.matches� s � � �|�|�~��!1�!1�!3�3�3r1 c �X � d| j j � d| j � � d�S )N�<� �>)r� r' rT r� s r2 r� zPublicKey.__repr__� s) � ��4�>�>�*�*�+�1�T�\�\�^�,<�A�>�>r1 c � � t j t j | j � }t � }|j |� |j
� S )at
Compute a hash of the underlying PKey object.
The purpose of this method is to allow you to determine if two
certificates share the same public key; it is not really useful for
anything else.
In versions of Twisted prior to 15.0, C{keyHash} used a technique
involving certificate requests for computing the hash that was not
stable in the face of changes to the underlying OpenSSL library.
@return: Return a 32-character hexadecimal string uniquely identifying
this public key, I{for this version of Twisted}.
@rtype: native L{str}
)r �dump_publickeyr r� r r? � hexdigest)r� �raw�hs r2 rT zPublicKey.keyHash� s> � � �#�#�F�$8�$8�$�-�-�H�� �E�� ����
��{�{�}� r1 c �( � d| j � � �S )NzPublic Key with Hash: rS r� s r2 r� zPublicKey.inspect� s � �'�� � ��'7�8�8r1 Nr� ) r' r( r) r* r� r, r� rT r� r0 r1 r2 r r � s � �
�!�
4�?� �*9r1 r c �r � e Zd Zeej
fd�� Zej
fd�Z e e dddd� d� d� � Z
e e dddd� d� d� � Z d � Z eej d
fd �� Zej
fd �Zdd�Zej
d
fd�Zej
ej
dd
fd�Z dd�Zd� Zy)r6 c �: � | t j ||� � S rM )r �load_privatekey)r� r� r� s r2 r� z KeyPair.load� s � ��V�+�+�F�D�9�:�:r1 c �B � t j || j � S rM )r �dump_privatekeyr� r s r2 r� z KeyPair.dump� s � ��%�%�f�d�m�m�<�<r1 �Twisted� r �a real persistence systemc �" � | j � S rM )r� r� s r2 � __getstate__zKeyPair.__getstate__� s � ��y�y�{�r1 c �j � | j t j t j |� � y rM )r� r rb r �r� �states r2 � __setstate__zKeyPair.__setstate__ s! � � �
�
�f�,�,�V�-A�-A�5�I�Jr1 c �� � | j j � }|t j k( rd}n|t j k( rd}nd}| j j � || j
� f}d|z S )N�RSA�DSAz(Unknown Type!)z %s-bit %s Key Pair with Hash: %s)r� �typer �TYPE_RSA�TYPE_DSA�bitsrT )r� �t�tsr� s r2 r� zKeyPair.inspect se � � �M�M� � � �� ���� ��B�
�&�/�/�
!��B�"�B�
�]�]�
�
�
!�2�t�|�|�~� 6��1�A�5�5r1 i c �^ � t j � }|j ||� | |� S rM )r �PKey� generate_key)r� �kind�size�pkeys r2 �generatezKeyPair.generate s' � ��{�{�}�� ���$��%��T�{�r1 c �0 � t j || |� S rM )r( r� r/ s r2 r1 zKeyPair.newCertificate s � �!�&�&�{�D�&�A�Ar1 rB c �� � t j � }|j | j � |j |j � � |j
| j |� t |� S rM )r �X509Req�
set_pubkeyr� r� rC �signr )r� �distinguishedNamerE r$ s r2 �
requestObjectzKeyPair.requestObject sP � ��n�n� �� ���t�}�}�%��#�#�C�O�O�$5�6� ���� � ��0�!�#�&�&r1 c �D � | j ||� j |� S )z�
Create a certificate request signed with this key.
@return: a string, formatted according to the 'format' argument.
)r� r� )r� r� r� rE s r2 rD zKeyPair.certificateRequest" s# � � �!�!�"3�_�E�J�J�6�R�Rr1 rN c �� � ������� � � t j ||� � � j � � �� � } ��� � ��� ��f d�}
t | t � r| j |
� S |
| � S )a&
Given a blob of certificate request data and a certificate authority's
DistinguishedName, return a blob of signed certificate data.
If verifyDNCallback returns a Deferred, I will return a Deferred which
fires the data when that Deferred has completed.
c � � � | st dj � �� � ��j ������ j �� S )Nz)DN callback {!r} rejected request DN {!r})r r� rK r� )
r� rI rE r� �hlreq�issuerDistinguishedNamerL r� r rH s
���������r2 �verifiedz0KeyPair.signCertificateRequest.<locals>.verifiedC sW �� ��!�?�F�F�(�"��� �
�)�)�'�� � � � � �d�$�%�
&r1 )r r� r� r� r � addCallback)
r� r� r� rH r r# rI rL rE �vvalr� r� r� s
`` `` ``` @@r2 rG z KeyPair.signCertificateRequest, sa ��� �$ #�'�'� �]�C��
�
�
�
�� ��#��
&�
&� �d�H� %��#�#�H�-� -��D�>� !r1 c � � |j }t j � }|j |j � � |j |j
� � |j |j � � |j d� |j |� |j |� |j | j |� t |� S )zW
Sign a CertificateRequest instance, returning a Certificate instance.
r )r� r �X509r� �
get_issuer� set_subjectrC r� r �gmtime_adj_notBefore�gmtime_adj_notAfter�set_serial_numberr� r� )r� r� r� r rL rE r$ r� s r2 rK zKeyPair.signRequestObjectW s� � � �$�$���{�{�}�� �)�)�$�/�/�*;�<� ���� � �*�+� ������(�)� �!�!�!�$� � � � �1� � � �|�,� � � �$�-�-� �1��4� � r1 c � � t di |��}t j | j || j |� |� | � S )Nr0 )�DNr( r: rK r� )r� r r� r� s r2 �selfSignedCertzKeyPair.selfSignedCertm s? � �
�X�"�X��!�;�;� � "� "�2�t�'9�'9�"�'=�|� L�d�
�
r1 N)rB rM )r' r( r) r r r r� r� r r ri rm r� rr r} r1 r� rD rG rK r� r0 r1 r2 r6 r6 � s� � ��!'�!5�!5� ;� �;� !�.�.� =� �� �2�q�!�,�.I�J�� K�� �� �2�q�!�,�.I�J�K� K�K� 6� � #�_�_�4� � ��
28�1E�1E� B�'� )/�(<�(<�h�S� �*�*� �.�.�*� �)"�` +� �
!�,
r1 r6 c � � e Zd ZdZd� Zy)r� z�
Trust settings for an OpenSSL context.
Note that this interface's methods are private, so things outside of
Twisted shouldn't implement it.
c � � y)aI
Add certificate-authority certificates to an SSL context whose
connections should trust those authorities.
@param context: An SSL context for a connection which should be
verified by some certificate authority.
@type context: L{OpenSSL.SSL.Context}
@return: L{None}
Nr0 )�contexts r2 �_addCACertsToContextz&IOpenSSLTrustRoot._addCACertsToContext| rv r1 N�r' r( r) r* r� r0 r1 r2 r� r� t s � ��
r1 r� c � � e Zd ZdZd� Zd� Zy)r� zy
Trust an explicitly specified set of certificates, represented by a list of
L{OpenSSL.crypto.X509} objects.
c � � || _ y)z�
@param caCerts: The certificate authorities to trust when using this
object as a C{trustRoot} for L{OpenSSLCertificateOptions}.
@type caCerts: L{list} of L{OpenSSL.crypto.X509}
N)�_caCerts)r� �caCertss r2 r� z&OpenSSLCertificateAuthorities.__init__� s � � ��
r1 c �h � |j � }| j D ] }|j |� � y rM )�get_cert_storer� �add_cert)r� r� �storer� s r2 r� z2OpenSSLCertificateAuthorities._addCACertsToContext� s/ � ��&�&�(���M�M� !�D� �N�N�4� � !r1 N)r' r( r) r* r� r� r0 r1 r2 r� r� � s � ��
�!r1 r� c � � g }| D ]; }t |t � r
|j }n t d� �|j |� �= t |� S )a
Builds an object that trusts multiple root L{Certificate}s.
When passed to L{optionsForClientTLS}, connections using those options will
reject any server certificate not signed by at least one of the
certificates in the `certificates` list.
@since: 16.0
@param certificates: All certificates which will be trusted.
@type certificates: C{iterable} of L{CertBase}
@rtype: L{IOpenSSLTrustRoot}
@return: an object suitable for use as the trustRoot= keyword argument to
L{optionsForClientTLS}
zBcertificates items must be twisted.internet.ssl.CertBase instances)r� r� r� � TypeErrorr� r� )� certificates�certsr� s r2 �trustRootFromCertificatesr� � sV � �$
�E� � �� �d�H� %��=�=�D��W��
� � � �T��� )�� /�/r1 c � � e Zd ZdZd� Zy)�OpenSSLDefaultPathsz�
Trust the set of default verify paths that OpenSSL was built with, as
specified by U{SSL_CTX_set_default_verify_paths
<https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_load_verify_locations.html>}.
c �$ � |j � y rM )�set_default_verify_paths)r� r� s r2 r� z(OpenSSLDefaultPaths._addCACertsToContext� s � ��(�(�*r1 Nr� r0 r1 r2 r� r� � s � �� +r1 r� c � � t � S )aD
Attempt to discover a set of trusted certificate authority certificates
(or, in other words: trust roots, or root certificates) whose trust is
managed and updated by tools outside of Twisted.
If you are writing any client-side TLS code with Twisted, you should use
this as the C{trustRoot} argument to L{CertificateOptions
<twisted.internet.ssl.CertificateOptions>}.
The result of this function should be like the up-to-date list of
certificates in a web browser. When developing code that uses
C{platformTrust}, you can think of it that way. However, the choice of
which certificate authorities to trust is never Twisted's responsibility.
Unless you're writing a very unusual application or library, it's not your
code's responsibility either. The user may use platform-specific tools for
defining which server certificates should be trusted by programs using TLS.
The purpose of using this API is to respect that decision as much as
possible.
This should be a set of trust settings most appropriate for I{client} TLS
connections; i.e. those which need to verify a server's authenticity. You
should probably use this by default for any client TLS connection that you
create. For servers, however, client certificates are typically not
verified; or, if they are, their verification will depend on a custom,
application-specific certificate authority.
@since: 14.0
@note: Currently, L{platformTrust} depends entirely upon your OpenSSL build
supporting a set of "L{default verify paths <OpenSSLDefaultPaths>}"
which correspond to certificate authority trust roots. Unfortunately,
whether this is true of your system is both outside of Twisted's
control and difficult (if not impossible) for Twisted to detect
automatically.
Nevertheless, this ought to work as desired by default on:
- Ubuntu Linux machines with the U{ca-certificates
<https://launchpad.net/ubuntu/+source/ca-certificates>} package
installed,
- macOS when using the system-installed version of OpenSSL (i.e.
I{not} one installed via MacPorts or Homebrew),
- any build of OpenSSL which has had certificate authority
certificates installed into its default verify paths (by default,
C{/usr/local/ssl/certs} if you've built your own OpenSSL), or
- any process where the C{SSL_CERT_FILE} environment variable is
set to the path of a file containing your desired CA certificates
bundle.
Hopefully soon, this API will be updated to use more sophisticated
trust-root discovery mechanisms. Until then, you can follow tickets in
the Twisted tracker for progress on this implementation on U{Microsoft
Windows <https://twistedmatrix.com/trac/ticket/6371>}, U{macOS
<https://twistedmatrix.com/trac/ticket/6372>}, and U{a fallback for
other platforms which do not have native trust management tools
<https://twistedmatrix.com/trac/ticket/6934>}.
@return: an appropriate trust settings object for your platform.
@rtype: L{IOpenSSLTrustRoot}
@raise NotImplementedError: if this platform is not yet supported by
Twisted. At present, only OpenSSL is supported.
)r� r0 r1 r2 �
platformTrustr� � s � �F � � r1 c � � � � fd�}|S )a-
Wrap up an C{info_callback} for pyOpenSSL so that if something goes wrong
the error is immediately logged and the connection is dropped if possible.
This wrapper exists because some versions of pyOpenSSL don't handle errors
from callbacks at I{all}, and those which do write tracebacks directly to
stderr rather than to a supplied logging system. This reports unexpected
errors to the Twisted logging system.
Also, this terminates the connection immediately if possible because if
you've got bugs in your verification logic it's much safer to just give up.
@param wrapped: A valid C{info_callback} for pyOpenSSL.
@type wrapped: L{callable}
@return: A valid C{info_callback} for pyOpenSSL that handles any errors in
C{wrapped}.
@rtype: L{callable}
c � �� �| ||� S # t $ rB t � }t j |d� | j � j |� Y y w xY w)NzError during info_callback)�
BaseExceptionr! r �err� get_app_data�failVerification)rF �where�ret�f�wrappeds �r2 � infoCallbackz%_tolerateErrors.<locals>.infoCallback$ sS �� � :��:�u�c�2� 2�� � :�� �A� �G�G�A�3� 4� � #� #� %� 6� 6�q� 9� :�s �
�AA�Ar0 )r� r� s ` r2 �_tolerateErrorsr� s �� �*:� �r1 c �" � e Zd ZdZd� Zd� Zd� Zy)�ClientTLSOptionsa
Client creator for TLS.
Private implementation type (not exposed to applications) for public
L{optionsForClientTLS} API.
@ivar _ctx: The context to use for new connections.
@type _ctx: L{OpenSSL.SSL.Context}
@ivar _hostname: The hostname to verify, as specified by the application,
as some human-readable text.
@type _hostname: L{unicode}
@ivar _hostnameBytes: The hostname to verify, decoded into IDNA-encoded
bytes. This is passed to APIs which think that hostnames are bytes,
such as OpenSSL's SNI implementation.
@type _hostnameBytes: L{bytes}
@ivar _hostnameASCII: The hostname, as transcoded into IDNA ASCII-range
unicode code points. This is pre-transcoded because the
C{service_identity} package is rather strict about requiring the
C{idna} package from PyPI for internationalized domain names, rather
than working with Python's built-in (but sometimes broken) IDNA
encoding. ASCII values, however, will always work.
@type _hostnameASCII: L{unicode}
@ivar _hostnameIsDnsName: Whether or not the C{_hostname} is a DNSName.
Will be L{False} if C{_hostname} is an IP address or L{True} if
C{_hostname} is a DNSName
@type _hostnameIsDnsName: L{bool}
c �> � || _ || _ t |� s t |� r |j d� | _ d| _ nt |� | _ d| _ | j
j d� | _ |j t | j � � y)a
Initialize L{ClientTLSOptions}.
@param hostname: The hostname to verify as input by a human.
@type hostname: L{unicode}
@param ctx: an L{OpenSSL.SSL.Context} to use for new connections.
@type ctx: L{OpenSSL.SSL.Context}.
r� FTN)
�_ctx� _hostnamer r r� �_hostnameBytes�_hostnameIsDnsNamer$ �decode�_hostnameASCII�set_info_callbackr� � _identityVerifyingInfoCallback)r� rG r� s r2 r� zClientTLSOptions.__init__Q s� � � �� �!��� �x� �M�(�$;�"*�/�/�'�":�D� �&+�D� #�",�X�"6�D� �&*�D� #� "� 1� 1� 8� 8�� A��� � � �o�d�.Q�.Q� R�Sr1 c �l � | j }t j |d� }|j |� |S )ap
Create a TLS connection for a client.
@note: This will call C{set_app_data} on its connection. If you're
delegating to this implementation of this method, don't ever call
C{set_app_data} or C{set_info_callback} on the returned connection,
or you'll break the implementation of various features of this
class.
@param tlsProtocol: the TLS protocol initiating the connection.
@type tlsProtocol: L{twisted.protocols.tls.TLSMemoryBIOProtocol}
@return: the configured client connection.
@rtype: L{OpenSSL.SSL.Connection}
N)r� r �
Connection� set_app_data)r� � tlsProtocolr� rF s r2 �clientConnectionForTLSz'ClientTLSOptions.clientConnectionForTLSh s1 � � �)�)���^�^�G�T�2�
�� � � �,��r1 c � � |t j z r(| j r |j | j � y|t j
z r; | j rt
|| j � yt || j � yy# t $ r. t � }|j � }|j |� Y yw xY w)a
U{info_callback
<http://pythonhosted.org/pyOpenSSL/api/ssl.html#OpenSSL.SSL.Context.set_info_callback>
} for pyOpenSSL that verifies the hostname in the presented certificate
matches the one passed to this L{ClientTLSOptions}.
@param connection: the connection which is handshaking.
@type connection: L{OpenSSL.SSL.Connection}
@param where: flags indicating progress through a TLS handshake.
@type where: L{int}
@param ret: ignored
@type ret: ignored
N)
r �SSL_CB_HANDSHAKE_STARTr� �set_tlsext_host_namer� �SSL_CB_HANDSHAKE_DONE�verifyHostnamer� �verifyIPAddressr\ r! r� r� )r� rF r� r� r� r� s r2 r� z/ClientTLSOptions._identityVerifyingInfoCallback} s� � �$ �3�-�-� -�$�2I�2I� � +� +�D�,?�,?� @�
�S�.�.�
.�
.��*�*�"�:�t�/B�/B�C�#�J��0C�0C�D� /�� %�
.��I�� &� 3� 3� 5� ��*�*�1�-�
.�s �"B �3B � 4C�CN)r' r( r) r* r� r� r� r0 r1 r2 r� r� / s � � �@T�.�* .r1 r� )�extraCertificateOptionsc �< � |�i }|�
t � }t | t � s"t d| j j
z � �|r1|j
|j j |j �� t d||d�|��}t | |j � � S )a�
Create a L{client connection creator <IOpenSSLClientConnectionCreator>} for
use with APIs such as L{SSL4ClientEndpoint
<twisted.internet.endpoints.SSL4ClientEndpoint>}, L{connectSSL
<twisted.internet.interfaces.IReactorSSL.connectSSL>}, and L{startTLS
<twisted.internet.interfaces.ITLSTransport.startTLS>}.
@since: 14.0
@param hostname: The expected name of the remote host. This serves two
purposes: first, and most importantly, it verifies that the certificate
received from the server correctly identifies the specified hostname.
The second purpose is to use the U{Server Name Indication extension
<https://en.wikipedia.org/wiki/Server_Name_Indication>} to indicate to
the server which certificate should be used.
@type hostname: L{unicode}
@param trustRoot: Specification of trust requirements of peers. This may be
a L{Certificate} or the result of L{platformTrust}. By default it is
L{platformTrust} and you probably shouldn't adjust it unless you really
know what you're doing. Be aware that clients using this interface
I{must} verify the server; you cannot explicitly pass L{None} since
that just means to use L{platformTrust}.
@type trustRoot: L{IOpenSSLTrustRoot}
@param clientCertificate: The certificate and private key that the client
will use to authenticate to the server. If unspecified, the client will
not authenticate.
@type clientCertificate: L{PrivateCertificate}
@param acceptableProtocols: The protocols this peer is willing to speak
after the TLS negotiation has completed, advertised over both ALPN and
NPN. If this argument is specified, and no overlap can be found with
the other peer, the connection will fail to be established. If the
remote peer does not offer NPN or ALPN, the connection will be
established, but no protocol wil be negotiated. Protocols earlier in
the list are preferred over those later in the list.
@type acceptableProtocols: L{list} of L{bytes}
@param extraCertificateOptions: A dictionary of additional keyword arguments
to be presented to L{CertificateOptions}. Please avoid using this unless
you absolutely need to; any time you need to pass an option here that is
a bug in this interface.
@type extraCertificateOptions: L{dict}
@return: A client connection creator.
@rtype: L{IOpenSSLClientConnectionCreator}
z6optionsForClientTLS requires text for host names, not r< )r> �acceptableProtocolsr0 ) r� r� rh r� r� r' r? r* r� r@ r� �
getContext)rG r> �clientCertificater� r� �certificateOptionss r2 �optionsForClientTLSr� � s� � �p �&�"$� ���!�O� � �h�� $�� D�� � �)�)�
*�
�
� � �&�&�(�3�3�<�<�)�2�2� '�
� 3� �� /�� "���
�H�&8�&C�&C�&E� F�Fr1 c
�� � e Zd ZdZej
ZdZee j Z e j Z
eddgddgddgddgdd gd dgdd
gg� dd �� Zd � Zd
� Zd� Zd� Zy)r@ a�
A L{CertificateOptions <twisted.internet.ssl.CertificateOptions>} specifies
the security properties for a client or server TLS connection used with
OpenSSL.
@ivar _options: Any option flags to set on the L{OpenSSL.SSL.Context}
object that will be created.
@type _options: L{int}
@ivar _cipherString: An OpenSSL-specific cipher string.
@type _cipherString: L{unicode}
@ivar _defaultMinimumTLSVersion: The default TLS version that will be
negotiated. This should be a "safe default", with wide client and
server support, vs an optimally secure one that excludes a large number
of users. As of May 2022, TLSv1.2 is that safe default.
@type _defaultMinimumTLSVersion: L{TLSVersion} constant
Nr> �requireCertificater" r� r� �insecurelyLowerMinimumTo�raiseMinimumTo�lowerMaximumSecurityToc
� � |du |du k7 r t d� �|| _ || _ t j t j
z t j z | _ t j | _ |��t j | _ |r#|r||kD r t d� �|| j kD r|}|�| j }|r||kD r|}|r||kD r t d� �t ||� }|D ] }| xj t | z c_ � n#t j dt" d�� || _ |r
|s t d� �|| _ |
�d||fv r t d � �|
�|
| _ ng | _ || _ || _ || _ || _ | | _ | r4| xj t j2 t j4 z z c_ |
| _ | | _ | r#| xj t j: z c_ | | _ | s#| xj t j> z c_ || _ tC t jD tF tH �
� | _% |�tL }d jO d � |jQ tS d
| j | j � � D � � | _* | jT dk( r t d� �|�| j$ r%tW |� }nd| _ d| _ tY |� }|| _- |�t] � s t_ d� �|| _0 y)a�
Create an OpenSSL context SSL connection context factory.
@param privateKey: A PKey object holding the private key.
@param certificate: An X509 object holding the certificate.
@param method: Deprecated, use a combination of
C{insecurelyLowerMinimumTo}, C{raiseMinimumTo}, or
C{lowerMaximumSecurityTo} instead. The SSL protocol to use, one of
C{TLS_METHOD}, C{TLSv1_2_METHOD}, or C{TLSv1_2_METHOD} (or any
future method constants provided by pyOpenSSL). By default, a
setting will be used which allows TLSv1.2 and TLSv1.3. Can not be
used with C{insecurelyLowerMinimumTo}, C{raiseMinimumTo}, or
C{lowerMaximumSecurityTo}.
@param verify: Please use a C{trustRoot} keyword argument instead,
since it provides the same functionality in a less error-prone way.
By default this is L{False}.
If L{True}, verify certificates received from the peer and fail the
handshake if verification fails. Otherwise, allow anonymous
sessions and sessions with certificates which fail validation.
@param caCerts: Please use a C{trustRoot} keyword argument instead,
since it provides the same functionality in a less error-prone way.
List of certificate authority certificate objects to use to verify
the peer's certificate. Only used if verify is L{True} and will be
ignored otherwise. Since verify is L{False} by default, this is
L{None} by default.
@type caCerts: L{list} of L{OpenSSL.crypto.X509}
@param verifyDepth: Depth in certificate chain down to which to verify.
If unspecified, use the underlying default (9).
@param requireCertificate: Please use a C{trustRoot} keyword argument
instead, since it provides the same functionality in a less
error-prone way.
If L{True}, do not allow anonymous sessions; defaults to L{True}.
@param verifyOnce: If True, do not re-verify the certificate on session
resumption.
@param enableSingleUseKeys: If L{True}, generate a new key whenever
ephemeral DH and ECDH parameters are used to prevent small subgroup
attacks and to ensure perfect forward secrecy.
@param enableSessions: This allows a shortened handshake to be used
when a known client reconnects to the same process. If True,
enable OpenSSL's session caching. Note that session caching only
works on a single Twisted node at once. Also, it is currently
somewhat risky due to U{a crashing bug when using OpenSSL 1.1.1
<https://twistedmatrix.com/trac/ticket/9764>}.
@param fixBrokenPeers: If True, enable various non-spec protocol fixes
for broken SSL implementations. This should be entirely safe,
according to the OpenSSL documentation, but YMMV. This option is
now off by default, because it causes problems with connections
between peers using OpenSSL 0.9.8a.
@param enableSessionTickets: If L{True}, enable session ticket
extension for session resumption per RFC 5077. Note there is no
support for controlling session tickets. This option is off by
default, as some server implementations don't correctly process
incoming empty session ticket extensions in the hello.
@param extraCertChain: List of certificates that I{complete} your
verification chain if the certificate authority that signed your
C{certificate} isn't widely supported. Do I{not} add
C{certificate} to it.
@type extraCertChain: C{list} of L{OpenSSL.crypto.X509}
@param acceptableCiphers: Ciphers that are acceptable for connections.
Uses a secure default if left L{None}.
@type acceptableCiphers: L{IAcceptableCiphers}
@param dhParameters: Key generation parameters that are required for
Diffie-Hellman key exchange. If this argument is left L{None},
C{EDH} ciphers are I{disabled} regardless of C{acceptableCiphers}.
@type dhParameters: L{DiffieHellmanParameters
<twisted.internet.ssl.DiffieHellmanParameters>}
@param trustRoot: Specification of trust requirements of peers. If
this argument is specified, the peer is verified. It requires a
certificate, and that certificate must be signed by one of the
certificate authorities specified by this object.
Note that since this option specifies the same information as
C{caCerts}, C{verify}, and C{requireCertificate}, specifying any of
those options in combination with this one will raise a
L{TypeError}.
@type trustRoot: L{IOpenSSLTrustRoot}
@param acceptableProtocols: The protocols this peer is willing to speak
after the TLS negotiation has completed, advertised over both ALPN
and NPN. If this argument is specified, and no overlap can be
found with the other peer, the connection will fail to be
established. If the remote peer does not offer NPN or ALPN, the
connection will be established, but no protocol wil be negotiated.
Protocols earlier in the list are preferred over those later in the
list.
@type acceptableProtocols: L{list} of L{bytes}
@param raiseMinimumTo: The minimum TLS version that you want to use, or
Twisted's default if it is higher. Use this if you want to make
your client/server more secure than Twisted's default, but will
accept Twisted's default instead if it moves higher than this
value. You probably want to use this over
C{insecurelyLowerMinimumTo}.
@type raiseMinimumTo: L{TLSVersion} constant
@param insecurelyLowerMinimumTo: The minimum TLS version to use,
possibly lower than Twisted's default. If not specified, it is a
generally considered safe default (TLSv1.0). If you want to raise
your minimum TLS version to above that of this default, use
C{raiseMinimumTo}. DO NOT use this argument unless you are
absolutely sure this is what you want.
@type insecurelyLowerMinimumTo: L{TLSVersion} constant
@param lowerMaximumSecurityTo: The maximum TLS version to use. If not
specified, it is the most recent your OpenSSL supports. You only
want to set this if the peer that you are communicating with has
problems with more recent TLS versions, it lowers your security
when communicating with newer peers. DO NOT use this argument
unless you are absolutely sure this is what you want.
@type lowerMaximumSecurityTo: L{TLSVersion} constant
@raise ValueError: when C{privateKey} or C{certificate} are set without
setting the respective other.
@raise ValueError: when C{verify} is L{True} but C{caCerts} doesn't
specify any CA certificates.
@raise ValueError: when C{extraCertChain} is passed without specifying
C{privateKey} or C{certificate}.
@raise ValueError: when C{acceptableCiphers} doesn't yield any usable
ciphers for the current platform.
@raise TypeError: if C{trustRoot} is passed in combination with
C{caCert}, C{verify}, or C{requireCertificate}. Please prefer
C{trustRoot} in new code, as its semantics are less tricky.
@raise TypeError: if C{method} is passed in combination with
C{tlsProtocols}. Please prefer the more explicit C{tlsProtocols}
in new code.
@raises NotImplementedError: If acceptableProtocols were provided but
no negotiation mechanism is available.
Nz5Specify neither or both of privateKey and certificatez<raiseMinimumTo needs to be lower than lowerMaximumSecurityTozFinsecurelyLowerMinimumTo needs to be lower than lowerMaximumSecurityToz�Passing method to twisted.internet.ssl.CertificateOptions was deprecated in Twisted 17.1.0. Please use a combination of insecurelyLowerMinimumTo, raiseMinimumTo, and lowerMaximumSecurityTo instead, as Twisted will correctly configure the method.� )�
stacklevelzZSpecify client CA certificate information if and only if enabling certificate verificationzZA private key and a certificate are required when adding a supplemental certificate chain.)�
openSSLlib�
openSSLcrypto�:c 3 �4 K � | ] }|j �� � y �wrM )�fullName)rO rt s r2 rQ z5OpenSSLCertificateOptions.__init__.<locals>.<genexpr>2 s � �� � &
��
�J�J�&
�s ��ALLr_ zGSupplied IAcceptableCiphers yielded no usable ciphers on this platform.Tz5No support for protocol negotiation on this platform.)1�
ValueErrorr* r= r � OP_NO_SSLv2�OP_NO_COMPRESSION�OP_CIPHER_SERVER_PREFERENCE�_options�MODE_RELEASE_BUFFERS�_mode�
TLS_METHODr� �_defaultMinimumTLSVersionr> �_tlsDisableFlagsrf �warn�DeprecationWarningr" �extraCertChainr� � verifyDepthr� �
verifyOnce�enableSingleUseKeys�OP_SINGLE_DH_USE�OP_SINGLE_ECDH_USE�enableSessions�fixBrokenPeers�OP_ALL�enableSessionTickets� OP_NO_TICKET� dhParameters�!_ChooseDiffieHellmanEllipticCurve�OPENSSL_VERSION_NUMBER� pyOpenSSLlibr �
_ecChooser�defaultCiphersr� �
selectCiphers�_expandCipherString�
_cipherStringr� r� r> r� r} �_acceptableProtocols)r� r* r= r� r" r� r� r� r� r� r� r� r� r� �acceptableCiphersr� r> r� r� r� r� r= rW s r2 r� z"OpenSSLCertificateOptions.__init__ s' � �r
�$� �K�4�$7� 8� � T�U� U�$���&���
�O�O�c� 3� 3� 3�c�6U�6U� U�
�
� �-�-��
� �>� �.�.�D�K� �)�n�?U�.U�$�1�� �
"�D�$B�$B�B�/=�,�'�/�+/�+I�+I�(�
+�0�3I�I�/E�,� '�,�/E�E� �-�� �
8�(�*@� � � ,�
;���
�
�!1�'�!:�:�
�
;�
�M�M�,� #� �
� !�D�K� �'� �=��
� �� � � %�$�:�{�2K�*K� �@��
� � %�"0�D� �"$�D� � �� �&���"4�� �$���#6�� � � �M�M�S� 1� 1�C�4J�4J� J� J�M� ,��� ,��� � �M�M�S�Z�Z� '�M�$8��!�#� �M�M�S� -� -� -�M� (���;� � &� &�#� �
��� � $� .� � �X�X� &
�&�4�4�#�E�4�;�;��
�
�F��&
�
��� � � �� #� �$��
�
� ��{�{� 9�'� B� � �D�K�&*�D� #�)�)�4�I�"��� � *�3P�3R�%�G��
� %8��!r1 c �b � | j j � } |d= |S # t $ r Y |S w xY w)N�_context)�__dict__�copyr� )r� �ds r2 ri z&OpenSSLCertificateOptions.__getstate__N s@ � � �M�M� � � �� ��*�
� ��� � � ��� �s �! � .�.c � � || _ y rM )r
rk s r2 rm z&OpenSSLCertificateOptions.__setstate__V s � � ��
r1 c �\ � | j �| j � | _ | j S )z:
Return an L{OpenSSL.SSL.Context} object.
)r � _makeContextr� s r2 r� z$OpenSSLCertificateOptions.getContextY s( � � �=�=� � � -� -� /�D�M��}�}� r1 c �F � | j | j � }|j | j � |j | j
� | j �t| j �h|j | j � |j | j � | j D ] }|j |� � |j � t j }| j rit j }| j" r|t j$ z }| j& r|t j( z }| j* j- |� |j/ |� | j0 �|j3 | j0 � t5 t7 d� � }|j9 |� | j: r |j= t j> � n |j= t j@ � | jB r/|jE | jB jF jH � |jK | jL jO d� � | jP jS |� | jT rtW || jT � |S )N� r� ),�_contextFactoryr� � set_optionsr� �set_moder� r= r* �use_certificate�use_privatekeyr� �add_extra_chain_cert�check_privatekeyr � VERIFY_NONEr" � VERIFY_PEERr� �VERIFY_FAIL_IF_NO_PEER_CERTr� �VERIFY_CLIENT_ONCEr> r� �
set_verifyr� �set_verify_depthr r" �set_session_idr� �set_session_cache_mode�SESS_CACHE_SERVER�SESS_CACHE_OFFr� � load_tmp_dh�_dhFile�path�set_cipher_listr r� r �configureECDHCurver �_setAcceptableProtocols)r� r� � extraCert� verifyFlags�sessionIDContexts r2 r z&OpenSSLCertificateOptions._makeContexta s� � ��"�"�4�;�;�/�� ����
�
�&� � � �T�Z�Z� � � � � '�D�O�O�,G� � � �� 0� 0� 1� � � �t��� /� !� 0� 0�
4� ��(�(��3�
4�
� � � "��o�o� � �;�;� �/�/�K��&�&��s� >� >�>� �����s� 5� 5�5� � �N�N� /� /�� 4� ���{�#� � � � '� � � ��!1�!1� 2� #�<��?�3�� ���+�,� � � � � &� &�s�'<�'<� =� � &� &�s�'9�'9� :� � � � �O�O�D� -� -� 5� 5� :� :� ;� ���D� .� .� 5� 5�g� >�?� ���*�*�3�/� � $� $�
$�C��)B�)B� C��
r1 )NNNFN� TTTFFFNNNNNNNN)r' r( r) r* r ry r r r� r& r/ �_OP_NO_TLSv1_3r. r� r r� ri rm r� r r0 r1 r2 r@ r@ � s� � ��( �k�k�O��H�%�j�&8�&8�9�N� *� 2� 2� � �
�.� /�
�(� #�
�)� $�
�1� 2�
�'� (�
� 9� :�
�/� 0�
�
� ������ �� � � � "�� ��� ��!%� #�+y8�
�y8�v � � �8r1 r@ re rf rg T)�frozen� auto_attribsc � � e Zd ZU dZded< y)�
OpenSSLCipherz�
A representation of an OpenSSL cipher.
@ivar fullName: The full name of the cipher. For example
C{u"ECDHE-RSA-AES256-GCM-SHA384"}.
@type fullName: L{unicode}
rh r� N)r' r( r) r* �__annotations__r0 r1 r2 r1 r1 � s � �� �Mr1 r1 � )�maxsizec � � t j |� }|j |� |j | j d� � t j |d� }|j � }t |d t � rt d� |D � � S t d� |D � � S # t j
$ rK}|j d st � cY d}~S |j d d d dk( rt � cY d}~S � d}~ww xY w)af
Expand C{cipherString} according to C{method} and C{options} to a tuple of
explicit ciphers that are supported by the current platform.
@param cipherString: An OpenSSL cipher string to expand.
@type cipherString: L{unicode}
@param method: An OpenSSL method like C{SSL.TLS_METHOD} used for
determining the effective ciphers.
@param options: OpenSSL options like C{SSL.OP_NO_SSLv3} ORed together.
@type options: L{int}
@return: The effective list of explicit ciphers that results from the
arguments on the current platform.
@rtype: L{tuple} of L{ICipher}
r� r NrT zno cipher matchc 3 �2 K � | ] }t |� �� � y �wrM )r1 �rO �ciphers r2 rQ z&_expandCipherString.<locals>.<genexpr>� s � �� �A�v�]�6�*�A�rR c 3 �P K � | ] }t |j d � � �� � y�w)r� N)r1 r� r7 s r2 rQ z&_expandCipherString.<locals>.<genexpr>� s � �� �Q�v�]�6�=�=��#9�:�Q�s �$&) r ry r r& r� �Errorr� �tupler� �get_cipher_listr� rh )� cipherStringr� r r� rk �conn�cipherss r2 r r � s� � �& �+�+�f�
�C��O�O�G� � � ���L� /� /�� 8�9� �>�>�#�t� $�D��"�"�$�G��'�!�*�c�"��A��A�A�A��Q��Q�Q�Q��! �9�9�
�
�v�v�a�y��7�N� �6�6�!�9�Q�<��?� /� /��7�N� ��
�s/ � B% �%D�8C>�D�!C>�7D�=C>�>D� c �, �� t �fd�| D � � S )a�
Caclulate the acceptable list of ciphers from the ciphers we want and the
ciphers we have support for.
@param wantedCiphers: The ciphers we want to use.
@type wantedCiphers: L{tuple} of L{OpenSSLCipher}
@param availableCiphers: The ciphers we have available to use.
@type availableCiphers: L{tuple} of L{OpenSSLCipher}
@rtype: L{tuple} of L{OpenSSLCipher}
c 3 �, �K � | ] }|�v s�|�� �
y �wrM r0 )rO r8 �availableCipherss �r2 rQ z!_selectCiphers.<locals>.<genexpr>� s �� �� �R�F�v�AQ�7Q��R�s � �)r; )�
wantedCiphersrC s `r2 �_selectCiphersrE � s �� � �R�m�R� R�Rr1 c �, � e Zd ZdZd� Zd� Zed� � Zy)�OpenSSLAcceptableCipherszN
A representation of ciphers that are acceptable for TLS connections.
c �$ � t |� | _ y rM )r; �_ciphers)r� r? s r2 r� z!OpenSSLAcceptableCiphers.__init__� s
� � �g���
r1 c �@ � t | j t |� � S rM )rE rI r; )r� rC s r2 r z&OpenSSLAcceptableCiphers.selectCiphers� s � � �d�m�m�U�3C�-D�E�Er1 c � � | t t |� t j t j t j
z � � S )aR
Create a new instance using an OpenSSL cipher string.
@param cipherString: An OpenSSL cipher string that describes what
cipher suites are acceptable.
See the documentation of U{OpenSSL
<http://www.openssl.org/docs/apps/ciphers.html#CIPHER_STRINGS>} or
U{Apache
<http://httpd.apache.org/docs/2.4/mod/mod_ssl.html#sslciphersuite>}
for details.
@type cipherString: L{unicode}
@return: Instance representing C{cipherString}.
@rtype: L{twisted.internet.ssl.AcceptableCiphers}
)r r r r� r� � OP_NO_SSLv3)�clsr= s r2 �fromOpenSSLCipherStringz0OpenSSLAcceptableCiphers.fromOpenSSLCipherString� s8 � �" � � �\�*�������#�/�/�1�
�
�
r1 N)r' r( r) r* r� r r rN r0 r1 r2 rG rG � s& � ��'�F� �
� �
r1 rG z�TLS13-AES-256-GCM-SHA384:TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-128-GCM-SHA256:ECDH+AESGCM:ECDH+CHACHA20:DH+AESGCM:DH+CHACHA20:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:RSA+AESGCM:RSA+AES:!aNULL:!MD5:!DSS�
prime256v1c �. � e Zd ZdZd� Zd� Zd� Zd� Zd� Zy)r� a
Chooses the best elliptic curve for Elliptic Curve Diffie-Hellman
key exchange, and provides a C{configureECDHCurve} method to set
the curve, when appropriate, on a new L{OpenSSL.SSL.Context}.
The C{configureECDHCurve} method will be set to one of the
following based on the provided OpenSSL version and configuration:
- L{_configureOpenSSL110}
- L{_configureOpenSSL102}
- L{_configureOpenSSL101}
- L{_configureOpenSSL101NoCurves}.
@param openSSLVersion: The OpenSSL version number.
@type openSSLVersion: L{int}
@see: L{OpenSSL.SSL.OPENSSL_VERSION_NUMBER}
@param openSSLlib: The OpenSSL C{cffi} library module.
@param openSSLcrypto: The OpenSSL L{crypto} module.
@see: L{crypto}
c � � || _ || _ |dk\ r| j | _ y |dk\ r| j | _ y |j t � | _ | j | _ y # t $ r | j | _ Y y w xY w)Ni i ) � _openSSLlib�_openSSLcrypto�_configureOpenSSL110r' �_configureOpenSSL102�get_elliptic_curve�_defaultCurveName�_ecCurve�_configureOpenSSL101r� � _configureOpenSSL101NoCurves)r� �openSSLVersionr� r� s r2 r� z*_ChooseDiffieHellmanEllipticCurve.__init__H s� � �%��� +��� �Z� '�&*�&?�&?�D� #�
�z�
)�&*�&?�&?�D� #�
D� -� @� @�AR� S��
� +/�*C�*C��'�� �
L� +/�*K�*K��'�
L�s �A* �*B�Bc � � y)z�
OpenSSL 1.1.0 Contexts are preconfigured with an optimal set
of ECDH curves. This method does nothing.
@param ctx: L{OpenSSL.SSL.Context}
Nr0 �r� r� s r2 rT z6_ChooseDiffieHellmanEllipticCurve._configureOpenSSL110Y rv r1 c �t � |j } | j j |d� y# t $ r Y yw xY w)a
Have the context automatically choose elliptic curves for
ECDH. Run on OpenSSL 1.0.2 and OpenSSL 1.1.0+, but only has
an effect on OpenSSL 1.0.2.
@param ctx: The context which .
@type ctx: L{OpenSSL.SSL.Context}
TN)r rR �SSL_CTX_set_ecdh_autor� )r� r� �ctxPtrs r2 rU z6_ChooseDiffieHellmanEllipticCurve._configureOpenSSL102a s: � � � � �� � � � � 2� 2�6�4� @�� � � � �s � + � 7�7c �Z � |j | j � y# t $ r Y yw xY w)z�
Set the default elliptic curve for ECDH on the context. Only
run on OpenSSL 1.0.1.
@param ctx: The context on which to set the ECDH curve.
@type ctx: L{OpenSSL.SSL.Context}
N)� set_tmp_ecdhrX r� r] s r2 rY z6_ChooseDiffieHellmanEllipticCurve._configureOpenSSL101p s+ � � � � � �T�]�]� +�� � � � �s � � *�*c � � y)z�
No elliptic curves are available on OpenSSL 1.0.1. We can't
set anything, so do nothing.
@param ctx: The context on which to set the ECDH curve.
@type ctx: L{OpenSSL.SSL.Context}
Nr0 r] s r2 rZ z>_ChooseDiffieHellmanEllipticCurve._configureOpenSSL101NoCurves} rv r1 N) r' r( r) r* r� rT rU rY rZ r0 r1 r2 r� r� , s! � ��6D�" �
� � r1 r� c �& � e Zd ZdZd� Zed� � Zy)� OpenSSLDiffieHellmanParameterszn
A representation of key generation parameters that are required for
Diffie-Hellman key exchange.
c � � || _ y rM )r$ )r� �
parameterss r2 r� z'OpenSSLDiffieHellmanParameters.__init__� s � �!�� r1 c � � | |� S )a�
Load parameters from a file.
Such a file can be generated using the C{openssl} command line tool as
following:
C{openssl dhparam -out dh_param_2048.pem -2 2048}
Please refer to U{OpenSSL's C{dhparam} documentation
<http://www.openssl.org/docs/apps/dhparam.html>} for further details.
@param filePath: A file containing parameters for Diffie-Hellman key
exchange.
@type filePath: L{FilePath <twisted.python.filepath.FilePath>}
@return: An instance that loads its parameters from C{filePath}.
@rtype: L{DiffieHellmanParameters
<twisted.internet.ssl.DiffieHellmanParameters>}
r0 )rM �filePaths r2 �fromFilez'OpenSSLDiffieHellmanParameters.fromFile� s � �* �8�}� r1 N)r' r( r) r* r� r rj r0 r1 r2 re re � s � ��
"� � � � r1 re c �
�� �fd�}�syt � }|t j z r'�fd�}| j |� | j |� |t j
z r#| j
|� | j �� yy)a�
Called to set up the L{OpenSSL.SSL.Context} for doing NPN and/or ALPN
negotiation.
@param context: The context which is set up.
@type context: L{OpenSSL.SSL.Context}
@param acceptableProtocols: The protocols this peer is willing to speak
after the TLS negotiation has completed, advertised over both ALPN and
NPN. If this argument is specified, and no overlap can be found with
the other peer, the connection will fail to be established. If the
remote peer does not offer NPN or ALPN, the connection will be
established, but no protocol wil be negotiated. Protocols earlier in
the list are preferred over those later in the list.
@type acceptableProtocols: L{list} of L{bytes}
c �R �� t |� t �� z }�D ]
}||v s�|c S y)at
NPN client-side and ALPN server-side callback used to select
the next protocol. Prefers protocols found earlier in
C{_acceptableProtocols}.
@param conn: The context which is set up.
@type conn: L{OpenSSL.SSL.Connection}
@param conn: Protocols advertised by the other side.
@type conn: L{list} of L{bytes}
r1 )r� )r> � protocols�overlap�pr� s �r2 �protoSelectCallbackz4_setAcceptableProtocols.<locals>.protoSelectCallback� s9 �� � �i�.�3�':�#;�;��$� �A��G�|��� � r1 Nc � �� �S rM r0 )r> r� s �r2 �npnAdvertiseCallbackz5_setAcceptableProtocols.<locals>.npnAdvertiseCallback� s �� �&� &r1 )r� rn ro r{ �set_npn_select_callbackrp r~ �set_alpn_protos)r� r� rp � supportedrr s ` r2 r( r( � s~ �� �$�0 ��-�/�I��-�1�1�1� '� �*�*�+?�@��'�'�(;�<��-�2�2�2��(�(�)<�=�� � � 3�4� 3r1 )NNN)s�
__future__r rf �binasciir � functoolsr �hashlibr �typingr �zope.interfacer r
�OpenSSLr r �
OpenSSL._utilr
r r� �
constantlyr r r r � incrementalr �twisted.internet.abstractr r �twisted.internet.deferr �twisted.internet.errorr r �twisted.internet.interfacesr r r r �twisted.pythonr r �twisted.python.compatr �twisted.python.deprecater r �twisted.python.failurer! �twisted.python.randbytesr" �_idnar$ r& r+ rL r, � OP_NO_TLSv1r- �
OP_NO_TLSv1_1r. �
OP_NO_TLSv1_2r/ r� r� r> � Exceptionr@ rH rJ rZ rl r� r� r\ rn ro rx r� r� rh r� r� r� r� r� r� r r( r r6 r� r� r� r� r� r� r� r� r@ ri rm �sr1 r rE rG rN r rW r� re r( r0 r1 r2 �<module>r� s� ��
#� � � � � � 1� � -� � @� @� � @� +� @�� � %� .� L� *� 1� � �� � ���c�o�o�����������)�)�����)�)� �����_�d�;� � � �0�i� � P�2 L�
%�"P�J 6Q�5R� 2���!2�
��
�* �"�"�%?�%C�%C�C� � $�
�> � � �*�
"� 6� �"�
�0� � �"��
�"a ��S�%�Z�(� a �H ��& � & �R�0IM�(� IM�XF�� F�*m
�� m
�`99� 99�xz
�i� z
�z � � �*
�
� �!� !� �!�( 0�>
�
� �+� +� �+�C!�L �@
�
,�-�j.� j.� .�j.�^ �� � KG� !�
KG�\
�
#�$�m� m� %�m�`
*�� �I�r�1�a� �"=�*��(�(�**� � &�*�� �I�r�1�a� �"=�*��(�(�**� � &�
�W������t�$�'� � � (� � � �2��&R� �&R�R �3��
S� �
S�
�
� �"
� "
� !�"
�h *�A�A���� !� �X � X �v � �B95r1
Mini Shell