
    }tf                       d Z ddlmZ ddlmZ ddlmZ ddlmZm	Z	 ddl
mZ ddlmZmZmZ g d	Ze	j"                  Z	  G d
 de      Zef	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddZef	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddZddZddZddZy)a>  
Low-level functions if you want to build your own higher level abstractions.

.. warning::
    This is a "Hazardous Materials" module.  You should **ONLY** use it if
    you're 100% absolutely sure that you know what you're doing because this
    module is full of land mines, dragons, and dinosaurs with laser guns.
    )annotations)Enum)Any)ffilib   )Literal)HashingErrorVerificationErrorVerifyMismatchError)ARGON2_VERSIONTyper   hash_secrethash_secret_rawverify_secretc                  X    e Zd ZdZej
                  Zej                  Zej                  Z
y)r   zX
    Enum of Argon2 variants.

    Please see :doc:`parameters` on how to pick one.
    N)__name__
__module____qualname____doc__r   Argon2_dDArgon2_iI	Argon2_idID     Z/var/www/html/software/conda/envs/higlass/lib/python3.12/site-packages/argon2/low_level.pyr   r   )   s$     	AA	Br   r   c                   t        j                  |||t        |      ||j                        dz   }t	        j
                  d|      }	t        j                  |||t	        j
                  d|       t        |       t	        j
                  d|      t        |      t        j                  ||	||j                  |      }
|
t         j                  k7  rt        t        |
            t	        j                  |	      S )a  
    Hash *secret* and return an **encoded** hash.

    An encoded hash can be directly passed into :func:`verify_secret` as it
    contains all parameters and the salt.

    :param bytes secret: Secret to hash.
    :param bytes salt: A salt_.  Should be random and different for each
        secret.
    :param Type type: Which Argon2 variant to use.
    :param int version: Which Argon2 version to use.

    For an explanation of the Argon2 parameters see
    :class:`argon2.PasswordHasher`.

    :rtype: bytes

    :raises argon2.exceptions.HashingError: If hashing fails.

    .. versionadded:: 16.0.0

    .. _salt: https://en.wikipedia.org/wiki/Salt_(cryptography)
    .. _kibibytes: https://en.wikipedia.org/wiki/Binary_prefix#kibi
    r   char[]	uint8_t[])r   argon2_encodedlenlenvaluer   newargon2_hashNULL	ARGON2_OKr
   error_to_strstring)secretsalt	time_costmemory_costparallelismhash_lentypeversionsizebufrvs              r   r   r   5   s    F 	IJJ	
 	 	 ''(D
!C	V$FT"D	


B 
S]]<+,,::c?r   c                   t        j                  d|      }t        j                  |||t        j                  d|       t	        |       t        j                  d|      t	        |      ||t         j
                  d|j                  |      }	|	t        j                  k7  rt        t        |	            t        t        j                  ||            S )z
    Hash *password* and return a **raw** hash.

    This function takes the same parameters as :func:`hash_secret`.

    .. versionadded:: 16.0.0
    r"   r   )r   r&   r   r'   r$   r(   r%   r)   r
   r*   bytesbuffer)
r,   r-   r.   r/   r0   r1   r2   r3   r5   r6   s
             r   r   r   x   s    " ''+x
(C	V$FT"D		


B 
S]]<+,,C*++r   c                F   t        j                  t        j                  d|       t        j                  d|      t	        |      |j
                        }|t         j                  k(  ry|t         j                  k(  rt        t        |            t        t        |            )a8  
    Verify whether *secret* is correct for *hash* of *type*.

    :param bytes hash: An encoded Argon2 hash as returned by
        :func:`hash_secret`.
    :param bytes secret: The secret to verify whether it matches the one
        in *hash*.
    :param Type type: Type for *hash*.

    :raises argon2.exceptions.VerifyMismatchError: If verification fails
        because *hash* is not valid for *secret* of *type*.
    :raises argon2.exceptions.VerificationError: If verification fails for
        other reasons.

    :return: ``True`` on success, raise
        :exc:`~argon2.exceptions.VerificationError` otherwise.
    :rtype: bool

    .. versionadded:: 16.0.0
    .. versionchanged:: 16.1.0
        Raise :exc:`~argon2.exceptions.VerifyMismatchError` on mismatches
        instead of its more generic superclass.
    r!   r"   T)r   argon2_verifyr   r&   r$   r%   r)   ARGON2_VERIFY_MISMATCHr   r*   r   )hashr,   r2   r6   s       r   r   r      s}    0 
		$V$F

	
B 
S]]	S'''!,r"233
L,
--r   c                .    t        j                  | |      S )a  
    Direct binding to the ``argon2_ctx`` function.

    .. warning::
        This is a strictly advanced function working on raw C data structures.
        Both Argon2's and *argon2-cffi*'s higher-level bindings do a lot of
        sanity checks and housekeeping work that *you* are now responsible for
        (e.g. clearing buffers). The structure of the *context* object can,
        has, and will change with *any* release!

        Use at your own peril; *argon2-cffi* does *not* use this binding
        itself.

    :param context: A CFFI Argon2 context object (i.e. an ``struct
        Argon2_Context`` / ``argon2_context``).
    :param int type: Which Argon2 variant to use.  You can use the ``value``
        field of :class:`Type`'s fields.

    :rtype: int
    :return: An Argon2 error code.  Can be transformed into a string using
        :func:`error_to_str`.

    .. versionadded:: 16.0.0
    )r   
argon2_ctx)contextr2   s     r   corerA      s    2 >>'4((r   c                p    t        j                  t        j                  |             j	                  d      S )z
    Convert an Argon2 error code into a native string.

    :param int error: An Argon2 error code as returned by :func:`core`.

    :rtype: str

    .. versionadded:: 16.0.0
    ascii)r   r+   r   argon2_error_messagedecode)errors    r   r*   r*      s)     ::c..u56==gFFr   N)r,   r8   r-   r8   r.   intr/   rG   r0   rG   r1   rG   r2   r   r3   rG   returnr8   )r=   r8   r,   r8   r2   r   rH   zLiteral[True])r@   r   r2   rG   rH   rG   )rF   rG   rH   str)r   
__future__r   enumr   typingr   _argon2_cffi_bindingsr   r   _typingr	   
exceptionsr
   r   r   __all__ARGON2_VERSION_NUMBERr   r   r   r   r   rA   r*   r   r   r   <module>rR      s#   #   *  L L **	4 	( "@@
@ @ 	@
 @ @ @ @ @V "%,%,
%, %, 	%,
 %, %, %, %, %,P%.P)8
Gr   