ok

Mini Shell

Direktori : /opt/imunify360/venv/lib/python3.11/site-packages/Crypto/Protocol/__pycache__/
Upload File :
Current File : //opt/imunify360/venv/lib/python3.11/site-packages/Crypto/Protocol/__pycache__/KDF.cpython-311.pyc

�

f��f)W��:�ddlZddlZddlmZddlmZmZmZmZm	Z	m
Z
mZddlm
Z
mZmZmZmZddlmZddlmZddlmZmZmZddlmZmZmZmZed	d
��Z edd��Z!dd�Z"dd�Z#Gd�de$��Z%dd�Z&d d�Z'd�Z(d�Z)d�Z*d!d�Z+d�Z,d"d�Z-dS)#�N)�reduce)�tobytes�bord�_copy_bytes�
iter_range�tostr�bchr�bstr)�SHA1�SHA256�HMAC�CMAC�BLAKE2s)�strxor)�get_random_bytes)�size�
long_to_bytes�
bytes_to_long)�load_pycryptodome_raw_lib�create_string_buffer�get_raw_buffer�c_size_tzCrypto.Cipher._Salsa20z�
                    int Salsa20_8_core(const uint8_t *x, const uint8_t *y,
                                       uint8_t *out);
                    zCrypto.Protocol._scrypta
                    typedef int (core_t)(const uint8_t [64], const uint8_t [64], uint8_t [64]);
                    int scryptROMix(const uint8_t *data_in, uint8_t *data_out,
                           size_t data_len, unsigned N, core_t *core);
                    ��c��|st}t|��}|�||z��}|j}||krt	d|z���t|��dkrt
dt|��z���t|dz
��D])}|�|�����}�*|���d|�S)aMDerive one key from a password (or passphrase).

    This function performs key derivation according to an old version of
    the PKCS#5 standard (v1.5) or `RFC2898
    <https://www.ietf.org/rfc/rfc2898.txt>`_.

    Args:
     password (string):
        The secret password to generate the key from.
     salt (byte string):
        An 8 byte string to use for better protection from dictionary attacks.
        This value does not need to be kept secret, but it should be randomly
        chosen for each derivation.
     dkLen (integer):
        The length of the desired key. The default is 16 bytes, suitable for
        instance for :mod:`Crypto.Cipher.AES`.
     count (integer):
        The number of iterations to carry out. The recommendation is 1000 or
        more.
     hashAlgo (module):
        The hash algorithm to use, as a module or an object from the :mod:`Crypto.Hash` package.
        The digest length must be no shorter than ``dkLen``.
        The default algorithm is :mod:`Crypto.Hash.SHA1`.

    Return:
        A byte string of length ``dkLen`` that can be used as key.
    z:Selected hash algorithm has a too short digest (%d bytes).�z,Salt is not 8 bytes long (%d bytes instead).�N)	rr�new�digest_size�	TypeError�len�
ValueErrorr�digest)�password�salt�dkLen�count�hashAlgo�pHashr"�is        �u/builddir/build/BUILD/imunify360-venv-2.3.5/opt/imunify360/venv/lib64/python3.11/site-packages/Crypto/Protocol/KDF.py�PBKDF1r+7s���:�����x� � �H��L�L��$��'�'�E�
�
�F��v�~�~��T�W]�]�^�^�^�
�4�y�y�A�~�~��G�#�d�)�)�S�T�T�T�
��a��
 �
 �*�*���	�	�%�,�,�.�.�)�)����<�<�>�>�&�5�&�!�!��c�@����
