File Manager

Viewing File: /usr/lib/python2.7/site-packages/passlib/pwd.pyc

ó
öK@Xc@`sSdZddlmZmZmZmZddlZddlmZm	Z	ddl
mZmZ
ddlZejeƒZddlZddlZddlmZddlmZmZmZmZddlmZmZmZdd	lmZd
ddd
gZ e!ddddddddddƒZ"d„Z#d„Z$dd„Z&e'e(fZ)e*e+fZ,e*ƒZ-dd„Z.de/fd„ƒYZ0e!dd d!d"d#d$d%d&ƒZ1d'e0fd(„ƒYZ2dddd)„Z3d*„Z4d+e	fd,„ƒYZ5e5ƒZ6x(d-j7ƒD]Z8e6j9e8d.e8ƒq	Wd/e0fd0„ƒYZ:dddd1„Z;dS(2u*passlib.pwd -- password generation helpersi(tabsolute_importtdivisiontprint_functiontunicode_literalsN(tdefaultdicttMutableMapping(tceiltlog(texc(tPY2tiranget
itervaluest	int_types(trngt
getrandstrt
to_unicode(tmemoized_propertyugenwordudefault_charsetsu	genphraseudefault_wordsetstunsafeitweakitfairi$tstrongi0tsecurei<cC`s$t|ƒj}||j|ƒdS(u2return remaining classes in object's MRO after clsi(ttypet__mro__tindex(tobjtclstmro((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt
_superclasses3scC`s¹yt|ƒ}Wntk
r)d}nXttƒ}x|D]}||cd7<q=W|dkr~|jƒ}t|ƒ}nt|ƒ}|s”dSt|dƒtd„|Dƒƒ|S(u÷
    returns 'rate of self-information' --
    i.e. average (per-symbol) entropy of the sequence **source**,
    where probability of a given symbol occurring is calculated based on
    the number of occurrences within the sequence itself.

    if all elements of the source are unique, this should equal ``log(len(source), 2)``.

    :arg source:
        iterable containing 0+ symbols
        (e.g. list of strings or ints, string of characters, etc).

    :returns:
        float bits of entropy
    iiics`s"|]}|t|dƒVqdS(iN(tlogf(t.0tvalue((s//usr/lib/python2.7/site-packages/passlib/pwd.pys	<genexpr>ZsN(	tlent	TypeErrortNoneRtinttvaluestsumRR(tsourcetsizetcountstcharR$((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt_self_info_rate9s

cC`s‚|rtj|ƒt|ƒƒStjj|ƒr>t|dƒS|jdƒ\}}}|srtd|fƒ‚nt	j
||ƒS(u
    :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)
    urbu:uKasset path must be absolute file path or use 'pkg.name:sub/path' format: %r(tcodecst	getreadert_open_asset_pathtostpathtisabstopent	partitiont
ValueErrort
pkg_resourcestresource_stream(R/tencodingtpackagetseptsubpath((s//usr/lib/python2.7/site-packages/passlib/pwd.pyR-es
usourcec	C`slt}t}y||krtSWntk
r9t}nXt|tƒsgtt|ƒƒt|ƒkr™|r•y|j|ƒWq•tk
r‘q•XntStƒ}tƒ}x-|D]%}||krÊ|n|j|ƒq²Wt	|ƒ}d}t|ƒ|krd}ndj
d„|| Dƒƒ}t|ƒ|krR|dt|ƒ|7}ntd||fƒ‚dS(u¯
    helper for generators --
    Throws ValueError if source elements aren't unique.
    Error message will display (abbreviated) repr of the duplicates in a string/list
    iiu, cs`s!|]}tt|ƒƒVqdS(N(treprtstr(Rtword((s//usr/lib/python2.7/site-packages/passlib/pwd.pys	<genexpr>¦su, ... plus %d othersu*`%s` cannot contain duplicate elements: %sN(t_ensure_unique_cachetTrueR!tFalset
isinstancet
_set_typesR tsettaddtsortedtjoinR3(	R&tparamtcachethashabletseentdupstelemttrunctdup_repr((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt_ensure_uniqueƒs6
-
		
#	tSequenceGeneratorcB`s†eZdZd	ZdZeZd	Zd	d	d	d„Ze	d„ƒZ
e	d„ƒZd„Zd	d„Z
d„Zer„d„ZnRS(
uY
    Base class used by word & phrase generators.

    These objects take a series of options, corresponding
    to those of the :func:`generate` function.
    They act as callables which can be used to generate a password
    or a list of 1+ passwords. They also expose some read-only
    informational attributes.

    Parameters
    ----------
    :param entropy:
        Optionally specify the amount of entropy the resulting passwords
        should contain (as measured with respect to the generator itself).
        This will be used to auto-calculate the required password size.

    :param length:
        Optionally specify the length of password to generate,
        measured as count of whatever symbols the subclass uses (characters or words).
        Note if ``entropy`` requires a larger minimum length,
        that will be used instead.

    :param rng:
        Optionally provide a custom RNG source to use.
        Should be an instance of :class:`random.Random`,
        defaults to :class:`random.SystemRandom`.

    Attributes
    ----------
    .. autoattribute:: length
    .. autoattribute:: symbol_count
    .. autoattribute:: entropy_per_symbol
    .. autoattribute:: entropy

    Subclassing
    -----------
    Subclasses must implement the ``.__next__()`` method,
    and set ``.symbol_count`` before calling base ``__init__`` method.
    ustrongcK`sT|jdk	stdƒ‚|dk	s3|dkrµ|dkrK|j}ntj||ƒ}|dkrxtdƒ‚ntt||j	ƒƒ}|dks©||krµ|}qµn||_|dkrÙtdƒ‚n||_
|dk	rú||_n|r:t|t
ƒtfkr:tddj|jƒƒƒ‚ntt
|ƒj|dS(Nusubclass must set .symbol_countiu!`entropy` must be positive numberiu!`length` must be positive integeruUnexpected keyword(s): %su, (tsymbol_countR"tAssertionErrortrequested_entropytentropy_aliasestgetR3R#Rtentropy_per_symboltlengthR
RROtobjectR!REtkeystsupert__init__(tselftentropyRVR
tkwdst
min_length((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRZìs&		"cC`st|jdƒS(uZ
        Average entropy per symbol (assuming all symbols have equal probability)
        i(RRP(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRUscC`s|j|jS(u+
        Effective entropy of generated passwords.

        This value will always be a multiple of :attr:`entropy_per_symbol`.
        If entropy is specified in constructor, :attr:`length` will be chosen so
        so that this value is the smallest multiple >= :attr:`requested_entropy`.
        (RVRU(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyR\s	cC`stdƒ‚dS(u;main generation function, should create one password/phraseuimplement in subclassN(tNotImplementedError(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__next__$scC`sq|dkrt|ƒSt|tƒrHgt|ƒD]}t|ƒ^q2S|tkrX|Stj|ddƒ‚dS(uN
        frontend used by genword() / genphrase() to create passwords
        u<None>, int, or <iter>ureturnsN(R"tnextR@RR
titerRtExpectedTypeError(R[treturnst_((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__call__(s
#cC`s|S(N((R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__iter__5scC`s
|jƒS(N(R`(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRa9sN(t__name__t
__module__t__doc__R"RVRRR
RPRZRRUR\R`RfRgR	Ra(((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRO±s'#	
	tascii_72uH0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/tascii_62u>0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZtascii_50u2234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZthexu0123456789abcdeft
WordGeneratorcB`sAeZdZdZdZddd„Zed„ƒZd„Z	RS(uê
    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
    uascii_62cK`s”|r|rFtdƒ‚qFn(|s<|j}|s<t‚nt|}||_t|ddƒ}t|ddƒ||_tt|ƒj	|dS(Nu,`chars` and `charset` are mutually exclusiveRFuchars(
R!tcharsetRQtdefault_charsetsRRNtcharsRYRoRZ(R[RrRpR]((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRZys	
		cC`s
t|jƒS(N(R Rr(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRP‘scC`st|j|j|jƒS(N(RR
RrRV(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyR`™sN(
RhRiRjRpR"RrRZRRPR`(((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRoWscK`s"td|d||}||ƒS(u¶
Generate one or more random passwords.

    This function uses :mod:`random.SystemRandom` to generate
    one or more passwords using various character sets.
    The complexity of the password can be specified
    by size, or by the desired amount of entropy.

    Usage Example::

        >>> # 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.
    RVR\(Ro(R\RVRdR]tgen((s//usr/lib/python2.7/site-packages/passlib/pwd.pytgenword£sFcC`s[t|dƒ-}d„|Dƒ}td„|Dƒƒ}WdQXtjdt|ƒ|ƒ|S(u2
    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.
    uutf-8cs`s|]}|jƒVqdS(N(tstrip(RR<((s//usr/lib/python2.7/site-packages/passlib/pwd.pys	<genexpr>þscs`s|]}|r|VqdS(N((RR<((s//usr/lib/python2.7/site-packages/passlib/pwd.pys	<genexpr>ÿsNu!loaded %d-element wordset from %r(R-ttupleRtdebugR (t
asset_pathtfhRstwords((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt
_load_wordsetðs

tWordsetDictcB`sqeZdZd
Zd
Zd„Zd„Zd„Zd„Z	d„Z
ed„ƒZd„Z
d„Zd	„ZRS(u¢
    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.
    cO`s/i|_i|_tt|ƒj||ŽdS(N(tpathst_loadedRYR|RZ(R[targsR]((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRZ s		cC`sKy|j|SWntk
r"nX|j|}t|ƒ}|j|<|S(N(R~tKeyErrorR}R{(R[tkeyR/R((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__getitem__%s

cC`s||j|<dS(u;
        set asset path to lazy-load wordset from.
        N(R}(R[RR/((s//usr/lib/python2.7/site-packages/passlib/pwd.pytset_path.scC`s||j|<dS(N(R~(R[RR((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__setitem__4scC`s:||kr,|j|=|jj|dƒn
|j|=dS(N(R~R}tpopR"(R[R((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__delitem__7s
cC`s#t|jƒ}|j|jƒ|S(N(RBR~tupdateR}(R[RX((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt_keyset>scC`s
t|jƒS(N(RbRˆ(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRgDscC`s
t|jƒS(N(R Rˆ(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__len__GscC`s||jkp||jkS(N(R~R}(R[R((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt__contains__KsN(RhRiRjR"R}R~RZR‚RƒR„R†tpropertyRˆRgR‰RŠ(((s//usr/lib/python2.7/site-packages/passlib/pwd.pyR|s								u%eff_long eff_short eff_prefixed bip39upasslib:_data/wordsets/%s.txttPhraseGeneratorcB`sJeZdZdZdZdZdddd„Zed„ƒZ	d„Z
RS(uÌclass 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
    ueff_longu cK`så|dk	r*|dk	rXtdƒ‚qXn.|dkrN|j}|sNt‚nt|}||_t|tƒst|ƒ}nt|ddƒ||_	|dkr°|j
}nt|ddƒ}||_
tt
|ƒj|dS(Nu,`words` and `wordset` are mutually exclusiveRFuwordsusep(R"R!twordsetRQtdefault_wordsetsR@t_sequence_typesRvRNRzR8RRYRŒRZ(R[RRzR8R]((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRZys"	
			cC`s
t|jƒS(N(R Rz(R[((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRP›sc`s/‡fd†tˆjƒDƒ}ˆjj|ƒS(Nc3`s$|]}ˆjjˆjƒVqdS(N(R
tchoiceRz(RRe(R[(s//usr/lib/python2.7/site-packages/passlib/pwd.pys	<genexpr>¤s(R
RVR8RE(R[Rz((R[s//usr/lib/python2.7/site-packages/passlib/pwd.pyR`£sN(RhRiRjRR"RzR8RZRRPR`(((s//usr/lib/python2.7/site-packages/passlib/pwd.pyRŒZs"cK`s"td|d||}||ƒS(umGenerate 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 <https://www.eff.org/deeplinks/2016/07/new-wordlists-random-passphrases>`_
            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 <https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt>`_,
            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.
    R\RV(RŒ(R\RVRdR]Rs((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt	genphrase¬sa(<Rjt
__future__RRRRR+tcollectionsRRtmathRRRtloggingt	getLoggerRhR4R.tpasslibRtpasslib.utils.compatR	R
RRt
passlib.utilsR
RRtpasslib.utils.decorRt__all__tdictRSRR*R"R-tlistRvRRBt	frozensetRAR=RNRWRORqRoRtR{R|RŽtsplittnameRƒRŒR‘(((s//usr/lib/python2.7/site-packages/passlib/pwd.pyt<module>sT""			,	.”	LM	#>	R
Back to Directory File Manager