
    nhf(                     4   U d dl mZ d dlmZ d dlmZmZ d dlm	Z	  ej                         Zeed<    ej                         dz  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<   deeef   fdZdedeeef   fdZdededefdZdededefdZdedefdZdedefdZdedefdZdedefdZ G d d      Z de dedd 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_sign_BYTES   crypto_sign_SEEDBYTEScrypto_sign_PUBLICKEYBYTEScrypto_sign_SECRETKEYBYTEScrypto_sign_curve25519_BYTES crypto_sign_ed25519ph_STATEBYTES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 )zu
    Returns a randomly generated public key and secret key.

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

21215

21215     seedc                    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 )z
    Computes and returns the public key and secret key using the seed ``seed``.

    :param seed: bytes
    :rtype: (bytes(public_key), bytes(secret_key))
    zInvalid seedr   r   r   r   N)lenr
   r   
ValueErrorr   r   r   r   r   crypto_sign_seed_keypairr   r   r   )r   r   r   r   s       r   r#   r#   2   s     4y))nn^,,	"$>	?B	"$>	?B		%	%b"d	3B
27.8H8HI 	

21215

21215 r   messager   c                 2   t        j                  dt        |       t        z         }t        j                  d      }t	        j
                  ||| t        |       |      }t        |dk(  dt        j                         t        j                  ||d         dd S )z
    Signs the message ``message`` using the secret key ``sk`` and returns the
    signed message.

    :param message: bytes
    :param sk: bytes
    :rtype: bytes
    r   unsigned long long *r   r   r   N)
r   r   r!   r   r   crypto_signr   r   r   r   )r$   r   signed
signed_lenr   s        r   r'   r'   H   sy     WW&G7H(HIF/0J	Wc'lB	GB
27.8H8HI::fjm,Q//r   r(   r   c                    t        j                  dt        |             }t        j                  d      }t        j                  ||| t        |       |      dk7  rt        j                  d      t        j                  ||d         dd S )z
    Verifies the signature of the signed message ``signed`` using the public
    key ``pk`` and returns the unsigned message.

    :param signed: bytes
    :param pk: bytes
    :rtype: bytes
    r   r&   r   Signature was forged or corruptN)r   r   r!   r   crypto_sign_openr   BadSignatureErrorr   )r(   r   r$   message_lens       r   r,   r,   Z   sz     gg'V5G''01K 	Wk63v;K	 ##$EFF::g{1~.q11r   public_key_bytesc                 $   t        |       t        k7  rt        j                  d      t        }t        j                  d|      }t        j                  ||       }t        |dk(  dt        j                         t        j                  ||      dd S )a  
    Converts a public Ed25519 key (encoded as bytes ``public_key_bytes``) to
    a public Curve25519 key as bytes.

    Raises a ValueError if ``public_key_bytes`` is not of length
    ``crypto_sign_PUBLICKEYBYTES``

    :param public_key_bytes: bytes
    :rtype: bytes
    zInvalid curve public keyr   r   r   r   N)r!   r   r   r"   r   r   r   r   $crypto_sign_ed25519_pk_to_curve25519r   r   r   )r/   curve_public_key_lencurve_public_keyr   s       r   r1   r1   o         ::nn7887ww02FG		1	1*
B 27.8H8HI::&(<=a@@r   secret_key_bytesc                 $   t        |       t        k7  rt        j                  d      t        }t        j                  d|      }t        j                  ||       }t        |dk(  dt        j                         t        j                  ||      dd S )a  
    Converts a secret Ed25519 key (encoded as bytes ``secret_key_bytes``) to
    a secret Curve25519 key as bytes.

    Raises a ValueError if ``secret_key_bytes``is not of length
    ``crypto_sign_SECRETKEYBYTES``

    :param secret_key_bytes: bytes
    :rtype: bytes
    zInvalid curve secret keyr   r   r   r   N)r!   r   r   r"   r   r   r   r   $crypto_sign_ed25519_sk_to_curve25519r   r   r   )r5   curve_secret_key_lencurve_secret_keyr   s       r   r7   r7      r4   r   c                 b    t        |       t        k7  rt        j                  d      | t        d S )a	  
    Extract the public Ed25519 key from a secret Ed25519 key (encoded
    as bytes ``secret_key_bytes``).

    Raises a ValueError if ``secret_key_bytes``is not of length
    ``crypto_sign_SECRETKEYBYTES``

    :param secret_key_bytes: bytes
    :rtype: bytes
    Invalid secret keyNr!   r   r   r"   r
   r5   s    r   crypto_sign_ed25519_sk_to_pkr>      s2      ::nn1221233r   c                 b    t        |       t        k7  rt        j                  d      | dt         S )z
    Extract the seed from a secret Ed25519 key (encoded
    as bytes ``secret_key_bytes``).

    Raises a ValueError if ``secret_key_bytes``is not of length
    ``crypto_sign_SECRETKEYBYTES``

    :param secret_key_bytes: bytes
    :rtype: bytes
    r;   Nr<   r=   s    r   crypto_sign_ed25519_sk_to_seedr@      s2      ::nn1222233r   c                       e Zd ZdZdgZddZy)crypto_sign_ed25519ph_statezO
    State object wrapping the sha-512 state used in ed25519ph computation
    stateNc                     t        j                  dt              | _        t	        j
                  | j                        }t        |dk(  dt        j                         y )Nr   r   r   r   )	r   r   r   rC   r   crypto_sign_ed25519ph_initr   r   r   )selfr   s     r   __init__z$crypto_sign_ed25519ph_state.__init__   sE    GG?

 ++DJJ7rQw2C<L<LMr   )r   N)__name__