��t����t|��}�r�rtd�����	��t��st�d��s����fd����fd��
d}d}t	|��|krp��|tjd|��z��gd	z�|tt�
�fd
�t|��D����z
}|dz
}t	|��|k�pn�d}d}t	|��|kr�tj�d���}|����
|tjd|��z�����}	||�|	|��z
}|dz
}t	|��|k��|d|�S)a�Derive one or more keys from a password (or passphrase).

    This function performs key derivation according to the PKCS#5 standard (v2.0).

    Args:
     password (string or byte string):
        The secret password to generate the key from.

        Strings will be encoded as ISO 8859-1 (also known as Latin-1),
        which does not allow any characters with codepoints > 255.
     salt (string or byte string):
        A (byte) string to use for better protection from dictionary attacks.
        This value does not need to be kept secret, but it should be randomly
        chosen for each derivation. It is recommended to use at least 16 bytes.

        Strings will be encoded as ISO 8859-1 (also known as Latin-1),
        which does not allow any characters with codepoints > 255.
     dkLen (integer):
        The cumulative length of the keys to produce.

        Due to a flaw in the PBKDF2 design, you should not request more bytes
        than the ``prf`` can output. For instance, ``dkLen`` should not exceed
        20 bytes in combination with ``HMAC-SHA1``.
     count (integer):
        The number of iterations to carry out. The higher the value, the slower
        and the more secure the function becomes.

        You should find the maximum number of iterations that keeps the
        key derivation still acceptable on the slowest hardware you must support.

        Although the default value is 1000, **it is recommended to use at least
        1000000 (1 million) iterations**.
     prf (callable):
        A pseudorandom function. It must be a function that returns a
        pseudorandom byte string from two parameters: a secret and a salt.
        The slower the algorithm, the more secure the derivation function.
        If not specified, **HMAC-SHA1** is used.
     hmac_hash_module (module):
        A module from ``Crypto.Hash`` implementing a Merkle-Damgard cryptographic
        hash, which PBKDF2 must use in combination with HMAC.
        This parameter is mutually exclusive with ``prf``.

    Return:
        A byte string of length ``dkLen`` that can be used as key material.
        If you want multiple keys, just break up this string into segments of the desired length.
    z2'prf' and 'hmac_hash_module' are mutually exlusiveN�_pbkdf2_hmac_assistc�T��tj||������S�N)r
rr")�p�s�hmac_hash_modules  �r*�<lambda>zPBKDF2.<locals>.<lambda>�s"���d�h�q�!�-=�>�>�E�E�G�G�r,c�V��|d��|d��c|d<|d<|dS)Nrr�)r3r#�prfs ��r*�linkzPBKDF2.<locals>.link�s3����1��s�s�8�Q�q�T�2�2�J�A�a�D�!�A�$��Q�4�Kr,r,rz>I�c3�.�K�|]}����V��dSr1r7)�.0�jr9r3s  ��r*�	<genexpr>zPBKDF2.<locals>.<genexpr>�s+�����"A�"A�q�4�4��7�7�"A�"A�"A�"A�"A�"Ar,)rr!r�hasattrr �struct�packrr�ranger
r�copy�updater"r/)r#r$r%r&r8r4�keyr)�base�first_digestr9r3s`   ``    @@r*�PBKDF2rHbs��������`�x� � �H��4�=�=�D�
�O��O��M�N�N�N�
�{�'�/���
��'�*�,A�B�B���;�G�G�G�G�C�	�	�	�	�	�	���
���#�h�h�����#�h��v�{�4��';�';� ;�<�<�>��B�A��6�&�"A�"A�"A�"A�"A�E�%�L�L�"A�"A�"A�C�C�C�C�
��F�A��#�h�h�������
���#�h�h�u�n�n��8�H�c�+;�<�<�D��9�9�;�;�-�-�d�V�[��q�5I�5I�.I�J�J�Q�Q�S�S�L��4�+�+�L�%�@�@�@�C�
��F�A�	�#�h�h�u�n�n��v��v�;�r,c�B�eZdZdZdd�Zed���Zd�Zd�Zd�Z	dS)	�_S2Vz�String-to-vector PRF as defined in `RFC5297`_.

    This class implements a pseudorandom function family
    based on CMAC that takes as input a vector of strings.

    .. _RFC5297: http://tools.ietf.org/html/rfc5297
    Nc���tdd|��|_||_d|jzx|_|_|jdzdz
|_|�	i|_dSt|��|_dS)a~Initialize the S2V PRF.

        :Parameters:
          key : byte string
            A secret that can be used as key for CMACs
            based on ciphers from ``ciphermod``.
          ciphermod : module
            A block cipher module from `Crypto.Cipher`.
          cipher_params : dictionary
            A set of extra parameters to use to create a cipher instance.
        N�rr)	r�_key�
_ciphermod�
block_size�_last_string�_cache�
_n_updates�_cipher_params�dict)�selfrE�	ciphermod�
cipher_paramss    r*�__init__z
_S2V.__init__�su�� ��d�C�0�0��	�#���*1�I�4H�*H�H���D�K�$�.��2�Q�6���� �"$�D����"&�}�"5�"5�D���r,c�"�t||��S)a
Create a new S2V PRF.

        :Parameters:
          key : byte string
            A secret that can be used as key for CMACs
            based on ciphers from ``ciphermod``.
          ciphermod : module
            A block cipher module from `Crypto.Cipher`.
        )rJ)rErVs  r*rz_S2V.new�s���C��#�#�#r,c���t|��dz}t|d��dzr|dz}t|t|����t|��d�S)Nrr��)rrrr )rU�bs�doubleds   r*�_doublez_S2V._double�s[����#�#�Q�&����1��;�;���	��t�O�G��W�c�"�g�g�.�.��B���x�y�y�9�9r,c�\�|jdkrtd���|xjdzc_tj|j|j|j|j���}t|�	|j
