
    7g                         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dS )    N)ffilib)ensureinp1inp2returnc                 j   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    }|o|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          M/var/www/html/syslog/venv/lib/python3.11/site-packages/nacl/bindings/utils.pyr   r      s     :dE""CM::::
:dE""CM::::	SYYD			"	"B79b!!D79b!!DKdCII&&&KdCII&&&
d))s4yy
 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777
:i%%s}====A~~nFFEIE
'$e
,
,CGK##EKQ	sE9e	<	<B
27%s????:c58$$QQQ''r   c                    t          t          | t                    t          j                   t          t          |t
                    t          j                   t          |           }t          j        dd          }t          j
        || ||          }|dk    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777
:i%%s}====FFEGK##E		%E9	5	5B	Qwwo1222ZuQxZ=r   inpc                 6   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   s     :c5!!3=9999	SB
'$b
)
)CKS"b!!!:c2qqq!!r   abc                 B   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777
:a7777	QB
3q66R<////G&++EG&++EKq"Kq"N5%$$$: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   