Current File : //lib/python2.7/site-packages/passlib/pwd.pyc
�
�K@Xc @` sS d Z d d l m Z m Z m Z m Z d d l Z d d l m Z m Z d d l
m Z m Z
d d l Z e j e � Z d d l Z d d l Z d d l m Z d d l m Z m Z m Z m Z d d l m Z m Z m Z d d l m Z d
d d d
g Z e! d d d d d d d d d d � Z" d � Z# d � Z$ d d � Z& e' e( f Z) e* e+ f Z, e* � Z- d d � Z. d e/ f d � � YZ0 e! d d d! d" d# d$ d% d& � Z1 d' e0 f d( � � YZ2 d d d d) � Z3 d* � Z4 d+ e f d, � � YZ5 e5 � Z6 x( d- j7 � D] Z8 e6 j9 e8 d. e8 � q Wd/ e0 f d0 � � YZ: d d d d1 � Z; d S(2 u* passlib.pwd -- password generation helpersi ( t absolute_importt divisiont print_functiont unicode_literalsN( t defaultdictt MutableMapping( t ceilt log( t exc( t PY2t iranget
itervaluest int_types( t rngt
getrandstrt
to_unicode( t memoized_propertyu genwordu default_charsetsu genphraseu default_wordsetst unsafei t weaki t fairi$ t strongi0 t securei< c C` s$ t | � j } | | j | � d S( u2 return remaining classes in object's MRO after clsi ( t typet __mro__t index( t objt clst mro( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt
_superclasses3 s c C` s� y t | � } Wn t k
r) d } n Xt t � } x | D] } | | c d 7<q= W| d k r~ | j � } t | � } n t | � } | s� d St | d � t d � | 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
i i i c s` s" | ] } | t | d � Vq d S( i N( t logf( t .0t value( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pys <genexpr>Z s N( t lent TypeErrort NoneR t intt valuest sumR R ( t sourcet sizet countst charR$ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt _self_info_rate9 s
c C` s� | r t j | � t | � � St j j | � r> t | d � S| j d � \ } } } | sr t d | f � � n t 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)
u rbu :uK asset path must be absolute file path or use 'pkg.name:sub/path' format: %r( t codecst getreadert _open_asset_patht ost patht isabst opent partitiont
ValueErrort
pkg_resourcest resource_stream( R/ t encodingt packaget sept subpath( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyR- e s
u sourcec C` sl t } t } y | | k r t SWn t k
r9 t } n Xt | t � sg t t | � � t | � k r� | r� y | j | � Wq� t k
r� q� Xn t St � } t � } x- | D]% } | | k r� | n | j | � q� Wt | � } d } t | � | k rd } n d j
d � | | D� � } t | � | k rR| d t | � | 7} n t d | | f � � d S( 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
i i u , c s` s! | ] } t t | � � Vq d S( N( t reprt str( R t word( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pys <genexpr>� s u , ... plus %d othersu* `%s` cannot contain duplicate elements: %sN( t _ensure_unique_cachet TrueR! t Falset
isinstancet
_set_typesR t sett addt sortedt joinR3 ( R& t paramt cachet hashablet seent dupst elemt trunct dup_repr( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt _ensure_unique� s6
-
# t SequenceGeneratorc B` s� e Z d Z d Z d Z e Z d Z d d d d � Z e d � � Z
e d � � Z d � Z d d � Z
d � Z e r� d � Z n RS(
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.
u strongc K` sT | j d k s t d � � | d k s3 | d k r� | d k rK | j } n t j | | � } | d k rx t d � � n t t | | j � � } | d k s� | | k r� | } q� n | | _ | d k r� t d � � n | | _
| d k r� | | _ n | r:t | t
� t f k r:t d d j | j � � � � n t t
| � j | � d S( Nu subclass must set .symbol_counti u! `entropy` must be positive numberi u! `length` must be positive integeru Unexpected keyword(s): %su , ( t symbol_countR" t AssertionErrort requested_entropyt entropy_aliasest getR3 R# R t entropy_per_symbolt lengthR
R RO t objectR! RE t keyst supert __init__( t selft entropyRV R
t kwdst
min_length( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRZ � s& "c C` s t | j d � S( uZ
Average entropy per symbol (assuming all symbols have equal probability)
i ( R RP ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRU s c C` s | j | j S( 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`.
( RV RU ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyR\ s c C` s t d � � d S( u; main generation function, should create one password/phraseu implement in subclassN( t NotImplementedError( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __next__$ s c C` sq | d k r t | � St | t � rH g t | � D] } t | � ^ q2 S| t k rX | St j | d d � � d S( uN
frontend used by genword() / genphrase() to create passwords
u <None>, int, or <iter>u returnsN( R" t nextR@ R R
t iterR t ExpectedTypeError( R[ t returnst _( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __call__( s
# c C` s | S( N( ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __iter__5 s c C` s
| j � S( N( R` ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRa 9 s N( t __name__t
__module__t __doc__R" RV RR R
RP RZ R RU R\ R` Rf Rg R Ra ( ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRO � s '#
t ascii_72uH 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/t ascii_62u> 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZt ascii_50u2 234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZt hexu 0123456789abcdeft
WordGeneratorc B` sA e Z d Z d Z d Z d d d � Z e d � � Z d � 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
u ascii_62c K` s� | r | rF t d � � qF n( | s< | j } | s< t � n t | } | | _ t | d d �} t | d d �| | _ t t | � j | � d S( Nu, `chars` and `charset` are mutually exclusiveRF u chars(
R! t charsetRQ t default_charsetsR RN t charsRY Ro RZ ( R[ Rr Rp R] ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRZ y s
c C` s
t | j � S( N( R Rr ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRP � s c C` s t | j | j | j � S( N( R R
Rr RV ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyR` � s N(
Rh Ri Rj Rp R" Rr RZ R RP R` ( ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRo W s c K` s" t d | 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.
RV R\ ( Ro ( R\ RV Rd R] t gen( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt genword� s Fc C` s[ t | d � �- } d � | D� } t d � | D� � } Wd QXt j d t | � | � | 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.
u utf-8c s` s | ] } | j � Vq d S( N( t strip( R R< ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pys <genexpr>� s c s` s | ] } | r | Vq d S( N( ( R R< ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pys <genexpr>� s Nu! loaded %d-element wordset from %r( R- t tupleR t debugR ( t
asset_patht fhRs t words( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt
_load_wordset� s
t WordsetDictc B` sq e Z d Z d
Z d
Z d � Z d � Z d � Z d � Z d � Z
e d � � Z d � Z
d � Z d � Z RS( 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.
c O` s/ i | _ i | _ t t | � j | | � d S( N( t pathst _loadedRY R| RZ ( R[ t argsR] ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRZ s c C` sK y | j | SWn t k
r" n X| j | } t | � } | j | <| S( N( R~ t KeyErrorR} R{ ( R[ t keyR/ R ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __getitem__% s
c C` s | | j | <d S( u;
set asset path to lazy-load wordset from.
N( R} ( R[ R� R/ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt set_path. s c C` s | | j | <d S( N( R~ ( R[ R� R ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __setitem__4 s c C` s: | | k r, | j | =| j j | d � n
| j | =d S( N( R~ R} t popR" ( R[ R� ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __delitem__7 s
c C` s# t | j � } | j | j � | S( N( RB R~ t updateR} ( R[ RX ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt _keyset> s c C` s
t | j � S( N( Rb R� ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRg D s c C` s
t | j � S( N( R R� ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __len__G s c C` s | | j k p | | j k S( N( R~ R} ( R[ R� ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt __contains__K s N( Rh Ri Rj R" R} R~ RZ R� R� R� R� t propertyR� Rg R� R� ( ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyR| s u% eff_long eff_short eff_prefixed bip39u passlib:_data/wordsets/%s.txtt PhraseGeneratorc B` sJ e Z d Z d Z d Z d Z d d d d � Z e d � � 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
u eff_longu c K` s� | d k r* | d k rX t d � � qX n. | d k rN | j } | sN t � n t | } | | _ t | t � s t | � } n t | d d �| | _ | d k r� | j
} n t | d d �} | | _
t t
| � j | � d S( Nu, `words` and `wordset` are mutually exclusiveRF u wordsu sep( R" R! t wordsetRQ t default_wordsetsR@ t _sequence_typesRv RN Rz R8 R RY R� RZ ( R[ R� Rz R8 R] ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRZ y s"
c C` s
t | j � S( N( R Rz ( R[ ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyRP � s c ` s/ � f d � t � j � D� } � j j | � S( Nc 3` s$ | ] } � j j � j � Vq d S( N( R
t choiceRz ( R Re ( R[ ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pys <genexpr>� s ( R
RV R8 RE ( R[ Rz ( ( R[ s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyR` � s N( Rh Ri Rj R� R" Rz R8 RZ R RP R` ( ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyR� Z s "c K` s" t d | d | | � } | | � S( um Generate 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\ RV Rd R] Rs ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt genphrase� s a(< Rj t
__future__R R R R R+ t collectionsR R t mathR R R t loggingt getLoggerRh R4 R. t passlibR t passlib.utils.compatR R
R R t
passlib.utilsR
R R t passlib.utils.decorR t __all__t dictRS R R* R" R- t listRv R� RB t frozensetRA R= RN RW RO Rq Ro Rt R{ R| R� t splitt nameR� R� R� ( ( ( s/ /usr/lib/python2.7/site-packages/passlib/pwd.pyt <module> sT " " , .� LM #> R
Mini Shell