��|�����|_
tdd|��|_dS)adPass the next component of the vector.

        The maximum number of components you can pass is equal to the block
        length of the cipher (in bits) minus 1.

        :Parameters:
          item : byte string
            The next component of the vector.
        :Raise TypeError: when the limit on the number of components has been reached.
        rz!Too many components passed to S2Vr��msgrVrWN)
rRrrrrMrPrNrSrr_rQr"r)rU�item�macs   r*rDz_S2V.update�s����?�a����?�@�@�@����1�����h�t�y��,�!%��%)�%8�:�:�:���T�\�\�$�+�6�6��
�
���E�E���'��d�D�9�9����r,c��t|j��dkr3|jdd�t|jdd�|j��z}n=|jdzdzdd�}t||�|j����}tj|j||j|j	���}|�
��S)z�"Derive a secret from the vector of components.

        :Return: a byte string, as long as the block length of the cipher.
        r-Ni���sra)r rPrrQr_rrrMrNrSr")rU�final�paddedrds    r*�derivez_S2V.derives����t� �!�!�R�'�'��%�d�s�d�+�f�T�5F�s�t�t�5L�d�k�.Z�.Z�Z�E�E��'�'�1�L�@�#�2�#�F�F��6�4�<�<���#<�#<�=�=�E��h�t�y� �!%��%)�%8�:�:�:���z�z�|�|�r,r1)
�__name__�
__module__�__qualname__�__doc__rX�staticmethodrr_rDrir7r,r*rJrJ�sz��������6�6�6�6�2�
$�
$��\�
$�:�:�:�:�:�:�.����r,rJrc�r��
��|z}|d|jzkrtd���|s
d|jz}|�d}tj|||���}|���}dg}	d}
d}||krrtj||	d	|ztjd
|
��z|���}|	�|�����||jz
}|
dz
}
||k�rd�|	���
|dkr
�
d��S�
�fd�td|���D��}t|d|���S)a�Derive one or more keys from a master secret using
    the HMAC-based KDF defined in RFC5869_.

    Args:
     master (byte string):
        The unguessable value used by the KDF to generate the other keys.
        It must be a high-entropy secret, though not necessarily uniform.
        It must not be a password.
     key_len (integer):
        The length in bytes of every derived key.
     salt (byte string):
        A non-secret, reusable value that strengthens the randomness
        extraction step.
        Ideally, it is as long as the digest size of the chosen hash.
        If empty, a string of zeroes in used.
     hashmod (module):
        A cryptographic hash algorithm from :mod:`Crypto.Hash`.
        :mod:`Crypto.Hash.SHA512` is a good choice.
     num_keys (integer):
        The number of keys to derive. Every key is :data:`key_len` bytes long.
        The maximum cumulative length of all keys is
        255 times the digest size.
     context (byte string):
        Optional identifier describing what the keys are used for.

    Return:
        A byte string or a tuple of byte strings.

    .. _RFC5869: http://tools.ietf.org/html/rfc5869
    �zToo much secret data to deriverLNr,)�	digestmodrr����Bc�*��g|]}�||�z���Sr7r7)r<�idx�derived_output�key_lens  ��r*�
