o

�h�9�@s�dd
lm
Z
mZmZmZmZ
ddlZddlmZ
ddlm	Z

ddlmZ
ddl
mZmZmZ
Gdd�deje�ZGd	d
�d
eje�Zeddd
�ZGdd�deje�Zedee�ZGdd�deeeje�ZdS)�)�ClassVar�Generic�Optional�Type�TypeVarN)
�encoding)
�
exceptions)
�Encoder)�EncryptedMessage�StringFixer�randomc@s�eZ
dZUd
ZejjZee	e
d<ejf
de
dejfdd�Zde
fdd	�Zde	fd
d�Zdedefd
d�Zdedefdd�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
    �SIZE�
public_key�encodercCsH|�|
�
|_
t|j
t�st�d
�
�
t|j
�
|jkr"t�d�	|j�
�
�
dS)Nz'PublicKey must be created from 32 bytesz,The public key must be exactly {} bytes long)
�decode�_public_key�
isinstance�bytes�exc�	TypeError�lenr�
ValueError�format)�selfrr�r�>/usr/local/CyberCP/lib/python3.10/site-packages/nacl/public.py�__init__$s





���zPublicKey.__init__�returnc


C�|jS�
N�
r�
rrrr�	__bytes__4�
zPublicKey.__bytes__c

Cstt
|�
�
Sr )�hashrr"rrr�__hash__7s
zPublicKey.__hash__�othercCs&t|
|j
�sd
Stj�t|�
t|
�
�S�NF)r�	__class__�nacl�bindings�
sodium_memcmpr�rr'rrr�__eq__:s


zPublicKey.__eq__cC�
||
kSr rr-rrr�__ne__?�

zPublicKey.__ne__N)�__name__�
__module__�__qualname__�__doc__r*r+�crypto_box_PUBLICKEYBYTESrr�int�__annotations__r�
RawEncoderrr	rr#r&�object�boolr.r0rrrrr
s


��
�r
c@s�eZ
dZUd
ZejjZee	e
d<ejjZee	e
d<e
jf
dede
jfdd�Zee
jf
dede
jd	dfd
d��
Zd	efdd
�Zd	e	fdd�Zded	efdd�Zded	efdd�Zeddd��
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
    r�	SEED_SIZE�private_keyrcCsT|�|
�
}
t
|
t�rt|
�
|jkst�d
�|j�
�
�
tj	�
|
�
}|
|_t|�
|_
dS)Nz>PrivateKey must be created from a {} bytes long raw secret key)rrrrrrrrr*r+�crypto_scalarmult_base�_private_keyr
r)rr>r�raw_public_keyrrrrWs
�
�
zPrivateKey.__init__�seedrcCsL|�|
�
}
t
|
t�rt|
�
|jkst�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`
        z7PrivateKey seed must be a {} bytes long binary sequence)rrrrr=rrrr*r+�crypto_box_seed_keypair)�clsrBr�raw_pk�raw_skrrr�	from_seedns

�zPrivateKey.from_seedc


Crr )
r@r"rrrr#�r$zPrivateKey.__bytes__c

Cstt
|�
t|j�
f�
Sr )r%�typerrr"rrrr&�s
zPrivateKey.__hash__r'cCst|
|j
�sd
S|j|
jkSr()rr)rr-rrrr.�s


zPrivateKey.__eq__cCr/r rr-rrrr0�r1zPrivateKey.__ne__c

Cs|tt
j�
tjd
�S)z~
        Generates a random :class:`~nacl.public.PrivateKey` object

        :rtype: :class:`~nacl.public.PrivateKey`
        �
r)rr<rrr9)
rDrrr�generate�szPrivateKey.generateN)rr<)r2r3r4r5r*r+�crypto_box_SECRETKEYBYTESrrr7r8�crypto_box_SEEDBYTESr=rr9rr	r�classmethodrGr#r&r:r;r.r0rJrrrrr<Cs2


��
�����#
r<�_Box�Box)
�boundc
@s�eZ
dZUd
ZejjZee	e
d<ee
d<dede
fdd�Zdefd	d
�Zeejf
deeded
edefdd��
Zdejfdedeed
ejdefdd�Zdejfdedeed
ejdefdd�Zdefdd�ZdS)rOa/
    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.
    �
NONCE_SIZE�_shared_keyr>rcCsFt|
t
�r
t|t�st�d
�
�
tj�|jt	j
d�
|
jt	j
d�
�|_dS)Nz5Box must be created from a PrivateKey and a PublicKeyrI)rr<r
rrr*r+�crypto_box_beforenm�encoderr9rR)rr>rrrrr�s

�
�


�zBox.__init__rc


Crr �
rRr"rrrr#�r$z
Box.__bytes__rD�encodedrcCs|�|�
}|�
|
�
|_|S)
z[
        Alternative constructor. Creates a Box from an existing Box's shared key.
        )�__new__rrR)rDrVr�boxrrrr�s
z
Box.decodeN�	plaintext�noncecCsn|d
ur	t|j
�
}t|�
|j
krt�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rQrrrr*r+�crypto_box_afternmrRrTr
�_from_parts)rrYrZr�
ciphertext�
encoded_nonce�encoded_ciphertextrrr�encrypt�s$



�


�





�zBox.encryptr^cCsb|�|
�
}
|d
ur|
d
|j
�}|
|j
d
�}
t|�
|j
kr&t�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[)	rrQrrrr*r+�crypto_box_open_afternmrR)rr^rZrrYrrr�decrypt

s



�


�zBox.decryptc


Cr)
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`]
        rUr"rrr�
shared_key3
szBox.shared_key)r2r3r4r5r*r+�crypto_box_NONCEBYTESrQrr7r8rr<r
rr#rMrr9rrNr	rrr
rarcrdrrrrrO�sP


�
�
�
��
����
�.
����
�&�_Keyc	@s�eZ
dZUd
Zeed<eeed<defdd�Zdefdd	�Z	e
jf
d
ede
jdefdd
�Z
e
jf
dddede
jdefdd�ZdS)�	SealedBoxa_
    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 recipient_key: a :class:`~nacl.public.PublicKey` used to encrypt
        messages and derive nonces, or a :class:`~nacl.public.PrivateKey` used
        to decrypt messages.

    .. versionadded:: 1.2
    rr@�
recipient_keycCs^t|
t
�r|
jtjd
�
|_d|_dSt|
t�r*|
jtjd
�
|_|
jjtjd
�
|_dSt	�
d�
�
)NrIz:SealedBox must be created from a PublicKey or a PrivateKey)rr
rTrr9rr@r<rrr)rrhrrrrZ
s



�




�
�
�zSealedBox.__init__rc


Crr r!r"rrrr#l
r$zSealedBox.__bytes__rYrcCstj
�|
|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+�crypto_box_sealrrT)rrYrr^r`rrrrao
s
zSealedBox.encryptrzSealedBox[PrivateKey]r^cCs4|�|
�
}
|j
d
urtd�
�
tj�|
|j|j
�}|S)a
        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
        :raises TypeError: if this SealedBox was created with a
            :class:`~nacl.public.PublicKey` rather than a
            :class:`~nacl.public.PrivateKey`.
        Nz4SealedBoxes created with a public key cannot decrypt)rr@rr*r+�crypto_box_seal_openr)rr^rrYrrrrc�
s



�


�zSealedBox.decryptN)r2r3r4r5rr8rrfrr#rr9r	rarcrrrrrgE
s0


���
��
����rg)�typingrrrrr�
nacl.bindingsr*rrr�
nacl.encodingr	�
nacl.utilsr
rr�	Encodabler
r<rNrOrfrgrrrr�<module>
s




,g