�
�M�g#p � �> � S r SSKJrJrJrJr SSKrSSKJr SSK J
r
SSK J
r
Jr SSKr\R" " \5 rSSKJr SSKrSSKJr SS KJrJrJrJ r SS
K J r J r J r SS K!J"r" / S Qr#\$" S
SSSSS9r%S r&S r'S)S jr(\)\*4r+\,\-4r.\," 5 r/S*S jr0 " S S\15 r2\$" SSSS S 9r3 " S S \25 r4S+S jr5S! r6 " S" S#\
5 r7\7" 5 r8S$Rs 5 H r:\8Rw \:S%\:- 5 M " S& S'\25 r<S+S( jr=g! \ a SSKJ
r
N�f = f),z*passlib.pwd -- password generation helpers� )�absolute_import�division�print_function�unicode_literalsN)� defaultdict)�MutableMapping)�ceil�log)� resources)�exc)�PY2�irange�
itervalues� int_types)�rng�
getrandstr�
to_unicode)�memoized_property)�genword�default_charsets� genphrase�default_wordsets� � �$ �0 �< )�unsafe�weak�fair�strong�securec �X � [ U 5 R nX"R U5 S- S $ )z2return remaining classes in object's MRO after cls� N)�type�__mro__�index)�obj�cls�mros �-/usr/lib/python3/dist-packages/passlib/pwd.py�
_superclassesr, 8 s* � �
�s�)�
�
�C� �y�y��~�a� � � !�!� c �. � [ U 5 n[ [ 5 nU H nX#== S-
ss' M Uc UR 5 n[ U5 nO [
U5 nU( d g[ US5 [ S U 5 5 U- -
$ ! [ a Sn N�f = f)a�
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
Nr$ r � c 3 �> # � U H o[ US 5 - v � M g7f)r/ N)�logf)�.0�values r+ � <genexpr>�"_self_info_rate.<locals>.<genexpr>_ s � � � J�6�%�t�E�1�~� 5�6�s � )�len� TypeErrorr �int�values�sumr r1 )�source�size�counts�charr9 s r+ �_self_info_rater? > s� � � ��6�{�� ��
�F���� ��� � � �|�� � � ���6�{���F�#�� �� ��a�=�3� J�6� J�J�T�Q� Q�Q�� � ����s � B � B�Bc �v � U( a% [ R " U5 " [ U 5 5 $ [ R R U 5 ( a [
U S5 $ U R S5 u p#nU( d [ SU < 35 e[ R " U5 R U5 R
S5 $ )z�
: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_path�os�path�isabs�open� partition�
ValueErrorr �files�joinpath)rG �encoding�package�sep�subpaths r+ rE rE j s� � � �� � ��)�*:�4�*@�A�A� �w�w�}�}�T����D�$� � � �N�N�3� /��G�'� ��DH�K� L� L� �?�?�7� #� ,� ,�W� 5� :� :�4� @�@r- c �R � [ nSn X; a g [ U [ 5 ( d! [ [ U 5 5 [ U 5 :X a U( a UR
U 5 gg[ 5 n[ 5 nU H nXd; a UOUR
U5 M [ U5 nSn[ U5 U:� a SnSR S USU 5 5 n[ U5 U:� a US[ U5 U-
- -
n[ S U< S
U< 35 e! [ a Sn GNf = f! [ a gf = f) 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� � �, c 3 �J # � U H n[ [ U5 5 v � M g 7f�N)�repr�str�r2 �words r+ r4 �!_ensure_unique.<locals>.<genexpr>� s � � �B�\�T��c�$�i� � �\�s �!#Nz, ... plus %d others�`z%` cannot contain duplicate elements: )
�_ensure_unique_cacher7 �
isinstance�
_set_typesr6 �set�add�sorted�joinrK ) r; �param�cache�hashable�seen�dups�elem�trunc�dup_reprs r+ �_ensure_uniquerm � s/ � �
!�E��H�� �?�� � �&�*�%�%��S��[�)9�S��[�)H� �
�� � �&�!�
� �5�D� �5�D���� ��4�,�,�T�2� � �$�<�D�
�E�
�4�y�5�����y�y�B�T�&�5�\�B�B�H�
�4�y�5���*�c�$�i�%�.?�@�@�� ��X�'� (� (��9 � ����� �
� ��
�s# �D �D � D�D�
D&�%D&c � ^ � \ rS rSrSrSrSr\rSrS
U 4S jjr \
S 5 r \
S 5 r S r
SS jrS
r\( a S rS rU =r$ S rU =r$ )�SequenceGenerator� a�
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.
Nr! c � >� U R c S5 eUc Uc_ Uc U R n[ R X5 nUS:: a [ S5 e[ [
XR - 5 5 nUb X%: a UnXl US: a [ S5 eX l Ub X0l U( aD [ U [ 5 [ 4:X a+ [ SSR UR 5 5 - 5 e[ [ U ]F " S0 UD6 g ) Nz subclass must set .symbol_countr z!`entropy` must be positive numberr$ z!`length` must be positive integerzUnexpected keyword(s): %srU � )� symbol_count�requested_entropy�entropy_aliases�getrK r8 r �entropy_per_symbol�lengthr r, ro �objectr7 rd �keys�super�__init__)�self�entropyrx r �kwds�
min_length� __class__s �r+ r| �SequenceGenerator.__init__� s� �� � � � �,�O�.O�O�,� � �&�.��� �0�0��%�)�)�'�;�G��!�|� �!D�E�E� �T�'�,C�,C�"C� D�E�J��~��!4�#��!(� � �A�:� � @�A� A� � � �?��H� �M�$�(9�:�v�i�G�� 7�$�)�)�D�I�I�K�:P� P�Q� Q�
� ��/�7�$�7r- c �. � [ U R S5 $ )zJ
Average entropy per symbol (assuming all symbols have equal probability)
r/ )r1 rs �r} s r+ rw �$SequenceGenerator.entropy_per_symbol s � �
�D�%�%�q�)�)r- c �4 � U R U R - $ )a
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`.
)rx rw r� s r+ r~ �SequenceGenerator.entropy s � � �{�{�T� 4� 4�4�4r- c � � [ S5 e)z;main generation function, should create one password/phrasezimplement in subclass)�NotImplementedErrorr� s r+ �__next__�SequenceGenerator.__next__) s � �!�"9�:�:r- c �� � Uc [ U 5 $ [ U[ 5 ( a% [ U5 Vs/ s H n[ U 5 PM sn$ U[ L a U $ [
R " USS5 es snf )z>
frontend used by genword() / genphrase() to create passwords
z<None>, int, or <iter>�returns)�nextr_ r r �iterr �ExpectedTypeError)r} r� �_s r+ �__call__�SequenceGenerator.__call__- sd � � �?���:� �
���
+�
+�(.�w��8��1�D��J��8� 8�
��_��K��'�'��1I�9�U� U�� 9s �A,c � � U $ rW rr r� s r+ �__iter__�SequenceGenerator.__iter__: s � �� r- c �" � U R 5 $ rW )r� r� s r+ r� �SequenceGenerator.next> s � ��=�=�?� "r- )rx rt r �NNNrW )�__name__�
__module__� __qualname__�__firstlineno__�__doc__rx rt r rs r| r rw r~ r� r� r� r
r� �__static_attributes__�
__classcell__�r� s @r+ ro ro � sx �� �&�X �F� !�� �C� �L�
8�F �*� �*� �5� �5�;� V�� � #� #� r- ro zH0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/�>0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ�2234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZ�0123456789abcdef)�ascii_72�ascii_62�ascii_50�hexc �N ^ � \ rS rSrSrSrSrS U 4S jjr\S 5 r S r
Sr U =r $ )
�
WordGeneratori\ a�
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
r� Nc �� >� U( a U( a [ S5 eO%U( d U R nU( d e[ U nX l [ USS9n[ USS9 Xl [ [ U ]" " S0 UD6 g )Nz,`chars` and `charset` are mutually exclusive�chars�re rr ) r7 �charsetr r rm r� r{ r� r| )r} r� r� r r� s �r+ r| �WordGenerator.__init__~ so �� � �� � N�O�O� � � �,�,�� ��w�$�W�-�E� � ��5��0���u�G�,��
� �m�T�+�3�d�3r- c �, � [ U R 5 $ rW )r6 r� r� s r+ rs �WordGenerator.symbol_count� � � ��4�:�:�� r- c �X � [ U R U R U R 5 $ rW )r r r� rx r� s r+ r� �WordGenerator.__next__� s � � �$�(�(�D�J�J�� � �<�<r- )r� r� )NN)
r� r� r� r� r� r� r� r| r rs r� r� r� r� s @r+ r� r� \ s9 �� ��2 �G�
�E�
4�0 � � � �=� =r- r� c �, � [ SXS.UD6nU" U5 $ )a� 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.
)rx r~ rr )r� �r~ rx r� r �gens r+ r r � s! � �L �
?�v�
?�$�
?�C� �w�<�r- c �� � [ U S5 nS U 5 n[ S U 5 5 nSSS5 [ R S[ W5 U 5 U$ ! , ( d f N0= f)a
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-8c 3 �@ # � U H oR 5 v � M g 7frW )�striprZ s r+ r4 � _load_wordset.<locals>.<genexpr> s � � �+���z�z�|�|��s � c 3 �6 # � U H o( d M Uv � M g 7frW rr rZ s r+ r4 r� s � � �3�s�t�d�d�d�s�s �
� Nz!loaded %d-element wordset from %r)rE �tupler
�debugr6 )�
asset_path�fhr� �wordss r+ �
_load_wordsetr� � sT � �
�*�g� .�"�+��+���3�s�3�3��
/�$ �I�I�1�3�u�:�z�J� �L�'
/� .�s � A�
A!c �n ^ � \ rS rSrSrSrSrU 4S jrS rS r S r
S r \ S 5 r
S
rS rS rS
rU =r$ )� WordsetDicti z�
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.
Nc �J >� 0 U l 0 U l [ [ U ] " U0 UD6 g rW )�paths�_loadedr{ r� r| )r} �argsr r� s �r+ r| �WordsetDict.__init__% s% �� ���
��� �
�k�4�)�4�8�4�8r- c � � U R U $ ! [ a Of = fU R U n[ U5 =o0R U' U$ rW )r� �KeyErrorr� r� )r} �keyrG r3 s r+ � __getitem__�WordsetDict.__getitem__* sP � � ��<�<��$� $��� � � ���z�z�#���$1�$�$7�7�� � �S�!�� s � �
� c � � X R U' g)z+
set asset path to lazy-load wordset from.
N)r� )r} r� rG s r+ �set_path�WordsetDict.set_path3 s � � �
�
�3�r- c � � X R U' g rW )r� )r} r� r3 s r+ � __setitem__�WordsetDict.__setitem__9 s � � !� � �S�r- c �| � X; a* U R U U R R US 5 g U R U g rW )r� r� �pop�r} r� s r+ � __delitem__�WordsetDict.__delitem__< s0 � � �;�� � �S�!� �J�J�N�N�3�� %��
�
�3�r- c �f � [ U R 5 nUR U R 5 U$ rW )ra r� �updater� )r} rz s r+ �_keyset�WordsetDict._keysetC s% � ��4�<�<� �� � � �D�J�J� �� r- c �, � [ U R 5 $ rW )r� r� r� s r+ r� �WordsetDict.__iter__I s � ��D�L�L�!�!r- c �, � [ U R 5 $ rW )r6 r� r� s r+ �__len__�WordsetDict.__len__L s � ��4�<�<� � r- c �H � XR ; =( d XR ; $ rW �r� r� r� s r+ � __contains__�WordsetDict.__contains__P s � ��l�l�"�7�c�Z�Z�&7�7r- r� )r� r� r� r� r� r� r� r| r� r� r� r� �propertyr� r� r� r� r� r� r� s @r+ r� r� sW �� ��
�E� �G�9�
� � "� � �� ��
"�!�8� 8r- r� z%eff_long eff_short eff_prefixed bip39z passlib:_data/wordsets/%s.txtc �R ^ � \ rS rSrSrSrSrSrS
U 4S jjr\ S 5 r
S r S r U =r
$ ) �PhraseGeneratori_ a� 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
�eff_longN� c �> >� Ub Ub [ S5 eO!Uc U R nU( d e[ U nXl [ U[ 5 ( d [ U5 n[
USS9 X l Uc U R n[ USS9nX0l [ [ U ]2 " S0 UD6 g )Nz,`words` and `wordset` are mutually exclusiver� r� rP rr )
r7 �wordsetr r_ �_sequence_typesr� rm r� rP r r{ r� r| )r} r� r� rP r r� s �r+ r| �PhraseGenerator.__init__~ s� �� � � ��"� � N�O�O� #� �� �,�,�� ��w�$�W�-�E� � � �%� �1�1��%�L�E��u�G�,��
� �;��(�(�C���E�*���� �o�t�-�5��5r- c �, � [ U R 5 $ rW )r6 r� r� s r+ rs � PhraseGenerator.symbol_count� r� r- c �x ^ � U 4S j[ T R 5 5 nT R R U5 $ )Nc 3 �n ># � U H* nTR R TR 5 v � M, g 7frW )r �choicer� )r2 r� r} s �r+ r4 �+PhraseGenerator.__next__.<locals>.<genexpr>� s' �� � �J�6I����� � ����,�,�6I�s �25)r rx rP rd )r} r� s ` r+ r� �PhraseGenerator.__next__� s) �� �J�f�T�[�[�6I�J���x�x�}�}�U�#�#r- )rP r� r� r� )r� r� r� r� r� r� r� rP r| r rs r� r� r� r� s @r+ r� r� _ sA �� �
�& �G�
�E� �C�
6�D � � � �$� $r- r� c �, � [ SXS.UD6nU" U5 $ )a] 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~ rx rr )r� r� s r+ r r � s! � �B �
A�'�
A�D�
A�C� �w�<�r- rW )r; r� )>r� �
__future__r r r r rC � collectionsr �collections.abcr � ImportError�mathr r
r1 �logging� getLoggerr� � importlibr rF �passlibr �passlib.utils.compatr
r r r �
passlib.utilsr r r �passlib.utils.decorr �__all__�dictru r, r? rE �listr� r� ra � frozensetr` r^ rm ry ro r r� r r� r� r �split�namer� r� r rr r- r+ �<module>r
sk �� 0� S� R�
� #�+�.� #� �g�'�'��1�� � � � C� C� 5� 5� 1� �� �
�
�
� � � ��*"� !R�XA�. ��-���9�
�
� �u� �)(�\I#�� I#�h �
W� N� B� � � �$E=�%� E=�XG�Z �F98�.� 98�| �=� �
4� 9� 9� ;�D�� � �d�$C�d�$J�K�
<� K$�'� K$�db��M � +�*�+�s �D
�
D �D