<listcomp>zHKDF.<locals>.<listcomp>Qs7���:�:�:���#�c�G�m�+�,�:�:�:r,)rr!r
rr"r@rA�append�joinr�list)�masterrwr$�hashmod�num_keys�context�
output_len�hmac�prk�t�n�tlen�kolrvs `           @r*�HKDFr�sy����@�8�#�J��S�7�.�.�/�/��9�:�:�:��-���,�,�������8�D�&�G�4�4�4�D�
�+�+�-�-�C���A�	�A��D�
��
�
��x��Q�r�U�W�_�v�{�3��/B�/B�B�g�V�V�V��	�������������#�#��	�Q���	��
�
�
�X�X�a�[�[�N��1�}�}��h�w�h�'�'�:�:�:�:�:� ��J��8�8�:�:�:�C���I�X�I����r,c	�����dt|��dz
z|krtd���|dkrtd���|dd|zzkrtd���d	�}t|||dz|zd|�
��}tj}	t
j}
g}t|��D]p}|dz|z}
td|z��}|	||
|
d|zz�|td|z��||
��}|rtd|z���|t|��gz
}�qt|d�|���|zd|�
���|dkr�S��fd
�td�|z���D��}|S)uGDerive one or more keys from a passphrase.

    Args:
     password (string):
        The secret pass phrase to generate the keys from.
     salt (string):
        A string to use for better protection from dictionary attacks.
        This value does not need to be kept secret,
        but it should be randomly chosen for each derivation.
        It is recommended to be at least 16 bytes long.
     key_len (integer):
        The length in bytes of each derived key.
     N (integer):
        CPU/Memory cost parameter. It must be a power of 2 and less
        than :math:`2^{32}`.
     r (integer):
        Block size parameter.
     p (integer):
        Parallelization parameter.
        It must be no greater than :math:`(2^{32}-1)/(4r)`.
     num_keys (integer):
        The number of keys to derive. Every key is :data:`key_len` bytes long.
        By default, only 1 key is generated.
        The maximum cumulative length of all keys is :math:`(2^{32}-1)*32`
        (that is, 128TB).

    A good choice of parameters *(N, r , p)* was suggested
    by Colin Percival in his `presentation in 2009`__:

    - *( 2¹⁴, 8, 1 )* for interactive logins (≤100ms)
    - *( 2²⁰, 8, 1 )* for file encryption (≤5s)

    Return:
        A byte string or a tuple of byte strings.

    .. __: http://www.tarsnap.com/scrypt/scrypt-slides.pdf
    r:rzN must be a power of 2lzN is too bigl��r[zp or r are too bigc�\�tj||t�����Sr1)r
rrr")r2r3s  r*r5zscrypt.<locals>.<lambda>�s ��4�8�A�q�&�#9�#9�#@�#@�#B�#B�r,)r8zError %X while running scryptr,c�*��g|]}�||�z���Sr7r7�r<ru�dkrws  ��r*rxzscrypt.<locals>.<listcomp>�s=���B�B�B���c�#��-�� �B�B�Br,r)�bit_sizer!rH�_raw_scrypt_lib�scryptROMix�_raw_salsa20_lib�Salsa20_8_corerrrrrz)r#r$rw�N�rr2r~�prf_hmac_sha256�stage_1r��core�data_out�flowru�
buffer_out�resultr�r�s  `              @r*�scryptr�Ws�����N	�X�a�[�[�1�_���"�"��1�2�2�2��G�|�|���(�(�(���S�1�W�-�-�-��-�.�.�.�B�B�O��X�t�Q��W�q�[�!��I�I�I�G�!�-�K��*�D��H��1�
�
�
3�
3���S�j�1�n��)�#��'�2�2�
���W�S�3��q��=�%8�9�'�%�c�A�g�.�.��!�	#�#��
�	G��<�v�E�F�F�F��n�Z�0�0�2�2���	������"�"��(�"�A�#�
%�
%�
%�B�
�1�}�}��	�B�B�B�B�B� ��G�h�$6��@�@�B�B�B�C��Jr,c���d}g�|D][}tt|����dd��d��}��t	|�����\d������fd�t
dt���d��D��}g}|dd�D]-}t|d��}|�||���.|d}t|d��dt|��z
z}|�||��d	�|��}t|��S)
N�@./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789r:rr,c�*��g|]}�||dz���S)�r7�r<ru�bitss  �r*rxz"_bcrypt_encode.<locals>.<listcomp>��%���A�A�A�#�d�3�s�1�u�9�o�A�A�Ar,rr�rr�)
�binr�zfillryr
rzrBr �intr)	�datar3�c�bits_c�bits6r��grur�s	        @r*�_bcrypt_encoder��s1���J�A�
�D�
�"�"���T�!�W�W���a�b�b�!�'�'��*�*�����D��L�L�!�!�!�!��8�8�D�>�>�D�A�A�A�A��q�#�d�)�)�Q�)?�)?�A�A�A�E�
�F�
�3�B�3�Z�����!�Q�i�i���
�
�a��f�����
�b�	�A�

