a
f�Wcp � @ s� d Z ddlmZmZmZmZ ddlZddlmZ zddl m
Z
W n e y^ ddlm
Z
Y n0 ddl m
Z
mZ ddlZe�e�ZddlZddlZddlmZ ddlmZmZmZmZ dd l m Z m Z m Z dd
l m!Z! g d �Z"e#d d
dddd�Z$dd� Z%dd� Z&d0dd�Z'e(e)fZ*e+e,fZ-e+� Z.d1dd�Z/G dd � d e0�Z1e#d d d d d!�Z2G d"d#� d#e1�Z3d2d$d%�Z4d&d'� Z5G d(d)� d)e
�Z6e6� Z7d*�8� D ]Z9e7�:e9d+e9 � �q�G d,d-� d-e1�Z;d3d.d/�Z<dS )4z*passlib.pwd -- password generation helpers� )�absolute_import�division�print_function�unicode_literalsN)� defaultdict)�MutableMapping)�ceil�log)�exc)�PY2�irange�
itervalues� int_types)�rng�
getrandstr�
to_unicode)�memoized_property)�genword�default_charsets� genphrase�default_wordsets� � �$ �0 �< )ZunsafeZweakZfair�strongZsecurec C s t | �j}||�|�d d� S )z2return remaining classes in object's MRO after cls� N)�type�__mro__�index)�obj�cls�mro� r$ �//usr/lib/python3.9/site-packages/passlib/pwd.py�
_superclasses8 s
r& c C s� z t | �}W n ty" d}Y n0 tt�}| D ]}|| d7 < q0|du r`|�� }t|�}nt|�}|spdS t|d�tdd� |D ��| S )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 s s | ]}|t |d � V qdS )r' N)�logf)�.0�valuer$ r$ r% � <genexpr>_ � z"_self_info_rate.<locals>.<genexpr>)�len� TypeErrorr �int�values�sumr
r( )�source�sizeZcounts�charr0 r$ r$ r% �_self_info_rate> s
r5 c C sZ |rt �|�t| ��S tj�| �r,t| d�S | �d�\}}}|sNtd| f ��t �
||�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�:zKasset path must be absolute file path or use 'pkg.name:sub/path' format: %r) �codecs� getreader�_open_asset_path�os�path�isabs�open� partition�
ValueError�
pkg_resourcesZresource_stream)r< �encoding�package�sepZsubpathr$ r$ r% r: j s
�r: r2 c C s t }d}z| |v rW dS W n ty0 d}Y n0 t| t�sPtt| ��t| �krz|rvz|�| � W n tyt Y n0 dS t� }t� }| D ]}||v r�|n|�|� q�t|�}d}t|�|kr�d}d�dd� |d|� D ��}t|�|kr�|d t|�| 7 }t d
||f ��dS ) 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 s s | ]}t t|��V qd S �N)�repr�str�r) Zwordr$ r$ r% r+ � r, z!_ensure_unique.<locals>.<genexpr>Nz, ... plus %d othersz*`%s` cannot contain duplicate elements: %s)
�_ensure_unique_cacher. �
isinstance�
_set_typesr- �set�add�sorted�joinr@ ) r2 �param�cacheZhashable�seenZdups�elemZtruncZdup_reprr$ r$ r% �_ensure_unique� s8
�rW c sp e Zd ZdZdZdZeZdZd� fdd� Ze dd� �Z
e dd � �Z d
d � Z dd d
�Z
dd� Zerhdd� Z� ZS )�SequenceGeneratoraY
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 s� | j d usJ d��|d us"|d u rr|d u r0| j}t�||�}|dkrLtd��tt|| j ��}|d u sn||k rr|}|| _|dk r�td��|| _|d ur�|| _ |r�t
| t �t fkr�t
dd�|�� � ��tt | �jf i |�� d S )Nz subclass must set .symbol_countr z!`entropy` must be positive numberr z!`length` must be positive integerzUnexpected keyword(s): %srG )� symbol_count�requested_entropy�entropy_aliases�getr@ r/ r �entropy_per_symbol�lengthr r& rX �objectr. rR �keys�super�__init__)�self�entropyr^ r �kwdsZ
min_length�� __class__r$ r% rb � s& zSequenceGenerator.__init__c C s t | jd�S )zZ
Average entropy per symbol (assuming all symbols have equal probability)
r' )r( rY �rc r$ r$ r% r] s z$SequenceGenerator.entropy_per_symbolc C s | j | j S )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`.
)r^ r] rh r$ r$ r% rd s zSequenceGenerator.entropyc C s t d��dS )z;main generation function, should create one password/phrasezimplement in subclassN)�NotImplementedErrorrh r$ r$ r% �__next__) s zSequenceGenerator.__next__c sN |du rt � �S t|t�r0� fdd�t|�D �S |tu r<� S t�|dd��dS )zN
frontend used by genword() / genphrase() to create passwords
Nc s g | ] }t � ��qS r$ )�next�r) �_rh r$ r% �
<listcomp>4 r, z.SequenceGenerator.__call__.<locals>.<listcomp>z<None>, int, or <iter>�returns)rk rM r r �iterr
ZExpectedTypeError)rc ro r$ rh r% �__call__- s
zSequenceGenerator.__call__c C s | S rH r$ rh r$ r$ r% �__iter__: s zSequenceGenerator.__iter__c C s | � � S rH )rj rh r$ r$ r% rk > s zSequenceGenerator.next)NNN)N)�__name__�
__module__� __qualname__�__doc__r^ rZ r rY rb r r] rd rj rq rr r rk �
__classcell__r$ r$ rf r% rX � s ,#
rX zH0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/Z>0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZZ2234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZZ0123456789abcdef)Zascii_72�ascii_62Zascii_50�hexc s> e Zd ZdZdZdZd
� fdd� Zedd� �Zdd � Z � Z
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
rx Nc sj |r|r,t d��n|s$| j}|s$J �t| }|| _t|dd�}t|dd� || _tt| �jf i |�� d S )Nz,`chars` and `charset` are mutually exclusive�chars�rS ) r. �charsetr r rW r{ ra rz rb )rc r{ r} re rf r$ r% rb ~ s
zWordGenerator.__init__c C s
t | j�S rH )r- r{ rh r$ r$ r% rY � s zWordGenerator.symbol_countc C s t | j| j| j�S rH )r r r{ r^ rh r$ r$ r% rj � s zWordGenerator.__next__)NN) rs rt ru rv r} r{ rb r rY rj rw r$ r$ rf r% rz \ s
rz c K s t f || d�|��}||�S )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.
)r^ rd )rz �rd r^ ro re �genr$ r$ r% r � s Fr c C s` t | d��0}dd� |D �}tdd� |D ��}W d � n1 s@0 Y t�dt|�| � |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-8c s s | ]}|� � V qd S rH )�striprK r$ r$ r% r+ r, z _load_wordset.<locals>.<genexpr>c s s | ]}|r|V qd S rH r$ rK r$ r$ r% r+ r, Nz!loaded %d-element wordset from %r)r: �tupler �debugr- )Z
asset_pathZfhr �wordsr$ r$ r% �
_load_wordset� s
0r� c sl e Zd ZdZdZdZ� fdd�Zdd� Zdd� Zd d
� Z d d � Z
e d
d� �Z dd� Z
dd� Zdd� Z� ZS )� 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.
Nc s& i | _ i | _tt| �j|i |�� d S rH )�paths�_loadedra r� rb )rc �argsre rf r$ r% rb % s zWordsetDict.__init__c C s@ z | j | W S ty Y n0 | j| }t|� }| j |< |S rH )r� �KeyErrorr� r� )rc �keyr< r* r$ r$ r% � __getitem__* s
zWordsetDict.__getitem__c C s || j |< dS )z;
set asset path to lazy-load wordset from.
N)r� )rc r� r< r$ r$ r% �set_path3 s zWordsetDict.set_pathc C s || j |< d S rH )r� )rc r� r* r$ r$ r% � __setitem__9 s zWordsetDict.__setitem__c C s, || v r | j |= | j�|d � n| j|= d S rH )r� r� �pop�rc r� r$ r$ r% � __delitem__< s zWordsetDict.__delitem__c C s t | j�}|�| j� |S rH )rO r� �updater� )rc r` r$ r$ r% �_keysetC s
zWordsetDict._keysetc C s
t | j�S rH )rp r� rh r$ r$ r% rr I s zWordsetDict.__iter__c C s
t | j�S rH )r- r� rh r$ r$ r% �__len__L s zWordsetDict.__len__c C s || j v p|| jv S rH )r� r� r� r$ r$ r% � __contains__P s zWordsetDict.__contains__)rs rt ru rv r� r� rb r� r� r� r� �propertyr� rr r� r� rw r$ r$ rf r% r� s
r� z%eff_long eff_short eff_prefixed bip39z passlib:_data/wordsets/%s.txtc sB e Zd ZdZdZdZdZd � fdd� Zedd� �Z d d
� Z
� Z S ) �PhraseGeneratora� 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
Zeff_longN� c s� |d ur|d ur8t d��n |d u r0| j}|s0J �t| }|| _t|t�sPt|�}t|dd� || _|d u rp| j}t |dd�}|| _t
t | �j f i |�� d S )Nz,`words` and `wordset` are mutually exclusiver� r| rD )
r. �wordsetr rM �_sequence_typesr� rW r� rD r ra r� rb )rc r� r� rD re rf r$ r% rb ~ s"
zPhraseGenerator.__init__c C s
t | j�S rH )r- r� rh r$ r$ r% rY � s z PhraseGenerator.symbol_countc s$ � fdd�t � j�D �}� j�|�S )Nc 3 s | ]}� j �� j�V qd S rH )r �choicer� rl rh r$ r% r+ � r, z+PhraseGenerator.__next__.<locals>.<genexpr>)r r^ rD rR )rc r� r$ rh r% rj � s zPhraseGenerator.__next__)NNN) rs rt ru rv r� r� rD rb r rY rj rw r$ r$ rf r% r� _ s "
r� c K s t f | |d�|��}||�S )am 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.
)rd r^ )r� r~ r$ r$ r% r � s ar )N)r2 )NNN)NNN)=rv Z
__future__r r r r r8 � collectionsr �collections.abcr � ImportErrorZmathr r r( ZloggingZ getLoggerrs rA r; Zpasslibr
Zpasslib.utils.compatr r r
r Z
passlib.utilsr r r Zpasslib.utils.decorr �__all__�dictr[ r& r5 r: �listr� r� rO � frozensetrN rL rW r_ rX r rz r r� r� r �split�namer� r� r r$ r$ r$ r% �<module> s^
�,
. �L
M#> R