403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.206
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/lib/python3/dist-packages/nacl/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /usr/lib/python3/dist-packages/nacl/__pycache__/public.cpython-310.pyc
o

��a�9�@s�ddlmZmZmZmZmZddlZddlmZddlm	Z
ddlmZddl
mZmZmZGdd�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�eZdZUdZejjZee	e
d<ejfde
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|jt�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/lib/python3/dist-packages/nacl/public.py�__init__$s
���zPublicKey.__init__�returncC�|jS�N�r�rrrr�	__bytes__4�zPublicKey.__bytes__cCstt|��Sr )�hashrr"rrr�__hash__7szPublicKey.__hash__�othercCs&t||j�sdStj�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�eZdZUdZejjZee	e
d<ejjZee	e
d<e
jfdede
jfdd�Zee
jfdede
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_seedcCrr )r@r"rrrr#�r$zPrivateKey.__bytes__cCstt|�t|j�f�Sr )r%�typerrr"rrrr&�szPrivateKey.__hash__r'cCst||j�sdS|j|jkSr()rr)rr-rrrr.�szPrivateKey.__eq__cCr/r rr-rrrr0�r1zPrivateKey.__ne__cCs|ttj�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�eZdZUdZejjZee	e
d<ee
d<dede
fdd�Zdefd	d
�Zeejfdeed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__rcCrr �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|dur	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rQrrrr*r+�crypto_box_afternmrRrTr
�_from_parts)rrYrZr�
ciphertext�
encoded_nonce�encoded_ciphertextrrr�encrypt�s$
��

�zBox.encryptr^cCsb|�|�}|dur|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[)	rrQrrrr*r+�crypto_box_open_afternmrR)rr^rZrrYrrr�decrypt
s
��zBox.decryptcCr)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_key3szBox.shared_key)r2r3r4r5r*r+�crypto_box_NONCEBYTESrQrr7r8rr<r
rr#rMrr9rrNr	rrr
rarcrdrrrrrO�sP
���������
�.����
�&�_Keyc	@s�eZdZUdZeed<eeed<defdd�Zdefdd	�Z	e
jfd
ede
jdefdd
�Z
e
jfdddede
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)rrhrrrrZs
�

���zSealedBox.__init__rcCrr r!r"rrrr#lr$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`rrrraos
zSealedBox.encryptrzSealedBox[PrivateKey]r^cCs4|�|�}|jdurtd��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	rarcrrrrrgEs0
���
������rg)�typingrrrrr�
nacl.bindingsr*rrr�
nacl.encodingr	�
nacl.utilsr
rr�	Encodabler
r<rNrOrfrgrrrr�<module>s
,g

Youez - 2016 - github.com/yon3zu
LinuXploit