�a��)�)��C��F�F�
�
#�C�
�M�M�!�C�&����
�W�W�V�_�_�F��6�?�?�r,c	��	�d}g�	t|��D]V}|�|��}t|��dd��d��}�	�|���Wd��	���	t
|��dz}|dkrtd���|dkr�	dd��	n|d	kr
�	dd
��	�	fd�tdt
�	��d
��D��}g}|D]2}|�tt|d�������3d�|��}|S)Nr�r:r�r��rzIncorrect length�������c�*��g|]}�||dz���S)rr7r�s  �r*rxz"_bcrypt_decode.<locals>.<listcomp>�r�r,rrr,)r�findr�r�ryrzr r!rBr	r�)
r�r3r�rur��modulo4�bits8r�r�r�s
         @r*�_bcrypt_decoder��sC���J�A�
�D�
�4�[�[�����f�f�Q�i�i���C�������"�"�1�%�%�����E�����
�7�7�4�=�=�D��$�i�i�!�m�G��!�|�|��+�,�,�,�	�A����C�R�C�y���	�A����C�R�C�y��A�A�A�A��q�#�d�)�)�Q�)?�)?�A�A�A�E�
�F�
�'�'���
�
�d�3�q�!�9�9�o�o�&�&�&�&�
�X�X�f�
�
�F��Mr,c� �ddlm}t|��dkrtd���d|cxkrdksntd���|�||j|||��}|}t
d��D]}|�|��}�|S)	Nr)�_EKSBlowfish�Hz6The password is too long. It must be 72 bytes at most.r��z-bcrypt cost factor must be in the range 4..31�@)�
Crypto.Cipherr�r r!r�MODE_ECBrB�encrypt)	r#�costr$�constant�invertr��cipher�ctext�_s	         r*�_bcrypt_hashr��s���*�*�*�*�*�*�
�8�}�}�r����Q�R�R�R�
��O�O�O�O��O�O�O�O��H�I�I�I�
�
�
�h��(=�t�T�6�
R�
R�F��E�
�2�Y�Y�&�&�����u�%�%����Lr,c� �t|d��}|�td��d��dkrtd���t	|��dkr|dz
}|�td��}t	|��dkrtd	���t
|||d
d��}dtt|���	d
����z}dt|��z}t|dd���}d|z|z|zS)a>Hash a password into a key, using the OpenBSD bcrypt protocol.

    Args:
      password (byte string or string):
        The secret password or pass phrase.
        It must be at most 72 bytes long.
        It must not contain the zero byte.
        Unicode strings will be encoded as UTF-8.
      cost (integer):
        The exponential factor that makes it slower to compute the hash.
        It must be in the range 4 to 31.
        A value of at least 12 is recommended.
      salt (byte string):
        Optional. Random byte string to thwarts dictionary and rainbow table
        attacks. It must be 16 bytes long.
        If not passed, a random value is generated.

    Return (byte string):
        The bcrypt hash

    Raises:
        ValueError: if password is longer than 72 bytes or if it contains the zero byte

   zutf-8rrrz#The password contains the zero byter�rLNr-z!bcrypt salt must be 16 bytes longsOrpheanBeholderScryDoubtT�$r:s$2a)rr�r	r!r rr�r
�strr�r�)r#r�r$r��cost_enc�salt_enc�hash_encs       r*�bcryptr��s��4�x��)�)�H��}�}�T�!�W�W�Q�Z� � �B�&�&��>�?�?�?�
�8�}�}�r����G����|���#�#��
�4�y�y�B����<�=�=�=���4��/J�D�Q�Q�E��d�3�t�9�9�?�?�1�-�-�.�.�.�H��n�T�*�*�*�H��e�C�R�C�j�)�)�H��H��x�'�(�2�2r,c��t|��}t|��dkrtdt|��z���|dd�dkrtd���tjd��}|�|��}|std���t
|�d	����}d|cxkrd
ksntd���t|�d����}t|||��}td
��}tjd||����
��}tjd||����
��}	||	krtd���dS)a�Verify if the provided password matches the given bcrypt hash.

    Args:
      password (byte string or string):
        The secret password or pass phrase to test.
        It must be at most 72 bytes long.
        It must not contain the zero byte.
        Unicode strings will be encoded as UTF-8.
      bcrypt_hash (byte string, bytearray):
        The reference bcrypt hash the password needs to be checked against.

    Raises:
        ValueError: if the password does not match
    �<z;Incorrect length of the bcrypt hash: %d bytes instead of 60Nr�s$2a$zUnsupported prefixs@\$2a\$([0-9][0-9])\$([A-Za-z0-9./]{22,22})([A-Za-z0-9./]{31,31})zIncorrect bcrypt hash formatrr�zIncorrect costr:r-�)�digest_bitsrEr�zIncorrect bcrypt hash)rr r!�re�compile�matchr��groupr�r�rrrr")
