File manager

File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/pwhash.zip

Back
PK��Z3�?Q��Q��argon2id.pynu��[��# Copyright 2013 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import nacl.bindings import nacl.encoding from . import _argon2 ALG = _argon2.ALG_ARGON2ID13 STRPREFIX = nacl.bindings.crypto_pwhash_argon2id_STRPREFIX SALTBYTES = _argon2.SALTBYTES PASSWD_MIN = _argon2.PASSWD_MIN PASSWD_MAX = _argon2.PASSWD_MAX PWHASH_SIZE = _argon2.PWHASH_SIZE BYTES_MIN = _argon2.BYTES_MIN BYTES_MAX = _argon2.BYTES_MAX verify = _argon2.verify MEMLIMIT_MIN = nacl.bindings.crypto_pwhash_argon2id_MEMLIMIT_MIN MEMLIMIT_MAX = nacl.bindings.crypto_pwhash_argon2id_MEMLIMIT_MAX OPSLIMIT_MIN = nacl.bindings.crypto_pwhash_argon2id_OPSLIMIT_MIN OPSLIMIT_MAX = nacl.bindings.crypto_pwhash_argon2id_OPSLIMIT_MAX OPSLIMIT_INTERACTIVE = ( nacl.bindings.crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE ) MEMLIMIT_INTERACTIVE = ( nacl.bindings.crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE ) OPSLIMIT_SENSITIVE = nacl.bindings.crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE MEMLIMIT_SENSITIVE = nacl.bindings.crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE OPSLIMIT_MODERATE = nacl.bindings.crypto_pwhash_argon2id_OPSLIMIT_MODERATE MEMLIMIT_MODERATE = nacl.bindings.crypto_pwhash_argon2id_MEMLIMIT_MODERATE def kdf( size: int, password: bytes, salt: bytes, opslimit: int = OPSLIMIT_SENSITIVE, memlimit: int = MEMLIMIT_SENSITIVE, encoder: nacl.encoding.Encoder = nacl.encoding.RawEncoder, ) -> bytes: """ Derive a ``size`` bytes long key from a caller-supplied ``password`` and ``salt`` pair using the argon2i memory-hard construct. the enclosing module provides the constants - :py:const:`.OPSLIMIT_INTERACTIVE` - :py:const:`.MEMLIMIT_INTERACTIVE` - :py:const:`.OPSLIMIT_MODERATE` - :py:const:`.MEMLIMIT_MODERATE` - :py:const:`.OPSLIMIT_SENSITIVE` - :py:const:`.MEMLIMIT_SENSITIVE` as a guidance for correct settings. :param size: derived key size, must be between :py:const:`.BYTES_MIN` and :py:const:`.BYTES_MAX` :type size: int :param password: password used to seed the key derivation procedure; it length must be between :py:const:`.PASSWD_MIN` and :py:const:`.PASSWD_MAX` :type password: bytes :param salt: RANDOM salt used in the key derivation procedure; its length must be exactly :py:const:`.SALTBYTES` :type salt: bytes :param opslimit: the time component (operation count) of the key derivation procedure's computational cost; it must be between :py:const:`.OPSLIMIT_MIN` and :py:const:`.OPSLIMIT_MAX` :type opslimit: int :param memlimit: the memory occupation component of the key derivation procedure's computational cost; it must be between :py:const:`.MEMLIMIT_MIN` and :py:const:`.MEMLIMIT_MAX` :type memlimit: int :rtype: bytes .. versionadded:: 1.2 """ return encoder.encode( nacl.bindings.crypto_pwhash_alg( size, password, salt, opslimit, memlimit, ALG ) ) def str( password: bytes, opslimit: int = OPSLIMIT_INTERACTIVE, memlimit: int = MEMLIMIT_INTERACTIVE, ) -> bytes: """ Hashes a password with a random salt, using the memory-hard argon2id construct and returning an ascii string that has all the needed info to check against a future password The default settings for opslimit and memlimit are those deemed correct for the interactive user login case. :param bytes password: :param int opslimit: :param int memlimit: :rtype: bytes .. versionadded:: 1.2 """ return nacl.bindings.crypto_pwhash_str_alg( password, opslimit, memlimit, ALG ) PK��ZJ�� _argon2.pynu��[��# Copyright 2013 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import nacl.bindings _argon2_strbytes_plus_one = nacl.bindings.crypto_pwhash_STRBYTES PWHASH_SIZE = _argon2_strbytes_plus_one - 1 SALTBYTES = nacl.bindings.crypto_pwhash_SALTBYTES PASSWD_MIN = nacl.bindings.crypto_pwhash_PASSWD_MIN PASSWD_MAX = nacl.bindings.crypto_pwhash_PASSWD_MAX PWHASH_SIZE = _argon2_strbytes_plus_one - 1 BYTES_MAX = nacl.bindings.crypto_pwhash_BYTES_MAX BYTES_MIN = nacl.bindings.crypto_pwhash_BYTES_MIN ALG_ARGON2I13 = nacl.bindings.crypto_pwhash_ALG_ARGON2I13 ALG_ARGON2ID13 = nacl.bindings.crypto_pwhash_ALG_ARGON2ID13 ALG_ARGON2_DEFAULT = nacl.bindings.crypto_pwhash_ALG_DEFAULT def verify(password_hash: bytes, password: bytes) -> bool: """ Takes a modular crypt encoded argon2i or argon2id stored password hash and checks if the user provided password will hash to the same string when using the stored parameters :param password_hash: password hash serialized in modular crypt() format :type password_hash: bytes :param password: user provided password :type password: bytes :rtype: boolean .. versionadded:: 1.2 """ return nacl.bindings.crypto_pwhash_str_verify(password_hash, password) PK��Z�^\|>J��J�� scrypt.pynu��[��# Copyright 2013 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import cast import nacl.bindings import nacl.encoding from nacl import exceptions as exc from nacl.exceptions import ensure _strbytes_plus_one = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_STRBYTES AVAILABLE = nacl.bindings.has_crypto_pwhash_scryptsalsa208sha256 STRPREFIX = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_STRPREFIX SALTBYTES = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_SALTBYTES PASSWD_MIN = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN PASSWD_MAX = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX PWHASH_SIZE = _strbytes_plus_one - 1 BYTES_MIN = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN BYTES_MAX = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX MEMLIMIT_MIN = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN MEMLIMIT_MAX = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX OPSLIMIT_MIN = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN OPSLIMIT_MAX = nacl.bindings.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX OPSLIMIT_INTERACTIVE = ( nacl.bindings.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE ) MEMLIMIT_INTERACTIVE = ( nacl.bindings.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE ) OPSLIMIT_SENSITIVE = ( nacl.bindings.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE ) MEMLIMIT_SENSITIVE = ( nacl.bindings.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE ) OPSLIMIT_MODERATE = 8 * OPSLIMIT_INTERACTIVE MEMLIMIT_MODERATE = 8 * MEMLIMIT_INTERACTIVE def kdf( size: int, password: bytes, salt: bytes, opslimit: int = OPSLIMIT_SENSITIVE, memlimit: int = MEMLIMIT_SENSITIVE, encoder: nacl.encoding.Encoder = nacl.encoding.RawEncoder, ) -> bytes: """ Derive a ``size`` bytes long key from a caller-supplied ``password`` and ``salt`` pair using the scryptsalsa208sha256 memory-hard construct. the enclosing module provides the constants - :py:const:`.OPSLIMIT_INTERACTIVE` - :py:const:`.MEMLIMIT_INTERACTIVE` - :py:const:`.OPSLIMIT_SENSITIVE` - :py:const:`.MEMLIMIT_SENSITIVE` - :py:const:`.OPSLIMIT_MODERATE` - :py:const:`.MEMLIMIT_MODERATE` as a guidance for correct settings respectively for the interactive login and the long term key protecting sensitive data use cases. :param size: derived key size, must be between :py:const:`.BYTES_MIN` and :py:const:`.BYTES_MAX` :type size: int :param password: password used to seed the key derivation procedure; it length must be between :py:const:`.PASSWD_MIN` and :py:const:`.PASSWD_MAX` :type password: bytes :param salt: RANDOM salt used in the key derivation procedure; its length must be exactly :py:const:`.SALTBYTES` :type salt: bytes :param opslimit: the time component (operation count) of the key derivation procedure's computational cost; it must be between :py:const:`.OPSLIMIT_MIN` and :py:const:`.OPSLIMIT_MAX` :type opslimit: int :param memlimit: the memory occupation component of the key derivation procedure's computational cost; it must be between :py:const:`.MEMLIMIT_MIN` and :py:const:`.MEMLIMIT_MAX` :type memlimit: int :rtype: bytes :raises nacl.exceptions.UnavailableError: If called when using a minimal build of libsodium. .. versionadded:: 1.2 """ ensure( AVAILABLE, "Not available in minimal build", raising=exc.UnavailableError, ) ensure( len(salt) == SALTBYTES, "The salt must be exactly %s, not %s bytes long" % (SALTBYTES, len(salt)), raising=exc.ValueError, ) n_log2, r, p = nacl.bindings.nacl_bindings_pick_scrypt_params( opslimit, memlimit ) maxmem = memlimit + (2 16) return encoder.encode( nacl.bindings.crypto_pwhash_scryptsalsa208sha256_ll( password, salt, # Cast safety: n_log2 is a positive integer, and so 2 n_log2 is also # a positive integer. Mypy+typeshed can't deduce this, because there's no # way to for them to know that n_log2: int is positive. cast(int, 2 ** n_log2), r, p, maxmem=maxmem, dklen=size, ) ) def str( password: bytes, opslimit: int = OPSLIMIT_INTERACTIVE, memlimit: int = MEMLIMIT_INTERACTIVE, ) -> bytes: """ Hashes a password with a random salt, using the memory-hard scryptsalsa208sha256 construct and returning an ascii string that has all the needed info to check against a future password The default settings for opslimit and memlimit are those deemed correct for the interactive user login case. :param bytes password: :param int opslimit: :param int memlimit: :rtype: bytes :raises nacl.exceptions.UnavailableError: If called when using a minimal build of libsodium. .. versionadded:: 1.2 """ ensure( AVAILABLE, "Not available in minimal build", raising=exc.UnavailableError, ) return nacl.bindings.crypto_pwhash_scryptsalsa208sha256_str( password, opslimit, memlimit ) def verify(password_hash: bytes, password: bytes) -> bool: """ Takes the output of scryptsalsa208sha256 and compares it against a user provided password to see if they are the same :param password_hash: bytes :param password: bytes :rtype: boolean :raises nacl.exceptions.UnavailableError: If called when using a minimal build of libsodium. .. versionadded:: 1.2 """ ensure( AVAILABLE, "Not available in minimal build", raising=exc.UnavailableError, ) ensure( len(password_hash) == PWHASH_SIZE, "The password hash must be exactly %s bytes long" % nacl.bindings.crypto_pwhash_scryptsalsa208sha256_STRBYTES, raising=exc.ValueError, ) return nacl.bindings.crypto_pwhash_scryptsalsa208sha256_str_verify( password_hash, password ) PK��Z�3��$��__pycache__/__init__.cpython-310.pycnu��[��o ��hs ��@��s��d�dl�mZ�ddlmZmZmZmZ�ejZejZej ej ks J��ejZejZej Z ejZejZejZejZejZejZejZejZejZejZejejksOJ��ejZejZejZejZejZejZej Z!ejZ"ej#Z$de%de%de&fdd�Z#d S�) ��)�CryptPrefixError��)�_argon2�argon2i�argon2id�scrypt� password_hash�password�returnc��C��sV��\|��tj�rt�\|�\|�S�\|��tj�rt�\|�\|�S�tjr'\|��tj�r't�\|�\|�S�td��)z� Takes a modular crypt encoded stored password hash derived using one of the algorithms supported by `libsodium` and checks if the user provided password will hash to the same string when using the parameters saved in the stored hash z0given password_hash is not in a supported format)� startswithr�� STRPREFIX�verifyr��r�� AVAILABLEr��)r��r ��r��J/usr/local/CyberPanel/lib/python3.10/site-packages/nacl/pwhash/__init__.pyr ��9��s��r ��N)'�nacl.exceptionsr��r��r��r��r��r��PWHASH_SIZE�ALG_ARGON2_DEFAULT�ALG_ARGON2ID13� PASSWD_MIN� PASSWD_MAX�MEMLIMIT_MAX�MEMLIMIT_MIN�OPSLIMIT_MAX�OPSLIMIT_MIN�OPSLIMIT_INTERACTIVE�MEMLIMIT_INTERACTIVE�OPSLIMIT_MODERATE�MEMLIMIT_MODERATE�OPSLIMIT_SENSITIVE�MEMLIMIT_SENSITIVE�str�ALG� SALTBYTES�SCRYPT_SALTBYTES�SCRYPT_PWHASH_SIZE�SCRYPT_OPSLIMIT_INTERACTIVE�SCRYPT_MEMLIMIT_INTERACTIVE�SCRYPT_OPSLIMIT_SENSITIVE�SCRYPT_MEMLIMIT_SENSITIVE�kdf�kdf_scryptsalsa208sha256�scryptsalsa208sha256_strr ��verify_scryptsalsa208sha256�bytes�boolr��r��r��r��<module>��s:��PK��Z'�`&��&��$��__pycache__/argon2id.cpython-310.pycnu��[��o ��hQ��@��s��d�dl�Zd�dlZddlmZ�ejZejjZ ej Z ejZejZej Z ejZejZejZejjZejjZejjZejjZejjZejjZejjZejjZ ejj!Z"ejj#Z$ee ej%j&fde'de(de(de'de'd ej%j)d e(fdd�Zeefde(de'de'd e(fd d�Z+dS�)��N��)�_argon2�size�password�salt�opslimit�memlimit�encoder�returnc�� C��s��\|��tj�\|�\|\|\|\|t��S�)a�� Derive a ``size`` bytes long key from a caller-supplied ``password`` and ``salt`` pair using the argon2i memory-hard construct. the enclosing module provides the constants - :py:const:`.OPSLIMIT_INTERACTIVE` - :py:const:`.MEMLIMIT_INTERACTIVE` - :py:const:`.OPSLIMIT_MODERATE` - :py:const:`.MEMLIMIT_MODERATE` - :py:const:`.OPSLIMIT_SENSITIVE` - :py:const:`.MEMLIMIT_SENSITIVE` as a guidance for correct settings. :param size: derived key size, must be between :py:const:`.BYTES_MIN` and :py:const:`.BYTES_MAX` :type size: int :param password: password used to seed the key derivation procedure; it length must be between :py:const:`.PASSWD_MIN` and :py:const:`.PASSWD_MAX` :type password: bytes :param salt: RANDOM* salt used in the key derivation procedure; its length must be exactly :py:const:`.SALTBYTES` :type salt: bytes :param opslimit: the time component (operation count) of the key derivation procedure's computational cost; it must be between :py:const:`.OPSLIMIT_MIN` and :py:const:`.OPSLIMIT_MAX` :type opslimit: int :param memlimit: the memory occupation component of the key derivation procedure's computational cost; it must be between :py:const:`.MEMLIMIT_MIN` and :py:const:`.MEMLIMIT_MAX` :type memlimit: int :rtype: bytes .. versionadded:: 1.2 )�encode�nacl�bindings�crypto_pwhash_alg�ALG)r��r��r��r��r��r ��r��J/usr/local/CyberPanel/lib/python3.10/site-packages/nacl/pwhash/argon2id.py�kdf5��s ��5��r��c��C��s��t�j�\|�\|\|t�S�)a�� Hashes a password with a random salt, using the memory-hard argon2id construct and returning an ascii string that has all the needed info to check against a future password The default settings for opslimit and memlimit are those deemed correct for the interactive user login case. :param bytes password: :param int opslimit: :param int memlimit: :rtype: bytes .. versionadded:: 1.2 )r��r ��crypto_pwhash_str_algr��)r��r��r��r��r��r��strq��s��r��),� nacl.bindingsr�� nacl.encoding��r��ALG_ARGON2ID13r��r �� crypto_pwhash_argon2id_STRPREFIX� STRPREFIX� SALTBYTES� PASSWD_MIN� PASSWD_MAX�PWHASH_SIZE� BYTES_MIN� BYTES_MAX�verify�#crypto_pwhash_argon2id_MEMLIMIT_MIN�MEMLIMIT_MIN�#crypto_pwhash_argon2id_MEMLIMIT_MAX�MEMLIMIT_MAX�#crypto_pwhash_argon2id_OPSLIMIT_MIN�OPSLIMIT_MIN�#crypto_pwhash_argon2id_OPSLIMIT_MAX�OPSLIMIT_MAX�+crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE�OPSLIMIT_INTERACTIVE�+crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE�MEMLIMIT_INTERACTIVE�)crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE�OPSLIMIT_SENSITIVE�)crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE�MEMLIMIT_SENSITIVE�(crypto_pwhash_argon2id_OPSLIMIT_MODERATE�OPSLIMIT_MODERATE�(crypto_pwhash_argon2id_MEMLIMIT_MODERATE�MEMLIMIT_MODERATE�encoding� RawEncoder�int�bytes�Encoderr��r��r��r��r��r��<module>��sj�� >��PK��Z;س�;��;��#��__pycache__/_argon2.cpython-310.pycnu��[��o ��h��@��sz��d�dl�ZejjZed�ZejjZejjZ ejj Zed�ZejjZ ejjZejjZejjZejjZdededefdd�ZdS�)��N�� password_hash�password�returnc��C��s��t�j�\|�\|�S�)a�� Takes a modular crypt encoded argon2i or argon2id stored password hash and checks if the user provided password will hash to the same string when using the stored parameters :param password_hash: password hash serialized in modular crypt() format :type password_hash: bytes :param password: user provided password :type password: bytes :rtype: boolean .. versionadded:: 1.2 )�nacl�bindings�crypto_pwhash_str_verify)r��r��r ��I/usr/local/CyberPanel/lib/python3.10/site-packages/nacl/pwhash/_argon2.py�verify#��s��r��)� nacl.bindingsr��r��crypto_pwhash_STRBYTES�_argon2_strbytes_plus_one�PWHASH_SIZE�crypto_pwhash_SALTBYTES� SALTBYTES�crypto_pwhash_PASSWD_MIN� PASSWD_MIN�crypto_pwhash_PASSWD_MAX� PASSWD_MAX�crypto_pwhash_BYTES_MAX� BYTES_MAX�crypto_pwhash_BYTES_MIN� BYTES_MIN�crypto_pwhash_ALG_ARGON2I13� ALG_ARGON2I13�crypto_pwhash_ALG_ARGON2ID13�ALG_ARGON2ID13�crypto_pwhash_ALG_DEFAULT�ALG_ARGON2_DEFAULT�bytes�boolr��r ��r ��r ��r ��<module>��s��PK��Z봛��#��__pycache__/argon2i.cpython-310.pycnu��[��o ��h5��@��s��d�dl�Zd�dlZddlmZ�ejZejjZ ej Z ejZejZej Z ejZejZejZejjZejjZejjZejjZejjZejjZejjZejjZ ejj!Z"ejj#Z$ee ej%j&fde'de(de(de'de'd ej%j)d e(fdd�Zeefde(de'de'd e(fd d�Z+dS�)��N��)�_argon2�size�password�salt�opslimit�memlimit�encoder�returnc�� C��s��\|��tj�\|�\|\|\|\|t��S�)a�� Derive a ``size`` bytes long key from a caller-supplied ``password`` and ``salt`` pair using the argon2i memory-hard construct. the enclosing module provides the constants - :py:const:`.OPSLIMIT_INTERACTIVE` - :py:const:`.MEMLIMIT_INTERACTIVE` - :py:const:`.OPSLIMIT_MODERATE` - :py:const:`.MEMLIMIT_MODERATE` - :py:const:`.OPSLIMIT_SENSITIVE` - :py:const:`.MEMLIMIT_SENSITIVE` as a guidance for correct settings. :param size: derived key size, must be between :py:const:`.BYTES_MIN` and :py:const:`.BYTES_MAX` :type size: int :param password: password used to seed the key derivation procedure; it length must be between :py:const:`.PASSWD_MIN` and :py:const:`.PASSWD_MAX` :type password: bytes :param salt: RANDOM* salt used in the key derivation procedure; its length must be exactly :py:const:`.SALTBYTES` :type salt: bytes :param opslimit: the time component (operation count) of the key derivation procedure's computational cost; it must be between :py:const:`.OPSLIMIT_MIN` and :py:const:`.OPSLIMIT_MAX` :type opslimit: int :param memlimit: the memory occupation component of the key derivation procedure's computational cost; it must be between :py:const:`.MEMLIMIT_MIN` and :py:const:`.MEMLIMIT_MAX` :type memlimit: int :rtype: bytes .. versionadded:: 1.2 )�encode�nacl�bindings�crypto_pwhash_alg�ALG)r��r��r��r��r��r ��r��I/usr/local/CyberPanel/lib/python3.10/site-packages/nacl/pwhash/argon2i.py�kdf1��s ��5��r��c��C��s��t�j�\|�\|\|t�S�)a�� Hashes a password with a random salt, using the memory-hard argon2i construct and returning an ascii string that has all the needed info to check against a future password The default settings for opslimit and memlimit are those deemed correct for the interactive user login case. :param bytes password: :param int opslimit: :param int memlimit: :rtype: bytes .. versionadded:: 1.2 )r��r ��crypto_pwhash_str_algr��)r��r��r��r��r��r��strm��s��r��),� nacl.bindingsr�� nacl.encoding��r�� ALG_ARGON2I13r��r ��crypto_pwhash_argon2i_STRPREFIX� STRPREFIX� SALTBYTES� PASSWD_MIN� PASSWD_MAX�PWHASH_SIZE� BYTES_MIN� BYTES_MAX�verify�"crypto_pwhash_argon2i_MEMLIMIT_MAX�MEMLIMIT_MAX�"crypto_pwhash_argon2i_MEMLIMIT_MIN�MEMLIMIT_MIN�"crypto_pwhash_argon2i_OPSLIMIT_MAX�OPSLIMIT_MAX�"crypto_pwhash_argon2i_OPSLIMIT_MIN�OPSLIMIT_MIN�crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE�OPSLIMIT_INTERACTIVE�crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE�MEMLIMIT_INTERACTIVE�(crypto_pwhash_argon2i_OPSLIMIT_SENSITIVE�OPSLIMIT_SENSITIVE�(crypto_pwhash_argon2i_MEMLIMIT_SENSITIVE�MEMLIMIT_SENSITIVE�'crypto_pwhash_argon2i_OPSLIMIT_MODERATE�OPSLIMIT_MODERATE�'crypto_pwhash_argon2i_MEMLIMIT_MODERATE�MEMLIMIT_MODERATE�encoding� RawEncoder�int�bytes�Encoderr��r��r��r��r��r��<module>��sf�� >��PK��Z3#�W��"��__pycache__/scrypt.cpython-310.pycnu��[��o ��hJ��@��s<��d�dl�mZ�d�dlZd�dlZd�dlmZ�d�dlmZ�ej j Zej jZ ej jZej jZej jZej jZed�Zej jZej jZej jZej jZej jZ ej j!Z"ej j#Z$ej j%Z&ej j'Z(ej j)Zde$�Z+de&�Z,e(eej-j.fde/de0d e0d e/de/dej-j1d e0fdd�Z2e$e&fde0d e/de/d e0fdd�Z3de0de0d e4fdd�Z5dS�)��)�castN)� exceptions)�ensure��size�password�salt�opslimit�memlimit�encoder�returnc�� C��sz��t�tdtjd��t�t\|�tkdtt\|�f�tjd��tj� \|\|�\}}}\|d�} \|� tjj\|\|tt d\|��\|\|\| \|�d��S�)al�� Derive a ``size`` bytes long key from a caller-supplied ``password`` and ``salt`` pair using the scryptsalsa208sha256 memory-hard construct. the enclosing module provides the constants - :py:const:`.OPSLIMIT_INTERACTIVE` - :py:const:`.MEMLIMIT_INTERACTIVE` - :py:const:`.OPSLIMIT_SENSITIVE` - :py:const:`.MEMLIMIT_SENSITIVE` - :py:const:`.OPSLIMIT_MODERATE` - :py:const:`.MEMLIMIT_MODERATE` as a guidance for correct settings respectively for the interactive login and the long term key protecting sensitive data use cases. :param size: derived key size, must be between :py:const:`.BYTES_MIN` and :py:const:`.BYTES_MAX` :type size: int :param password: password used to seed the key derivation procedure; it length must be between :py:const:`.PASSWD_MIN` and :py:const:`.PASSWD_MAX` :type password: bytes :param salt: RANDOM salt used in the key derivation procedure; its length must be exactly :py:const:`.SALTBYTES` :type salt: bytes :param opslimit: the time component (operation count) of the key derivation procedure's computational cost; it must be between :py:const:`.OPSLIMIT_MIN` and :py:const:`.OPSLIMIT_MAX` :type opslimit: int :param memlimit: the memory occupation component of the key derivation procedure's computational cost; it must be between :py:const:`.MEMLIMIT_MIN` and :py:const:`.MEMLIMIT_MAX` :type memlimit: int :rtype: bytes :raises nacl.exceptions.UnavailableError: If called when using a minimal build of libsodium. .. versionadded:: 1.2 �Not available in minimal build��raisingz.The salt must be exactly %s, not %s bytes longi��)�maxmem�dklen)r�� AVAILABLE�exc�UnavailableError�len� SALTBYTES� ValueError�nacl�bindings� nacl_bindings_pick_scrypt_params�encode�%crypto_pwhash_scryptsalsa208sha256_llr��int) r��r��r ��r ��r��r��n_log2�r�pr��r#��H/usr/local/CyberPanel/lib/python3.10/site-packages/nacl/pwhash/scrypt.py�kdf;��s6��9� �� r%��c��C��s ��t�tdtjd��tj�\|�\|\|�S�)a$�� Hashes a password with a random salt, using the memory-hard scryptsalsa208sha256 construct and returning an ascii string that has all the needed info to check against a future password The default settings for opslimit and memlimit are those deemed correct for the interactive user login case. :param bytes password: :param int opslimit: :param int memlimit: :rtype: bytes :raises nacl.exceptions.UnavailableError: If called when using a minimal build of libsodium. .. versionadded:: 1.2 r��r��)r��r��r��r��r��r��&crypto_pwhash_scryptsalsa208sha256_str)r��r ��r��r#��r#��r$��str��s��r'�� password_hashc��C��s>��t�tdtjd��t�t\|��tkdtjj�tj d��tj� \|�\|�S�)aW�� Takes the output of scryptsalsa208sha256 and compares it against a user provided password to see if they are the same :param password_hash: bytes :param password: bytes :rtype: boolean :raises nacl.exceptions.UnavailableError: If called when using a minimal build of libsodium. .. versionadded:: 1.2 r��r��z/The password hash must be exactly %s bytes long)r��r��r��r��r��PWHASH_SIZEr��r��+crypto_pwhash_scryptsalsa208sha256_STRBYTESr��-crypto_pwhash_scryptsalsa208sha256_str_verify)r(��r��r#��r#��r$��verify��s�� r,��)6�typingr�� nacl.bindingsr�� nacl.encodingr��r��nacl.exceptionsr��r��r��_strbytes_plus_one�&has_crypto_pwhash_scryptsalsa208sha256r��,crypto_pwhash_scryptsalsa208sha256_STRPREFIX� STRPREFIX�,crypto_pwhash_scryptsalsa208sha256_SALTBYTESr��-crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN� PASSWD_MIN�-crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX� PASSWD_MAXr)��,crypto_pwhash_scryptsalsa208sha256_BYTES_MIN� BYTES_MIN�,crypto_pwhash_scryptsalsa208sha256_BYTES_MAX� BYTES_MAX�/crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN�MEMLIMIT_MIN�/crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX�MEMLIMIT_MAX�/crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN�OPSLIMIT_MIN�/crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX�OPSLIMIT_MAX�7crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE�OPSLIMIT_INTERACTIVE�7crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE�MEMLIMIT_INTERACTIVE�5crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE�OPSLIMIT_SENSITIVE�5crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE�MEMLIMIT_SENSITIVE�OPSLIMIT_MODERATE�MEMLIMIT_MODERATE�encoding� RawEncoderr��bytes�Encoderr%��r'��boolr,��r#��r#��r#��r$��<module>��st�� ]�� !PK��Zձ��5��5�� argon2i.pynu��[��# Copyright 2013 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import nacl.bindings import nacl.encoding from . import _argon2 ALG = _argon2.ALG_ARGON2I13 STRPREFIX = nacl.bindings.crypto_pwhash_argon2i_STRPREFIX SALTBYTES = _argon2.SALTBYTES PASSWD_MIN = _argon2.PASSWD_MIN PASSWD_MAX = _argon2.PASSWD_MAX PWHASH_SIZE = _argon2.PWHASH_SIZE BYTES_MIN = _argon2.BYTES_MIN BYTES_MAX = _argon2.BYTES_MAX verify = _argon2.verify MEMLIMIT_MAX = nacl.bindings.crypto_pwhash_argon2i_MEMLIMIT_MAX MEMLIMIT_MIN = nacl.bindings.crypto_pwhash_argon2i_MEMLIMIT_MIN OPSLIMIT_MAX = nacl.bindings.crypto_pwhash_argon2i_OPSLIMIT_MAX OPSLIMIT_MIN = nacl.bindings.crypto_pwhash_argon2i_OPSLIMIT_MIN OPSLIMIT_INTERACTIVE = nacl.bindings.crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE MEMLIMIT_INTERACTIVE = nacl.bindings.crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE OPSLIMIT_SENSITIVE = nacl.bindings.crypto_pwhash_argon2i_OPSLIMIT_SENSITIVE MEMLIMIT_SENSITIVE = nacl.bindings.crypto_pwhash_argon2i_MEMLIMIT_SENSITIVE OPSLIMIT_MODERATE = nacl.bindings.crypto_pwhash_argon2i_OPSLIMIT_MODERATE MEMLIMIT_MODERATE = nacl.bindings.crypto_pwhash_argon2i_MEMLIMIT_MODERATE def kdf( size: int, password: bytes, salt: bytes, opslimit: int = OPSLIMIT_SENSITIVE, memlimit: int = MEMLIMIT_SENSITIVE, encoder: nacl.encoding.Encoder = nacl.encoding.RawEncoder, ) -> bytes: """ Derive a ``size`` bytes long key from a caller-supplied ``password`` and ``salt`` pair using the argon2i memory-hard construct. the enclosing module provides the constants - :py:const:`.OPSLIMIT_INTERACTIVE` - :py:const:`.MEMLIMIT_INTERACTIVE` - :py:const:`.OPSLIMIT_MODERATE` - :py:const:`.MEMLIMIT_MODERATE` - :py:const:`.OPSLIMIT_SENSITIVE` - :py:const:`.MEMLIMIT_SENSITIVE` as a guidance for correct settings. :param size: derived key size, must be between :py:const:`.BYTES_MIN` and :py:const:`.BYTES_MAX` :type size: int :param password: password used to seed the key derivation procedure; it length must be between :py:const:`.PASSWD_MIN` and :py:const:`.PASSWD_MAX` :type password: bytes :param salt: RANDOM* salt used in the key derivation procedure; its length must be exactly :py:const:`.SALTBYTES` :type salt: bytes :param opslimit: the time component (operation count) of the key derivation procedure's computational cost; it must be between :py:const:`.OPSLIMIT_MIN` and :py:const:`.OPSLIMIT_MAX` :type opslimit: int :param memlimit: the memory occupation component of the key derivation procedure's computational cost; it must be between :py:const:`.MEMLIMIT_MIN` and :py:const:`.MEMLIMIT_MAX` :type memlimit: int :rtype: bytes .. versionadded:: 1.2 """ return encoder.encode( nacl.bindings.crypto_pwhash_alg( size, password, salt, opslimit, memlimit, ALG ) ) def str( password: bytes, opslimit: int = OPSLIMIT_INTERACTIVE, memlimit: int = MEMLIMIT_INTERACTIVE, ) -> bytes: """ Hashes a password with a random salt, using the memory-hard argon2i construct and returning an ascii string that has all the needed info to check against a future password The default settings for opslimit and memlimit are those deemed correct for the interactive user login case. :param bytes password: :param int opslimit: :param int memlimit: :rtype: bytes .. versionadded:: 1.2 """ return nacl.bindings.crypto_pwhash_str_alg( password, opslimit, memlimit, ALG ) PK��Ziŵ�s ��s ��__init__.pynu��[��# Copyright 2017 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from nacl.exceptions import CryptPrefixError from . import _argon2, argon2i, argon2id, scrypt STRPREFIX = argon2id.STRPREFIX PWHASH_SIZE = argon2id.PWHASH_SIZE assert _argon2.ALG_ARGON2_DEFAULT == _argon2.ALG_ARGON2ID13 # since version 1.0.15 of libsodium PASSWD_MIN = argon2id.PASSWD_MIN PASSWD_MAX = argon2id.PASSWD_MAX MEMLIMIT_MAX = argon2id.MEMLIMIT_MAX MEMLIMIT_MIN = argon2id.MEMLIMIT_MIN OPSLIMIT_MAX = argon2id.OPSLIMIT_MAX OPSLIMIT_MIN = argon2id.OPSLIMIT_MIN OPSLIMIT_INTERACTIVE = argon2id.OPSLIMIT_INTERACTIVE MEMLIMIT_INTERACTIVE = argon2id.MEMLIMIT_INTERACTIVE OPSLIMIT_MODERATE = argon2id.OPSLIMIT_MODERATE MEMLIMIT_MODERATE = argon2id.MEMLIMIT_MODERATE OPSLIMIT_SENSITIVE = argon2id.OPSLIMIT_SENSITIVE MEMLIMIT_SENSITIVE = argon2id.MEMLIMIT_SENSITIVE str = argon2id.str assert argon2i.ALG != argon2id.ALG SCRYPT_SALTBYTES = scrypt.SALTBYTES SCRYPT_PWHASH_SIZE = scrypt.PWHASH_SIZE SCRYPT_OPSLIMIT_INTERACTIVE = scrypt.OPSLIMIT_INTERACTIVE SCRYPT_MEMLIMIT_INTERACTIVE = scrypt.MEMLIMIT_INTERACTIVE SCRYPT_OPSLIMIT_SENSITIVE = scrypt.OPSLIMIT_SENSITIVE SCRYPT_MEMLIMIT_SENSITIVE = scrypt.MEMLIMIT_SENSITIVE kdf_scryptsalsa208sha256 = scrypt.kdf scryptsalsa208sha256_str = scrypt.str verify_scryptsalsa208sha256 = scrypt.verify def verify(password_hash: bytes, password: bytes) -> bool: """ Takes a modular crypt encoded stored password hash derived using one of the algorithms supported by `libsodium` and checks if the user provided password will hash to the same string when using the parameters saved in the stored hash """ if password_hash.startswith(argon2id.STRPREFIX): return argon2id.verify(password_hash, password) elif password_hash.startswith(argon2i.STRPREFIX): return argon2id.verify(password_hash, password) elif scrypt.AVAILABLE and password_hash.startswith(scrypt.STRPREFIX): return scrypt.verify(password_hash, password) else: raise ( CryptPrefixError( "given password_hash is not in a supported format" ) ) PK��Z3�?Q��Q��argon2id.pynu��[��PK��ZJ�� _argon2.pynu��[��PK��Z�^\|>J��J�� scrypt.pynu��[��PK��Z�3��$��<4��__pycache__/__init__.cpython-310.pycnu��[��PK��Z'�`&��&��$��$;��__pycache__/argon2id.cpython-310.pycnu��[��PK��Z;س�;��;��#��J��__pycache__/_argon2.cpython-310.pycnu��[��PK��Z봛��#��,P��__pycache__/argon2i.cpython-310.pycnu��[��PK��Z3#�W��"��_��__pycache__/scrypt.cpython-310.pycnu��[��PK��Zձ��5��5�� v��argon2i.pynu��[��PK��Ziŵ�s ��s ��5��__init__.pynu��[��PK�� c��

| ver. 1.4 | Github | . | PHP 8.2.28 | Generation time: 0.02 | proxy | phpinfo | Settings