
    nh'              
       z   U d dl mZ d dlmZ d dlmZmZ d dlm	Z	 ddgZ
 ej                         Zeed<    ej                         Zeed<    ej"                         Zeed	<    ej&                         Zeed
<    ej*                         Zeed<    ej.                         Zeed<    ej2                         Zeed<    ej6                         Zeed<   deeef   fdZdedeeef   fdZdededededef
dZ dededededef
dZ!dededefdZ"dedededefdZ#dedededefdZ$dededefdZ%dedededefdZ&y )!    )Tuple)
exceptions)ffilib)ensurecrypto_box_keypair
crypto_boxcrypto_box_SECRETKEYBYTEScrypto_box_PUBLICKEYBYTEScrypto_box_SEEDBYTEScrypto_box_NONCEBYTEScrypto_box_ZEROBYTEScrypto_box_BOXZEROBYTEScrypto_box_BEFORENMBYTEScrypto_box_SEALBYTESreturnc                  H   t        j                  dt              } t        j                  dt              }t	        j
                  | |      }t        |dk(  dt        j                         t        j                  | t              dd t        j                  |t              dd fS )zq
    Returns a randomly generated public and secret key.

    :rtype: (bytes(public_key), bytes(secret_key))
    unsigned char[]r   Unexpected library errorraisingN)
r   newr   r
   r   r   r   excRuntimeErrorbuffer)pkskrcs      j/var/www/pru.catia.catastroantioquia-mas.com/tasa/lib/python3.12/site-packages/nacl/bindings/crypto_box.pyr   r   "   s     
"$=	>B	"$=	>B			B	'B
27.8H8HI 	

201!4

201!4     seedc                    t        t        | t              dt               t	        |       t
        k7  rt        j                  d      t        j                  dt              }t        j                  dt              }t        j                  |||       }t        |dk(  dt        j                         t        j                  |t              dd t        j                  |t              dd fS )a  
    Returns a (public, secret) keypair deterministically generated
    from an input ``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: bytes
    :rtype: (bytes(public_key), bytes(secret_key))
    zseed must be bytesr   zInvalid seedr   r   r   N)r   
isinstancebytes	TypeErrorlenr   r   
ValueErrorr   r   r   r
   r   crypto_box_seed_keypairr   r   )r!   r   r   r   s       r   r(   r(   4   s    " :dE"$8)L
4y((nn^,,	"$=	>B	"$=	>B		$	$RT	2B
27.8H8HI 	

201!4

201!4 r    messagenoncer   r   c                    t        |      t        k7  rt        j                  d      t        |      t        k7  rt        j                  d      t        |      t
        k7  rt        j                  d      dt        z  | z   }t        j                  dt        |            }t        j                  ||t        |      |||      }t        |dk(  dt        j                         t        j                  |t        |            t        d	 S )
z
    Encrypts and returns a message ``message`` using the secret key ``sk``,
    public key ``pk``, and the nonce ``nonce``.

    :param message: bytes
    :param nonce: bytes
    :param pk: bytes
    :param sk: bytes
    :rtype: bytes
    Invalid nonce sizeInvalid public keyInvalid secret key    r   r   r   r   N)r&   r   r   r'   r   r
   r   r   r   r   r	   r   r   r   r   )r)   r*   r   r   padded
ciphertextr   s          r   r	   r	   V   s     5z**nn122
2w++nn122
2w++nn122,,7F*CK8J	
FCKB	GB
27.8H8HI::j#f+./F/GHHr    r1   c                    t        |      t        k7  rt        j                  d      t        |      t        k7  rt        j                  d      t        |      t
        k7  rt        j                  d      dt        z  | z   }t        j                  dt        |            }t        j                  ||t        |      |||      }t        |dk(  dt        j                         t        j                  |t        |            t        d	 S )
a  
    Decrypts and returns an encrypted message ``ciphertext``, using the secret
    key ``sk``, public key ``pk``, and the nonce ``nonce``.

    :param ciphertext: bytes
    :param nonce: bytes
    :param pk: bytes
    :param sk: bytes
    :rtype: bytes
    r,   r-   r.   r/   r   r   /An error occurred trying to decrypt the messager   N)r&   r   r   r'   r   r
   r   r   r   r   crypto_box_openr   CryptoErrorr   r   )r1   r*   r   r   r0   	plaintextress          r   r4   r4   s   s     5z**nn122
2w++nn122
2w++nn122//:=F)3v;7I


iVeR
LC
q9 ::iV-.B.CDDr    c                 x   t        |       t        k7  rt        j                  d      t        |      t        k7  rt        j                  d      t        j                  dt              }t        j                  || |      }t        |dk(  dt        j                         t        j                  |t              dd S )a  
    Computes and returns the shared key for the public key ``pk`` and the
    secret key ``sk``. This can be used to speed up operations where the same
    set of keys is going to be used multiple times.

    :param pk: bytes
    :param sk: bytes
    :rtype: bytes
    r-   r.   r   r   r   r   N)r&   r   r   r'   r
   r   r   r   r   crypto_box_beforenmr   r   r   )r   r   kr   s       r   r9   r9      s     2w++nn122
