HtjptdZddlmZmZmZmZddlZddlmZ ddl m Z n#e $r ddlm Z YnwxYwddl m Z mZddlZejeZddlZddlZddlmZddlmZmZmZmZdd lmZmZmZdd l m!Z!gd Z"e#d d dddZ$dZ%dZ&d)dZ'e(e)fZ*e+e,fZ-e+Z.d*dZ/Gdde0Z1e#ddddZ2Gdde1Z3d+d Z4d!Z5Gd"d#e Z6e6Z7d$8D]Z9e7:e9d%e9zGd&d'e1Z;d+d(Zz"_self_info_rate.._s/JJ%utE1~~5JJJJJJr,)len TypeErrorrintvaluessumrr0)sourcesizecountscharr7s r*_self_info_rater=>s 6{{   Ft   |6{{F## q a==3JJ6JJJJJTQ QQs  !!c<|r*tj|t|Stj|rt |dS|d\}}}|std|tj ||S)a :param asset_path: string containing absolute path to file, or package-relative path using format ``"python.module:relative/file/path"``. :returns: filehandle opened in 'rb' mode (unless encoding explicitly specified) rb:zIasset path must be absolute file path or use 'pkg.name:sub/path' format: ) codecs getreader_open_asset_pathospathisabsopen partition ValueError pkg_resourcesresource_stream)rEencodingpackagesepsubpaths r*rCrCjsB)v))*:4*@*@AAA w}}T D$ NN3//GS' LjDHDKLL L  (' : ::r,r9ct}d} ||vrdSn#t$rd}YnwxYwt|ts-t t |t |kr+|r' ||n#t$rYnwxYwdSt }t }|D]}||vr|n||t|}d}t ||krd}dd|d|D}t ||kr|dt ||z zz }td |d |) z helper for generators -- Throws ValueError if source elements aren't unique. Error message will display (abbreviated) repr of the duplicates in a string/list TF, c3NK|] }tt|V!dSN)reprstrr1words r*r3z!_ensure_unique..s.BBTc$iiBBBBBBr,Nz, ... plus %d others`z%` cannot contain duplicate elements: ) _ensure_unique_cacher5 isinstance _set_typesr4setaddsortedjoinrI) r9paramcachehashableseendupselemtruncdup_reprs r*_ensure_uniquerjs !EH U??4  &*%%S[[)9)9S[[)H)H    &!!!!    t 55D 55D334,,T2222 $<= :attr:`requested_entropy`. )rtrsrs r*rzzSequenceGenerator.entropys{T444r,c td)z;main generation function, should create one password/phrasezimplement in subclass)NotImplementedErrorrs r*__next__zSequenceGenerator.__next__)s!"9:::r,c|tSt|trfdt|DS|turSt j|dd)zN frontend used by genword() / genphrase() to create passwords Nc.g|]}tSrn)nextr1_rys r* z.SequenceGenerator.__call__..4s8881DJJ888r,z, int, or returns)rr\rr iterr ExpectedTypeError)ryrs` r*__call__zSequenceGenerator.__call__-sm ?::   + + V8888w888 8 __K'1I9UU Ur,c|SrUrnrs r*__iter__zSequenceGenerator.__iter__:s r,c*|SrU)rrs r*rzSequenceGenerator.next>s==?? "r,NNNrU)__name__ __module__ __qualname____doc__rtrprrorxrrsrzrrrr r __classcell__r}s@r*rlrls&&XF! CL 888888F*** 555;;; V V V V # # # # # # # #####r,rlzH0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/>0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZ0123456789abcdef)ascii_72ascii_62ascii_50hexcHeZdZdZdZdZdfd ZedZdZ xZ S) WordGeneratora Class which generates passwords by randomly choosing from a string of unique characters. Parameters ---------- :param chars: custom character string to draw from. :param charset: predefined charset to draw from. :param \*\*kwds: all other keywords passed to the :class:`SequenceGenerator` parent class. Attributes ---------- .. autoattribute:: chars .. autoattribute:: charset .. autoattribute:: default_charsets rNc |r|rtdn|s |j}|sJt|}||_t|d}t |d||_t t|jdi|dS)Nz,`chars` and `charset` are mutually exclusivecharsrbrn) r5charsetrrrjrrwrrx)ryrrr{r}s r*rxzWordGenerator.__init__~s  . P NOOO P ,w$W-E 5000uG,,,,  ,mT""+33d33333r,c*t|jSrU)r4rrs r*rozWordGenerator.symbol_count4:r,cBt|j|j|jSrU)rrrrtrs r*rzWordGenerator.__next__s$(DJ <<>> # generate a random alphanumeric string with 48 bits of entropy (the default) >>> from passlib import pwd >>> pwd.genword() 'DnBHvDjMK6' >>> # generate a random hexadecimal string with 52 bits of entropy >>> pwd.genword(entropy=52, charset="hex") '310f1a7ac793f' :param entropy: Strength of resulting password, measured in 'guessing entropy' bits. An appropriate **length** value will be calculated based on the requested entropy amount, and the size of the character set. This can be a positive integer, or one of the following preset strings: ``"weak"`` (24), ``"fair"`` (36), ``"strong"`` (48), and ``"secure"`` (56). If neither this or **length** is specified, **entropy** will default to ``"strong"`` (48). :param length: Size of resulting password, measured in characters. If omitted, the size is auto-calculated based on the **entropy** parameter. If both **entropy** and **length** are specified, the stronger value will be used. :param returns: Controls what this function returns: * If ``None`` (the default), this function will generate a single password. * If an integer, this function will return a list containing that many passwords. * If the ``iter`` constant, will return an iterator that yields passwords. :param chars: Optionally specify custom string of characters to use when randomly generating a password. This option cannot be combined with **charset**. :param charset: The predefined character set to draw from (if not specified by **chars**). There are currently four presets available: * ``"ascii_62"`` (the default) -- all digits and ascii upper & lowercase letters. Provides ~5.95 entropy per character. * ``"ascii_50"`` -- subset which excludes visually similar characters (``1IiLl0Oo5S8B``). Provides ~5.64 entropy per character. * ``"ascii_72"`` -- all digits and ascii upper & lowercase letters, as well as some punctuation. Provides ~6.17 entropy per character. * ``"hex"`` -- Lower case hexadecimal. Providers 4 bits of entropy per character. :returns: :class:`!unicode` string containing randomly generated password; or list of 1+ passwords if :samp:`returns={int}` is specified. )rtrzrn)rrzrtrr{gens r*rrs-L  ?vw ? ?$ ? ?C 3w<<r,ct|d5}d|D}td|D}dddn #1swxYwYtdt |||S)a2 load wordset from compressed datafile within package data. file should be utf-8 encoded :param asset_path: string containing absolute path to wordset file, or "python.module:relative/file/path". :returns: tuple of words, as loaded from specified words file. zutf-8c3>K|]}|VdSrU)striprXs r*r3z _load_wordset..s*++tzz||++++++r,c3K|]}||V dSrUrnrXs r*r3z _load_wordset..s'33td3d333333r,Nz!loaded %d-element wordset from %r)rCtupler debugr4) asset_pathfhrwordss r* _load_wordsetrs *g . .4"+++++33s33333444444444444444$II13u::zJJJ Ls&AA AcjeZdZdZdZdZfdZdZdZdZ dZ e dZ d Z d Zd ZxZS) WordsetDictz Special mapping used to store dictionary of wordsets. Different from a regular dict in that some wordsets may be lazy-loaded from an asset path. Ncdi|_i|_tt|j|i|dSrU)paths_loadedrwrrx)ryargsr{r}s r*rxzWordsetDict.__init__%s9  )k4  )48488888r,c |j|S#t$rYnwxYw|j|}t|x}|j|<|SrU)rKeyErrorrr)rykeyrEr2s r* __getitem__zWordsetDict.__getitem__*s] <$ $    D z#$1$$7$77 S! s  c||j|<dS)z; set asset path to lazy-load wordset from. N)r)ryrrEs r*set_pathzWordsetDict.set_path3s 3r,c||j|<dSrU)r)ryrr2s r* __setitem__zWordsetDict.__setitem__9s! Sr,ch||vr%|j|=|j|ddS|j|=dSrU)rrpopryrs r* __delitem__zWordsetDict.__delitem__<s> $;; S! JNN3 % % % % % 3r,cbt|j}||j|SrU)r^rupdater)ryrvs r*_keysetzWordsetDict._keysetCs*4<   DJ r,c*t|jSrU)rrrs r*rzWordsetDict.__iter__IsDL!!!r,c*t|jSrU)r4rrs r*__len__zWordsetDict.__len__Ls4<   r,c&||jvp||jvSrU)rrrs r* __contains__zWordsetDict.__contains__Psdl"7cTZ&77r,)rrrrrrrxrrrrpropertyrrrrrrs@r*rrs EG99999  """   X """!!!8888888r,rz%eff_long eff_short eff_prefixed bip39zpasslib:_data/wordsets/%s.txtcLeZdZdZdZdZdZdfd ZedZ dZ xZ S) PhraseGeneratoraclass which generates passphrases by randomly choosing from a list of unique words. :param wordset: wordset to draw from. :param preset: name of preset wordlist to use instead of ``wordset``. :param spaces: whether to insert spaces between words in output (defaults to ``True``). :param \*\*kwds: all other keywords passed to the :class:`SequenceGenerator` parent class. .. autoattribute:: wordset eff_longN c l||tdn| |j}|sJt|}||_t|tst |}t |d||_||j}t|d}||_tt|j di|dS)Nz,`words` and `wordset` are mutually exclusiverrrNrn) r5wordsetrr\_sequence_typesrrjrrNrrwrrx)ryrrrNr{r}s r*rxzPhraseGenerator.__init__~s  " NOOO#,w$W-E %11 !%LLEuG,,,,  ;(CE*** .ot$$-5555555r,c*t|jSrU)r4rrs r*rozPhraseGenerator.symbol_countrr,cxfdtjD}j|S)Nc3VK|]#}jjV$dSrU)rchoicerrs r*r3z+PhraseGenerator.__next__..s3JJ,,JJJJJJr,)r rtrNra)ryrs` r*rzPhraseGenerator.__next__s:JJJJfT[6I6IJJJx}}U###r,r) rrrrrrrNrxrrorrrs@r*rr_s  &G E C 666666D$$$$$$$r,rc 6td||d|}||S)amGenerate one or more random password / passphrases. This function uses :mod:`random.SystemRandom` to generate one or more passwords; it can be configured to generate alphanumeric passwords, or full english phrases. The complexity of the password can be specified by size, or by the desired amount of entropy. Usage Example:: >>> # generate random phrase with 48 bits of entropy >>> from passlib import pwd >>> pwd.genphrase() 'gangly robbing salt shove' >>> # generate a random phrase with 52 bits of entropy >>> # using a particular wordset >>> pwd.genword(entropy=52, wordset="bip39") 'wheat dilemma reward rescue diary' :param entropy: Strength of resulting password, measured in 'guessing entropy' bits. An appropriate **length** value will be calculated based on the requested entropy amount, and the size of the word set. This can be a positive integer, or one of the following preset strings: ``"weak"`` (24), ``"fair"`` (36), ``"strong"`` (48), and ``"secure"`` (56). If neither this or **length** is specified, **entropy** will default to ``"strong"`` (48). :param length: Length of resulting password, measured in words. If omitted, the size is auto-calculated based on the **entropy** parameter. If both **entropy** and **length** are specified, the stronger value will be used. :param returns: Controls what this function returns: * If ``None`` (the default), this function will generate a single password. * If an integer, this function will return a list containing that many passwords. * If the ``iter`` builtin, will return an iterator that yields passwords. :param words: Optionally specifies a list/set of words to use when randomly generating a passphrase. This option cannot be combined with **wordset**. :param wordset: The predefined word set to draw from (if not specified by **words**). There are currently four presets available: ``"eff_long"`` (the default) Wordset containing 7776 english words of ~7 letters. Constructed by the EFF, it offers ~12.9 bits of entropy per word. This wordset (and the other ``"eff_"`` wordsets) were `created by the EFF `_ to aid in generating passwords. See their announcement page for more details about the design & properties of these wordsets. ``"eff_short"`` Wordset containing 1296 english words of ~4.5 letters. Constructed by the EFF, it offers ~10.3 bits of entropy per word. ``"eff_prefixed"`` Wordset containing 1296 english words of ~8 letters, selected so that they each have a unique 3-character prefix. Constructed by the EFF, it offers ~10.3 bits of entropy per word. ``"bip39"`` Wordset of 2048 english words of ~5 letters, selected so that they each have a unique 4-character prefix. Published as part of Bitcoin's `BIP 39 `_, this wordset has exactly 11 bits of entropy per word. This list offers words that are typically shorter than ``"eff_long"`` (at the cost of slightly less entropy); and much shorter than ``"eff_prefixed"`` (at the cost of a longer unique prefix). :param sep: Optional separator to use when joining words. Defaults to ``" "`` (a space), but can be an empty string, a hyphen, etc. :returns: :class:`!unicode` string containing randomly generated passphrase; or list of 1+ passphrases if :samp:`returns={int}` is specified. )rzrtrn)rrs r*rrs-B  A'& A AD A AC 3w<<r,rU)r9r)=r __future__rrrrrA collectionsrcollections.abcr ImportErrormathr r r0logging getLoggerrrJrDpasslibr passlib.utils.compatr r rr passlib.utilsrrrpasslib.utils.decorr__all__dictrqr+r=rClistrrr^ frozensetr]r[rjrurlrrrrrrsplitnamerrrrnr,r*rs00SRRRRRRRRRRR ######+.......+++********+#"""""""'g'11 CCCCCCCCCCCC5555555555111111   $     *""" !R!R!RX;;;;.-9  suu)()()()(\I#I#I#I#I#I#I#I#h4 WNB    $E=E=E=E=E=%E=E=E=XGGGGZ   F9898989898.989898|;== 4 9 9 ; ;LLDd$Cd$JKKKK K$K$K$K$K$'K$K$K$dbbbbbbs ! //