o 5 hBJ@sdZddlmZmZddlmZmZddlZee Z ddl m Z ddl mZmZddlmZmZmZmZddlmZddlmmZgd ZGd d d ejejejejZ d de fd dZ!e!dddeddZ"e!dddZ#e!dddZ$ej%de"ddddZ&ej%de#ddddZ'ej%d e$d!d"ddZ(d#Z)Gd$d%d%ejejejejZ*Gd&d'd'ejej+ejZ,Gd(d)d)ejejejZ-Gd*d+d+ejejejejZ.dS),z,passlib.handlers.pbkdf - PBKDF2 based hashes)hexlify unhexlify) b64encode b64decodeN) to_unicode) ab64_decode ab64_encode) str_to_basciiu uascii_to_strunicode) pbkdf2_hmac) pbkdf2_sha1 pbkdf2_sha256 pbkdf2_sha512cta_pbkdf2_sha1dlitz_pbkdf2_sha1grub_pbkdf2_sha512c@sReZdZdZdZejZdZdZ dZ dZ dZ dZ dZed d Zd d Zd dZdS)Pbkdf2DigestHandlerz1base class for various pbkdf2_{digest} algorithmssalt salt_sizeroundsNlinearcCsFtj||j|d\}}}t|d}|rt|d}||||dS)N)handlerasciirrchecksum)uh parse_mc3identrencodeclshashrrchkr*k/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/passlib/handlers/pbkdf2.py from_string?s zPbkdf2DigestHandler.from_stringcCs4t|jd}t|jd}t|j|j||SNr)rrdecoder!r" render_mc3r$rselfrr)r*r*r+ to_stringGszPbkdf2DigestHandler.to_stringcCst|j||j|j|jS)N)r _digestrr checksum_sizer1secretr*r*r+_calc_checksumLsz"Pbkdf2DigestHandler._calc_checksum)__name__ __module__ __qualname____doc__ setting_kwdsr" HASH64_CHARSchecksum_charsdefault_salt_size max_salt_sizedefault_rounds min_rounds max_rounds rounds_costr3 classmethodr,r2r7r*r*r*r+rs  ri.cCsdd|}|durtd|f}t}t||ft|||||||ddddt||j|dd S) z;create new Pbkdf2DigestHandler subclass for a specific hashpbkdf2_Nz $pbkdf2-%s$a$This class implements a generic ``PBKDF2-HMAC-%(digest)s``-based password hash, and follows the :ref:`password-hash-api`. It supports a variable-length salt, and a variable number of rounds. The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords: :type salt: bytes :param salt: Optional salt bytes. If specified, the length must be between 0-1024 bytes. If not specified, a %(dsc)d byte salt will be autogenerated (this is recommended). :type salt_size: int :param salt_size: Optional number of bytes to use when autogenerating new salts. Defaults to %(dsc)d bytes, but can be any value between 0 and 1024. :type rounds: int :param rounds: Optional number of rounds to use. Defaults to %(dr)d, but must be within ``range(1,1<<32)``. :type relaxed: bool :param relaxed: By default, providing an invalid value for one of the other keywords will result in a :exc:`ValueError`. If ``relaxed=True``, and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning` will be issued instead. Correctable errors include ``rounds`` that are too small or too large, and ``salt`` strings that are too long. .. versionadded:: 1.6 )digestdscdr)r9namer$r3rAr4encoded_checksum_sizer;)r rtypedictupperr?) hash_name digest_sizerr$modulerMbaser*r*r+create_pbkdf2_hashPs  rVsha1iz$pbkdf2$)r$sha256 iHqsha512@ialdap_pbkdf2_sha1z{PBKDF2}Tldap_pbkdf2_sha256z{PBKDF2-SHA256}z$pbkdf2-sha256$ldap_pbkdf2_sha512z{PBKDF2-SHA512}z$pbkdf2-sha512$s-_c@sZeZdZdZdZdZedZdZdZ dZ e j Z dZ dZd Zed d Zd d ZddZdS)raThis class implements Cryptacular's PBKDF2-based crypt algorithm, and follows the :ref:`password-hash-api`. It supports a variable-length salt, and a variable number of rounds. The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords: :type salt: bytes :param salt: Optional salt bytes. If specified, it may be any length. If not specified, a one will be autogenerated (this is recommended). :type salt_size: int :param salt_size: Optional number of bytes to use when autogenerating new salts. Defaults to 16 bytes, but can be any value between 0 and 1024. :type rounds: int :param rounds: Optional number of rounds to use. Defaults to 60000, must be within ``range(1,1<<32)``. :type relaxed: bool :param relaxed: By default, providing an invalid value for one of the other keywords will result in a :exc:`ValueError`. If ``relaxed=True``, and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning` will be issued instead. Correctable errors include ``rounds`` that are too small or too large, and ``salt`` strings that are too long. .. versionadded:: 1.6 r$p5k2$rXrrrrrcCsLtj||jd|d\}}}t|dt}|rt|dt}||||dS)Nr) rounds_baserrr )r"r#r$rr% CTA_ALTCHARSr&r*r*r+r,s zcta_pbkdf2_sha1.from_stringcCs<t|jtd}t|jtd}tj|j|j||ddS)Nrrra) rrrbr.r!r"r/r$rr0r*r*r+r2szcta_pbkdf2_sha1.to_stringcCtd||j|jdS)NrWrXr rrr5r*r*r+r7szcta_pbkdf2_sha1._calc_checksumN)r8r9r:r;rMr<r r$r4r?r@rrArBrCrDrEr,r2r7r*r*r*r+rs %  rc@sleZdZdZdZdZedZedZdZ dZ e j Z ejZdZdZd Zed d Zd d ZddZddZdS)raCThis class implements Dwayne Litzenberger's PBKDF2-based crypt algorithm, and follows the :ref:`password-hash-api`. It supports a variable-length salt, and a variable number of rounds. The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords: :type salt: str :param salt: Optional salt string. If specified, it may be any length, but must use the characters in the regexp range ``[./0-9A-Za-z]``. If not specified, a 16 character salt will be autogenerated (this is recommended). :type salt_size: int :param salt_size: Optional number of bytes to use when autogenerating new salts. Defaults to 16 bytes, but can be any value between 0 and 1024. :type rounds: int :param rounds: Optional number of rounds to use. Defaults to 60000, must be within ``range(1,1<<32)``. :type relaxed: bool :param relaxed: By default, providing an invalid value for one of the other keywords will result in a :exc:`ValueError`. If ``relaxed=True``, and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning` will be issued instead. Correctable errors include ``rounds`` that are too small or too large, and ``salt`` strings that are too long. .. versionadded:: 1.6 rr`z1000000000000000000000000000000000000000000000000=rrrrrcCs*tj||jdd|d\}}}||||dS)Nr)rarArr )r"r#r$r&r*r*r+r,9s  zdlitz_pbkdf2_sha1.from_stringcCs,|j}|dkr d}tj|j||j|jddSNrfrrc)rr"r/r$rr!r1rr*r*r+r2?szdlitz_pbkdf2_sha1.to_stringcCs*|j}|dkr d}tj|j||jdddSrg)rr"r/r$rrhr*r*r+ _get_configEszdlitz_pbkdf2_sha1._get_configcCs(|}td|||jd}t|dS)NrWr)rir rrr.)r1r6rresultr*r*r+r7Nsz dlitz_pbkdf2_sha1._calc_checksumN)r8r9r:r;rMr<r r$_stub_checksumr?r@r"r= salt_charsrrArBrCrDrEr,r2rir7r*r*r*r+rs$%  rc@sHeZdZdZdZdZedZdZdZ Z e ddZ dd Z d d Zd S) atlassian_pbkdf2_sha1aBThis class implements the PBKDF2 hash used by Atlassian. It supports a fixed-length salt, and a fixed number of rounds. The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords: :type salt: bytes :param salt: Optional salt bytes. If specified, the length must be exactly 16 bytes. If not specified, a salt will be autogenerated (this is recommended). :type relaxed: bool :param relaxed: By default, providing an invalid value for one of the other keywords will result in a :exc:`ValueError`. If ``relaxed=True``, and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning` will be issued instead. Correctable errors include ``salt`` strings that are too long. .. versionadded:: 1.6 )rz {PKCS5S2}rZrcCsht|dd}|j}||stj|t|t|dd}|dd|dd}}|||dS)Nrr(r)rr!) rr$ startswithr"excInvalidHashErrorrlenr%)r'r(r$datarr)r*r*r+r,{s    z!atlassian_pbkdf2_sha1.from_stringcCs(|j|j}|jt|d}t|Sr-)rr!r$rr.r )r1rsr(r*r*r+r2s zatlassian_pbkdf2_sha1.to_stringcCstd||jddS)NrWi'rZ)r rr5r*r*r+r7sz$atlassian_pbkdf2_sha1._calc_checksumN)r8r9r:r;rMr<r r$r4 min_salt_sizer@rEr,r2r7r*r*r*r+rn[s  rnc@sZeZdZdZdZdZedZdZdZ dZ e j Z dZ dZdZed d Zd d Zd dZdS)raThis class implements Grub's pbkdf2-hmac-sha512 hash, and follows the :ref:`password-hash-api`. It supports a variable-length salt, and a variable number of rounds. The :meth:`~passlib.ifc.PasswordHash.using` method accepts the following optional keywords: :type salt: bytes :param salt: Optional salt bytes. If specified, the length must be between 0-1024 bytes. If not specified, a 64 byte salt will be autogenerated (this is recommended). :type salt_size: int :param salt_size: Optional number of bytes to use when autogenerating new salts. Defaults to 64 bytes, but can be any value between 0 and 1024. :type rounds: int :param rounds: Optional number of rounds to use. Defaults to 19000, but must be within ``range(1,1<<32)``. :type relaxed: bool :param relaxed: By default, providing an invalid value for one of the other keywords will result in a :exc:`ValueError`. If ``relaxed=True``, and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning` will be issued instead. Correctable errors include ``rounds`` that are too small or too large, and ``salt`` strings that are too long. .. versionadded:: 1.6 rzgrub.pbkdf2.sha512.r\rrrrcCsLtj||jtd|d\}}}t|d}|rt|d}||||dS)N.)seprrr )r"r#r$r rr%r&r*r*r+r,s zgrub_pbkdf2_sha512.from_stringcCsDt|jd}t|jd}tj|j|j||t ddS)Nrru)rv) rrr.rQr!r"r/r$rr r0r*r*r+r2szgrub_pbkdf2_sha512.to_stringcCrd)Nr[r\rer5r*r*r+r7sz!grub_pbkdf2_sha512._calc_checksumN)r8r9r:r;rMr<r r$r4r?r@rrArBrCrDrEr,r2r7r*r*r*r+rs    r)/r;binasciirrbase64rrlogging getLoggerr8log passlib.utilsrpasslib.utils.binaryrrpasslib.utils.compatr r r r passlib.crypto.digestr passlib.utils.handlersutilshandlersr"__all__ HasRounds HasRawSaltHasRawChecksumGenericHandlerrrVrrr PrefixWrapperr]r^r_rbrHasSaltrrnrr*r*r*r+s.   33  `i"8