XR_BJdZddlmZmZddlmZmZddlZeje Z ddl m Z ddl mZmZddlmZmZmZmZddlmZddlmcmZgd ZGd d ejejejejZ d de fd Z!e!dddedZ"e!dddZ#e!dddZ$ej%de"dddZ&ej%de#dddZ'ej%de$d d!dZ(d"Z)Gd#d$ejejejejZ*Gd%d&ejej+ejZ,Gd'd(ejejejZ-Gd)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_sha512cbeZdZdZdZejZdZdZ dZ dZ dZ dZ dZed Zd Zd ZdS) Pbkdf2DigestHandlerz1base class for various pbkdf2_{digest} algorithmssalt salt_sizeroundsNlinearctj||j|\}}}t|d}|r"t|d}||||S)N)handlerasciirrchecksum)uh parse_mc3identrencodeclshashrrchks 9/usr/lib/python3/dist-packages/passlib/handlers/pbkdf2.py from_stringzPbkdf2DigestHandler.from_string?srLsy#FFFc4;;w//00  3cjj1122Cs&tc::::ct|jd}t|jd}t j|j|j||SNr")r rdecoder$r% render_mc3r'rselfrr,s r- to_stringzPbkdf2DigestHandler.to_stringGsV49%%,,W55$-((//88}TZdC@@@r/cPt|j||j|j|jS)N)r_digestrr checksum_sizer5secrets r-_calc_checksumz"Pbkdf2DigestHandler._calc_checksumLs!4<DKI[\\\r/)__name__ __module__ __qualname____doc__ setting_kwdsr% HASH64_CHARSchecksum_charsdefault_salt_size max_salt_sizedefault_rounds min_rounds max_rounds rounds_costr8 classmethodr.r6r<r/r-rrs;; 3L_NMNJJKG;;[;AAA ]]]]]r/ri.cd|z}|td|fz}t}t||ft|||||||dzdzdzdt||j|z 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)r>namer'r8rFr9encoded_checksum_sizer@)r rtypedictupperrD) hash_name digest_sizerr'modulerTbases r-create_pbkdf2_hashr]Ps y D }-  I</ D tgt !*1}Q2> ioo''T-C O O O?P( ( ( ( ( (r/sha1iz$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-_cxeZdZdZdZdZedZdZdZ dZ e j Z dZ dZd Zed Zd Zd Zd S)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$r_rrrrrctj||jd|\}}}t|dt }|r(t|dt }||||S)Nr) rounds_baser!r"r#)r%r&r'rr( CTA_ALTCHARSr)s r-r.zcta_pbkdf2_sha1.from_strings{LsybRUVVVcW--|<<  ?CJJw//>>Cs&tc::::r/ct|jtd}t|jtd}t j|j|j||dS)Nr"rrj) rrrkr2r$r%r3r'rr4s r-r6zcta_pbkdf2_sha1.to_strings_L1188AA |44;;GDD}TZdCRPPPPr/c<td||j|jdS)Nr^r_rrrr:s r-r<zcta_pbkdf2_sha1._calc_checksums6649dk2FFFr/N)r=r>r?r@rTrAr r'r9rDrErrFrGrHrIrJr.r6r<rKr/r-rrsJ D2L AhKKEMM!/NJJK;;[;QQQGGGGGr/rceZdZdZdZdZedZedZdZ dZ e j Z ejZdZdZd Zed Zd Zd Zd ZdS)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 rrhz1000000000000000000000000000000000000000000000000=rrrrrcbtj||jdd|\}}}||||S)Nr)rjrFr!r#)r%r&r'r)s r-r.zdlitz_pbkdf2_sha1.from_string9sFLsyb8;SJJJcs&tc::::r/cp|j}|dkrd}tj|j||j|jdSNrrrrm)rr%r3r'rr$r5rs r-r6zdlitz_pbkdf2_sha1.to_string?s9 S==F}TZDMWYZZZZr/cf|j}|dkrd}tj|j||jddSrt)rr%r3r'rrus r- _get_configzdlitz_pbkdf2_sha1._get_configEs6 S==F}TZDbQQQQr/c|}td|||jd}t|dS)Nr^r")rwrrr r2)r5r;rresults r-r<z dlitz_pbkdf2_sha1._calc_checksumNsF!!VVT4;CC6""))'222r/N)r=r>r?r@rTrAr r'_stub_checksumrDrEr%rB salt_charsrrFrGrHrIrJr.r6rwr<rKr/r-rrsJ D2L AhKKEQ~&&NMJ !/NJJK;;[; [[[ RRR33333r/rc^eZdZdZdZdZedZdZdxZ Z e dZ dZ dZd 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}rarcJt|dd}|j}||stj|t |t|dd}|dd|dd}}|||S)Nr"r+r)rr$) rr' startswithr%excInvalidHashErrorrlenr()r*r+r'datarr,s r-r.z!atlassian_pbkdf2_sha1.from_string{s$00 u%% /&))#.. .c%jjkk*11'::;;"ItBCCycss++++r/c|j|jz}|jt|dz}t |Sr1)rr$r'rr2r )r5rr+s r-r6zatlassian_pbkdf2_sha1.to_strings>y4=(zIdOO227;;;T"""r/c2td||jddS)Nr^i'ra)rrr:s r-r<z$atlassian_pbkdf2_sha1._calc_checksums6649eR@@@r/N)r=r>r?r@rTrAr r'r9 min_salt_sizerErJr.r6r<rKr/r-r~r~[s. #DL AkNNEM%'&MM,,[,### AAAAAr/r~cxeZdZdZdZdZedZdZdZ dZ e j Z dZ dZdZed Zd Zd Zd S) 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.rcrrrrctj||jtd|\}}}t |d}|r"t |d}||||S)N.)sepr!r"r#)r%r&r'r rr(r)s r-r.zgrub_pbkdf2_sha512.from_stringsLsyaff14666cW--..  1CJJw//00Cs&tc::::r/c Ft|jd}t|jd}t j|j|j||tdS)Nr"r)r) rrr2rXr$r%r3r'rr r4s r-r6zgrub_pbkdf2_sha512.to_stringsyty!!((117799dm$$++G44::<<}TZdCQsVVLLLLr/c<td||j|jdS)Nrbrcror:s r-r<z!grub_pbkdf2_sha512._calc_checksums8VTY RHHHr/N)r=r>r?r@rTrAr r'r9rDrErrFrGrHrIrJr.r6r<rKr/r-rrs@ D2L A# $ $EM M"1NJJK;;[;MMM IIIIIr/r)/r@binasciirrbase64rrlogging getLoggerr=log passlib.utilsrpasslib.utils.binaryrr passlib.utils.compatr r r r passlib.crypto.digestrpasslib.utils.handlersutilshandlersr%__all__ HasRounds HasRawSaltHasRawChecksumGenericHandlerrr]rrr PrefixWrapperrdrerfrkrHasSaltrr~rrKr/r-rs22 (''''''''''''''''g'11%$$$$$99999999IIIIIIIIIIII------#########   1]1]1]1]1]", r7H"J[1]1]1]f7<4PX....f! V11Z==III ""8R77 ""8R77 #2#$6 ZQ[cghhh%R%&:MK\^ow{|||%R%&:MK\^ow{||| WGWGWGWGWGblBM23DbFWWGWGWG@`3`3`3`3`3 bj"2C`3`3`3R3A3A3A3A3ABM2+O3A3A3ApDIDIDIDIDIr}b6GIZDIDIDIDIDIr/