
    Mh                         d dl mZ d dlmZmZ d dl mZ dedede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defdZy)    N)ffilib)ensureinp1inp2returnc                 (   t        t        | t              t        j                         t        t        |t              t        j                         t        t        |       t        |            }t        j                  d|      }t        j                  d|      }t        j                  || t        |              t        j                  ||t        |             t        |       t        |      k(  }t        j                  |||      dk(  }|xr |S )zA
    Compare contents of two memory regions in constant time
    raisingzchar []r   )r   
isinstancebytesexc	TypeErrormaxlenr   newmemmover   sodium_memcmp)r   r   lnbuf1buf2eqLeqCs          k/var/www/pru.catia.catastroantioquia-mas.com/valormasv2/lib/python3.12/site-packages/nacl/bindings/utils.pyr   r      s     :dE"CMM:
:dE"CMM:	SYD		"B779b!D779b!DKKdCI&KKdCI&
d)s4y
 C


D$
+q
0C;3    s	blocksizec                    t        t        | t              t        j                         t        t        |t
              t        j                         |dk  rt        j                  t        |       }||z   }t        j                  d|      }t        j                  dd      }t        j                  || |       t        j                  |||||      }t        |dk(  dt        j                         t        j                  ||d         dd S )z
    Pad the input bytearray ``s`` to a multiple of ``blocksize``
    using the ISO/IEC 7816-4 algorithm

    :param s: input bytes string
    :type s: bytes
    :param blocksize:
    :type blocksize: int
    :return: padded string
    :rtype: bytes
    r
   r   unsigned char []	size_t []   zPadding failureN)r   r   r   r   r   int
ValueErrorr   r   r   r   r   
sodium_padCryptoErrorbuffer)r   r   s_lenm_lenbufp_lenrcs          r   r$   r$   )   s     :a7
:i%s}}=A~nnFEIE
''$e
,CGGK#EKKQ	sE9e	<B
27%s?::c58$Q''r   c                 \   t        t        | t              t        j                         t        t        |t
              t        j                         t        |       }t        j                  dd      }t        j                  || ||      }|dk7  rt        j                  d      | d|d    S )z
    Remove ISO/IEC 7816-4 padding from the input byte array ``s``

    :param s: input bytes string
    :type s: bytes
    :param blocksize:
    :type blocksize: int
    :return: unpadded string
    :rtype: bytes
    r
   r    r!   r   zUnpadding failureN)r   r   r   r   r   r"   r   r   r   r   sodium_unpadr%   )r   r   r'   u_lenr+   s        r   r-   r-   C   s     :a7
:i%s}}=FEGGK#E			%E9	5B	Qwoo122ZuQx=r   inpc                 "   t        t        | t              t        j                         t        |       }t        j                  d|      }t        j                  || |       t        j                  ||       t        j                  ||      dd S )ag  
    Increment the value of a byte-sequence interpreted
    as the little-endian representation of a unsigned big integer.

    :param inp: input bytes buffer
    :type inp: bytes
    :return: a byte-sequence representing, as a little-endian
             unsigned big integer, the value ``to_int(inp)``
             incremented by one.
    :rtype: bytes

    r
   r   N)r   r   r   r   r   r   r   r   r   r   sodium_incrementr&   )r/   r   r)   s      r   r1   r1   X   si     :c5!3==9	SB
''$b
)CKKS"b!::c2q!!r   abc                    t        t        | t              t        j                         t        t        |t              t        j                         t        |       }t        t        |      |k(  t        j                         t        j                  d|      }t        j                  d|      }t        j                  || |       t        j                  |||       t        j                  |||       t        j                  ||      dd S )a  
    Given a couple of *same-sized* byte sequences, interpreted as the
    little-endian representation of two unsigned integers, compute
    the modular addition of the represented values, in constant time for
    a given common length of the byte sequences.

    :param a: input bytes buffer
    :type a: bytes
    :param b: input bytes buffer
    :type b: bytes
    :return: a byte-sequence representing, as a little-endian big integer,
             the integer value of ``(to_int(a) + to_int(b)) mod 2^(8*len(a))``
    :rtype: bytes
    r
   r   N)r   r   r   r   r   r   r   r   r   r   
sodium_addr&   )r2   r3   r   buf_abuf_bs        r   r5   r5   q   s     :a7
:a7	QB
3q6R</GG&+EGG&+EKKq"KKq"NN5%$::eR ##r   )nacl.exceptions
exceptionsr   nacl._sodiumr   r   r   r   boolr   r"   r$   r-   r1   r5    r   r   <module>r=      s     ! " U t *(% (C (E (4E c e *"% "E "2$% $E $e $r   