2w++nn122!#;<A		 	 B	+B
27.8H8HI::a12155r    r:   c                    t        |      t        k7  rt        j                  d      t        |      t        k7  rt        j                  d      dt
        z  | z   }t        j                  dt        |            }t        j                  ||t        |      ||      }t        |dk(  dt        j                         t        j                  |t        |            t        d S )	z
    Encrypts and returns the message ``message`` using the shared key ``k`` and
    the nonce ``nonce``.

    :param message: bytes
    :param nonce: bytes
    :param k: bytes
    :rtype: bytes
    Invalid nonceInvalid shared keyr/   r   r   r   r   N)r&   r   r   r'   r   r   r   r   r   crypto_box_afternmr   r   r   r   )r)   r*   r:   r0   r1   r   s         r   r>   r>      s     5z**nn_--
1v))nn122++g5F*CK8J			
FCK	JB
27.8H8HI::j#f+./F/GHHr    c                    t        |      t        k7  rt        j                  d      t        |      t        k7  rt        j                  d      dt
        z  | z   }t        j                  dt        |            }t        j                  ||t        |      ||      }t        |dk(  dt        j                         t        j                  |t        |            t        d S )	z
    Decrypts and returns the encrypted message ``ciphertext``, using the shared
    key ``k`` and the nonce ``nonce``.

    :param ciphertext: bytes
    :param nonce: bytes
    :param k: bytes
    :rtype: bytes
    r<   r=   r/   r   r   r3   r   N)r&   r   r   r'   r   r   r   r   r   crypto_box_open_afternmr   r5   r   r   )r1   r*   r:   r0   r6   r7   s         r   r@   r@      s     5z**nn_--
1v))nn122//:=F)3v;7I

%
%iVeQ
OC
q9 ::iV-.B.CDDr    c                    t        t        | t              dt               t        t        |t              dt               t	        |      t
        k7  rt        j                  d      t	        |       }t        |z   }t        j                  d|      }t        j                  || ||      }t        |dk(  dt        j                         t        j                  ||      dd S )	a  
    Encrypts and returns a message ``message`` using an ephemeral secret key
    and the public key ``pk``.
    The ephemeral public key, which is embedded in the sealed box, is also
    used, in combination with ``pk``, to derive the nonce needed for the
    underlying box construct.

    :param message: bytes
    :param pk: bytes
    :rtype: bytes

    .. versionadded:: 1.2
    zinput message must be bytesr   public key must be bytesr-   r   r   r   N)r   r#   r$   r%   r&   r   r   r'   r   r   r   r   crypto_box_sealr   r   )r)   r   _mlen_clenr1   r   s         r   rC   rC      s     7E"% 2u99 2w++nn122LE 5(E*E2J			Z%	<B
27.8H8HI::j%(++r    c                    t        t        | t              dt               t        t        |t              dt               t        t        |t              dt               t	        |      t
        k7  rt        j                  d      t	        |      t        k7  rt        j                  d      t	        |       }t        |t        k\  dj                  t              t        j                         |t        z
  }t        j                  dt        d	|            }t        j                  || |||      }t        |d
k(  dt        j                          t        j"                  ||      dd S )a  
    Decrypts and returns an encrypted message ``ciphertext``, using the
    recipent's secret key ``sk`` and the sender's ephemeral public key
    embedded in the sealed box. The box contruct nonce is derived from
    the recipient's public key ``pk`` and the sender's public key.

    :param ciphertext: bytes
    :param pk: bytes
    :param sk: bytes
    :rtype: bytes

    .. versionadded:: 1.2
    zinput ciphertext must be bytesr   rB   zsecret key must be bytesr-   r.   z)Input cyphertext must be at least {} longr      r   r3   N)r   r#   r$   r%   r&   r   r   r'   r
   r   formatr   r   maxr   crypto_box_seal_openr5   r   )r1   r   r   rE   rD   r6   r7   s          r   rJ   rJ     s-    :u%( 2u99 2u99 2w++nn122
2w++nn122
OE
%%	4<< 	
  ((E )3q%=9I

"
"9j%R
HC
q9 ::i'**r    N)'typingr   naclr   r   nacl._sodiumr   r   nacl.exceptionsr   __all__crypto_box_secretkeybytesr
   int__annotations__crypto_box_publickeybytesr   crypto_box_seedbytesr   crypto_box_noncebytesr   crypto_box_zerobytesr   crypto_box_boxzerobytesr   crypto_box_beforenmbytesr   crypto_box_sealbytesr   r$   r   r(   r	   r4   r9   r>   r@   rC   rJ    r    r   <module>r[      s    " ! "  
. "?!>!>!@ 3 @!>!>!>!@ 3 @4C446 c 66S668 s 84C446 c 6:s::<  < < < < > # >4C446 c 6E%,/ $% E%,,? DI Ie I IE Ie I: E E# E). E49 E
 EF6E 6u 6 60I Ie I I% I2EE#E(-E
E>#,U #, #,% #,L8+U 8+ 8+5 8+U 8+r    