HEX

File: //usr/lib/python3/dist-packages/nacl/__pycache__/signing.cpython-38.pyc
U

�֫[��@s�ddlmZmZmZddlZddlmZddlmZddl	m
ZmZ
ddlmZmZGdd�de�ZGd	d
�d
ejee�ZGdd�dejee�ZdS)
�)�absolute_import�division�print_functionN)�encoding)�
exceptions)�
PrivateKey�	PublicKey)�StringFixer�randomc@s4eZdZdZedd��Zedd��Zedd��ZdS)	�
SignedMessagezc
    A bytes subclass that holds a messaged that has been signed by a
    :class:`SigningKey`.
    cCs||�}||_||_|S�N)�
_signature�_message)�cls�	signature�messageZcombined�obj�r�./usr/lib/python3/dist-packages/nacl/signing.py�_from_partsszSignedMessage._from_partscCs|jS)zL
        The signature contained within the :class:`SignedMessage`.
        )r
��selfrrrr&szSignedMessage.signaturecCs|jS)zJ
        The message contained within the :class:`SignedMessage`.
        )rrrrrr-szSignedMessage.messageN)	�__name__�
__module__�__qualname__�__doc__�classmethodr�propertyrrrrrrrs

rc@sVeZdZdZejfdd�Zdd�Zdd�Zdd	�Z	d
d�Z
dejfd
d�Zdd�ZdS)�	VerifyKeyz�
    The public key counterpart to an Ed25519 SigningKey for producing digital
    signatures.

    :param key: [:class:`bytes`] Serialized Ed25519 public key
    :param encoder: A class that is able to decode the `key`
    cCsJ|�|�}t|t�st�d��t|�tjjkr@t�	dtjj��||_
dS)Nz'VerifyKey must be created from 32 bytesz%The key must be exactly %s bytes long)�decode�
isinstance�bytes�exc�	TypeError�len�nacl�bindingsZcrypto_sign_PUBLICKEYBYTES�
ValueError�_key)r�key�encoderrrr�__init__>s


��zVerifyKey.__init__cCs|jSr)r(rrrr�	__bytes__LszVerifyKey.__bytes__cCstt|��Sr��hashr!rrrr�__hash__OszVerifyKey.__hash__cCs&t||j�sdStj�t|�t|��S�NF�r �	__class__r%r&Z
sodium_memcmpr!�r�otherrrr�__eq__RszVerifyKey.__eq__cCs
||kSrrr3rrr�__ne__WszVerifyKey.__ne__NcCs*|dk	r||}|�|�}tj�||j�S)aS
        Verifies the signature of a signed message, returning the message
        if it has not been tampered with else raising
        :class:`~nacl.signing.BadSignatureError`.

        :param smessage: [:class:`bytes`] Either the original messaged or a
            signature and message concated together.
        :param signature: [:class:`bytes`] If an unsigned message is given for
            smessage then the detached signature must be provided.
        :param encoder: A class that is able to decode the secret message and
            signature.
        :rtype: :class:`bytes`
        N)rr%r&Zcrypto_sign_openr()rZsmessagerr*rrr�verifyZs
zVerifyKey.verifycCstj�|j�}t|�S)z�
        Converts a :class:`~nacl.signing.VerifyKey` to a
        :class:`~nacl.public.PublicKey`

        :rtype: :class:`~nacl.public.PublicKey`
        )r%r&Z$crypto_sign_ed25519_pk_to_curve25519r(�_Curve25519_PublicKey)rZraw_pkrrr�to_curve25519_public_keyrsz"VerifyKey.to_curve25519_public_key)
rrrrr�
RawEncoderr+r,r/r5r6r7r9rrrrr5src@s`eZdZdZejfdd�Zdd�Zdd�Zdd	�Z	d
d�Z
edd
��Zejfdd�Z
dd�ZdS)�
SigningKeya�
    Private key for producing digital signatures using the Ed25519 algorithm.

    Signing keys are produced from a 32-byte (256-bit) random seed value. This
    value can be passed into the :class:`~nacl.signing.SigningKey` as a
    :func:`bytes` whose length is 32.

    .. warning:: This **must** be protected and remain secret. Anyone who knows
        the value of your :class:`~nacl.signing.SigningKey` or it's seed can
        masquerade as you.

    :param seed: [:class:`bytes`] Random 32-byte value (i.e. private key)
    :param encoder: A class that is able to decode the seed

    :ivar: verify_key: [:class:`~nacl.signing.VerifyKey`] The verify
        (i.e. public) key that corresponds with this signing key.
    cCsj|�|�}t|t�st�d��t|�tjjkr@t�	dtjj��tj�
|�\}}||_||_t
|�|_dS)Nz.SigningKey must be created from a 32 byte seedz&The seed must be exactly %d bytes long)rr r!r"r#r$r%r&�crypto_sign_SEEDBYTESr'Zcrypto_sign_seed_keypair�_seed�_signing_keyrZ
verify_key)rZseedr*Z
public_keyZ
secret_keyrrrr+�s

���zSigningKey.__init__cCs|jSr)r=rrrrr,�szSigningKey.__bytes__cCstt|��Srr-rrrrr/�szSigningKey.__hash__cCs&t||j�sdStj�t|�t|��Sr0r1r3rrrr5�szSigningKey.__eq__cCs
||kSrrr3rrrr6�szSigningKey.__ne__cCs|ttjj�tjd�S)z�
        Generates a random :class:`~nacl.signing.SigningKey` object.

        :rtype: :class:`~nacl.signing.SigningKey`
        )r*)r
r%r&r<rr:)rrrr�generate�s
�zSigningKey.generatecCsTtj�||j�}tjj}|�|d|��}|�||d��}|�|�}t�|||�S)z�
        Sign a message using this key.

        :param message: [:class:`bytes`] The data to be signed.
        :param encoder: A class that is used to encode the signed message.
        :rtype: :class:`~nacl.signing.SignedMessage`
        N)r%r&Zcrypto_signr>�crypto_sign_BYTES�encoderr)rrr*Z
raw_signedr@rZsignedrrr�sign�s
zSigningKey.signcCs|j}tj�|�}t|�S)z�
        Converts a :class:`~nacl.signing.SigningKey` to a
        :class:`~nacl.public.PrivateKey`

        :rtype: :class:`~nacl.public.PrivateKey`
        )r>r%r&Z$crypto_sign_ed25519_sk_to_curve25519�_Curve25519_PrivateKey)rZskZraw_privaterrr�to_curve25519_private_key�sz$SigningKey.to_curve25519_private_keyN)rrrrrr:r+r,r/r5r6rr?rBrDrrrrr;}s
r;)Z
__future__rrrZ
nacl.bindingsr%rrr"Znacl.publicrrCrr8Z
nacl.utilsr	r
r!rZ	Encodable�objectrr;rrrr�<module>sH