CasperSecurity
o
��a�9 � @ s� d dl mZmZmZmZmZ d dlZd dlmZ d dlm Z
d dl m Z d dl
mZmZmZ G dd� deje�ZG d d
� d
eje�Zed d d
�ZG dd � d eje�Zedee�ZG dd� dee eje�ZdS )� )�ClassVar�Generic�Optional�Type�TypeVarN)�encoding)�
exceptions)�Encoder)�EncryptedMessage� StringFixer�randomc @ s� e Zd ZU dZejjZee e
d< e j fde
de jfdd�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�encoderc C sH |� |�| _t| jt�st�d��t| j�| jkr"t�d� | j���d S )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)�selfr r � r �-/usr/lib/python3/dist-packages/nacl/public.py�__init__$ s
���zPublicKey.__init__�returnc C � | j S �N�r �r r r r � __bytes__4 � zPublicKey.__bytes__c C s t t| ��S r )�hashr r" r r r �__hash__7 s zPublicKey.__hash__�otherc C s& t || j�sdS tj�t| �t|��S �NF)r � __class__�nacl�bindings�
sodium_memcmpr �r r' r r r �__eq__: s zPublicKey.__eq__c C �
| |k S r r r- r r r �__ne__? �
zPublicKey.__ne__N)�__name__�
__module__� __qualname__�__doc__r* r+ �crypto_box_PUBLICKEYBYTESr r �int�__annotations__r �
RawEncoderr r r r# r& �object�boolr. r0 r r r r r
s
��
�r
c @ s� e Zd ZU dZejjZee e
d< ejj Z ee e
d< e
jfdede
jfdd�Zee
jfdede
jd d fd
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_keyr c C sT |� |�}t|t�rt|�| jkst�d�| j���tj �
|�}|| _ t |�| _
d S )Nz>PrivateKey must be created from a {} bytes long raw secret key)r r r r r r r r r* r+ �crypto_scalarmult_base� _private_keyr
r )r r> r �raw_public_keyr r r r W s
�� zPrivateKey.__init__�seedr c C sL |� |�}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) r r r r r= r r r r* r+ �crypto_box_seed_keypair)�clsrB r �raw_pk�raw_skr r r � from_seedn s
�zPrivateKey.from_seedc C r r )r@ r" r r r r# � r$ zPrivateKey.__bytes__c C s t t| �t| j�f�S r )r% �typer r r" r r r r& � s zPrivateKey.__hash__r' c C s t || j�sdS | j|jkS r( )r r) r r- r r r r. � s zPrivateKey.__eq__c C r/ r r r- r r r r0 � r1 zPrivateKey.__ne__c C s | t tj�tjd�S )z~
Generates a random :class:`~nacl.public.PrivateKey` object
:rtype: :class:`~nacl.public.PrivateKey`
�r )r r< r r r9 )rD r r r �generate� s zPrivateKey.generateN)r r< )r2 r3 r4 r5 r* r+ �crypto_box_SECRETKEYBYTESr r r7 r8 �crypto_box_SEEDBYTESr= r r9 r r r � classmethodrG r# r& r: r; r. r0 rJ r r r r r< C s2
��
���� �#r< �_Box�Box)�boundc
@ s� e Zd ZU dZejjZee e
d< e e
d< de de
fdd�Zde fd d
�Zeejfd ee d e d
edefdd��Zdejfde dee d
ejdefdd�Zdejfde dee d
ejde fdd�Zde fdd�ZdS )rO a/
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> r c C sF t |t�r
t |t�st�d��tj�|jt j
d�|jt j
d��| _ d S )Nz5Box must be created from a PrivateKey and a PublicKeyrI ) r r< r
r r r* r+ �crypto_box_beforenm�encoder r9 rR )r r> r r r r r � s ��
�z Box.__init__r c C r r �rR r" r r r r# � r$ z
Box.__bytes__rD �encodedr c C s | � | �}|�|�|_|S )z[
Alternative constructor. Creates a Box from an existing Box's shared key.
)�__new__r rR )rD rV r �boxr r r r � s
z
Box.decodeN� plaintext�noncec C sn |du r t | j�}t|�| jkrt�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 rQ r r r r* r+ �crypto_box_afternmrR rT r
� _from_parts)r rY rZ r �
ciphertext�
encoded_nonce�encoded_ciphertextr r r �encrypt� s$
��
�z Box.encryptr^ c C sb |� |�}|du r|d| j� }|| jd� }t|�| jkr&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[ ) r rQ r r r r* r+ �crypto_box_open_afternmrR )r r^ rZ r rY r r r �decrypt
s
��z Box.decryptc C r )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`]
rU r" r r r �
shared_key3 s zBox.shared_key) r2 r3 r4 r5 r* r+ �crypto_box_NONCEBYTESrQ r r7 r8 r r< r
r r# rM r r9 r rN r r r r
ra rc rd r r r r rO � sP
���� �����
�.����
�&�_Keyc @ s� e Zd ZU dZeed< ee ed< defdd�Zdefdd �Z e
j fd
ed e
j defd d
�Z
e
j fddded e
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
r r@ �
recipient_keyc C s^ t |t�r|jtjd�| _d | _d S t |t�r*|jtjd�| _|jjtjd�| _d S t �
d��)NrI z:SealedBox must be created from a PublicKey or a PrivateKey) r r
rT r r9 r r@ r< r r r )r rh r r r r Z s
�
� ��zSealedBox.__init__r c C r r r! r" r r r r# l r$ zSealedBox.__bytes__rY r c C s t j�|| 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_sealr rT )r rY r r^ r` r r r ra o s
zSealedBox.encryptr zSealedBox[PrivateKey]r^ c C s4 |� |�}| jdu rtd��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)r r@ r r* r+ �crypto_box_seal_openr )r r^ r rY r r r rc � s
��zSealedBox.decryptN)r2 r3 r4 r5 r r8 r rf r r# r r9 r ra rc r r r r rg E s0
���
� �����rg )�typingr r r r r �
nacl.bindingsr* r r r �
nacl.encodingr �
nacl.utilsr
r r � Encodabler
r< rN rO rf rg r r r r �<module> s
, g