Xc @ s d Z d d l Z d d l Z e j e Z d d l m Z d d l m Z d d l
m Z m Z d d l
m Z d d l m Z m Z m Z d d l m Z d d l m Z d
d d d
g Z d e f d YZ e Z e Z e j Z e d d d d d d d d d d d d d d d d d d d d d! d d" d d# d d$ d d% d& d' d& d( d& d) d& d* d& d+ d& d, d& d- d& d. d& d/ d d0 d1 d2 d d3 d4 d5 d4 d6 d4 d7 d4 d8 d4 d9 d4 d: d; d< d; d= d; d> d? d@ d? dA d; dB d; dC d; dD d; dE d; dF d; dG d; dH d; dI d; dJ d dK d dL d dM d dN d dO d dP d dQ dR dS dR dT dU dV dU dW d dX dY dZ dY d[ d d\ d d] d d^ d_ d` da db dc dd d? de df dg dh di dj dk dl dm dl dn do dp da dq da KZ! e j" dr Z# e$ ds dt du dv dw dx dy g Z% dz Z& d{ Z' e( d d| Z* e d} Z+ e( d~ Z, e( d Z- e. d Z/ d d Z0 d Z1 d Z2 d Z3 e1 e( d Z4 e d Z5 d Z6 d S( s6 passlib.registry - registry for password hash handlersiN( t warn( t exc( t ExpectedTypeErrort PasslibWarning( t PasswordHash( t is_crypt_handlert has_cryptt unix_crypt_schemes( t unicode_or_str( t memoize_single_valuet register_crypt_handler_patht register_crypt_handlert get_crypt_handlert list_crypt_handlerst _PasslibRegistryProxyc B s> e Z d Z d Z d Z d Z d Z d Z d Z RS( s proxy module passlib.hash
this module is in fact an object which lazy-loads
the requested password hash algorithm from wherever it has been stored.
it acts as a thin wrapper around :func:`passlib.registry.get_crypt_handler`.
s passlib.hashc C sU | j d r% t d | f n t | d } | r> | St d | f d S( Nt _s missing attribute: %rs unknown password hash: %r( t
startswitht AttributeErrorR t None( t selft attrt handler( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt __getattr__( s c C s9 | j d r% t j | | | n t | d | d S( NR t _attr( R t objectt __setattr__R ( R R t value( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyR 1 s c C s d S( Ns <proxy module 'passlib.hash'>( ( R ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt __repr__; s c C s< t t | j } | j | j | j t t | S( N( t sett dirt __class__t updatet __dict__t
_locationst sorted( R t attrs( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt __dir__> s
N( t __name__t
__module__t __doc__R t __package__R R R R$ ( ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyR s
t
apr_md5_crypts passlib.handlers.md5_cryptt argon2s passlib.handlers.argon2t atlassian_pbkdf2_sha1s passlib.handlers.pbkdf2t bcrypts passlib.handlers.bcryptt
bcrypt_sha256t bigcrypts passlib.handlers.des_cryptt
bsd_nthashs passlib.handlers.windowst
bsdi_cryptt cisco_pixs passlib.handlers.ciscot cisco_asat cisco_type7t cta_pbkdf2_sha1t crypt16t des_cryptt
django_argon2s passlib.handlers.djangot
django_bcryptt django_bcrypt_sha256t django_pbkdf2_sha256t django_pbkdf2_sha1t django_salted_sha1t django_salted_md5t django_des_cryptt django_disabledt dlitz_pbkdf2_sha1t fshps passlib.handlers.fshpt grub_pbkdf2_sha512t hex_md4s passlib.handlers.digestst hex_md5t hex_sha1t
hex_sha256t
hex_sha512t htdigestt ldap_plaintexts passlib.handlers.ldap_digestst ldap_md5t ldap_sha1t ldap_hex_md5s passlib.handlers.roundupt
ldap_hex_sha1t ldap_salted_md5t ldap_salted_sha1t ldap_des_cryptt ldap_bsdi_cryptt ldap_md5_cryptt ldap_bcryptt ldap_sha1_cryptt ldap_sha256_cryptt ldap_sha512_cryptt ldap_pbkdf2_sha1t ldap_pbkdf2_sha256t ldap_pbkdf2_sha512t lmhasht md5_cryptt msdcct msdcc2t mssql2000s passlib.handlers.mssqlt mssql2005t mysql323s passlib.handlers.mysqlt mysql41t nthasht oracle10s passlib.handlers.oraclet oracle11t pbkdf2_sha1t
pbkdf2_sha256t
pbkdf2_sha512t phpasss passlib.handlers.phpasst plaintexts passlib.handlers.misct postgres_md5s passlib.handlers.postgrest roundup_plaintextt scrams passlib.handlers.scramt scrypts passlib.handlers.scryptt
sha1_crypts passlib.handlers.sha1_cryptt sha256_crypts passlib.handlers.sha2_cryptt sha512_cryptt
sun_md5_crypts passlib.handlers.sun_md5_cryptt
unix_disabledt
unix_fallbacks ^[a-z][a-z0-9_]+[a-z0-9]$t onloadt policyt contextt allt defaultt nonet autoc C s | s t d | f n | j | k rD t d | f n t j | si t d | f n d | k r t d | f n | t k r t d | f n t S( s helper to validate handler name
:raises ValueError:
* if empty name
* if name not lower case
* if name contains double underscores
* if name is reserved (e.g. ``context``, ``all``).
s handler name cannot be empty: %rs name must be lower-case: %rs` invalid name (must be 3+ characters, begin with a-z, and contain only underscore, a-z, 0-9): %rt __s+ name may not contain double-underscores: %rs that name is not allowed: %r( t
ValueErrort lowert _name_ret matcht _forbidden_namest True( t name( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt _validate_handler_name s c C s t | | j d r( t d n d | k r | j d d k rX t d n | j d | j d d k r t d q n | t | <t j d | | d S(
sv register location to lazy-load handler when requested.
custom hashes may be registered via :func:`register_crypt_handler`,
or they may be registered by this function,
which will delay actually importing and loading the handler
until a call to :func:`get_crypt_handler` is made for the specified name.
:arg name: name of handler
:arg path: module import path
the specified module path should contain a password hash handler
called :samp:`{name}`, or the path may contain a colon,
specifying the module and module attribute to use.
for example, the following would cause ``get_handler("myhash")`` to look
for a class named ``myhash`` within the ``myapp.helpers`` module::
>>> from passlib.registry import registry_crypt_handler_path
>>> registry_crypt_handler_path("myhash", "myapp.helpers")
...while this form would cause ``get_handler("myhash")`` to look
for a class name ``MyHash`` within the ``myapp.helpers`` module::
>>> from passlib.registry import registry_crypt_handler_path
>>> registry_crypt_handler_path("myhash", "myapp.helpers:MyHash")
t .s path cannot start with '.'t :i s" path cannot have more than one ':'is$ path cannot have '.' to right of ':'s! registered path to %r handler: %rN( R R R| t countt findt indexR! t logt debug( R t path( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyR
s
!
c C s t | s! t | d d n | s6 t d n | j } t | | rt | | k rt t d | | f n t j | } | r | | k r t j d | | d S| r t j
d | | q t d | | f n | t | <t j d | | d S(
s@ register password hash handler.
this method immediately registers a handler with the internal passlib registry,
so that it will be returned by :func:`get_crypt_handler` when requested.
:arg handler: the password hash handler to register
:param force: force override of existing handler (defaults to False)
:param _attr:
[internal kwd] if specified, ensures ``handler.name``
matches this value, or raises :exc:`ValueError`.
:raises TypeError:
if the specified object does not appear to be a valid handler.
:raises ValueError:
if the specified object's name (or other required attributes)
contain invalid values.
:raises KeyError:
if a (different) handler was already registered with
the same name, and ``force=True`` was not specified.
s password hash handlerR s ``bool(handler)`` must be Trues< handlers must be stored only under their own name (%r != %r)s& same %r handler already registered: %rNs/ overriding previously registered %r handler: %rs2 another %r handler has already been registered: %rs registered %r handler: %r( R R t AssertionErrorR R R| t _handlerst getR R t warningt KeyError( R t forceR R t other( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyR s*
c C s | j d r8 | t k r1 t d | f q8 | Sn y t | SWn t k
rW n X| j d d j } | | k r t d | | f t d d | } y t | SWq t k
r q Xn t j | } | r_d | k r | j
d \ } } n
| | } } t | d | g d d
} t j | } | r<| St | | } t
| d | | S| t k rt d | f n | Sd
S( s' return handler for specified password hash scheme.
this method looks up a handler for the specified scheme.
if the handler is not already loaded,
it checks if the location is known, and loads it first.
:arg name: name of handler to return
:param default: optional default value to return if no handler with specified name is found.
:raises KeyError: if no handler matching that name is found, and no default specified, a KeyError will be raised.
:returns: handler attached to name, or default value (if specified).
R s invalid handler name: %rt -sT handler names should be lower-case, and use underscores instead of hyphens: %r => %rt
stackleveli R t fromlistt leveli R s( no crypt handler found for algorithm: %rN( R t _UNSETR R t replaceR} R R R! R t splitt
__import__t getattrR ( R Rx t altR t modnamet modattrt modR ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyR ( sB
c C s6 t t } | s" | j t n t d | D S( s return sorted list of all known crypt handler names.
:param loaded_only: if ``True``, only returns names of handlers which have actually been loaded.
:returns: list of names of all known handlers
c s s$ | ] } | j d s | Vq d S( R N( R ( t .0R ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pys <genexpr> s ( R R R R! R" ( t loaded_onlyt names( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyR
s s c C s | t k p | o | t k S( sA check if handler name is known.
this is only useful for two cases:
* quickly checking if handler has already been loaded
* checking if handler exists, without actually loading it
:arg name: name of handler
:param loaded_only: if ``True``, returns False if handler exists but hasn't been loaded
( R R! ( R R ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt _has_crypt_handler s c C s6 | t k r t | =n | r2 | t k r2 t | =n d S( s unloads a handler from the registry.
.. warning::
this is an internal function,
used only by the unittests.
if loaded handler is found with specified name, it's removed.
if path to lazy load handler is found, it's removed.
missing names are a noop.
:arg name: name of handler to unload
:param locations: if False, won't purge registered handler locations (default True)
N( R R! ( R t locations( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt _unload_handler_name s
R c C sB t | r | St | t r) t | St j | t | d S( s>
internal helper to resolve argument to hasher object
N( R t
isinstanceR R R R ( t hashert param( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt _resolve s
t anyt builtint os_cryptc C s t | } | t k rX t | d s+ t Sy | j t SWqX t j k
rT t SXn t | d r | r | | j k r d S| j
| S| t k r t S| r d St j | | d S( s
Test if specified backend is available for hasher.
:param hasher:
Hasher name or object.
:param backend:
Name of backend, or ``"any"`` if any backend will do.
For hashers without multiple backends, will pretend
they have a single backend named ``"builtin"``.
:param safe:
By default, throws error if backend is unknown.
If ``safe=True``, will just return false value.
:raises ValueError:
* if hasher name is unknown.
* if backend is unknown to hasher, and safe=False.
:return:
True if backend available, False if not available,
and None if unknown + safe=True.
t get_backendt has_backendN(
R t ANYt hasattrR R R t MissingBackendErrort Falset backendsR R t BUILTINt UnknownBackendError( R t backendt safe( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyR s$
c C s= t s
d St d t D } | s9 t d t j n | S( sN
return tuple of schemes which :func:`crypt.crypt` natively supports.
c s s* | ] } t | j t r | Vq d S( N( R R t OS_CRYPT( R R ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pys <genexpr> s sT crypt.crypt() function is present, but doesn't support any formats known to passlib!( ( t os_crypt_presentt tuplet os_crypt_schemesR R t PasslibRuntimeWarning( t cache( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt get_supported_os_crypt_schemes s
c C s t o t | t d t S( s
check if hash is supported by native :func:`crypt.crypt` function.
if :func:`crypt.crypt` is not present, will always return False.
:param hasher:
name or hasher object.
:returns bool:
True if hash format is supported by OS, else False.
R ( R R R R ( R ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt has_os_crypt_support s (7 R' t ret loggingt getLoggerR% R t warningsR t passlibR t passlib.excR R t passlib.ifcR t
passlib.utilsR R R R R t passlib.utils.compatR t passlib.utils.decorR t __all__R R t _proxyR R R t dictR! t compileR~ t frozensetR R R
R R R R R
R R R R R R R R R R ( ( ( s4 /usr/lib/python2.7/site-packages/passlib/registry.pyt <module> s ) *5 K
>