HEX

File: //proc/thread-self/root/lib/python3/dist-packages/nacl/__pycache__/public.cpython-38.pyc
U

�֫[�4�@s�ddlmZmZmZddlZddlmZddlmZddl	m
Z
mZmZGdd�dej
ee�ZGdd	�d	ej
ee�ZGd
d�dej
ee�ZGdd
�d
ej
ee�ZdS)�)�absolute_import�division�print_functionN)�encoding)�
exceptions)�EncryptedMessage�StringFixer�randomc@sFeZdZdZejjZej	fdd�Z
dd�Zdd�Zdd	�Z
d
d�ZdS)
�	PublicKeya=
    The public key counterpart to an Curve25519 :class:`nacl.public.PrivateKey`
    for encrypting messages.

    :param public_key: [:class:`bytes`] Encoded Curve25519 public key
    :param encoder: A class that is able to decode the `public_key`

    :cvar SIZE: The size that the public key is required to be
    cCsH|�|�|_t|jt�s"t�d��t|j�|jkrDt�d�	|j���dS)Nz'PublicKey must be created from 32 bytesz-The public key must be exactly {0} bytes long)
�decode�_public_key�
isinstance�bytes�exc�	TypeError�len�SIZE�
ValueError�format)�self�
public_key�encoder�r�-/usr/lib/python3/dist-packages/nacl/public.py�__init__$s
��zPublicKey.__init__cCs|jS�N�r�rrrr�	__bytes__0szPublicKey.__bytes__cCstt|��Sr)�hashrrrrr�__hash__3szPublicKey.__hash__cCs&t||j�sdStj�t|�t|��S�NF)r
�	__class__�nacl�bindingsZ
sodium_memcmpr�r�otherrrr�__eq__6szPublicKey.__eq__cCs
||kSrrr%rrr�__ne__;szPublicKey.__ne__N)�__name__�
__module__�__qualname__�__doc__r#r$Zcrypto_box_PUBLICKEYBYTESrr�
RawEncoderrrr r'r(rrrrr
s
r
c@sleZdZdZejjZejjZ	e
jfdd�Ze
e
jfdd��Zdd�Zdd	�Zd
d�Zdd
�Ze
dd��ZdS)�
PrivateKeya{
    Private key for decrypting messages using the Curve25519 algorithm.

    .. warning:: This **must** be protected and remain secret. Anyone who
        knows the value of your :class:`~nacl.public.PrivateKey` can decrypt
        any message encrypted by the corresponding
        :class:`~nacl.public.PublicKey`

    :param private_key: The private key used to decrypt messages
    :param encoder: The encoder class used to decode the given keys

    :cvar SIZE: The size that the private key is required to be
    :cvar SEED_SIZE: The size that the seed used to generate the
                     private key is required to be
    cCsT|�|�}t|t�r"t|�|jks4t�d�|j���tj	�
|�}||_t|�|_
dS)Nz?PrivateKey must be created from a {0} bytes long raw secret key)rr
rrrrrrr#r$Zcrypto_scalarmult_base�_private_keyr
r)r�private_keyrZraw_public_keyrrrrSs

��zPrivateKey.__init__cCsL|�|�}t|t�r"t|�|jks4t�d�|j���tj	�
|�\}}||�S)ah
        Generate a PrivateKey using a deterministic construction
        starting from a caller-provided seed

        .. warning:: The seed **must** be high-entropy; therefore,
            its generator **must** be a cryptographic quality
            random function like, for example, :func:`~nacl.utils.random`.

        .. warning:: The seed **must** be protected and remain secret.
            Anyone who knows the seed is really in possession of
            the corresponding PrivateKey.

        :param seed: The seed used to generate the private key
        :rtype: :class:`~nacl.public.PrivateKey`
        z8PrivateKey seed must be a {0} bytes long binary sequence)rr
rr�	SEED_SIZErrrr#r$Zcrypto_box_seed_keypair)�clsZseedrZraw_pkZraw_skrrr�	from_seedbs
�zPrivateKey.from_seedcCs|jSr)r/rrrrrszPrivateKey.__bytes__cCstt|�t|j�f�Sr)r�typerrrrrrr �szPrivateKey.__hash__cCst||j�sdS|j|jkSr!)r
r"rr%rrrr'�szPrivateKey.__eq__cCs
||kSrrr%rrrr(�szPrivateKey.__ne__cCs|ttj�tjd�S)z~
        Generates a random :class:`~nacl.public.PrivateKey` object

        :rtype: :class:`~nacl.public.PrivateKey`
        �r)r	r.rrr-)r2rrr�generate�szPrivateKey.generateN)r)r*r+r,r#r$Zcrypto_box_SECRETKEYBYTESrZcrypto_box_SEEDBYTESr1rr-r�classmethodr3rr r'r(r6rrrrr.?sr.c@sbeZdZdZejjZdd�Zdd�Z	e
ejfdd��Z
dejfd	d
�Zdejfdd�Zd
d�ZdS)�Boxa/
    The Box class boxes and unboxes messages between a pair of keys

    The ciphertexts generated by :class:`~nacl.public.Box` include a 16
    byte authenticator which is checked as part of the decryption. An invalid
    authenticator will cause the decrypt function to raise an exception. The
    authenticator is not a signature. Once you've decrypted the message you've
    demonstrated the ability to create arbitrary valid message, so messages you
    send are repudiable. For non-repudiable messages, sign them after
    encryption.

    :param private_key: :class:`~nacl.public.PrivateKey` used to encrypt and
        decrypt messages
    :param public_key: :class:`~nacl.public.PublicKey` used to encrypt and
        decrypt messages

    :cvar NONCE_SIZE: The size that the nonce is required to be.
    cCsV|rL|rLt|t�rt|t�s&t�d��tj�|jt	j