__module____qualname____doc__	__slots__rG    r   r   rB   rB      s     	INr   rB   edphpmsgNc                 >   t        t        | t              dt        j                         t        t        |t
              dt        j                         t        j                  | j                  |t        |            }t        |dk(  dt        j                         y)z
    Update the hash state wrapped in edph

    :param edph: the ed25519ph state being updated
    :type edph: crypto_sign_ed25519ph_state
    :param pmsg: the partial message
    :type pmsg: bytes
    :rtype: None
    /edph parameter must be a ed25519ph_state objectr   z%pmsg parameter must be a bytes objectr   r   N)r   
isinstancerB   r   	TypeErrorbytesr   crypto_sign_ed25519ph_updaterC   r!   r   )rN   rO   r   s      r   rU   rU      st     4459
 4/
 
	)	)$**dCI	FB
27.8H8HIr   c                 4   t        t        | t              dt        j                         t        t        |t
              dt        j                         t        t        |      t        k(  dj                  t              t        j                         t        j                  dt              }t        j                  | j                  |t        j                  |      }t        |dk(  dt        j                          t        j"                  |t              dd S )	aR  
    Create a signature for the data hashed in edph
    using the secret key sk

    :param edph: the ed25519ph state for the data
                 being signed
    :type edph: crypto_sign_ed25519ph_state
    :param sk: the ed25519 secret part of the signing key
    :type sk: bytes
    :return: ed25519ph signature
    :rtype: bytes
    rQ   r   z+secret key parameter must be a bytes objectz secret key must be {} bytes longr   r   r   N)r   rR   rB   r   rS   rT   r!   r   formatr   r   r   r   "crypto_sign_ed25519ph_final_createrC   NULLr   r   )rN   r   	signaturer   s       r   rX   rX      s     4459
 2u5
 B--	+33&	
  )+<=I		/	/

Isxx
B 27.8H8HI::i!23A66r   rZ   c                 r   t        t        | t              dt        j                         t        t        |t
              dt        j                         t        t        |      t        k(  dj                  t              t        j                         t        t        |t
              dt        j                         t        t        |      t        k(  dj                  t              t        j                         t        j                  | j                  ||      }|dk7  rt        j                  d      y	)
a  
    Verify a prehashed signature using the public key pk

    :param edph: the ed25519ph state for the data
                 being verified
    :type edph: crypto_sign_ed25519ph_state
    :param signature: the signature being verified
    :type signature: bytes
    :param pk: the ed25519 public part of the signing key
    :type pk: bytes
    :return: True if the signature is valid
    :rtype: boolean
    :raises exc.BadSignatureError: if the signature is not valid
    rQ   r   z*signature parameter must be a bytes objectzsignature must be {} bytes longz+public key parameter must be a bytes objectz public key must be {} bytes longr   r+   T)r   rR   rB   r   rS   rT   r!   r   rW   r   r   "crypto_sign_ed25519ph_final_verifyrC   r-   )rN   rZ   r   r   s       r   r\   r\     s    " 4459
 9e$4
 I++	*223DE
 2u5
 B--	+33&	
  
	/	/

Ir	JB	Qw##$EFFr   )%typingr   naclr   r   nacl._sodiumr   r   nacl.exceptionsr   crypto_sign_bytesr   int__annotations__crypto_sign_secretkeybytesr
   crypto_sign_publickeybytesr   r   crypto_box_secretkeybytesr    crypto_sign_ed25519ph_statebytesr   rT   r   r#   r'   r,   r1   r7   r>   r@   rB   rU   rX   boolr\   rM   r   r   <module>ri      s    " ! " /..0 3 0;S;;=B s B"@#"@"@"B C B"@#"@"@"B C B$AC$A$A$C c C(L(L(L(N  # NU5%<0 $5 U5%<-@ ,0 0E 0e 0$2U 2 2% 2*A5 AU A2A5 AU A245 4U 4"4U 4u 4"N N"J
%J-2J	J4&7
%&7+0&7
&7R0
%0270=B0	0r   