| Current File : //lib/python2.7/site-packages/passlib/utils/handlers.pyc |
�
���Xc @� s: d Z d d l m Z d d l 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 j
Z
d d l j Z d d l m Z m Z m Z d d l m Z d d l m Z d d l m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m! Z! d d l" m# Z# m$ Z$ m% Z% m& Z& m' Z' m( Z( m) Z) d d
l* m+ Z+ m, Z, m- Z- m. Z. m/ Z/ m0 Z0 m1 Z1 m2 Z2 m0 Z0 m3 Z3 m4 Z4 m5 Z5 d d l6 m7 Z7 m8 Z8 d d
d d d d d d d d d d d d g Z9 e$ Z: e# Z; e% Z< e' Z= e( Z> d � Z? d d � Z@ d � ZA d � ZB e- d � ZC e- d � ZD d! � ZE d" � ZF eC eG d# � ZH eC d$ eG eG d% � ZI d$ eG d& eG d' � ZJ e- d � d( � ZK e- d � d$ d) � ZL d& d* � ZM d eG d& eN d+ � ZO d, e f d- � � YZP d. eP f d/ � � YZQ d eP f d0 � � YZR d eR f d1 � � YZS d2 eR f d3 � � YZT d eR f d4 � � YZU d eR f d5 � � YZV d eR f d6 � � YZW d eR f d7 � � YZX d eX f d8 � � YZY d eR f d9 � � YZZ d: eR f d; � � YZ[ e j\ � Z] d< e f d= � � YZ^ d> e^ f d? � � YZ_ d e^ eR f d@ � � YZ` d ea f dA � � YZb d S(B sR passlib.handler - code for implementing handlers, and global registry for handlersi����( t with_statementN( t warn( t MissingBackendErrort PasslibConfigWarningt PasslibHashWarning( t PasswordHash( t get_crypt_handler( t consteqt
getrandstrt getrandbytest rngt
to_native_strt is_crypt_handlert
to_unicodet MAX_PASSWORD_SIZEt accepts_keywordt as_boolt update_mixin_classes( t BASE64_CHARSt HASH64_CHARSt PADDED_BASE64_CHARSt HEX_CHARSt UPPER_HEX_CHARSt LOWER_HEX_CHARSt ALL_BYTE_VALUES( t join_byte_valuest iranget ut native_string_typest
uascii_to_strt join_unicodet unicodet
str_to_uasciiR t unicode_or_bytes_typest PY2t int_types( t
classpropertyt deprecated_methodt parse_mc2t parse_mc3t
render_mc2t
render_mc3t GenericHandlert
StaticHandlert HasUserContextt HasRawChecksumt
HasManyIdentst HasSaltt
HasRawSaltt HasRoundst HasManyBackendst
PrefixWrapperc C� s@ | r8 | r8 d d l } t | | j t | � d � � Sd Sd S( s helper for bitsize() methodsi����Ni i ( t matht intt logt len( t countt charsR4 ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _bitsizeJ s i c C� s� t j � } | } zi x^ | rv | j j d d � } | j d � sS | j d � r` t d | � S| d 7} | j } q W| SWd ~ Xd S( si
try to guess stacklevel for application warning.
looks for first frame not part of passlib.
t __name__t s passlib.tests.s passlib.i N( t inspectt currentframet f_globalst gett
startswitht maxt f_back( t startt frameR8 t name( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt guess_app_stacklevelR s
c C� s- t d t d | j � t d t d � �d S( Ns� passing settings to %(handler)s.hash() is deprecated, and won't be supported in Passlib 2.0; use '%(handler)s.using(**settings).hash(secret)' insteadt handlert
stackleveli ( R t dictRF t DeprecationWarningRG ( RH t kwds( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt warn_hash_settings_deprecationd s c � s2 t | j � � t � � f d � t � � D� � S( s�
helper to extract settings kwds from mix of context & settings kwds.
pops settings keys from kwds, returns them as a dict.
c 3� s0 | ]& } | � k r | � j | � f Vq d S( N( t pop( t .0t key( t context_keysRL ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>o s ( t sett context_kwdsRJ t list( RH RL ( ( RQ RL s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt extract_settings_kwdsi s t $t 0c C� sL t | t � s$ t j | d � � n t | � t k rH t j t � � n d S( s% ensure secret has correct type & sizet secretN( t
isinstanceR! t exct ExpectedStringErrorR7 R t PasswordSizeError( RX ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt validate_secretw s c C� sj t | t � r | St | t � rT y | j d � SWqf t k
rP | j d � SXn t j | d � � d S( s+ convert hash to unicode for identify methods utf-8s latin-1t hashN( RY R t bytest decodet UnicodeDecodeErrorRZ R[ ( R^ ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt to_unicode_for_identify~ s
c C� s� t | d d � } t | t � s' t � | j | � sH t j | � � n t | t � s] t � | t | � j | � } t | � d k r� | \ } } | | p� d f St | � d k r� | d d f St j
| � � d S( s� parse hash using 2-part modular crypt format.
this expects a hash of the format :samp:`{prefix}{salt}[${checksum}]`,
such as md5_crypt, and parses it into salt / checksum portions.
:arg hash: the hash to parse (bytes or unicode)
:arg prefix: the identifying prefix (unicode)
:param sep: field separator (unicode, defaults to ``$``).
:param handler: handler class to pass to error constructors.
:returns:
a ``(salt, chk | None)`` tuple.
t asciiR^ i i i N( R
RY R t AssertionErrorRA RZ t InvalidHashErrorR7 t splitt Nonet MalformedHashError( R^ t prefixt sepRH t partst saltt chk( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR& � s i
c
C� sO t | d d � } t | t � s' t � | j | � sH t j | � � n t | t � s] t � | t | � j | � } t | � d k r� | \ } } } n6 t | � d k r� | \ } } d } n t j
| � � | j t � r� | t k r� t j | � � n? | rt
| | � } n' | d k r6t j
| d � � n | } | | | pKd f S( sr parse hash using 3-part modular crypt format.
this expects a hash of the format :samp:`{prefix}[{rounds}]${salt}[${checksum}]`,
such as sha1_crypt, and parses it into rounds / salt / checksum portions.
tries to convert the rounds to an integer,
and throws error if it has zero-padding.
:arg hash: the hash to parse (bytes or unicode)
:arg prefix: the identifying prefix (unicode)
:param sep: field separator (unicode, defaults to ``$``).
:param rounds_base:
the numeric base the rounds are encoded in (defaults to base 10).
:param default_rounds:
the default rounds value to return if the rounds field was omitted.
if this is ``None`` (the default), the rounds field is *required*.
:param handler: handler class to pass to error constructors.
:returns:
a ``(rounds : int, salt, chk | None)`` tuple.
Rc R^ i i s empty rounds fieldN( R
RY R Rd RA RZ Re R7 Rf Rg Rh t _UZEROt ZeroPaddedRoundsErrorR5 (
R^ Ri Rj t rounds_baset default_roundsRH Rk t roundsRl Rm ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR' � s( t valuec C� st | j t � r4 | t k r4 t j | d | � � n< | rG t | | � S| d k rl t j | d | � � n | Sd S( s
helper to parse an integer config field
:arg source: unicode source string
:param base: numeric base
:param default: optional default if source is empty
:param param: name of variable, for error msgs
:param handler: handler class, for error msgs
s zero-padded %s fields empty %s fieldN( RA Rn RZ Rh R5 Rg ( t sourcet baset defaultt paramRH ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt parse_int� s
c C� s7 | r | | | | g } n | | g } t t | � � S( s� format hash using 2-part modular crypt format; inverse of parse_mc2()
returns native string with format :samp:`{ident}{salt}[${checksum}]`,
such as used by md5_crypt.
:arg ident: identifier prefix (unicode)
:arg salt: encoded salt (unicode)
:arg checksum: encoded checksum (unicode or None)
:param sep: separator char (unicode, defaults to ``$``)
:returns:
config or hash (native str)
( R R ( t identRl t checksumRj Rk ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR(
s c C� s� | d k r t d � } n= | d k r: t d � | } n | d k sL t � t | � } | ry | | | | | | g } n | | | | g } t t | � � S( s. format hash using 3-part modular crypt format; inverse of parse_mc3()
returns native string with format :samp:`{ident}[{rounds}$]{salt}[${checksum}]`,
such as used by sha1_crypt.
:arg ident: identifier prefix (unicode)
:arg rounds: rounds field (int or None)
:arg salt: encoded salt (unicode)
:arg checksum: encoded checksum (unicode or None)
:param sep: separator char (unicode, defaults to ``$``)
:param rounds_base: base to encode rounds value (defaults to base 10)
:returns:
config or hash (native str)
R< i s %xi
N( Rg R Rd R R R ( Ry Rr Rl Rz Rj Rp Rk ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR) ! s c C� sW | d k s% t d | j | f � � | | � | k sS t d | j | | f � � t S( s�
assert helper that quickly validates default value.
designed to get out of the way and reduce overhead when asserts are stripped.
s %s lacks default %ss %s: invalid default %s: %rN( Rg Rd RF t True( RH Rv t normRw ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt validate_default_valueB s %.c C� s� t | t � s' t j | d | � � n | | k rz d | j | | | f } | rk t | t j � | } qz t | � � n | r� | | k r� d | j | | | f } | r� t | t j � | } q� t | � � n | S( s�
helper to normalize and validate an integer value (e.g. rounds, salt_size)
:arg value: value provided to constructor
:arg default: default value if none provided. if set to ``None``, value is required.
:arg param: name of parameter (xxx: move to first arg?)
:param min: minimum value (defaults to 1)
:param max: maximum value (default ``None`` means no maximum)
:returns: validated value
t integers+ %s: %s (%d) is too low, must be at least %ds0 %s: %s (%d) is too large, cannot be more than %d( RY R# RZ t ExpectedTypeErrorRF R R t
ValueError( RH Rs t minRB Rw t relaxedt msg( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt norm_integerK s
t MinimalHandlerc B� s& e Z d Z e Z e e d � � Z RS( s�
helper class for implementing hash handlers.
provides nothing besides a base implementation of the .using() subclass constructor.
c C� sD | j } | j s d | } n t | | f t d | j d t � � S( Ns <customized %s hasher>t
__module__t _configured( R; R� t typeRJ R� R{ ( t clsR� RF ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt using� s
( R; R� t __doc__t FalseR� t classmethodR� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� r s t
TruncateMixinc B� s; e Z d Z e Z e Z e d d � � Z e d � � Z RS( s�
PasswordHash mixin which provides a method
that will check if secret would be truncated,
and can be configured to throw an error.
.. warning::
Hashers using this mixin will generally need to override
the default PasswordHash.truncate_error policy of "True",
and will similarly want to override .truncate_verify_reject as well.
TODO: This should be done explicitly, but for now this mixin sets
these flags implicitly.
c K� sU t t | � j | � } | d k rQ t | d d �} | d k rQ | | _ qQ n | S( NRw t truncate_error( t superR� R� Rg R R� ( R� R� RL t subcls( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c C� sO | j d k s t d � � | j rK t | � | j k rK t j | � � n d S( s�
make sure secret won't be truncated.
NOTE: this should only be called for .hash(), not for .verify(),
which should honor the .truncate_verify_reject policy.
s% truncate_size must be set by subclassN( t
truncate_sizeRg Rd R� R7 RZ t PasswordTruncateError( R� RX ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _check_truncate_policy� s N(
R; R� R� R� R� t truncate_verify_rejectR� Rg R� R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c B� ss e Z d Z d Z d Z d Z d Z d Z d Z e
Z d Z d e
d � Z
e
d � Z e d � � Z e d � � Z d � Z e d � � Z d � Z e d � � Z e d � � Z e d
d d d
� e d � � � Z e d
d d d
� e d � � � Z e d d � � Z d d � Z d Z d Z e d � � Z e! e" d � d � � Z# e e$ e
d � � Z% e d � � Z& RS( s4 helper class for implementing hash handlers.
GenericHandler-derived classes will have (at least) the following
constructor options, though others may be added by mixins
and by the class itself:
:param checksum:
this should contain the digest portion of a
parsed hash (mainly provided when the constructor is called
by :meth:`from_string()`).
defaults to ``None``.
:param use_defaults:
If ``False`` (the default), a :exc:`TypeError` should be thrown
if any settings required by the handler were not explicitly provided.
If ``True``, the handler should attempt to provide a default for any
missing values. This means generate missing salts, fill in default
cost parameters, etc.
This is typically only set to ``True`` when the constructor
is called by :meth:`hash`, allowing user-provided values
to be handled in a more permissive manner.
:param relaxed:
If ``False`` (the default), a :exc:`ValueError` should be thrown
if any settings are out of bounds or otherwise invalid.
If ``True``, they should be corrected if possible, and a warning
issue. If not possible, only then should an error be raised.
(e.g. under ``relaxed=True``, rounds values will be clamped
to min/max rounds).
This is mainly used when parsing the config strings of certain
hashes, whose specifications implementations to be tolerant
of incorrect values in salt strings.
Class Attributes
================
.. attribute:: ident
[optional]
If this attribute is filled in, the default :meth:`identify` method will use
it as a identifying prefix that can be used to recognize instances of this handler's
hash. Filling this out is recommended for speed.
This should be a unicode str.
.. attribute:: _hash_regex
[optional]
If this attribute is filled in, the default :meth:`identify` method
will use it to recognize instances of the hash. If :attr:`ident`
is specified, this will be ignored.
This should be a unique regex object.
.. attribute:: checksum_size
[optional]
Specifies the number of characters that should be expected in the checksum string.
If omitted, no check will be performed.
.. attribute:: checksum_chars
[optional]
A string listing all the characters allowed in the checksum string.
If omitted, no check will be performed.
This should be a unicode str.
.. attribute:: _stub_checksum
Placeholder checksum that will be used by genconfig()
in lieu of actually generating a hash for the empty string.
This should be a string of the same datatype as :attr:`checksum`.
Instance Attributes
===================
.. attribute:: checksum
The checksum string provided to the constructor (after passing it
through :meth:`_norm_checksum`).
Required Subclass Methods
=========================
The following methods must be provided by handler subclass:
.. automethod:: from_string
.. automethod:: to_string
.. automethod:: _calc_checksum
Default Methods
===============
The following methods have default implementations that should work for
most cases, though they may be overridden if the hash subclass needs to:
.. automethod:: _norm_checksum
.. automethod:: genconfig
.. automethod:: genhash
.. automethod:: identify
.. automethod:: hash
.. automethod:: verify
c K� sD | | _ t t | � j | � | d k r@ | j | � | _ n d S( N( t use_defaultsR� R* t __init__Rg t _norm_checksumRz ( t selfRz R� RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� L s c � s | j } | r9 t | t � s� t j | d d � � q� n[ t | t � s� t | t � r| | r| t d t � | j d � } q� t j | d d � � n | j } | r� t
| � | k r� t j | d | �� n | s| j � � rt
� f d � | D� � rt d | j f � � qn | S( so validates checksum keyword against class requirements,
returns normalized version of checksum.
R_ Rz s% checksum should be unicode, not bytesRc R t rawc 3� s | ] } | � k Vq d S( N( ( RO t c( t cs( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>t s s! invalid characters in %s checksum( t _checksum_is_bytesRY R_ RZ R R R R R` t
checksum_sizeR7 t ChecksumSizeErrort checksum_charst anyR� RF ( R� Rz R� R� t cc( ( R� s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� U s"
" c C� s� t | � } | s t S| j } | d k r8 | j | � S| j } | d k r` | j | � d k Sy | j | � t SWn t k
r� t SXd S( N(
Rb R� Ry Rg RA t _hash_regext matcht from_stringR{ R� ( R� R^ Ry t pat( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt identify| s
c K� s t d | f � � d S( sV
return parsed instance from hash/configuration string
:param \*\*context:
context keywords to pass to constructor (if applicable).
:raises ValueError: if hash is incorrectly formatted
:returns:
hash parsed into components,
for formatting / calculating checksum.
s %s must implement from_string()N( t NotImplementedError( R� R^ t context( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c C� s t d | j f � � d S( s� render instance to hash or configuration string
:returns:
hash string with salt & digest included.
should return native string type (ascii-bytes under python 2,
unicode under python 3)
s %s must implement from_string()N( R� t __class__( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt to_string� s c C� s� | j r; | j r d | j S| j r; | j d | j Sn t | t � r� | j } | j p_ d | _ z | j d � SWd | | _ Xn | j d � S( si
placeholder used by default .genconfig() so it can avoid expense of calculating digest.
t i i R< N( R� R� R� RY R1 Rr t
min_roundst _calc_checksum( R� t orig( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _stub_checksum� s
c C� s t d | j f � � d S( s given secret; calcuate and return encoded checksum portion of hash
string, taking config from object state
calc checksum implementations may assume secret is always
either unicode or bytes, checks are performed by verify/etc.
s" %s must implement _calc_checksum()N( R� R� ( R� RX ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c K� s| | rD t | | � } | rD t | | � | j | � j | | � Sn t | � | d t | � } | j | � | _ | j � S( NR� ( RU RM R� R^ R] R{ R� Rz R� ( R� RX RL t settingsR� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR^ � s
c K� sY t | � | j | | � } | j } | d k rC t j | � � n t | j | � | � S( N( R] R� Rz Rg RZ t MissingDigestErrorR R� ( R� RX R^ R� R� Rm ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt verify� s
t
deprecateds 1.7t removeds 2.0c K� sS t | | � } | r+ | j | � j | � S| d t | � } | j | _ | j � S( NR� ( RU R� t genconfigR{ R� Rz R� ( R� RL R� R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c K� sS | d k r t d � � n t | � | j | | � } | j | � | _ | j � S( Ns config must be string( Rg t TypeErrorR] R� R� Rz R� ( R� RX t configR� R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt genhash s
c K� s7 | j | � } t | | � s$ t � | j d | | � S( NRX ( R� RY Rd t _calc_needs_update( R� R^ RX RL R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt needs_update s c C� s t S( s;
internal helper for :meth:`needs_update`.
( R� ( R� RX ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� " s t salt_sizeR� Rl Rz c � s � f d � � j D� S( Nc 3� s$ | ] } | � j k r | Vq d S( N( t _unparsed_settings( RO RP ( R� ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>3 s ( t setting_kwds( R� ( ( R� s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _parsed_settings1 s t *c C� s� | d k r d St | t � rG d d l m } | | � j d � } n t | t � se t | � } n t | � } t d | d � } | | | | | S( s* default method to obscure sensitive fieldsi����( t ab64_encodeRc i i N( Rg RY R_ t passlib.utils.binaryR� R` R R7 R� ( Rs t charR� t sizet clip( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _sanitize7 s c � s� � j | � � t � � t � � � f d � � j D� � } | rb � j d k rb � j | d <n | r� | t k r� � j } n x7 � j D]) } | | k r� | | | � | | <q� q� Wn | S( s� [experimental method] parse hash into dictionary of settings.
this essentially acts as the inverse of :meth:`hash`: for most
cases, if ``hash = cls.hash(secret, **opts)``, then
``cls.parsehash(hash)`` will return a dict matching the original options
(with the extra keyword *checksum*).
this method may not work correctly for all hashes,
and may not be available on some few. its interface may
change in future releases, if it's kept around at all.
:arg hash: hash to parse
:param checksum: include checksum keyword? (defaults to True)
:param sanitize: mask data for sensitive fields? (defaults to False)
c 3� sE | ]; } t � | � t � | � � k r | t � | � f Vq d S( N( t getattr( RO RP ( t UNSETR� R� ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>] s Rz N( R� t objectRJ R� Rz Rg R{ R� t _unsafe_settings( R� R^ Rz t sanitizeRL RP ( ( R� R� R� s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt parsehashE s % c K� sz y t t | � j | � } Wn t k
r5 i } n X| j rE t n | j } | j rv | rv t | j | � | d <n | S( s8 [experimental method] return info about bitsizes of hashRz ( R� R* t bitsizet AttributeErrorR� R R� R� R: ( R� RL t infoR� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� i s
N( ( s salt_sizes relaxed( s salts checksum(' R; R� R� Rg R� RS Ry R� R� R� R� R� Rz R� R� R� R� R� R� t propertyR� R� R^ R� R% R� R� R� R� R� R� R$ R� t staticmethodR R� R{ R� R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR* � sB j '
#c B� sV e Z d Z d Z e d � Z e d � � Z e d � � Z d � Z d Z d � Z RS( s; GenericHandler mixin for classes which have no settings.
This mixin assumes the entirety of the hash ise stored in the
:attr:`checksum` attribute; that the hash has no rounds, salt,
etc. This class provides the following:
* a default :meth:`genconfig` that always returns None.
* a default :meth:`from_string` and :meth:`to_string`
that store the entire hash within :attr:`checksum`,
after optionally stripping a constant prefix.
All that is required by subclasses is an implementation of
the :meth:`_calc_checksum` method.
R< c K� st t | d d � } | j | � } | j } | rd | j | � rR | t | � } qd t j | � � n | d | | � S( NRc R^ Rz ( R
t
_norm_hasht _hash_prefixRA R7 RZ Re ( R� R^ R� Ri ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c C� s | S( s1 helper for subclasses to normalize case if needed( ( R� R^ ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c C� s t | j | j � S( N( R R� Rz ( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c � s � j � � j t k s t � � j } | d k rz � f d � } t � j d � f t d | d � j � � } � _ n t � f d � � j D� � } y | j | d | � } Wn> t
k
r� } t | � d k r� t d � f � � q� � n Xt
d � t � t | � S(
s{ given secret; calcuate and return encoded checksum portion of hash
string, taking config from object state
c � s t d � f � � d S( Ns" %s must implement _calc_checksum()( R� ( R� RX ( R� ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt inner� s t _wrapperR� R� c 3� s$ | ] } | t � | � f Vq d S( N( R� ( RO t k( R� ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>� s s config must be strings" %s must implement _calc_checksum()s� %r should be updated to implement StaticHandler._calc_checksum() instead of StaticHandler.genhash(), support for the latter style will be removed in Passlib 1.8N( R� R� R; Rd t _StaticHandler__cc_compat_hackRg R� RJ RS R� R� t strR� R RK R ( R� RX t wrapper_clsR� R� R^ t err( ( R� R� s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s&
+ ( N(
R; R� R� R� R R� R� R� R� R� Rg R� R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR+ { s t HasEncodingContextc B� s& e Z d Z d Z d Z d d � Z RS( s? helper for classes which require knowledge of the encoding usedt encodings utf-8c K� s, t t | � j | � | p" | j | _ d S( N( R� R� R� t default_encodingR� ( R� R� RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s ( s encodingN( R; R� R� RS R� Rg R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c B� sk e Z d Z d
Z d d � Z e d d � � Z e d d � � Z e d d d d � e d d � � � Z
RS( s7 helper for classes which require a user context keywordt userc K� s# t t | � j | � | | _ d S( N( R� R, R� R� ( R� R� RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c K� s t t | � j | d | | �S( NR� ( R� R, R^ ( R� RX R� R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR^ � s c K� s" t t | � j | | d | | �S( NR� ( R� R, R� ( R� RX R^ R� R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s R� s 1.7R� s 2.0c K� s" t t | � j | | d | | �S( NR� ( R� R, R� ( R� RX R� R� R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s ( s userN( R; R� R� RS Rg R� R� R^ R� R% R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR, � s c B� s e Z d Z e Z RS( sq mixin for classes which work with decoded checksum bytes
.. todo::
document this class's usage
( R; R� R� R{ R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR- s c B� st e Z d Z d Z d Z d Z d Z e d d d � � Z d d � Z
e d � � Z e d � � Z e d � � Z
RS( s mixin for hashes which use multiple prefix identifiers
For the hashes which may use multiple identifier prefixes,
this mixin adds an ``ident`` keyword to constructor.
Any value provided is passed through the :meth:`norm_idents` method,
which takes care of validating the identifier,
as well as allowing aliases for easier specification
of the identifiers by the user.
.. todo::
document this class's usage
Class Methods
=============
.. todo:: document using() and needs_update() options
c K� sv | d k r0 | d k r' t d � � n | } n t t | � j | � } | d k rr | d | d t � j | _ n | S( s4
This mixin adds support for the following :meth:`~passlib.ifc.PasswordHash.using` keywords:
:param default_ident:
default identifier that will be used by resulting customized hasher.
:param ident:
supported as alternate alias for **default_ident**.
s2 'default_ident' and 'ident' are mutually exclusiveRy R� N( Rg R� R� R. R� R{ Ry t
default_ident( R� R� Ry RL R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� > s
c K� s� t t | � j | � | d k r4 | j | � } nB | j rj | j } t | | | j d d �sv t � n t d � � | | _
d S( NRw R� s no ident specified( R� R. R� Rg t _norm_identR� R� R} Rd R� Ry ( R� Ry RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� \ s $ c C� s� | d k s t � t | t � r3 | j d � } n | j } | | k rL | S| j } | r� y | | } Wn t k
r| q� X| | k r� | Sn t d | f � � d S( sD
helper which normalizes & validates 'ident' value.
Rc s invalid ident: %rN( Rg Rd RY R_ R` t ident_valuest
ident_aliasest KeyErrorR� ( R� Ry t ivt iaRs ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� i s
c C� s t | � } | j | j � S( N( Rb RA R� ( R� R^ ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c C� s\ t | d d � } x4 | j D]) } | j | � r | | t | � f Sq Wt j | � � d S( sD extract ident prefix from hash, helper for subclasses' from_string()Rc R^ N( R
R� RA R7 RZ Re ( R� R^ Ry ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _parse_ident� s
N( R; R� R� Rg R� R� R� Ry R� R� R� R� R� R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR. s
c B� s� e Z d Z d Z d Z d Z e d � � Z e d � � Z e
Z d Z d Z
e d d d d � � Z e d e d � � Z d d � Z d � Z e e
d
� � Z e d � � Z e d � � Z e d d
� � Z RS( s2
mixin for validating salts.
This :class:`GenericHandler` mixin adds a ``salt`` keyword to the class constuctor;
any value provided is passed through the :meth:`_norm_salt` method,
which takes care of validating salt length and content,
as well as generating new salts if one it not provided.
:param salt:
optional salt string
:param salt_size:
optional size of salt (only used if no salt provided);
defaults to :attr:`default_salt_size`.
Class Attributes
================
In order for :meth:`!_norm_salt` to do its job, the following
attributes should be provided by the handler subclass:
.. attribute:: min_salt_size
The minimum number of characters allowed in a salt string.
An :exc:`ValueError` will be throw if the provided salt is too small.
Defaults to ``0``.
.. attribute:: max_salt_size
The maximum number of characters allowed in a salt string.
By default an :exc:`ValueError` will be throw if the provided salt is
too large; but if ``relaxed=True``, it will be clipped and a warning
issued instead. Defaults to ``None``, for no maximum.
.. attribute:: default_salt_size
[required]
If no salt is provided, this should specify the size of the salt
that will be generated by :meth:`_generate_salt`. By default
this will fall back to :attr:`max_salt_size`.
.. attribute:: salt_chars
A string containing all the characters which are allowed in the salt
string. An :exc:`ValueError` will be throw if any other characters
are encountered. May be set to ``None`` to skip this check (but see
in :attr:`default_salt_chars`).
.. attribute:: default_salt_chars
[required]
This attribute controls the set of characters use to generate
*new* salt strings. By default, it mirrors :attr:`salt_chars`.
If :attr:`!salt_chars` is ``None``, this attribute must be specified
in order to generate new salts. Aside from that purpose,
the main use of this attribute is for hashes which wish to generate
salts from a restricted subset of :attr:`!salt_chars`; such as
accepting all characters, but only using a-z.
Instance Attributes
===================
.. attribute:: salt
This instance attribute will be filled in with the salt provided
to the constructor (as adapted by :meth:`_norm_salt`)
Subclassable Methods
====================
.. automethod:: _norm_salt
.. automethod:: _generate_salt
i c C� s | j S( s/ default salt size (defaults to *max_salt_size*)( t
max_salt_size( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt default_salt_size� s c C� s | j S( sD charset used to generate new salt strings (defaults to *salt_chars*)( t
salt_chars( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt default_salt_chars� s R9 c � s� | d k r0 | d k r' t d � � n | } n t t | � j | � } | j d � } | d k r� t | t � r� t | � } n | j | d d d | �| _
n � d k r� | j � d | �� t � f d � � | _
n | S( NsB 'salt_size' and 'default_salt_size' aliases are mutually exclusiveR� Rw R� c � s � S( N( ( ( Rl ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt <lambda>& s ( Rg R� R� R/ R� R@ RY R R5 t _clip_to_valid_salt_sizeR� t
_norm_saltR� t _generate_salt( R� R� R� Rl RL R� R� ( ( Rl s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� s R� c C� s | j } | j } | | k rl | | k rh d | j | | | f } | rY t | t � qh t | � � n | S| | k r� d | j | | | f } | r� t | t � | } q� t | � � n | r| | k rd | j | | | f } | rt | t � | } qt | � � n | S( s�
internal helper --
clip salt size value to handler's absolute limits (min_salt_size / max_salt_size)
:param relaxed:
if ``True`` (the default), issues PasslibHashWarning is rounds are outside allowed range.
if ``False``, raises a ValueError instead.
:param param:
optional name of parameter to insert into error/warning messages.
:returns:
clipped rounds value
s %s: %s (%d) must be exactly %ds$ %s: %s (%r) below min_salt_size (%d)s$ %s: %s (%r) above max_salt_size (%d)( t
min_salt_sizeR� RF R R R� ( R� R� Rw R� t mnt mxR� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� + s,
c K� s� t t | � j | � | d k r4 | j | � } nL | j rt | j � } | j | � | k s� t d | f � � n t d � � | | _
d S( Ns generated invalid salt: %rs no salt specified( R� R/ R� Rg t _parse_saltR� R� R� Rd R� Rl ( R� Rl RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� _ s + c C� s
| j | � S( N( R� ( R� Rl ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� k s c
� s� | j r3 t | t � s� t j | d d � � q� n� t | t � s� t | t � ro t s] | ro | j d � } q� t j | d d � � n | j � � d k r� t
� f d � | D� � r� t d | j � � n | j
} | r/t | � | k r/d | j | | j k r
d n d | | j f } t | � � n | j } | r�t | � | k r�d
| j | | k rkd n d | | j f } | r�t | t � | j | | � } q�t | � � n | S(
sT helper to normalize & validate user-provided salt string
:arg salt:
salt string
:raises TypeError:
If salt not correct type.
:raises ValueError:
* if salt contains chars that aren't in :attr:`salt_chars`.
* if salt contains less than :attr:`min_salt_size` characters.
* if ``relaxed=False`` and salt has more than :attr:`max_salt_size`
characters (if ``relaxed=True``, the salt is truncated
and a warning is issued instead).
:returns:
normalized salt
R_ Rl Rc R c 3� s | ] } | � k Vq d S( N( ( RO R� ( t sc( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>� s s invalid characters in %s salts% salt too small (%s requires %s %d %s)t exactlys >=s% salt too large (%s requires %s %d %s)s <=N( t _salt_is_bytesRY R_ RZ R R R" R` R� Rg R� R� RF R� R7 R� t
_salt_unitR R t _truncate_salt( R� Rl R� R� R� R� ( ( R� s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� n s0 ( ( %
c C� s | | S( N( ( Rl R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c C� s t t | j | j � S( sU
helper method for _init_salt(); generates a new random salt string.
( R R
R� R� ( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c K� sJ t t | � j | � } | d k r0 | j } n t | | j � | d <| S( s8 [experimental method] return info about bitsizes of hashRl N( R� R/ R� Rg R� R: R� ( R� R� RL R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s
N( R; R� R� R� Rg R� R� R$ R� R� R� R� R� Rl R� R� R{ R� R� R� R� R� R� R� R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR/ � s. E 3 9c B� s/ e Z d Z e Z e Z d Z e d � � Z RS( s� mixin for classes which use decoded salt parameter
A variant of :class:`!HasSalt` which takes in decoded bytes instead of an encoded string.
.. todo::
document this class's usage
R_ c C� s+ | j d t g k s t � t t | j � S( N( R� Rg R Rd R R
R� ( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s (
R; R� R� R R� R{ R� R� R� R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR0 � s
c B� s� e Z d Z d Z d Z d Z d Z d Z d Z d Z
d Z d Z e
d d d d d d d d � � Z e
d
� � Z e
d � � Z d d � Z d
� Z e
e d d � � Z e
d � � Z d � Z e
d d d � � Z RS( s3 mixin for validating rounds parameter
This :class:`GenericHandler` mixin adds a ``rounds`` keyword to the class
constuctor; any value provided is passed through the :meth:`_norm_rounds`
method, which takes care of validating the number of rounds.
:param rounds: optional number of rounds hash should use
Class Attributes
================
In order for :meth:`!_norm_rounds` to do its job, the following
attributes must be provided by the handler subclass:
.. attribute:: min_rounds
The minimum number of rounds allowed. A :exc:`ValueError` will be
thrown if the rounds value is too small. Defaults to ``0``.
.. attribute:: max_rounds
The maximum number of rounds allowed. A :exc:`ValueError` will be
thrown if the rounds value is larger than this. Defaults to ``None``
which indicates no limit to the rounds value.
.. attribute:: default_rounds
If no rounds value is provided to constructor, this value will be used.
If this is not specified, a rounds value *must* be specified by the
application.
.. attribute:: rounds_cost
[required]
The ``rounds`` parameter typically encodes a cpu-time cost
for calculating a hash. This should be set to ``"linear"``
(the default) or ``"log2"``, depending on how the rounds value relates
to the actual amount of time that will be required.
Class Methods
=============
.. todo:: document using() and needs_update() options
Instance Attributes
===================
.. attribute:: rounds
This instance attribute will be filled in with the rounds value provided
to the constructor (as adapted by :meth:`_norm_rounds`)
Subclassable Methods
====================
.. automethod:: _norm_rounds
i t lineart min_desired_roundst max_desired_roundsR� t
max_roundsRq t vary_roundsc
K� s� | d k r0 | d k r' t d � � n | } n | d k r` | d k rW t d � � n | } n | d k r� | d k r� | } n | d k r� | } n | d k r� | } q� n t t | � j | � } | j d � }
| d k r� t } | j } nB t } t | t
� rt | � } n | j | d d d |
�| _ | d k rM| j
} n� t | t
� rkt | � } n | r�| | k r�d | j | | f } | r�t | � � q�t | t � | } n | j | d d d |
�| _
| d k r�t | t
� rt | � } n | r7| | k r7t d | j | | f � � n1 | rh| | k rht d | j | | f � � n | j | d d
d |
�| _ n | j d k r�| j | j � | _ n | d k r�t | t
� r| j d � r�t | d � d
} qd | k r t | � } qt | � } n | d k rCt d | j | f � � nX t | t � r}| d k r�t d | j | f � � q�n t | t � s�t d � � n | r�t d t � n | | _ n | S( NsD 'min_rounds' and 'min_desired_rounds' aliases are mutually exclusivesD 'max_rounds' and 'max_desired_rounds' aliases are mutually exclusiveR� Rw R� s9 %s: max_desired_rounds (%r) below min_desired_rounds (%r)R� s5 %s: default_rounds (%r) below min_desired_rounds (%r)s5 %s: default_rounds (%r) above max_desired_rounds (%r)Rq t %i����g{�G�z�?t .i s %s: vary_rounds (%r) below 0i s %s: vary_rounds (%r) above 1.0s vary_rounds must be int or floats\ The 'vary_rounds' option is deprecated as of Passlib 1.7, and will be removed in Passlib 2.0( Rg R� R� R1 R� R@ R� R� R{ RY R R5 t _norm_roundsR� RF R� R R Rq t _clip_to_desired_roundst endswitht floatR� (
R� R� R� Rq R� R� R� Rr RL R� R� t explicit_min_roundsR� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� 6 s�
c C� sB | j p d } | | k r | S| j } | r> | | k r> | S| S( s|
helper for :meth:`_generate_rounds` --
clips rounds value to desired min/max set by class (if any)
i ( R� R� ( R� Rr t mndt mxd( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR � s c C� s� | s t � | j } d � } t | t � r� d | k oD d k n sO t � | j d k rt d | >} d � } n t | | � } n | d k r� t | t � s� t � | | | t � } | | | t � } | j | � | j | � f S( s�
helper for :meth:`_generate_rounds` --
returns range for vary rounds generation.
:returns:
(lower, upper) limits suitable for random.randint()
c S� s | S( N( ( Rs t upper( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt linear_to_native� s i i t log2c S� sO | d k r d S| r, t t j | d � � St t j t j | d � � � Sd S( Ni i ( R5 R4 R6 t ceil( Rs R ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR � s
(
Rd R� RY R t rounds_costR5 R# R� R{ R ( R� Rq R� R t lowerR ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _calc_vary_rounds_range� s "
!c K� s� t t | � j | � | d k r4 | j | � } nL | j rt | j � } | j | � | k s� t d | f � � n t d � � | | _
d S( Ns generated invalid rounds: %rs no rounds specified( R� R1 R� Rg t
_parse_roundsR� t _generate_roundsR� Rd R� Rr ( R� Rr RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s + c C� s
| j | � S( N( R� ( R� Rr ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR
� s Rr c C� s% t | | | j | j d | d | �S( s�
helper for normalizing rounds value.
:arg rounds:
an integer cost parameter.
:param relaxed:
if ``True`` (the default), issues PasslibHashWarning is rounds are outside allowed range.
if ``False``, raises a ValueError instead.
:param param:
optional name of parameter to insert into error/warning messages.
:raises TypeError:
* if ``use_defaults=False`` and no rounds is specified
* if rounds is not an integer.
:raises ValueError:
* if rounds is ``None`` and class does not specify a value for
:attr:`default_rounds`.
* if ``relaxed=False`` and rounds is outside bounds of
:attr:`min_rounds` and :attr:`max_rounds` (if ``relaxed=True``,
the rounds value will be clamped, and a warning issued).
:returns:
normalized rounds value
Rw R� ( R� R� R� ( R� Rr R� Rw ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s c C� s� | j } | d k r. t d | j f � � n | j r� | j | � \ } } | | k oc | k n sn t � | | k r� t j | | � } q� n | S( s�
internal helper for :meth:`_norm_rounds` --
returns default rounds value, incorporating vary_rounds,
and any other limitations hash may place on rounds parameter.
s, %s rounds value must be specified explicitlyN( Rq Rg R� RF R� R Rd R
t randint( R� Rr R R ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR s " c K� sZ | j } | r" | j | k r" t S| j } | rD | j | k rD t St t | � j | � S( sR
mark hash as needing update if rounds is outside desired bounds.
( R� Rr R{ R� R� R1 R� ( R� RL R� R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� ) s g�������?c K� s t t | � j | � } | j d k r{ d d l } | d k rK | j } n t d t d | j | | d � � � | d <n | S( s8 [experimental method] return info about bitsizes of hashR i����Ni i i Rr (
R� R1 R� R
R4 Rg Rq RB R5 R6 ( R� Rr R� RL R� R4 ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� 8 s 0N( s min_desired_roundss max_desired_roundss
min_roundss
max_roundss default_roundss vary_rounds( R; R� R� R� Rg R� R
t using_rounds_kwdsR� R� Rq R� Rr R� R� R R R� R
R� R� R R� R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR1 � s4 5
h+ t ParallelismMixinc B� sM e Z d Z d Z e d d � � Z d d � Z e e d � � Z d � Z
RS( sH
mixin which provides common behavior for 'parallelism' setting
i c K� sj t t | � j | � } | d k rf t | t � rB t | � } n | j | d | j d � �| _ n | S( NR� (
R� R R� Rg RY R R5 t _norm_parallelismR@ t parallelism( R� R RL R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� j s $c K� s_ t t | � j | � | d k rI t | | j | j d d �s[ t � n | j | � | _ d S( NRw R ( R� R R� Rg R} R R Rd ( R� R RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� v s
c C� s t | | d d d d d | �S( NR� i Rw R R� ( R� ( R� R R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR � s c K� s2 | j t | � j k r t St t | � j | � S( sR
mark hash as needing update if rounds is outside desired bounds.
( R R� R{ R� R R� ( R� RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s N( R; R� R� R R� Rg R� R� R� R R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR U s
t BackendMixinc B� s� e Z d Z d Z d Z d Z d Z e Z e
d � � Z e
d d � � Z e
d e d � � Z
e
d � � Z e
d � � Z e
d � � Z e
d � � Z RS(
s�
PasswordHash mixin which provides generic framework for supporting multiple backends
within the class.
Public API
----------
.. attribute:: backends
This attribute should be a tuple containing the names of the backends
which are supported. Two common names are ``"os_crypt"`` (if backend
uses :mod:`crypt`), and ``"builtin"`` (if the backend is a pure-python
fallback).
.. automethod:: get_backend
.. automethod:: set_backend
.. automethod:: has_backend
.. warning::
:meth:`set_backend` is intended to be called during application startup --
it affects global state, and switching backends is not guaranteed threadsafe.
Private API (Subclass Hooks)
----------------------------
Subclasses should set the :attr:`!backends` attribute to a tuple of the backends
they wish to support. They should also define one method:
.. classmethod:: _load_backend_{name}(dryrun=False)
One copy of this method should be defined for each :samp:`name` within :attr:`!backends`.
It will be called in order to load the backend, and should take care of whatever
is needed to enable the backend. This may include importing modules, running tests,
issuing warnings, etc.
:param name:
[Optional] name of backend.
:param dryrun:
[Optional] True/False if currently performing a "dry run".
if True, the method should perform all setup actions *except*
switching the class over to the new backend.
:raises passlib.exc.PasslibSecurityError:
if the backend is available, but cannot be loaded due to a security issue.
:returns:
False if backend not available, True if backend loaded.
.. warning::
Due to the way passlib's internals are arranged,
backends should generally store stateful data at the class level
(not the module level), and be prepared to be called on subclasses
which may be set to a different backend from their parent.
(Idempotent module-level data such as lazy imports are fine).
.. automethod:: _finalize_backend
.. versionadded:: 1.7
c C� s2 | j s+ | j � | j s+ t d � � n | j S( s
Return name of currently active backend.
if no backend has been loaded, loads and returns name of default backend.
:raises passlib.exc.MissingBackendError:
if no backends are available.
:returns:
name of active backend
s. set_backend() failed to load a default backend( t _BackendMixin__backendt set_backendRd ( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt get_backend� s
R� c C� s@ y | j | d t �t SWn t j t j f k
r; t SXd S( s�
Check if support is currently available for specified backend.
:arg name:
name of backend to check for.
can be any string accepted by :meth:`set_backend`.
:raises ValueError:
if backend name is unknown
:returns:
* ``True`` if backend is available.
* ``False`` if it's available / can't be loaded.
* ``None`` if it's present, but won't load due to a security issue.
t dryrunN( R R{ RZ R t PasslibSecurityErrorR� ( R� RF ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt has_backend s
c C� s� | d k r | j s* | r1 | | j k r1 | j S| j � } | | k r\ | j | d | �S| d k st | d k r9d } xo | j D]d } y | j | d | �SWq� t j k
r� q� q� t j k
r� } | d k r� | } q� q� q� Xq� W| d k r0d | j } | j r | | j 7} n t j | � } n | � n | | j k r]t j
| | � � n t �i | j | j
f } z& | | _ | | _
| j | | � Wd | \ | _ | _
X| s�| | _ n | SWd QXd S( s
Load specified backend.
:arg name:
name of backend to load, can be any of the following:
* ``"any"`` -- use current backend if one is loaded,
otherwise load the first available backend.
* ``"default"`` -- use the first available backend.
* any string in :attr:`backends`, loads specified backend.
:param dryrun:
If True, this perform all setup actions *except* switching over to the new backend.
(this flag is used to implement :meth:`has_backend`).
.. versionadded:: 1.7
:raises ValueError:
If backend name is unknown.
:raises passlib.exc.MissingBackendError:
If specific backend is missing;
or in the case of ``"any"`` / ``"default"``, if *no* backends are available.
:raises passlib.exc.PasslibSecurityError:
If ``"any"`` or ``"default"`` was specified,
but the only backend available has a PasslibSecurityError.
R� R Rv s %s: no backends availableN( R t _get_backend_ownerR Rg t backendsRZ R R RF t _no_backend_suggestiont UnknownBackendErrort
_backend_lockt _pending_backendt _pending_dry_runt _set_backend( R� RF R t ownert
default_errorR� R� R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR " sD "*
c C� s | S( s�
return class that set_backend() should actually be modifying.
for SubclassBackendMixin, this may not always be the class that was invoked.
( ( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR v s c C� s� | j | � } i } t | d � r1 | | d <n t | d � rM | | d <n | | � } | t k r� t j d | j | f � � n" | t k r� t d | f � � n d S( s%
Internal method invoked by :meth:`set_backend`.
handles actual loading of specified backend.
global _backend_lock will be held for duration of this method,
and _pending_dry_run & _pending_backend will also be set.
should return True / False.
RF R s %s: backend not available: %ss- backend loaders must return True or False: %rN( t _get_backend_loaderR R� RZ R RF R{ Rd ( R� RF R t loaderRL t ok( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR" ~ s
c C� s t d � � d S( sf
Hook called to get the specified backend's loader.
Should return callable which optionally takes ``"name"`` and/or
``"dryrun"`` keywords.
Callable should return True if backend initialized successfully.
If backend can't be loaded, callable should return False
OR raise MissingBackendError directly.
s implement in subclassN( R� ( R� RF ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR% � s c C� sU | j r( t d | j | j f � � n | j � | j sQ t d | j � � n d S( sW
helper for subclasses to create stub methods which auto-load backend.
s7 %s: _finalize_backend(%r) failed to replace lazy loaders2 %s: set_backend() failed to load a default backendN( R Rd RF R ( R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _stub_requires_backend� s
N( R; R� R� Rg R R R R R� R! R� R R R R R" R% R( ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR � s @St SubclassBackendMixinc B� sG e Z d Z e Z d Z e d � � Z e d � � Z e d � � Z
RS( s�
variant of BackendMixin which allows backends to be implemented
as separate mixin classes, and dynamically switches them out.
backend classes should implement a _load_backend() classmethod,
which will be invoked with an optional 'dryrun' keyword,
and should return True or False.
_load_backend() will be invoked with ``cls`` equal to the mixin,
*not* the overall class.
.. versionadded:: 1.7
c C� sR | j s t d � � n x' | j D] } | j j d � r" | Sq" Wt d � � d S( s�
return base class that we're actually switching backends on
(needed in since backends frequently modify class attrs,
and .set_backend may be called from a subclass).
s _backend_mixin_target not sett _backend_mixin_targets5 expected to find class w/ '_backend_mixin_target' setN( R* Rd t __mro__t __dict__R@ ( R� Ru ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR � s c C� s� t t | � j | | � | | j � k s7 t d � � | j } | sR t d � � | | } t | t � sw t d � � t | d | d | j � d t d t d | �d S( Ns( _finalize_backend() not invoked on owners _backend_mixin_map not specifieds invalid mixin classt addt removet appendt beforeR (
R� R) R" R Rd t _backend_mixin_mapt
issubclassR t valuesR{ ( R� RF R t mixin_mapt mixin_cls( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR" � s
c C� s# | j s t d � � | j | j S( Ns _backend_mixin_map not specified( R1 Rd t _load_backend_mixin( R� RF ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR% � s N( R; R� R� R� R* Rg R1 R� R R" R% ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR) � s
c B� sM e Z d Z d � Z d � Z e d � � Z e d � � Z e d � � Z RS( s�
GenericHandler mixin which provides selecting from multiple backends.
.. todo::
finish documenting this class's usage
For hashes which need to select from multiple backends,
depending on the host environment, this class
offers a way to specify alternate :meth:`_calc_checksum` methods,
and will dynamically chose the best one at runtime.
.. versionchanged:: 1.7
This class now derives from :class:`BackendMixin`, which abstracts
out a more generic framework for supporting multiple backends.
The public api (:meth:`!get_backend`, :meth:`!has_backend`, :meth:`!set_backend`)
is roughly the same.
Private API (Subclass Hooks)
----------------------------
As of version 1.7, classes should implement :meth:`!_load_backend_{name}`, per
:class:`BackendMixin`. This hook should invoke :meth:`!_set_calc_checksum_backcend`
to install it's backend method.
.. deprecated:: 1.7
The following api is deprecated, and will be removed in Passlib 2.0:
.. attribute:: _has_backend_{name}
private class attribute checked by :meth:`has_backend` to see if a
specific backend is available, it should be either ``True``
or ``False``. One of these should be provided by
the subclass for each backend listed in :attr:`backends`.
.. classmethod:: _calc_checksum_{name}
private class method that should implement :meth:`_calc_checksum`
for a given backend. it will only be called if the backend has
been selected by :meth:`set_backend`. One of these should be provided
by the subclass for each backend listed in :attr:`backends`.
c C� s
| j | � S( s$ wrapper for backend, for common code( t _calc_checksum_backend( R� RX ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� 4 s c C� s | j � | j | � S( s�
stub for _calc_checksum_backend() --
should load backend if one hasn't been loaded;
if one has been loaded, this method should have been monkeypatched by _finalize_backend().
( R( R7 ( R� RX ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR7 ; s
c � sk t � d � d � } | d k r7 � � f d � } n0 t � d � � sg t d � j � � f � � | S( sp
subclassed to support legacy 1.6 HasManyBackends api.
(will be removed in passlib 2.0)
t _load_backend_c � s
� j � � S( N( t% _HasManyBackends__load_legacy_backend( ( R� RF ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR& Q s t
_has_backend_s? %s: can't specify both ._load_backend_%s() and ._has_backend_%sN( R� Rg t hasattrRd RF ( R� RF R& ( ( R� RF s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR% G s c C� sb t | d | � } t d | j | | f t � | rZ t | d | � } | j | � t St Sd S( NR: s� %s: support for ._has_backend_%s is deprecated as of Passlib 1.7, and will be removed in Passlib 1.9/2.0, please implement ._load_backend_%s() insteadt _calc_checksum_( R� R RF RK t _set_calc_checksum_backendR{ R� ( R� RF Rs t func( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt __load_legacy_backend[ s
c C� s_ | j } | s t d � � t | � sF t d | j | | f � � n | j s[ | | _ n d S( sl
helper used by subclasses to validate & set backend-specific
calc checksum helper.
s* should only be called during set_backend()s, %s: backend %r returned invalid callable: %rN( R Rd t callablet RuntimeErrorRF R! R7 ( R� R> t backend( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR= j s ( R; R� R� R� R7 R� R% R9 R= ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR2 s + c B� s[ e Z d Z d2 Z e d � e d � e d3 d3 d � Z d3 Z d3 Z d � Z
d � Z e e � Z
e Z e d � � Z e Z e d � � Z d4 Z d � Z d � Z d � Z d! � Z d" � Z d# � Z d3 Z d$ � Z d% � Z d& � Z e d' d( d) d* � d+ � � Z e d' d( d) d* � d, � � Z e d' d( d) d* d- d. � d/ � � Z d0 � Z! d1 � Z" RS(5 sU wraps another handler, adding a constant prefix.
instances of this class wrap another password hash handler,
altering the constant prefix that's prepended to the wrapped
handlers' hashes.
this is used mainly by the :doc:`ldap crypt <passlib.hash.ldap_crypt>` handlers;
such as :class:`~passlib.hash.ldap_md5_crypt` which wraps :class:`~passlib.hash.md5_crypt` and adds a ``{CRYPT}`` prefix.
usage::
myhandler = PrefixWrapper("myhandler", "md5_crypt", prefix="$mh$", orig_prefix="$1$")
:param name: name to assign to handler
:param wrapped: handler object or name of registered handler
:param prefix: identifying prefix to prepend to all hashes
:param orig_prefix: prefix to strip (defaults to '').
:param lazy: if True and wrapped handler is specified by name, don't look it up until needed.
R< c C� s@ | | _ t | t � r* | j d � } n | | _ t | t � rT | j d � } n | | _ | ro | | _ n t | d � r� | j | � n | | _ | s� | j
� n | d k r<| t k r� | r� | } q� t
d � � n t | t � r| j d � } n | t | � | t | � k r0t
d � � n | | _ n d S( NRc RF s no prefix specifieds ident must agree with prefix( RF RY R_ R` Ri t orig_prefixR� R; t _set_wrappedt
_wrapped_namet _get_wrappedRg R{ R� R7 t _ident( R� RF t wrappedRi RC t lazyt docRy ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s0
c C� sB d | j k r5 | j r5 t d | j f t j � n | | _ d S( NRy sk PrefixWrapper: 'orig_prefix' option may not work correctly for handlers which have multiple identifiers: %r( R� RC R RF RZ t PasslibRuntimeWarningt _wrapped_handler( R� RH ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyRD � s c C� s8 | j } | d k r4 t | j � } | j | � n | S( N( RL Rg R RE RD ( R� RH ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyRF � s
c C� sp | j } | t k rl d } | j s` | j } t | d d � } | d k r` | j | � } q` n | | _ n | S( NRy ( RG R� Rg RC RH R� t
_wrap_hash( R� Rs RH Ry ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyRy � s c � sw � j } | t k rs d } � j sg � j } t | d d � } | rg t � f d � | D� � } qg n | � _ n | S( NR� c 3� s | ] } � j | � Vq d S( N( RM ( RO Ry ( R� ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>� s ( t
_ident_valuesR� Rg RC RH R� t tuple( R� Rs RH t idents( ( R� s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� � s " R� RS Rq R� R� R
R� R� R� R� R� R� R� R� R R R R t is_disabledR� R� R� R� c C� s{ t | j p | j � g } | j r; | j d | j � n | j r[ | j d | j � n d j | � } d | j | f S( Ns prefix=%rs orig_prefix=%rs , s PrefixWrapper(%r, %s)( t reprRE RL Ri R/ RC t joinRF ( R� t args( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt __repr__
s c � sX t t | j � � } | j | j � | j � | j � f d � | j D� � t | � S( Nc 3� s$ | ] } t � | � r | Vq d S( N( R; ( RO t attr( RH ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pys <genexpr>
s ( RR t dirR� t updateR, RH t _proxy_attrsRT ( R� t attrs( ( RH s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt __dir__
s c C� s6 | | j k r t | j | � St d | f � � d S( sF proxy most attributes from wrapped class (e.g. rounds, salt size, etc)s missing attribute: %rN( RY R� RH R� ( R� RV ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt __getattr__
s c C� sZ | | j k rG | j rG | j } t | | � rG t | | | � d Sn t j | | | � S( N( RY t
_derived_fromRH R; t setattrR� t __setattr__( R� RV Rs RH ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR_
s c C� s? | j } | j | � s* t j | � � n | j | t | � S( s4 given hash belonging to wrapper, return orig version( Ri RA RZ Re RC R7 ( R� R^ Ri ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt _unwrap_hash+
s c C� so t | t � r! | j d � } n | j } | j | � sN t j | j � � n | j | t | � } t
| � S( s0 given orig hash; return one belonging to wrapperRc ( RY R_ R` RC RA RZ Re RH Ri R7 R ( R� R^ RC RH ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyRM 4
s c K� s� | j j | � } | | j k s' t � t | j | d | j d | j �} | | _ x* | j D] } t | | t
| | � � q^ W| S( NRi RC ( RH R� Rd R3 RF Ri RC R] t _using_clone_attrsR^ R� ( R� RL R� t wrapperRV ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� C
s $ c K� s" | j | � } | j j | | � S( N( R` RH R� ( R� R^ RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� N
s c C� sA t | � } | j | j � s" t S| j | � } | j j | � S( N( Rb RA Ri R� R` RH R� ( R� R^ ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� R
s
R� s 1.7R� s 2.0c K� s: | j j | � } | d k r- t d � � n | j | � S( Ns+ .genconfig() must return a string, not None( RH R� Rg RA RM ( R� RL R� ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� Y
s c K� sO | d k r0 t | d d � } | j | � } n | j | j j | | | � � S( NRc s config/hash( Rg R
R` RM RH R� ( R� RX R� RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� `
s t replacements .hash()c K� s | j | | � S( N( R^ ( R� RX RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt encrypth
s c K� s | j | j j | | � � S( N( RM RH R^ ( R� RX RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR^ l
s c K� s7 t | d d � } | j | � } | j j | | | � S( NRc R^ ( R
R` RH R� ( R� RX R^ RL ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR� o
s ( N( s setting_kwdss context_kwdss default_roundss
min_roundss
max_roundss rounds_costs min_desired_roundss max_desired_roundss vary_roundss default_salt_sizes
min_salt_sizes
max_salt_sizes
salt_charss default_salt_charss backendss has_backends get_backends set_backendRQ s
truncate_sizes truncate_errors truncate_verify_rejects _salt_is_bytes(# R; R� R� Ra R R� Rg R� RE RL RD RF R� RH RG Ry RN R� RY RU R[ R\ R_ R` RM R] R� R� R� R% R� R� Rd R^ R� ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyR3 � sJ
$ (c R� t
__future__R R= t loggingt getLoggerR; R6 R4 t threadingt warningsR t passlib.excRZ t passlib.ifct ifcR R R R t passlib.registryR t
passlib.utilsR R R R
R R R
R R R R R� R R R R R R R t passlib.utils.compatR R R R R R R R R! R" R# t passlib.utils.decorR$ R% t __all__t H64_CHARSt B64_CHARSt PADDED_B64_CHARSt UC_HEX_CHARSt LC_HEX_CHARSR: RG RM RU t _UDOLLARRn R] Rb Rg R& R' Rx R( R) R} R� R� R� R� R* R+ R� R, R- R. R/ R0 R1 R t RLockR R R) R2 R� R3 ( ( ( s: /usr/lib/python2.7/site-packages/passlib/utils/handlers.pyt <module> s� L4R J! &!*� �Z '�� &� xH � N|