r#�bcrypt_hashr2r�r�r$�bcrypt_hash2�secret�mac1�mac2s
          r*�bcrypt_checkr�so�� �+�&�&�K�
�;���2����V�Y\�]h�Yi�Yi�i�j�j�j��2�A�2��'�!�!��-�.�.�.�
�
�W�X�X�A�	������A��9��7�8�8�8��q�w�w�q�z�z�?�?�D�
��O�O�O�O��O�O�O�O��)�*�*�*��!�'�'�!�*�*�%�%�D��8�T�4�0�0�L�
�b�
!�
!�F��;�3�F��E�E�E�L�L�N�N�D��;�3�F��F�F�F�M�M�O�O�D��t�|�|��0�1�1�1��|r,r,c�"���|�d}|�d��dkrtd���|�d��dkrtd���t�|zdzd��}�|z}d}d	�t���|krXt|d��|zdz|z|z}	�|||	��z
�|dz
}|d
krtd���t���|k�X|dkr
�d��S��fd�t	d
|���D��}
|
S)aJDerive one or more keys from a master secret using
    a pseudorandom function in Counter Mode, as specified in
    `NIST SP 800-108r1 <https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1.pdf>`_.

    Args:
     master (byte string):
        The secret value used by the KDF to derive the other keys.
        It must not be a password.
        The length on the secret must be consistent with the input expected by
        the :data:`prf` function.
     key_len (integer):
        The length in bytes of each derived key.
     prf (function):
        A pseudorandom function that takes two byte strings as parameters:
        the secret and an input. It returns another byte string.
     num_keys (integer):
        The number of keys to derive. Every key is :data:`key_len` bytes long.
        By default, only 1 key is derived.
     label (byte string):
        Optional description of the purpose of the derived keys.
        It must not contain zero bytes.
     context (byte string):
        Optional information pertaining to
        the protocol that uses the keys, such as the identity of the
        participants, nonces, session IDs, etc.
        It must not contain zero bytes.

    Return:
        - a byte string (if ``num_keys`` is not specified), or
        - a tuple of byte strings (if ``num_key`` is specified).
    NrrLrrzNull byte found in labelzNull byte found in contextrr�r,l��zOverflow in SP800 108 counterc�*��g|]}�||�z���Sr7r7r�s  ��r*rxz%SP800_108_Counter.<locals>.<listcomp>�s7���>�>�>���#�c�G�m�#�$�>�>�>r,r)r�r!rr r)r|rwr8r~�labelr�key_len_encr�r)�infor�r�s `         @r*�SP800_108_Counterr�Gs`����B�����z�z�'���b� � ��3�4�4�4��|�|�G����"�"��5�6�6�6���(� 2�Q� 6��:�:�K��8�#�J�	�A�	�B�

�b�'�'�J�
�
��Q��"�"�U�*�W�4�w�>��L��
�c�c�&�$�����	�Q����z�>�>��<�=�=�=��b�'�'�J�
�
��1�}�}��(�7�(�|��>�>�>�>�>�$�Q�
�G�<�<�>�>�>���
r,)rN)r-rNN)rN)rr1)Nr,r,).r�r@�	functoolsr�Crypto.Util.py3compatrrrrrr	r
�Crypto.Hashrrr
rr�Crypto.Util.strxorr�
Crypto.Randomr�Crypto.Util.numberrr�rr�Crypto.Util._raw_apirrrrr�r�r+rH�objectrJr�r�r�r�r�r�r�r�r7r,r*�<module>r�sg��2
�	�	�	�
�
�
�
�������6�6�6�6�6�6�6�6�6�6�6�6�6�6�6�6�6�6�:�9�9�9�9�9�9�9�9�9�9�9�9�9�%�%�%�%�%�%�*�*�*�*�*�*�M�M�M�M�M�M�M�M�M�M�<�<�<�<�<�<�<�<�<�<�<�<�-�,�-E�����,�+�,E�����("�("�("�("�VT�T�T�T�n]�]�]�]�]�6�]�]�]�@: �: �: �: �|M�M�M�M�`���0���8
�
�
� ,3�,3�,3�,3�^*2�*2�*2�Z;�;�;�;�;�;r,

Zerion Mini Shell 1.0