d�|jt	j
d��|_nd|_dS)Nz5Box must be created from a PrivateKey and a PublicKeyr5)r
r.r
rrr#r$Zcrypto_box_beforenm�encoderr-�_shared_key)rr0rrrrr�s
�
�zBox.__init__cCs|jSr�r:rrrrr�sz
Box.__bytes__cCs|dd�}|�|�|_|Sr)rr:)r2ZencodedrZboxrrrr�s
z
Box.decodeNcCsn|dkrt|j�}t|�|jkr0t�d|j��tj�|||j�}|�	|�}|�	|�}t
�|||�	||��S)a�
        Encrypts the plaintext message using the given `nonce` (or generates
        one randomly if omitted) and returns the ciphertext encoded with the
        encoder.

        .. warning:: It is **VITALLY** important that the nonce is a nonce,
            i.e. it is a number used only once for any given key. If you fail
            to do this, you compromise the privacy of the messages encrypted.

        :param plaintext: [:class:`bytes`] The plaintext message to encrypt
        :param nonce: [:class:`bytes`] The nonce to use in the encryption
        :param encoder: The encoder to use to encode the ciphertext
        :rtype: [:class:`nacl.utils.EncryptedMessage`]
        N�'The nonce must be exactly %s bytes long)r	�
NONCE_SIZErrrr#r$Zcrypto_box_afternmr:r9rZ_from_parts)r�	plaintext�noncer�
ciphertextZ
encoded_nonce�encoded_ciphertextrrr�encrypt�s$
��

�zBox.encryptcCsb|�|�}|dkr.|d|j�}||jd�}t|�|jkrLt�d|j��tj�|||j�}|S)a�
        Decrypts the ciphertext using the `nonce` (explicitly, when passed as a
        parameter or implicitly, when omitted, as part of the ciphertext) and
        returns the plaintext message.

        :param ciphertext: [:class:`bytes`] The encrypted message to decrypt
        :param nonce: [:class:`bytes`] The nonce used when encrypting the
            ciphertext
        :param encoder: The encoder used to decode the ciphertext.
        :rtype: [:class:`bytes`]
        Nr<)	rr=rrrr#r$Zcrypto_box_open_afternmr:)rr@r?rr>rrr�decrypt�s
��zBox.decryptcCs|jS)a�
        Returns the Curve25519 shared secret, that can then be used as a key in
        other symmetric ciphers.

        .. warning:: It is **VITALLY** important that you use a nonce with your
            symmetric cipher. If you fail to do this, you compromise the
            privacy of the messages encrypted. Ensure that the key length of
            your cipher is 32 bytes.
        :rtype: [:class:`bytes`]
        r;rrrr�
shared_keyszBox.shared_key)r)r*r+r,r#r$Zcrypto_box_NONCEBYTESr=rrr7rr-rrBrCrDrrrrr8�s
	% r8c@s<eZdZdZdd�Zdd�Zejfdd�Zejfdd	�Z	d
S)�	SealedBoxak
    The SealedBox class boxes and unboxes messages addressed to
    a specified key-pair by using ephemeral sender's keypairs,
    whose private part will be discarded just after encrypting
    a single plaintext message.

    The ciphertexts generated by :class:`~nacl.public.SecretBox` include
    the public part of the ephemeral key before the :class:`~nacl.public.Box`
    ciphertext.

    :param public_key: :class:`~nacl.public.PublicKey` used to encrypt
        messages and derive nonces
    :param private_key: :class:`~nacl.public.PrivateKey` used to decrypt
        messages

    .. versionadded:: 1.2
    cCs^t|t�r"|jtjd�|_d|_n8t|t�rP|jtjd�|_|jjtjd�|_n
t	�
d��dS)Nr5z:SealedBox must be created from a PublicKey or a PrivateKey)r
r
r9rr-rr/r.rrr)rZ
recipient_keyrrrr.s
�
��
zSealedBox.__init__cCs|jSrrrrrrr=szSealedBox.__bytes__cCstj�||j�}|�|�}|S)ay
        Encrypts the plaintext message using a random-generated ephemeral
        keypair and returns a "composed ciphertext", containing both
        the public part of the keypair and the ciphertext proper,
        encoded with the encoder.

        The private part of the ephemeral key-pair will be scrubbed before
        returning the ciphertext, therefore, the sender will not be able to
        decrypt the generated ciphertext.

        :param plaintext: [:class:`bytes`] The plaintext message to encrypt
        :param encoder: The encoder to use to encode the ciphertext
        :return bytes: encoded ciphertext
        )r#r$Zcrypto_box_sealrr9)rr>rr@rArrrrB@s�
zSealedBox.encryptcCs"|�|�}tj�||j|j�}|S)ar
        Decrypts the ciphertext using the ephemeral public key enclosed
        in the ciphertext and the SealedBox private key, returning
        the plaintext message.

        :param ciphertext: [:class:`bytes`] The encrypted message to decrypt
        :param encoder: The encoder used to decode the ciphertext.
        :return bytes: The original plaintext
        )rr#r$Zcrypto_box_seal_openrr/)rr@rr>rrrrCYs
�zSealedBox.decryptN)
r)r*r+r,rrrr-rBrCrrrrrEs
rE)Z
__future__rrrZ
nacl.bindingsr#rrrZ
nacl.utilsrrr	Z	Encodable�objectr
r.r8rErrrr�<module>s(X