⚝
One Hat Cyber Team
⚝
Your IP:
216.73.216.24
Server IP:
50.6.168.112
Server:
Linux server-617809.webnetzimbabwe.com 5.14.0-570.25.1.el9_6.x86_64 #1 SMP PREEMPT_DYNAMIC Wed Jul 9 04:57:09 EDT 2025 x86_64
Server Software:
Apache
PHP Version:
8.4.10
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
lib
/
python3.9
/
site-packages
/
passlib
/
__pycache__
/
View File Name :
pwd.cpython-39.opt-1.pyc
a fWcp @ s d Z ddlmZmZmZmZ ddlZddlmZ zddl m Z W n e y^ ddlm Z Y n0 ddl m Z mZ ddlZeeZddlZddlZddlmZ ddlmZmZmZmZ dd l m Z m Z m Z dd l m!Z! g d Z"e#d d ddddZ$dd Z%dd Z&d0ddZ'e(e)fZ*e+e,fZ-e+ Z.d1ddZ/G dd d e0Z1e#d d d d d!Z2G d"d# d#e1Z3d2d$d%Z4d&d' Z5G d(d) d)e Z6e6 Z7d*8 D ]Z9e7:e9d+e9 qG d,d- d-e1Z;d3d.d/Z<dS )4z*passlib.pwd -- password generation helpers )absolute_importdivisionprint_functionunicode_literalsN) defaultdict)MutableMapping)ceillog)exc)PY2irange itervalues int_types)rng getrandstr to_unicode)memoized_property)genworddefault_charsets genphrasedefault_wordsets $ 0 < )ZunsafeZweakZfairstrongZsecurec C s t | j}|||d d S )z2return remaining classes in object's MRO after cls N)type__mro__index)objclsmro 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|dtdd |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).0valuer$ r$ r% <genexpr>_ z"_self_info_rate.<locals>.<genexpr>)len TypeErrorr intvaluessumr r( )sourcesizeZcountscharr0 r$ r$ r% _self_info_rate> s r5 c C sZ |rt |t| S tj| r,t| dS | 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_pathospathisabsopen partition ValueError pkg_resourcesZresource_stream)r< encodingpackagesepZsubpathr$ r$ r% r: j s r: r2 c C s t }d}z| |v rW dS W n ty0 d}Y n0 t| tsPtt| t| krz|rvz|| W n tyt Y n0 dS t }t }| D ]}||v r|n|| qt|}d}t||krd}ddd |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)reprstrr) 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- setaddsortedjoinr@ ) r2 paramcacheZhashableseenZdupselemZtruncZdup_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 |d us|d u r`|d u r | j }t||}|dkr:tdtt|| j }|d u s\||k r`|}|| _ |dk rvtd|| _|d ur|| _|rt | t t fkrt dd | tt | jf i | d S )Nr z!`entropy` must be positive numberr z!`length` must be positive integerzUnexpected keyword(s): %srG )requested_entropyentropy_aliasesgetr@ r/ r entropy_per_symbollengthr r& rX objectr. rR keyssuper__init__)selfentropyr] r kwdsZ min_length __class__r$ r% ra s$ zSequenceGenerator.__init__c C s t | jdS )zZ Average entropy per symbol (assuming all symbols have equal probability) r' )r( symbol_countrb 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% rc s zSequenceGenerator.entropyc C s t ddS )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|tr0 fddt|D S |tu r< S t|dddS )zN frontend used by genword() / genphrase() to create passwords Nc s g | ] }t qS r$ )nextr) _rh r$ r% <listcomp>4 r, z.SequenceGenerator.__call__.<locals>.<listcomp>z<None>, int, or <iter>returns)rk rM r r iterr ZExpectedTypeError)rb 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] rY r rg ra r r\ rc rj rq rr r rk __classcell__r$ r$ re r% rX s ,# rX zH0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/Z>0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZZ2234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZZ0123456789abcdef)Zascii_72ascii_62Zascii_50hexc 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 sb |r|r$t dn|s | j}t| }|| _t|dd}t|dd || _tt| jf i | d S )Nz,`chars` and `charset` are mutually exclusivecharsrS ) r. charsetr r rW r{ r` rz ra )rb r{ r} rd re r$ r% ra ~ s zWordGenerator.__init__c C s t | jS rH )r- r{ rh r$ r$ r% rg s zWordGenerator.symbol_countc C s t | j| j| jS rH )r r r{ r] rh r$ r$ r% rj s zWordGenerator.__next__)NN) rs rt ru rv r} r{ ra r rg rj rw r$ r$ re 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] rc )rz rc r] ro rd genr$ r$ r% r s Fr c C s` t | d0}dd |D }tdd |D }W d n1 s@0 Y tdt|| |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 fddZdd 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_loadedr` r ra )rb argsrd re r$ r% ra % s zWordsetDict.__init__c C s@ z | j | W S ty Y n0 | j| }t| }| j |< |S rH )r KeyErrorr r )rb 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 )rb r r< r$ r$ r% set_path3 s zWordsetDict.set_pathc C s || j |< d S rH )r )rb 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 poprb r r$ r$ r% __delitem__< s zWordsetDict.__delitem__c C s t | j}|| j |S rH )rO r updater )rb r_ r$ r$ r% _keysetC s zWordsetDict._keysetc C s t | jS rH )rp r rh r$ r$ r% rr I s zWordsetDict.__iter__c C s t | jS 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 ra r r r r propertyr rr r r rw r$ r$ re 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 ur0t dn|d u r(| j}t| }|| _t|tsHt|}t|dd || _|d u rh| 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 r` r ra )rb r r rD rd re r$ r% ra ~ s zPhraseGenerator.__init__c C s t | jS rH )r- r rh r$ r$ r% rg s z PhraseGenerator.symbol_countc s$ fddt jD } j|S )Nc 3 s | ]} j jV qd S rH )r choicer rl rh r$ r% r+ r, z+PhraseGenerator.__next__.<locals>.<genexpr>)r r] rD rR )rb r r$ rh r% rj s zPhraseGenerator.__next__)NNN) rs rt ru rv r r rD ra r rg rj rw r$ r$ re 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. )rc 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__dictrZ r& r5 r: listr r rO frozensetrN rL rW r^ rX r rz r r r r splitnamer r r r$ r$ r$ r% <module> s^ , . L M#> R