a
f�WcU@ � @ s� d Z ddlmZ ddlmZ ddlZddlmZmZ ddl Z ddl
Z
e
� e �Z
ddlZddlZddlZddlZddlZddlZddlZddlmZmZ ddlmZmZ ddlZddlm Z dd l m Z dd
lm Z ddl m!Z! dd l"m#Z$m%Z%m&Z&m'Z'm(Z( dd l)m*Z*m+Z+m,Z,m-Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4 dd
lm5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m> m?Z@ g d�ZAz ddlBZCW n eD�y� dZEY n0 dZEdd� ZFdd� ZGeGe3�ZHg d�ZIeI�JejK�Ldd��M� �N� �ZOdNdd�ZPdd � ZQdOd d �ZRd d � ZSdPd!d"�ZTd#d$� ZUd%d&� ZVd'd(� ZWejXd)d*� �ZYd+d,� ZZd-d.� Z[d/d0� Z\d1d2� Z]d3d4� Z^d5d6� Z_dQd9d:�Z`dRd=d>�ZaG d?d@� d@e$�Z#dAdgZbdBdC� ZcG dDdE� dEe#�ZdG dFdG� dGed�ZeG dHdI� dIed�ZfG dJdK� dKed�ZgG dLdM� dMejh�ZidS )Sz helpers for passlib unittests� )�with_statement)� unhexlifyN)�wraps�partial)�PasslibHashWarning�PasslibConfigWarning)�PY3�JYTHON)�warn)�exc)�MissingBackendError)�TestCase�skip�skipIf�
skipUnless�SkipTest)
�has_rounds_info�
has_salt_info�rounds_cost_values�rng�
getrandstr�
is_ascii_safe�
to_native_str�
repeat_string�tick�batch)� iteritems�irange�u�unicode�PY2� nullcontext)�
classproperty)� TEST_MODE�set_file�get_filer
� HandlerCaseFTc C s8 t j�| �}t j�| �|kr4t�d� t �| d� q dS )z ensure file's mtime has changed皙�����?N)�os�path�getmtime�time�sleep�utime)r) Zlast� r. �7/usr/lib/python3.9/site-packages/passlib/tests/utils.py�ensure_mtime_changed; s
r0 c s& �fdd�� t � fdd�td�D ��S )Nc s" � � } }| |kr� � }q
|| S �Nr. )�startZcur��timerr. r/ �sampleE s
z%_get_timer_resolution.<locals>.samplec 3 s | ] }� � V qd S r1 r. ��.0�_)r5 r. r/ � <genexpr>J � z(_get_timer_resolution.<locals>.<genexpr>� )�min�ranger3 r. )r5 r4 r/ �_get_timer_resolutionD s r> )�quick�default�fullZPASSLIB_TEST_MODEr@ c C s0 | rt t�| �k rdS |r,t t�|�kr,dS dS )a� check if test for specified mode should be enabled.
``"quick"``
run the bare minimum tests to ensure functionality.
variable-cost hashes are tested at their lowest setting.
hash algorithms are only tested against the backend that will
be used on the current host. no fuzz testing is done.
``"default"``
same as ``"quick"``, except: hash algorithms are tested
at default levels, and a brief round of fuzz testing is done
for each hash.
``"full"``
extra regression and internal tests are enabled, hash algorithms are tested
against all available backends, unavailable ones are mocked whre possible,
additional time is devoted to fuzz testing.
FT)�
_test_mode� _TEST_MODES�index)r< �maxr. r. r/ r# T s
r# c C s$ t | d�rdS d| jv p"t| tj�S )z'check if handler supports 'relaxed' kwd� orig_prefixF�relaxed)�hasattr� setting_kwds�
issubclass�uhZGenericHandler��handlerr. r. r/ �has_relaxed_settingp s
�rN c C s t | �} | |dd�jS )z'get effective rounds value from handlerT)�rounds� use_defaults)�unwrap_handlerrO )rM rO r. r. r/ �get_effective_rounds| s rR c C sV z | � � }W n ty Y dS 0 z"| �d� | � � |kW | �|� S | �|� 0 dS )z*check if backend is the default for sourceFr@ N)� get_backendr � set_backend)rM �backend�origr. r. r/ �is_default_backend� s
�rW c c sZ |du r| � � }| j}|r(|�|�d nd}||d� D ] }||kr8| �|�r8|V q8dS )z�
iterate over alternate backends available to handler.
.. warning::
not thread-safe due to has_backend() call
N� r )rS �backendsrD � has_backend)rM �current�fallbackrY �idxrU r. r. r/ �iter_alt_backends� s r^ c O s t | i |��D ]
}| S d S r1 )r^ )�args�kwdsrU r. r. r/ �get_alt_backend� s ra c C s t | d�r| j} q | S )z5return original handler, removing any wrapper objects�wrapped)rH rb rL r. r. r/ rQ � s
rQ c C sf | |kr dS t | tj�r4| r0| |kr(dS | j} qdS t | t�rTt| tj�rTt| |�S td| f ��dS )zG
test if <handler> was derived from <base> via <base.using()>.
TFz%don't know how to inspect handler: %rN)�
isinstancerK �
PrefixWrapperZ
_derived_from�typerJ ZMinimalHandler�NotImplementedError)rM �baser. r. r/ �handler_derived_from� s
rh c # s� t | t�rJt| tj�rJ| j� � fdd�}|| _zdV W � | _q�� | _0 nHt | tj�r�t| j�� dV W d � q�1 s|0 Y n
dV dS dS )a
internal helper for do_config_encrypt() --
context manager which temporarily replaces handler's _calc_checksum()
with one that uses min_rounds; useful when trying to generate config
with high rounds value, but don't care if output is correct.
c s: | j }z&| j| _ � | g|�R i |��W || _ S || _ 0 d S r1 )rO �
min_rounds)�selfr_ r` rO �rb r. r/ �wrapper� s �z&patch_calc_min_rounds.<locals>.wrapperN) rc re rJ rK Z HasRoundsZ_calc_checksumrd �patch_calc_min_roundsrb )rM rl r. rk r/ rm � s &rm c C sL t |t�r|�d�}t| d��}|�|� W d � n1 s>0 Y dS )zset file to specified bytes�utf-8�wbN)rc r �encode�open�write)r) Zcontent�fhr. r. r/ r$ � s
r$ c C s6 t | d��}|�� W d � S 1 s(0 Y dS )zread file as bytes�rbN)rq �read)r) rs r. r. r/ r% � s r% c C sJ t | t�s| S tr | �d�S z | �d�W S tyD | �d� Y S 0 dS )z*convert native string to non-native stringrn �latin-1N)rc �strr rp �decode�UnicodeDecodeError��sourcer. r. r/ �tonn� s
r| c C s t t�dd| ��S )zT
helper for represent byte strings in hex.
usage: ``hb("deadbeef23")``
z\s� )r �re�subrz r. r. r/ �hb� s r� c C s | |k r |S | |kr|S | S r1 r. )�value�lower�upperr. r. r/ �limit� s
r� c C s t � }t � | | k rqdS )zAbecause time.sleep() doesn't even have 10ms accuracy on some OSesN�r )Zdelayr2 r. r. r/ �
quicksleep s r� rX �
c
C st ddl m} ddlm} || |p"dd�}d}t� | }t|�||��} t� |krf| | t||d��fS |d9 }q6dS ) z�
timeit() wrapper which tries to get as accurate a measurement as possible w/in maxtime seconds.
:returns:
``(avg_seconds_per_call, log10_number_of_repetitions)``
r )�Timer��logr} )�setuprX r� N)Ztimeitr� �mathr� r r< �repeat�int)
�funcr� ZmaxtimeZbestofr� r� r4 Znumber�endZdeltar. r. r/ � time_call s
r� � � �F "*�! c s � �fdd�}|S )z<
decorator run test method w/ multiple fixed seeds.
c s t � ��� �fdd��}|S )Nc s8 t ���}t� �D ] }|�d�|d< �| i |�� qd S )N� �seed)�random�Randomr � getrandbits)r_ r` r r8 )�countr� � master_seedr. r/ rl s
z6run_with_fixed_seeds.<locals>.builder.<locals>.wrapper)r )r� rl �r� r� �r� r/ �builder s z%run_with_fixed_seeds.<locals>.builderr. )r� r� r� r. r� r/ �run_with_fixed_seeds s r� c s. e Zd ZdZdZ� fdd�Zedd� �Zedd� �Zd Z d Z
� fd
d �Z d d
� Z d Z
dd� Zd3� fdd� Zdd� Ze ZZd4dd�ZG dd� dej�Zd5dd�Zd6dd�Zd d � Zd d � Zd d!� Zd"d#� Z d$d%� Z e � � Z dZ!dZ"d7d'd(�Z#e$e%d)�Z&e'j(� fd*d+��Z)dZ*d,d-� Z+d8d/d0�Z,d1d2� Z-� Z.S )9r
aR passlib-specific test case class
this class adds a number of features to the standard TestCase...
* common prefix for all test descriptions
* resets warnings filter & registry for every test
* tweaks to message formatting
* __msg__ kwd added to assertRaises()
* suite of methods for matching against warnings
Nc s0 t t| ��� }| j}|r,d||p&t| �f }|S )z;wrap shortDescription() method to prepend descriptionPrefixz%s: %s)�superr
�shortDescription�descriptionPrefixrw )rj �desc�prefix�� __class__r. r/ r� B s
zTestCase.shortDescriptionc C s | j }|�d�p t| d| d�S )Nr8 z_%s__unittest_skipF)�__name__�
startswith�getattr)�cls�namer. r. r/ �__unittest_skip__N s
�zTestCase.__unittest_skip__c C s | j S r1 )r� �r� r. r. r/ �__test__U s zTestCase.__test__Tc s( t t| ��� | �� | �tdd� d S )NZENABLE_DEBUG_ONLY_REPRT)r� r
�setUp�
setUpWarnings� patchAttrr �rj r� r. r/ r� d s zTestCase.setUpc C sH | j rDt� }|�� | �|j� t�dd� t�dd� t�dd� dS )z6helper to init warning filters before subclass setUp()�ignorez<the method .*\.(encrypt|genconfig|genhash)\(\) is deprecatedz&the 'vary_rounds' option is deprecatedz0Support for `(py-bcrypt|bcryptor)` is deprecatedN)�resetWarningState�reset_warnings� __enter__�
addCleanup�__exit__�warnings�filterwarnings)rj �ctxr. r. r/ r� j s zTestCase.setUpWarningsc C s4 | j r(|r(|�� �d�r(d|�� |f S |p.|S d S )N�:z%s %s)� longMessage�rstrip�endswith)rj �msg�stdr. r. r/ �_formatMessage� s zTestCase._formatMessagec
s� |� dd �}|d u r4tt| �j|d g|�R i |��S z||i |��}W n( |yn } z|W Y d }~S d }~0 0 d||f }| �| �||���d S )N�__msg__z-function returned %r, expected it to raise %r)�popr� r
� assertRaises�failureExceptionr� ) rj Z _exc_typeZ _callabler_ r` r� �result�errr� r� r. r/ r� � s ���zTestCase.assertRaisesc O s t d��d S )Nz%this alias is deprecated by unittest2)�AssertionError)rj �a�kr. r. r/ � assertEquals� s zTestCase.assertEqualsc C s� t |d�r|} |j}nd} |r0| �t|�||� |rF| �t|�||� |rX| �|||� |s`|r�| sltd��| j}
|
�d�s�|
�d�r�|
dd� }
|r�| �|
||� |r�| �|
||� |r�| s�td��| �| j ||� dS )z�check if warning matches specified parameters.
'warning' is the instance of Warning to match against;
can also be instance of WarningMessage (as returned by catch_warnings).
�categoryNz7matching on filename requires a WarningMessage instancez.pycz.pyo���z5matching on lineno requires a WarningMessage instance)
rH �message� assertEqualrw � assertRegex�assertIsInstance� TypeError�filenamer� �lineno) rj �warning�
message_rer� r� Z filename_rer� r� r� Zwmsg�realr. r. r/ �
assertWarning� s0
zTestCase.assertWarningc s0 e Zd ZdZ� fdd�Zdd� Zdd� Z� ZS )zTestCase._AssertWarningListz'context manager for assertWarningList()c s, || _ || _ttj| �| _| jjdd� d S )NT��record)�caser` r� r
�_AssertWarningList�_AssertWarningList__super�__init__)rj r� r` r� r. r/ r� � s z$TestCase._AssertWarningList.__init__c C s | j �� | _d S r1 )r� r� r� r� r. r. r/ r� � s z%TestCase._AssertWarningList.__enter__c G s4 | j j|� |d d u r0| jj| jfi | j�� d S �Nr )r� r� r� �assertWarningListr� r` )rj �exc_infor. r. r/ r� � s z$TestCase._AssertWarningList.__exit__�r� �
__module__� __qualname__�__doc__r� r� r� �
__classcell__r. r. r� r/ r� � s r� c C s
|du r| j | ||d�S t|ttf�s,|g}t|�D ]�\}}t|t�rRt|d�}n2t|t�rrt|t �rrt|d�}nt|t�s�t
d��z || }W n t y� Y q�Y n0 | j |fd|i|�� q4t
|�t
|�kr�dS dt
|�t
|�| �|�|f }| �| �||���dS )zBcheck that warning list (e.g. from catch_warnings) matches patternN)r� r� )r� �r� z#entry must be str, warning, or dictr� z0expected %d warnings, found %d: wlist=%s desc=%r)r� rc �list�tuple� enumeraterw �dictre rJ �Warningr� �
IndexErrorr� �len�_formatWarningListr� r� )rj �wlistr� r� r] �entry�datar� r. r. r/ r� � s,
�zTestCase.assertWarningListc O s4 |du r g }| j ||g|�R i |�� |dd�= dS )zD[deprecated] assertWarningList() variant that clears list afterwardsN)r� )rj r� r� r_ r` r. r. r/ �consumeWarningList s zTestCase.consumeWarningListc C sZ d}t |d�r:d|j|jf }|jr4|d|jf 7 }|j}t|�}d|j|jt|�|f S )Nr} r� z filename=%r lineno=%rz line=%rz<%s.%s message=%r%s>) rH r� r� �liner� re r� r� rw )rj r� �tailr� r. r. r/ �_formatWarning s
�zTestCase._formatWarningc s dd� � fdd�|D �� S )Nz[%s]�, c 3 s | ]}� � |�V qd S r1 )r� )r7 r� r� r. r/ r9 r: z.TestCase._formatWarningList.<locals>.<genexpr>)�join)rj r� r. r� r/ r� s zTestCase._formatWarningListc C s. ddl m} |s*ddl m} | �d| ��dS )z,helper to skip test if stringprep is missingr )�
stringprep)�_stringprep_missing_reasonz%not available - stringprep module is N)�
passlib.utilsr� r� �skipTest)rj r� r� r. r. r/ �require_stringprep s �zTestCase.require_stringprepc C s t |�s| �d| ��dS )z8skip test for all PASSLIB_TEST_MODE values below <level>zrequires >= %r test modeN)r# r� )rj �levelr. r. r/ �require_TEST_MODE! s zTestCase.require_TEST_MODEc C s t r| �d�S dS )z'skip test if writeable FS not availablez.GAE doesn't offer read/write filesystem accessN)�GAEr� r� r. r. r/ � require_writeable_filesystem& s z%TestCase.require_writeable_filesystemr@ c C s* | j }|r||v r|| S | j� �� | j }|rL||v rL|| W d � S |sZi }| _ |pbtj}|du r�ttj�d�p�tj�d�p�t� d�� }t_t
� d|� t | �}d�
t|�|j|j| j|g�}t�|�d���� }t|dd� d�}t�|� }||< |W d � S 1 �s 0 Y dS ) aU
Return a :class:`random.Random` object for current test method to use.
Within an instance, multiple calls with the same name will return
the same object.
When first created, each RNG will be seeded with value derived from
a global seed, the test class module & name, the current test method name,
and the **name** parameter.
The global seed taken from the $RANDOM_TEST_SEED env var,
the $PYTHONHASHSEED env var, or a randomly generated the
first time this method is called. In all cases, the value
is logged for reproducibility.
:param name:
name to uniquely identify separate RNGs w/in a test
(e.g. for threaded tests).
:param seed:
override global seed when initialzing rng.
:rtype: random.Random
NZRANDOM_TEST_SEEDZPYTHONHASHSEEDr� zusing RANDOM_TEST_SEED=%d�
rn � )�
_random_cache�_random_global_lockr
�_random_global_seedr� r( �environ�get�sys_rngr� r� �infore r� rw r� r� �_testMethodName�hashlibZsha256rp � hexdigestr� r� ) rj r� r� �cacheZ global_seedr� r{ �digestr� r. r. r/ � getRandom9 s4
��� �zTestCase.getRandom�subTestc / s� ddd�}| � � }||i |��}| jr>tt| �j|i |��}nt� }|�� |�d|� z
dV W n\ ty~ |�d|� Y n@ ty� } z(|� d|t
|�j t |�� � W Y d}~n
d}~0 0 W d � n1 s�0 Y |�d|� dS ) zt
wrapper/backport for .subTest() which also traps SkipTest errors.
(see source for details)
Nc [ s@ | r d| nd}|r4|dd� dd� |�� D �� 7 }|�� p>dS )Nz[%s] r} z(%s)� c s s | ]}d t |� V qdS )z%s=%rN)r� )r7 �itemr. r. r/ r9 � r: z:TestCase.subTest.<locals>._render_title.<locals>.<genexpr>z <subtest>)r� �items�strip)Z_msg�params�outr. r. r/ �
_render_title� s z'TestCase.subTest.<locals>._render_titlezrunning subtest: %szsubtest skipped: %szsubtest failed: %s: %s: %rzsubtest passed: %s)N)
� getLogger�has_real_subtestr� r
r r! r
r � Exceptionr� re r� rw )rj r_ r` r Ztest_log�titler� r� r� r. r/ r | s"
6zTestCase.subTestc sb | � � tj|i |��\}}t�|� | j� � du rTg � | _� fdd�}| �|� � �|� |S )z1create temp file that's cleaned up at end of testNc s. � D ]} t j�| �rt �| � q� d d �= d S r1 )r( r) �exists�remove)r) �Zqueuer. r/ �cleaner� s z TestCase.mktemp.<locals>.cleaner)r �tempfileZmkstempr( �close�
_mktemp_queuer� �append)rj r_ r` �fdr) r r. r r/ �mktemp� s
zTestCase.mktempFc sz zt �� �}W n0 ty> |r"� � �fdd�}| �|� Y n0 | �t�� |� |rjt||�}t|�|� t�� |� dS )z=monkeypatch object value, restoring original value on cleanupc s& zt �� � W n ty Y n0 d S r1 )�delattr�AttributeErrorr. ��attr�objr. r/ �cleanup� s z#TestCase.patchAttr.<locals>.cleanupN)r� r( r� �setattrr r )rj r+ r* r� Zrequire_existing�wraprV r, r. r) r/ r� � s
zTestCase.patchAttrc C s@ t | �}|jd t|d|j� }| j}|r6|d | }t�|�S )z9
return logger named after current test.
�.r� )re r� r� r� r �loggingr )rj r� r) r� r. r. r/ r � s zTestCase.getLogger)N)NNNNNNN)NNN)N)r@ N)TF)/r� r� r� r� r� r� r" r� r� Z_TestCase__unittest_skipr� r� r� r� r� r� r� ZassertNotEqualsZassertRegexMatchesr� r� �catch_warningsr� r� r� r� r� r� r� r � threading�Lockr r r r rH � _TestCaser �
contextlib�contextmanagerr r# r& r� r r� r. r. r� r/ r
- sR
�
0
A
8
r
�anyc C s
d| _ | S )a0
decorator for HandlerCase.create_backend_case() --
used to decorate methods that should be run even if backend isn't present
(by default, full test suite is skipped when backend is missing)
NOTE: tests decorated with this should not rely on handler have expected (or any!) backend.
T)�_doesnt_require_backendr� r. r. r/ �doesnt_require_backend� s r9 c s< e Zd ZdZdZdZg Zg Zg Zg Z g Z
g d�Z e d�e d�dgZ
dZdZdZdZedd � �Zd
Zed d � �Zed
d� �Zdd� Zd�dd�Zdd� Zdd� Z dd� Z d�dd�Z d�dd �Z d d � Z d d � Z!d!d"� Z"d�d#d$�Z#d%Z$ed&d'� �Z%ed(d)� �Z&dZ'd*d+� Z(� fd,d-�Z)d.d/� Z*d0d1� Z+d2d3� Z,d�d4d5�Z-d6d7� Z.d8d9� Z/d:d;� Z0d<d=� Z1d>d?� Z2d@dA� Z3edBdC� �Z4dDdE� Z5dFdG� Z6dHdI� Z7dZ8dJdK� Z9dLdM� Z:edNdO� �Z;dPdQ� Z<dRdS� Z=dTdU� Z>dVdW� Z?dXdY� Z@dZd[� ZA� fd\d]�ZBd^d_� ZCd`da� ZDdbdc� ZEddde� ZFdfdg� ZGdhdi� ZHdjdk� ZIdldm� ZJdndo� ZKdpdq� ZLdrds� ZMdtdu� ZNdvdw� ZOdxdy� ZPdzd{� ZQd|d}� ZRd~d� ZSd�d�� ZTd�d�� ZUd�d�� ZVd�d�� ZWd�d�� ZXd�d�� ZYd�d�� ZZd�d�� Z[d�d�� Z\d�d�� Z]g Z^d�d�� Z_d�d�� Z`d�d�� Zad�d�� Zbd�d�d��Zcd�d�� Zded�d�� �Zeed�d�� �Zfd�Zgd�d�d��Zhd�d�� ZiG d�d�� d�ej�Zkd�d�� Zl� ZmS )�r& a� base class for testing password hash handlers (esp passlib.utils.handlers subclasses)
In order to use this to test a handler,
create a subclass will all the appropriate attributes
filled as listed in the example below,
and run the subclass via unittest.
.. todo::
Document all of the options HandlerCase offers.
.. note::
This is subclass of :class:`unittest.TestCase`
(or :class:`unittest2.TestCase` if available).
N))Z des_cryptZ
6f8c114b58f2c)Z md5_cryptz"$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.)Z sha512_cryptzx$6$rounds=123456$asaltof16chars..$BtCwjqMJGx5hrJhZywWvt0RLE8uZ4oPwcelCjmw2kSYu.Ec6ycULevoBK25fs2xXgMNrCzIMVcgEJAstJeonj1�testu €¥$s €¥$Fc C s dt | jdd�v rdS d S )N�os_cryptrY r. � )r� rM r� r. r. r/ �forbidden_charactersZ s z HandlerCase.forbidden_charactersTc C s, | j }|j}t|d�r(|d|�� f 7 }|S )NrS z
(%s backend))rM r� rH rS )rj rM r� r. r. r/ r� g s
z HandlerCase.descriptionPrefixc c sV | j D ]\}}||fV q| jD ]\}}}||fV q | jD ]\}}}||fV q<dS )z*iterate through known (secret, hash) pairsN)�known_correct_hashes�known_correct_configs�known_alternate_hashes)r� �secret�hash�config�altr. r. r/ �iter_known_hashesv s z HandlerCase.iter_known_hashesc C s t | �� �}| �� �|�S )z#test random sample secret/hash pair)r� rE r �choice)rj Zknownr. r. r/ �get_sample_hash� s zHandlerCase.get_sample_hashc C s� | � ||�}| �|du p |du d|f � | jjs6|rZ|s>dS |sNd||f }| �|��n"|rbdS |srd||f }| �|��dS )z>helper to check verify() outcome, honoring is_disabled_handlerTFz'verify() returned non-boolean value: %rNz4verify incorrectly returned True: secret=%r, hash=%rz!verify failed: secret=%r, hash=%r)� do_verify�
assertTruerM � is_disabledr� )rj rA rB r� �negater� r. r. r/ � check_verify� s" � � zHandlerCase.check_verifyc C s | � |td||f � d S )Nz'%s() failed to return native string: %r)r� rw )rj r� Z func_namer. r. r/ �check_returned_native_str� s
�z%HandlerCase.check_returned_native_strc C s| | j }d|jv rxd|vrx|j}|j}tdd�r>td|�|d< n:d}t|dd�dkr\||8 }n |d|> }td||�|d< dS ) z0subclassable method to populate default settingsrO r? �rE r; � rounds_costN�log2rX )rM rI ri �default_roundsr# rE r� )rj r` rM �mn�dfZfactorr. r. r/ �populate_settings� s
z HandlerCase.populate_settingsc C s |S )z?subclassable method allowing 'secret' to be encode context kwdsr. )rj rA r` r. r. r/ �populate_context� s z HandlerCase.populate_contextc K s� | � |� |du ri }| �||�}|r�g }|rH|jf i |�� |�d� | �|��( |p\| jj|fi |��W d � S 1 s�0 Y n$|p�| jjf i |��j|fi |��S dS )z3call handler's hash() method with specified optionsNz"passing settings to.*is deprecated) rT rU �updater$ r� rM Zencrypt�usingrB )rj rA � use_encryptrM �context�settingsr� r. r. r/ �
do_encrypt� s
8zHandlerCase.do_encryptc K s& | � ||�}|p| jj||fi |��S )z call handler's verify method)rU rM �verify)rj rA rB rM r` r. r. r/ rH � s zHandlerCase.do_verifyc C s | j �|�S )z call handler's identify method)rM �identify�rj rB r. r. r/ � do_identify� s zHandlerCase.do_identifyc K s | � |� | jjf i |��S )z6call handler's genconfig method with specified options)rT rM � genconfig)rj r` r. r. r/ � do_genconfig� s
zHandlerCase.do_genconfigc K s" | � ||�}| jj||fi |��S )z4call handler's genhash method with specified options)rU rM �genhash)rj rA rC r` r. r. r/ �
do_genhash� s zHandlerCase.do_genhashc K sl |p| j jf i |��}|du r"i }| �d|�}t|��" |j|fi |��W d � S 1 s^0 Y dS )z�
return sample hash for handler, w/o caring if digest is valid
(uses some monkeypatching to minimize digest calculation cost)
Nr} )rM rW rU rm rB )rj rM rY rZ rA r. r. r/ �do_stub_encrypt� s
zHandlerCase.do_stub_encryptzbackend not availablec C s0 | j }t||�s td�s dS |�|�r*dS | jS )z�
helper for create_backend_case() --
returns reason to skip backend, or None if backend should be tested
rA z$only default backend is being testedN)rM rW r# rZ �_BACKEND_NOT_AVAILABLE)r� rU rM r. r. r/ �_get_skip_backend_reason� s
z$HandlerCase._get_skip_backend_reasonc C sX | j }|j}| f}|dkr$|tf7 }td||f |td||f || �|�| jd��}|S )Nr; z
%s_%s_testz%s (%s backend))r� rU �_skip_backend_reasonr� )rM r� � OsCryptMixinre r� rf r� )r� rU rM r� �bases�subclsr. r. r/ �create_backend_case s
��
z HandlerCase.create_backend_casec C s t | | jd�}t |dd� S )z]
check if current test method decorated with doesnt_require_backend() helper
Nr8 F)r� r )rj �methr. r. r/ �_test_requires_backend s z"HandlerCase._test_requires_backendc s� | � � }|r | jr | �| j��tt| ��� | j}| j}|r�t|d�sNt d��z | �
|j |� � � |� |� W n t
jjy� |r�� Y n0 ddlm} | �|d| �d�� d S )NrT z)handler doesn't support multiple backendsr )�handlersr zsalt generator)rm rg r� r� r& r� rM rU rH � RuntimeErrorr� rT rS rK r r r� rn r� r )rj Ztest_requires_backendrM rU rn r� r. r/ r� $ s"
zHandlerCase.setUpc s� | j � � fdd�}|d�}| �|d� | �|td� | �|�� |kd� | �t�d|�d|f � |d �}| �|d
ud � | �|td � |d
�}| �|d
ud� | �|td� d
S )z validate required attributesc s t � | d �S r1 )r� �r� rL r. r/ �gaH s z3HandlerCase.test_01_required_attributes.<locals>.gar� zname not defined:zname must be native strzname not lower-case:z ^[a-z0-9_]+$z&name must be alphanum + underscore: %rrI Nz setting_kwds must be defined:z setting_kwds must be a tuple:Z context_kwdsz context_kwds must be defined:z context_kwds must be a tuple:)rM rI r� rw r� r~ �matchr� )rj rq r� rZ rY r. rL r/ �test_01_required_attributesE s �z'HandlerCase.test_01_required_attributesc C sT | � � }| �|d� | �d|�}| �|d� | �d|� | �| �|�d|f � dS )z�test basic config-string workflow
this tests that genconfig() returns the expected types,
and that identify() and genhash() handle the result correctly.
r` �stubrb r} z4identify() failed to identify genconfig() output: %rN)ra rM rc rH rI r_ )rj rC r� r. r. r/ �test_02_config_workflowe s
��z#HandlerCase.test_02_config_workflowc C s. | j }|�� }| �||� | �|j|j� dS )ztest basic using() workflowN)rM rW Z assertIsNotr� r� )rj rM rj r. r. r/ �test_02_using_workflow� s z"HandlerCase.test_02_using_workflowc
C s d}| j D ]�}| j||d�}| �|d� | �||� | j||dd� | �||�}| �|d� | jjr�| jr�| �||d|||f � n| � ||d|||f � | �||�}| �|d� | jjr�| js�| � ||d ||||f � n| �||d
||||f � | �
| � |�� q
d S ) z�test basic hash-string workflow.
this tests that hash()'s hashes are accepted
by verify() and identify(), and regenerated correctly by genhash().
the test is run against a couple of different stock passwords.
rt )rX rB T)rK rb zBgenhash() failed to salt result hash: secret=%r hash=%r: result=%rz@genhash() failed to reproduce hash: secret=%r hash=%r: result=%rzYgenhash() failed to reproduce disabled-hash: secret=%r hash=%r other_secret=%r: result=%rzGgenhash() duplicated hash: secret=%r hash=%r wrong_secret=%r: result=%rN) �stock_passwordsr[ rM rL rc rM rJ �disabled_contains_salt�assertNotEqualr� rI r_ )rj �
use_16_legacyZ wrong_secretrA r� �otherr. r. r/ �test_03_hash_workflow� s2
�
�
�
�z!HandlerCase.test_03_hash_workflowc C s | j dd� dS )zEtest hash-string workflow with legacy .encrypt() & .genhash() methodsT)rz N)r| r� r. r. r/ � test_03_legacy_hash_workflow� s z(HandlerCase.test_03_legacy_hash_workflowc C s� | � td��}| �|d� | �dt|�� | �td�t|�� | �dt|��}| �|d� | jjrv| jrv| �||� n | � ||� | �td�t|��}| �|d� | jjr�| jr�| �||� n | � ||� | �
| � t|��� dS )z#test hashes can be unicode or bytesrt rB rb N) r[ r| rM rL rc rM rJ rx ry r� rI r_ )rj r� r{ r. r. r/ �test_04_hash_types� s z HandlerCase.test_04_hash_typesc C s� | j }t|d�s| �d��| �|j|�� � |jD ]|}| �|t� | � |t
d|f � |� |�}|du r�|�|� | � |�� |� q2|du r�| �
t|j|� q2td||f ��q2dS )ztest multi-backend supportrT z handler only has one backendzinvalid backend name: %rTFz*has_backend(%r) returned invalid value: %rN)rM rH r� r� rT rS rY r� rw � assertNotIn�RESERVED_BACKEND_NAMESrZ r� r� r r� )rj rM rU �retr. r. r/ �test_05_backends� s(
�
��z HandlerCase.test_05_backendsc C s d| j jvr| �d��d S )N�saltzhandler doesn't have salt)rM rI r� r� r. r. r/ � require_salt! s zHandlerCase.require_saltc C s | � � t| j�s | �d��d S )Nz!handler doesn't provide salt info)r� r rM r� r� r. r. r/ �require_salt_info% s
z HandlerCase.require_salt_infoc C s | � � | j}| j}|jdu}|r4|jdk r4|d��|jdk rF|d��|r^|j|jkr^|d��|j|jk rr|d��|r�|j|jkr�|d��d |jvr�|r�|j|jk r�td
|jf � |j r�|j
s�|d ��|j
D ] }||j vr�|d |f ��q�n|j
s�|d
��dS )z!validate optional salt attributesNrX zmax_salt_chars must be >= 1r zmin_salt_chars must be >= 0z(min_salt_chars must be <= max_salt_charsz*default_salt_size must be >= min_salt_sizez*default_salt_size must be <= max_salt_size� salt_sizezT%s: hash handler supports range of salt sizes, but doesn't offer 'salt_size' settingz$default_salt_chars must not be emptyzEdefault_salt_chars must be subset of salt_chars: %r not in salt_charsz;default_salt_chars MUST be specified if salt_chars is empty) r� r� rM �
max_salt_size�
min_salt_size�default_salt_sizerI r
r� �
salt_chars�default_salt_chars)rj r� r� Zmx_set�cr. r. r/ � test_10_optional_salt_attributes* s4
�
z,HandlerCase.test_10_optional_salt_attributesc C s, | j }ddlm} t|j|t|j�d� �S )z%calculate number of salt bits in hashr r� � )rM r� r� r� r� r� r� )rj rM r� r. r. r/ � salt_bitsS s
�zHandlerCase.salt_bitsc sD �� � tdd�j �� � �fdd�}|�j� |�fdd�� dS )z4test hash() / genconfig() creates new salt each timerX r c s< | � }t � �D ]}| � }||kr d S q��d� f ��d S )Nz.failed to find different salt after %d samples)r r� )r� Zvalue1r8 Zvalue2��samplesrj r. r/ �sampleri s �z0HandlerCase.test_11_unique_salt.<locals>.samplerc s
� � d�S �Nrt )r[ r. r� r. r/ �<lambda>r r: z1HandlerCase.test_11_unique_salt.<locals>.<lambda>N)r� rE r� ra )rj r� r. r� r/ �test_11_unique_salt_ s
z HandlerCase.test_11_unique_saltc C s� | � � | j}|jdd� }|j}|| }| j|d� | jd|d� |dkrf| jt| j|dd� d� | jt| jd|d d� dS )z.test hash() / genconfig() honors min_salt_sizer rX �r� rt �r� Nr� )r� rM r� r� ra r[ r� �
ValueError)rj rM � salt_charZmin_size�s1r. r. r/ �test_12_min_salt_sizet s
� �z!HandlerCase.test_12_min_salt_sizec C s@ | � � | j}|j}|jdd� }|du s2|dkrp|d }| j|d�}| j|| d�}| �||� | jdd� n�|| }| j|d�}| j|d� || }| jt| j|d� | jt| j|d d� t|��rt j
dd �� | j|dd
�}W d � n1 s�0 Y | � ||� |j |k �r<| j|dd � d�}| �||� dS ) z.test hash() / genconfig() honors max_salt_sizer rX Ni i r� r� Tr� )r� rG r� )
r� rM r� r� rd ry r� r� rN r� r1 r� r� ) rj rM �max_sizer� r� Zc1Zc2�s2Zc3r. r. r/ �test_13_max_salt_size� s.
, z!HandlerCase.test_13_max_salt_sizec C s | j r ddlm} |�|�}|S )zprepare generated saltr )�bcrypt64)� fuzz_salts_need_bcrypt_repairZpasslib.utils.binaryr� Z
repair_unused)rj r� r� r. r. r/ � prepare_salt� s
zHandlerCase.prepare_saltc
C s� | � � | j}|j}|j}|j}t|t�}t||p4d�D ]0}t|�|k rRt ||�}| �
|�}| j |d� q8t d�}|r�|�
d�}t|d�}|D ]*} | |vr�| jt| j | | d| f d� q�dS ) z test hash() honors salt_charsr� r� u ÿrv rX zinvalid salt char %r:)r� r� N)r� rM r� r� r� rc �bytesr r� r r� rd r rp rE r� r� )
rj rM �mxrR �cs�rawr� r{ �chunkr� r. r. r/ �test_14_salt_chars� s(
�z HandlerCase.test_14_salt_charsc C s t | jdd�rtS tS dS )z)hack to determine salt keyword's datatypeZ_salt_is_bytesFN)r� rM r� r r� r. r. r/ � salt_type� s zHandlerCase.salt_typec C s� | � � | j}t| jdd�p d}G dd� dt�}| jt| jd|� d� |turj| jt| jdt d�| d� |t
u s�t r~|tu s�| jt| jdd | d� d
S ) ztest non-string salt valuesr� r � c @ s e Zd ZdS )z+HandlerCase.test_15_salt_type.<locals>.fakeN)r� r� r� r. r. r. r/ �fake� s r� rt r� �x� xN) r� r� r� rM �objectr� r� r[ r r r� r )rj r� r� r� r. r. r/ �test_15_salt_type� s z HandlerCase.test_15_salt_typec C s� | � � | j}|j}|j}|j}| jt|jdd� | �t g�� |jddd�}W d � n1 sb0 Y | �
|j|� |r�| jt|j|d d� | �t g��" |j|d dd�}W d � n1 s�0 Y | �
|j|� ||k�rJ|j|d d�}| �
|j|d � | �
|j|� |j|d d�}| �
|j|d � | �
|j|� ||k�rZ|}n|d }|jt |�d�}| �
|j|� | jt|jt |�d d� |j|d �}| �
|j|� dS )
z$Handler.using() -- default_salt_sizer� )r� T)r� rG NrX r� �xxxr� ) r� rM r� r� r� r� r� rW r� r r� rw )rj rM rR r� rS �temp�refr. r. r/ �test_using_salt_size s: ,0
z HandlerCase.test_using_salt_sizec C s t | j�s| �d��d S )Nz handler lacks rounds attributes)r rM r� r� r. r. r/ �require_rounds_info7 s
z HandlerCase.require_rounds_infoc C s� | � � | j}| j}|jdu r&|d��|jdk r8|d��|jdk rJ|d��|j|jkr^|d��|jdur�|j|jk r||d��|j|jkr�|d ��|jtvr�|d
|jf ��dS ) z#validate optional rounds attributesNzmax_rounds not specifiedrX zmax_rounds must be >= 1r zmin_rounds must be >= 0z min_rounds must be <= max_roundsz$default_rounds must be >= min_roundsz$default_rounds must be <= max_roundsz unknown rounds cost constant: %r)r� rM r� �
max_roundsri rQ rO r )rj r� r� r. r. r/ �"test_20_optional_rounds_attributes; s$
z.HandlerCase.test_20_optional_rounds_attributesc C s` | � � | j}|j}| j|d� | jd|d� | jt| j|d d� | jt| jd|d d� dS )z+test hash() / genconfig() honors min_rounds�rO rt rX N)r� rM ri ra r[ r� r� )rj rM ri r. r. r/ �test_21_min_roundsY s z HandlerCase.test_21_min_roundsc C sp | � � | j}|j}|durJ| jt| j|d d� | jt| jd|d d� |du r`| jdd� n | j|d� dS )z+test hash() / genconfig() honors max_roundsNrX r� rt i���)r� rM r� r� r� ra r[ rd )rj rM r� r. r. r/ �test_21b_max_roundsi s z HandlerCase.test_21b_max_roundsc
s� | � � | j}|jdkr8|� |�� }t�� fdd��|_|j}|j}|j}|pPd| d }||krj|d7 }|| d }|p|d| d }|jdkr�|dO }|dO }|dO }d}nd}| � g �� |j|||d�} W d � n1 s�0 Y || ||||fS ) zU
setup test helpers for testing handler.using()'s rounds parameters.
Z
bsdi_cryptc s t �| ��� S r1 )r� �_generate_roundsr� )r� � orig_handlerr. r/ r� � r: z9HandlerCase._create_using_rounds_helper.<locals>.<lambda>i' r� rX )�min_desired_rounds�max_desired_roundsrQ N)
r� rM r� rW � classmethodr� ri r� rQ r� )
rj rM �orig_min_rounds�orig_max_rounds�orig_default_rounds�medium�small�large�adjrj r� )r� r/ �_create_using_rounds_helper s6
�$z'HandlerCase._create_using_rounds_helperc
C s� | � � | j}|j}|j}|j}| �� \}}}}}} | �|j|� | �|j|� | �|jd� | �|jd� | �|j|� | �|j|� | �|j|� | �|j|� | �|j|� | �|j|� dS )z@
HasRounds.using() -- sanity check test harness
N) r� rM ri r� rQ r� r� r� r� )
rj rM r� r� r� rj r� r� r� r� r. r. r/ � test_has_rounds_using_harness� s z)HandlerCase.test_has_rounds_using_harnessc C s� | � � \}}}}}}|j}|j}|j} |dkr�| jt|j|| d� | �tg��" |j|| dd�}
W d � n1 sx0 Y | � |
j
|� |r�| jt|j|| d� | �tg��" |j|| dd�}
W d � n1 s�0 Y | � |
j
|� | �g �� |j|| d�}
W d � n1 �s(0 Y | � |
j
|| � |j|d| d�}
| � |
j
|d| � | �g �� |j|| d�}
W d � n1 �s�0 Y | � |
j
|| � | � t ||| �|| � | � t ||�|� | �g ��* | � t ||| �|| � W d � n1 �s$0 Y |j|d�}
| � |
j
|� |jt |�d�}
| � |
j
|� | jt|jt |�d d� dS ) zF
HasRounds.using() -- min_rounds / min_desired_rounds
r �r� T)r� rG Nr� �ri r� )
r� ri r� rQ r� r� rW r� r r� r� rR rw ) rj rM rj r� r� r� r� r� r� r� r� r. r. r/ �"test_has_rounds_using_w_min_rounds� s> 00 0 0 : z.HandlerCase.test_has_rounds_using_w_min_roundsc
C s� | � � \}}}}}}|j}|j}|dkr�| jt|j|| d� | �tg��" |j|| dd�} W d � n1 sr0 Y | �| j |� |r�| jt|j|| d� | �tg��" |j|| dd�} W d � n1 s�0 Y | �| j |� | �t
g�� |j|| d�} W d � n1 �s$0 Y | �| j |� | jt|j|| || d� |j|d| d�} | �| j |d| � | �g �� |j|| d�} W d � n1 �s�0 Y | �| j || � | �t ||| �|| � | �t ||�|� | �g ��* | �t ||| �|| � W d � n1 �s80 Y |j|d �} | �| j |� |jt
|�d�} | �| j |� | jt|jt
|�d
d� dS ) zF
HasRounds.using() -- max_rounds / max_desired_rounds
r )r� T)r� rG N�r� r� r� r� �r� r� )r� ri r� r� r� rW r� r r� r� r r� rR rw )
rj rM rj r� r� r� r� r� r� r� r. r. r/ �$test_has_rounds_replace_w_max_rounds� sD 000
� 0 : z0HandlerCase.test_has_rounds_replace_w_max_roundsc C s� | � � \}}}}}}|j}|j|| d�}| �|j|| � |j|| d�}| �|j|| � | jt|j|| d� |r�| jt|j|| d� | �t|�|� | �t||| �|| � |jt|�d�}| �|j|� | jt|jt|�d d� dS )z5
HasRounds.using() -- default_rounds
r� r� )rQ r� N) r� r� rW r� rQ r� r� rR rw � rj rM rj r� r� r� r� r� r� r. r. r/ �&test_has_rounds_using_w_default_rounds8 s z2HandlerCase.test_has_rounds_using_w_default_roundsc C s� | � � \}}}}}}|j}|j|| d�}| �|j|| � | �|j|| � | �|j|| � |j|d || ||| d�}| �|j|| � | �|j|� | �|j|| � dS )z-
HasRounds.using() -- rounds
r� rX )rO ri rQ r� N)r� r� rW r� r� rQ r� r� r. r. r/ � test_has_rounds_using_w_rounds^ s �z*HandlerCase.test_has_rounds_using_w_roundsc s� | � � \}� }}}}� fdd�}| �|d�d� | �|d�d� | �|d�d� | �|d�d� | �|d�d� | �t|d� | �t|d � d
S ) z:
HasRounds.using() -- vary_rounds parsing
c s � j | d�jS )N�� vary_rounds)rW r� �r� �rj r. r/ �parsez s zFHandlerCase.test_has_rounds_using_w_vary_rounds_parsing.<locals>.parser' z0.1z10%�� Z1000g��������g�������?N)r� r� r� r� )rj rM r� r� r� r� r� r. r� r/ �+test_has_rounds_using_w_vary_rounds_parsings s z7HandlerCase.test_has_rounds_using_w_vary_rounds_parsingc s �� � \}�}}}}dd� � � ��fdd�}|d||� |d||� |||| || � |dt||d �t||d �� |jdkr�|d ||� |d
||� |d || |� nl� �jd d ��\}}��|t||d
�� ��|t||d �� ��|t||d �� ��|t||d �� dS )z=
HasRounds.using() -- vary_rounds generation
c s* t � fdd�td�D ��}t|�t|�fS )Nc 3 s | ]}t � �V qd S r1 )rR r6 r� r. r/ r9 � r: zjHandlerCase.test_has_rounds_using_w_vary_rounds_generation.<locals>.get_effective_range.<locals>.<genexpr>r� )�setr r< rE )r� �seenr. r� r/ �get_effective_range� s zWHandlerCase.test_has_rounds_using_w_vary_rounds_generation.<locals>.get_effective_rangec s8 �j | d�}� |�\}}��||d� ��||d� d S )Nr� z"vary_rounds had wrong lower limit:z"vary_rounds had wrong upper limit:)rW r� )r� r� r� r� Z
seen_lowerZ
seen_upper�r� rj rj r. r/ �assert_rounds_range� s zWHandlerCase.test_has_rounds_using_w_vary_rounds_generation.<locals>.assert_rounds_ranger z0%�2 rP z1%z49%z50%r� � �?g�������?g333333�?g �?N)r� rE r< rO rW �assertGreaterEqualZassertLessEqual) rj rM r� r� r� r� r� r� r� r. r� r/ �.test_has_rounds_using_w_vary_rounds_generation� s
z:HandlerCase.test_has_rounds_using_w_vary_rounds_generationc C s� | � � \}}}}}}|j|d |d d�}| j||d�}| j||d�} | j||d�}
| �|�|�� | �|�| �� | �|�|
�� | �|�|�� | �|�| �� | �|�|
�� dS )zF
HasRounds.using() -- desired_rounds + needs_update()
r� r� r� N)r� rW rd � assertFalseZ needs_updaterI ) rj rM rj r� r� r� r� r� Z
small_hashZ medium_hashZ
large_hashr. r. r/ �&test_has_rounds_using_and_needs_update� s z2HandlerCase.test_has_rounds_using_and_needs_updatec C s* | j }t|t�r t|tj�s&| �d��d S )Nz)handler doesn't derive from HasManyIdents)rM rc re rJ rK Z
HasManyIdentsr� )rj rM r. r. r/ �require_many_idents� s z HandlerCase.require_many_identsc C s6 | j }| �� | �d|jv � |jD ]}| �|td� q$| �t|j�dkd� | �|jtd� | �|j|jv d� |j r�t
|j �D ]<\}}| �|td� | �|td� | �||jv d |f � q�|}| � � d }|� |�}|d= |f d|ji|�� | j
t|fi |�� |f d
d i|�� | j
t|fdd i|�� d
S )z$validate HasManyIdents configuration�identz!cls.ident_values must be unicode:rX z'cls.ident_values must have 2+ elements:z"cls.default_ident must be unicode:z9cls.default_ident must specify member of cls.ident_valuesz'cls.ident_aliases keys must be unicode:z)cls.ident_aliases values must be unicode:z:cls.ident_aliases must map to cls.ident_values members: %rrP T�xXxN)rM r� rI rI � ident_valuesr� r r� �
default_ident�
ident_aliasesr rG � parsehashr� r� r� )rj r� r� �aliasr� rM rB r` r. r. r/ �test_30_HasManyIdents� sF
��
���� �
z!HandlerCase.test_30_HasManyIdentsc C s6 | � � | j}|j}|jD ]}||kr q>qtd||jf ��dd� }|�� }| �|j|� |j|d�}| �|j|� | �|j|� | �||�|� | �||�|� | jt|jdd� |j|d�}| �|j|� | �|j|� | jt |j||d� |j
�r2|j
� � D ],\}}|j|d�}| j|j|d| d � �qd
S ) z=HasManyIdents.using() -- 'default_ident' and 'ident' keywordsz6expected to find alternate ident: default=%r values=%rc S s t | �} | dd�jS )NT)rP )rQ r� r� r. r. r/ �effective_ident s z?HandlerCase.test_has_many_idents_using.<locals>.effective_ident)r� r� )r� )r� r� z alias %r:�r� N) r� rM r� r� r� rW r� r� r� r� r� r )rj rM Z
orig_identZ alt_identr� rj r� r� r. r. r/ �test_has_many_idents_using s4
� z&HandlerCase.test_has_many_idents_usingc s� | j � � jdu r"| �d� j� dS � js4| �� j� d� jvrN| �� j� dS � fdd�}| �|d�� j� | �|d�d� | �|d�d� | �|d�d� | �|d�d� | � t
|d � dS )
zH
validate 'truncate_error' setting & related attributes
N�truncate_errorc s � j | d�jS )N�r� )rW r� r� ��hasherr. r/ � parse_valueS s z<HandlerCase.test_truncate_error_setting.<locals>.parse_valueT�trueFZfalser� ) rM �
truncate_sizer rI r� r� �truncate_verify_rejectrI r� r� r� )rj r� r. r� r/ �test_truncate_error_setting; s
z'HandlerCase.test_truncate_error_settingc C s� | j }|jdur(| �|jd� | �d��d}d}| �|�}|j }| j| �||�|dd� |dd� | }| �| �||�d � dS )
zO
test no password size limits enforced (if truncate_size=None)
NrX ztruncate_size is seta too many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretstoo many secretsr� z verify rejected correct secretr� r� z full password not used in digest) rM r� r� r� r[ rJ r� rH r� )rj r� rA rD rB Zverify_successZ
alt_secretr. r. r/ � test_secret_wo_truncate_size\ s
��z(HandlerCase.test_secret_wo_truncate_sizec C s� | j }|j}|s| �d��tj}d|jv rJ|jdd�}|jdd�}tj}n|jrZd}|}n|}d}d}d}t ||d �}|dd
� } |dd
� | }
| dd
� | } |j
} | o�|j }
||fD ]Z}| j | |d �}| �
| j| ||d �| � | �| j| ||d �d � | �
| j|||d �|
� q�|�rv| j ||d �}| �
| j|||d �| � | �
| j|
||d �| � | �| j| ||d �� |�r�| j|| j ||d �}| �
|j|� dS )
zQ
test password size limits raise truncate_error (if appropriate)
ztruncate_size not setr� Fr� TNztoo many secretsr� rX r� rL z truncate_size value is too large)rM r� r� r �PasswordSizeErrorrI rW ZPasswordTruncateErrorr� r rJ r� r[ r� rH r� rI r� r� )rj rM r� Zsize_error_typeZ
without_errorZ
with_errorrg rD Z long_secretZ short_secretZalt_long_secretZalt_short_secretZshort_verify_successZlong_verify_successZ cand_hasherZ
short_hashZ long_hashr� r. r. r/ �test_secret_w_truncate_size| sz
� �� �� �� �� �� �
�z'HandlerCase.test_secret_w_truncate_sizec C s� | j du }| j dv }d}d}| �|�}|rH| jjsH| �| �||�d� n| �| �||�d� | �|�}|r�| jjs�| �| �||�d� n| �| �||�d� | �||�}|s�| jjr�| js�| � ||d� n| �
||d� d S )
z test password case sensitivityT)Tz verify-onlyr: ZTESTz%verify() should not be case sensitivez!verify() should be case sensitivez&genhash() should not be case sensitivez"genhash() should be case sensitiveN) �secret_case_insensitiver[ rM rJ rI rH r� rc rx r� ry )rj Zhash_insensitiveZverify_insensitiver� r� �h1�h2r. r. r/ � test_61_secret_case_sensitive� s8
��
�� ��z)HandlerCase.test_61_secret_case_sensitivec C sx | � � d }| �t| jd� | �t| jd|� | �t| jd|� | �t| jd� | �t| jd|� | �t| jd|� dS )z&test non-string passwords are rejectedrX N)rG r� r� r[ rc rH r^ r. r. r/ �test_62_secret_border s z!HandlerCase.test_62_secret_borderc C sv ddl m} ddlm} dd| }| �� d }| �|| j||�}| �|j|� | �|| j |� | �|| j
||� dS )z"test MAX_PASSWORD_SIZE is enforcedr )r� )�MAX_PASSWORD_SIZEr/ rX N) � passlib.excr� r� r� rG r� rc r� r� r[ rH )rj r� r� rA rB r� r. r. r/ �test_63_large_secret s z HandlerCase.test_63_large_secretc C sj | j }|s| �d��td�}t|t�rDddlm} ||�}|�d�}|D ] }| �t | j
|| | � qHdS )z1test forbidden characters not allowed in passwordz none listedrt r )�iter_byte_chars�asciiN) r= r� r rc r� �passlib.utils.compatr rp r� r� r[ )rj �charsrg r r� r. r. r/ �test_64_forbidden_chars) s
z#HandlerCase.test_64_forbidden_charsc C s | � |i �}t|� S r1 )rU r �rj rA r. r. r/ �is_secret_8bit9 s zHandlerCase.is_secret_8bitc C s@ t r<| jdkr<t|t�r<z|�d� W n ty: Y dS 0 dS )zl
check if we're expecting potential verify failure due to crypt.crypt() encoding limitation
r; rn TF)r rU rc r� rx ry r r. r. r/ �expect_os_crypt_failure= s z#HandlerCase.expect_os_crypt_failurec C s� | � | jp| jd� d}| �� D ]�\}}| �|�r6d}| � | �|�d|f � | �|�}zd| �||d||f � | �||�}| � |t
d|f � | j j r�| j
r�W q | �||d|||f � W q ty� |sЂ Y q 0 q |s�td| j � d S )
ztest known hasheszOtest must set at least one of 'known_correct_hashes' or 'known_correct_configs'FTz&identify() failed to identify hash: %rz1verify() of known hash failed: secret=%r, hash=%r�,genhash() failed to return native string: %rzGgenhash() failed to reproduce known hash: secret=%r, hash=%r: result=%rz%s: no 8-bit secrets testedN)rI r> r? rE r r_ r rL rc r� rw rM rJ rx r� r r
r� )rj Zsaw8bitrA rB r r� r. r. r/ �test_70_hashesH s: �
�
� �
�
zHandlerCase.test_70_hashesc
C s� | j s| �d��| j D ]�\}}}| �| �|�d|f � | �||d||f � | �||�}| �|td|f � | jj r~| j
r~q| � ||d||||f � qdS )ztest known alternate hashesz no alternate hashes providedz0identify() failed to identify alternate hash: %rz;verify() of known alternate hash failed: secret=%r, hash=%rr
zYgenhash() failed to normalize known alternate hash: secret=%r, alt=%r, hash=%r: result=%rN) r@ r� rI r_ rL rc r� rw rM rJ rx r� )rj rD rA rB r� r. r. r/ �test_71_alternatest s(
��
� �
�z HandlerCase.test_71_alternatesc
C s� | j js | �| jd� | �d��| js0| �d��| jrDtjdtd� | jD ]x\}}}| � | �
|�d|f � | j t | j
||d|f d� | �||�}| �|td |f � | �||d
||||f � qJd S ) ztest known config stringsz&handler should not have config stringszhash has no settingszno config strings providedr� r� z5identify() failed to identify known config string: %rz+verify() failed to reject config string: %r�r� r
z^genhash() failed to reproduce known hash from config: secret=%r, config=%r, hash=%r: result=%rN)rM rI r� r? r� �filter_config_warningsr� r� r rI r_ r� r� rH rc r� rw r� )rj rC rA rB r� r. r. r/ �test_72_configs� s6 �
���� �
�zHandlerCase.test_72_configsc C sp | j s| �d��| j D ]T}| �| �|�d|f � | jt| jd|d|f d� | jt| jd|d|f d� qdS )z)test known unidentifiably-mangled stringsz no unidentified hashes providedz?identify() incorrectly identified known unidentifiable hash: %rrt z:verify() failed to throw error for unidentifiable hash: %rr
z;genhash() failed to throw error for unidentifiable hash: %rN)�known_unidentified_hashesr� r� r_ r� r� rH rc r^ r. r. r/ �test_73_unidentified� s$
������z HandlerCase.test_73_unidentifiedc C sp | j s| �d��| j D ]T}| �| �|�d|f � | jt| jd|d|f d� | jt| jd|d|f d� qdS )z-test known identifiable-but-malformed stringsz no malformed hashes providedz6identify() failed to identify known malformed hash: %rrt z5verify() failed to throw error for malformed hash: %rr
z6genhash() failed to throw error for malformed hash: %rN)�known_malformed_hashesr� rI r_ r� r� rH rc r^ r. r. r/ �test_74_malformed� s$
������z HandlerCase.test_74_malformedc C s� | j r| �d��| js | �d��| jD ]�\}}|| jjkr�| �| �|�d|f � | �d|� | �d|�}| � |t
d|f � q&| � | �|�d||f � | j t
| jd|d||f d� | j t
| jd|d ||f d� q&d
S ) ztest known foreign hashes�not applicablezno foreign hashes providedz,identify() failed to identify known hash: %rrt r
z:identify() incorrectly identified hash belonging to %s: %rz;verify() failed to throw error for hash belonging to %s: %rr
z<genhash() failed to throw error for hash belonging to %s: %rN)�accepts_all_hashesr� �known_other_hashesrM r� rI r_ rH rc r� rw r� r� r� )rj r� rB r� r. r. r/ �test_75_foreign� s:
� � ������zHandlerCase.test_75_foreignc C s | � t| jd� | � t| jdd� | � t| jdd� | � t| jd� | � t| jdd� | � t| jdd� td�dfD ]~}| jr�| �| �|�� | �d|� | �d|�}| �|d� qt| � | �|�d� | j t
| jd|dd � | j t
| jd|d
d � qt| �d � | �d � dS )
z#test non-string hashes are rejectedNrt rX r} r: rb z,identify() incorrectly identified empty hashz$verify() failed to reject empty hashr
z%genhash() failed to reject empty hashu â¬Â¥$u abc ) r� r� r_ rH rc r r rI rM r� r� )rj rB r� r. r. r/ �test_76_hash_border
s. ���
z HandlerCase.test_76_hash_borderc C s t | jd�std��d S )Nr� zparsehash() not implemented)rH rM r r� r. r. r/ �require_parsehash2
s z HandlerCase.require_parsehashc C s� | � � | j}| �d�}|�|�}| �|t� |j|dd�}|�� }|�dd� | �||� |j|dd�}|�� }t r�t
j dd t d
� d D ]:}||v r�| �
|| || � | �|| � || ||< q�| �||� dS ) z
parsehash()
rt F)�checksumr NT)Zsanitizer� z(.*unequal comparison failed to convert.*r� )r� r )r rM r[ r� r� r� �copyr� r� r r� r� �UnicodeWarningry �assert_is_masked) rj rM rB r� Zresult2Zcorrect2Zresult3Zcorrect3�keyr. r. r/ �test_70_parsehash6
s*
�z HandlerCase.test_70_parsehashc C s\ |du r dS | � |t� t|�dk r(|n
|dd� }t|�tdg�krJdS | �d| ��dS )zQ
check value properly masked by :func:`passlib.utils.mask_value`
Nr� � �*Tzvalue not masked: %r)r� r r� r� �fail)rj r� r� r. r. r/ r ]
s z HandlerCase.assert_is_maskedc C sN | � � | j}|s | �d��| jD ]&\}}| j�|�}| �||d| � q"dS )z.
parsehash() -- known outputs
zno samples presentzhash=%r:N)r �known_parsehash_resultsr� rM r� r� )rj r� rB Zcorrectr� r. r. r/ �test_71_parsehash_resultsk
s
z%HandlerCase.test_71_parsehash_resultsc s� | j jr| �d��ddlm} | j}|dkr6| �d��| j|d�}dd� � |rZt�� j }nd}| j
|d �}| � | |�}t �
d
| j||t|�d �� fd d
�|D ��� |� }|| } d}
|� | k�r�|�� } | d } | d }
| d }| d }|r�||d< | j| fi |��}|D ]�}� |�}|| |fi |��}|dk�r8�q |�sT| �d|| ||f ��|�� dk �r ||
|fi |��}|�r |dk�r | �d||
| ||f ���q |
d7 }
q�t �
d| j||� | |
� dS )a fuzz testing -- random passwords and options
This test attempts to perform some basic fuzz testing of the hash,
based on whatever information can be found about it.
It does as much as it can within a fixed amount of time
(defaults to 1 second, but can be overridden via $PASSLIB_TEST_FUZZ_TIME).
It tests the following:
* randomly generated passwords including extended unicode chars
* randomly selected rounds values (if rounds supported)
* randomly selected salt sizes (if salts supported)
* randomly selected identifiers (if multiple found)
* runs output of selected backend against other available backends
(if any) to detect errors occurring between different backends.
* runs output against other "external" verifiers such as OS crypt()
:param report_thread_state:
if true, writes state of loop to current_thread().passlib_fuzz_state.
used to help debug multi-threaded fuzz test issues (below)
r r r� �disabled by test mode��threadedc S s | j p
| j�� d S r� )r� r� �
splitlines)�vr. r. r/ �vname�
s z-HandlerCase.test_77_fuzz_input.<locals>.vnamez fuzz testrp z.%s: %s: started; max_time=%r verifiers=%d (%s)r� c 3 s | ]}� |�V qd S r1 r. )r7 r) �r* r. r/ r9 �
r: z1HandlerCase.test_77_fuzz_input.<locals>.<genexpr>rA r{ rZ rY r zAfailed to verify against %r verifier: secret=%r config=%r hash=%rr' z\was able to verify wrong password using %s: wrong_secret=%r real_secret=%r config=%r hash=%rrX z!%s: %s: done; elapsed=%r count=%rN)rM rJ r� r� r �
max_fuzz_time�get_fuzz_verifiersr2 �current_threadr� r �FuzzHashGeneratorr� �debugr� r� r� �generater[ r� r� )rj r' r Zmax_time� verifiersZ thread_namer � generatorr2 �stopr� ZoptsrA r{ rZ r� rB r\ r� r� r. r+ r/ �test_77_fuzz_input|
s`
�
� �
�z HandlerCase.test_77_fuzz_inputc s �� d� ddl��jjr$��d���j}|dk s<�jdkrF��d����� �dg� � ��fdd�����fd d
���fd d �t|�D �}�j| d
}d}|D ]0}|� |� |�
� s�q�t � d|j
|� |d7 }q�� d r��d� d |f ��|�r��d||f ��dS )z�multithreaded fuzz testing -- random password & options using multiple threads
run test_77 simultaneously in multiple threads
in an attempt to detect any concurrency issues
(e.g. the bug fixed by pybcrypt 0.3)
rA r Nr rX r% c sh z�j dd� W nR ty" Y nB �� � d d7 < W d � n1 sR0 Y � Y n0 d S )NTr& r rX )r5 r r. )�failed� failed_lockrj r. r/ rl �
s .z3HandlerCase.test_78_fuzz_threading.<locals>.wrapperc sB t � �}d| |j|j� jf }�j�|d�}|�d� |�� |S )NzFuzz-Thread-%d ('%s:%s.%s'))�targetr� T)re r� r� r �Thread� setDaemonr2 )�nr� r� �thread)rj r2 rl r. r/ �launch�
s �
z2HandlerCase.test_78_fuzz_threading.<locals>.launchc s g | ] }� |��qS r. r. )r7 r; )r= r. r/ �
<listcomp>�
r: z6HandlerCase.test_78_fuzz_threading.<locals>.<listcomp>r z %s timed out after %f secondszH%d/%d threads failed concurrent fuzz testing (see error log for details)zP%d/%d threads stalled during concurrent fuzz testing (see error log for details))r� r2 rM rJ r� �fuzz_thread_countr, r3 r r� �is_aliver� �errorr� r" )rj Z thread_count�threads�timeoutZstalledr< r. )r6 r7 r= rj r2 rl r/ �test_78_fuzz_threading�
s8
��z"HandlerCase.test_78_fuzz_threadingc C s@ t tj�d�pd�}|r |S tdd�r*dS tdd�r8dS dS dS ) z'amount of time to spend on fuzz testingZPASSLIB_TEST_FUZZ_TIMEr r? rN r@ rX � N)�floatr( r r r# �rj r� r. r. r/ r, s
zHandlerCase.max_fuzz_timec C s2 t tj�d�pd�}|r |S tdd�r*dS dS dS )z+number of threads for threaded fuzz testingZPASSLIB_TEST_FUZZ_THREADSr r? rN r� N)r� r( r r r# rG r. r. r/ r? $ s
z HandlerCase.fuzz_thread_count)�fuzz_verifier_defaultc sv | j � g }| jD ]"}t| |�� }|dur|�|� qt� d�rrtd�rr|sr� fdd�}t� �D ]}|�||�� q^|S )z�return list of password verifiers (including external libs)
used by fuzz testing.
verifiers should be callable with signature
``func(password: unicode, hash: ascii str) -> ok: bool``.
NrY rA c s* � �fdd�}d� d |_ � d |_|S )Nc s< �� � }z"��� � ��| |�W ��|� S ��|� 0 d S r1 )rS rT r\ )rA rB Z orig_backend)rU rM r. r/ r� M s
�z;HandlerCase.get_fuzz_verifiers.<locals>.maker.<locals>.funcZcheck_Z_backend�-backend)r� r� )rU r� rL )rU r/ �makerL s
z-HandlerCase.get_fuzz_verifiers.<locals>.maker)rM �fuzz_verifiersr� r$ rH r# r^ )rj r' r2 Z method_namer� rJ rU r. rL r/ r- 8 s
z HandlerCase.get_fuzz_verifiersc s* � fdd�}� j r � j d |_nd|_|S )Nc s � j | |fi |��S r1 )rH )rA rB r� r� r. r/ �
check_default^ s z8HandlerCase.fuzz_verifier_default.<locals>.check_defaultrI rj )rU r� )rj rL r. r� r/ rH \ s
z!HandlerCase.fuzz_verifier_defaultc @ sv e Zd ZdZed�ZdZedddd�Zi Z dd � Z
d
d � Z d d
� Z dd� Z
dd� Zdd� Zdd� Zdd� Zdd� ZdS )z HandlerCase.FuzzHashGeneratorz�
helper which takes care of generating random
passwords & configuration options to test hash with.
separate from test class so we can create one per thread.
u qwertyASDF1234<>.@*#! áəБℓrn �
random_rounds�random_salt_size� random_ident)rO r� r� c C s || _ |j| _|| _d S r1 )r: rM r )rj r: r r. r. r/ r� � s z&HandlerCase.FuzzHashGenerator.__init__c s4 � fdd�}� � � \}}t|||� j�|� j�d�S )z�
generate random password and options for fuzz testing.
:returns:
`(secret, other_secret, settings_kwds, context_kwds)`
c s6 i }| � � D ]$\}}t� |�� }|d ur |||< q |S r1 )r r� )�mapr r rl r� r� r. r/ �gendict� s
z7HandlerCase.FuzzHashGenerator.generate.<locals>.gendict)rA r{ rZ rY )�random_password_pairr� � settings_map� context_map)rj rQ rA r{ r. r� r/ r1 � s �z&HandlerCase.FuzzHashGenerator.generatec C s | j �||�}tt|||��S )z)generate random int w/ gauss distirbution)r Z
normalvariater� r� )rj r� r� ZmuZsigmar� r. r. r/ � randintgauss� s z*HandlerCase.FuzzHashGenerator.randintgaussc C sX | j }t|�sd S |jp |j}|j}|jdkr4|}nt|d |j�}| �||||d �S )NrP r� r� )rM r rQ ri rO r< r� rU �rj rM r@ r� r� r. r. r/ rM � s
z+HandlerCase.FuzzHashGenerator.random_roundsc C sJ | j }t|�rd|jv s d S |j}|j}|jp4|d }| �||||d �S )Nr� r r� )rM r rI r� r� r� rU rV r. r. r/ rN � s z.HandlerCase.FuzzHashGenerator.random_salt_sizec C sL | j }| j}d|jvs t|d�s$d S |�� dk r4d S t|d|�}|�|j�S )Nr� r� r� rb )r rM rI rH r� r� rF r� )rj r rM r. r. r/ rO � s z*HandlerCase.FuzzHashGenerator.random_identc C s^ | � � }| � � }| �||�rq q| j}|�dd�r>|�| j�}|�dd�rV|�| j�}||fS )z=generate random password, and non-matching alternate passwordr rX )�random_password�accept_password_pairr �randintrp �password_encoding)rj rA r{ r r. r. r/ rR � s z2HandlerCase.FuzzHashGenerator.random_password_pairc C s� | j }|�� dk rtd�S | j}|jo*|j}|p2d}|dk sH|�� dk r`| �dt|d�dd�}n| �dt|d�d d
�}t|| j |�}|r�t
|t �r�t |�
d ��|kr�|d d
� }q�|S )z*generate random passwords for fuzz testingg-C ��6?r} i?B r� r� rX � �c �F � rn Nr� )r r� r rM r� r� rU r< r �password_alphabetrc r r� rp )rj r rM r� r� �sizer� r. r. r/ rW � s z-HandlerCase.FuzzHashGenerator.random_passwordc C s ||kS )z-verify fuzz pair contains different passwordsr. )rj rA r{ r. r. r/ rX � s z2HandlerCase.FuzzHashGenerator.accept_password_pairN)r� r� r� r� r r_ rZ r� rS rT r� r1 rU rM rN rO rR rW rX r. r. r. r/ r/ i s"
� r/ c
C s� | j }|jsB| �t|d�� | �t|d�� | �| j� | �d��|�� }| j|tdd� | j |�
|�d| d� | � � � | j
�d }|�|�}| j|tdd� | j |�
|�d| d� | �td|j|� z|�|�}d }W n. t�y
} zd }|}W Y d }~n
d }~0 0 |d u �r4| j|td
d� | �||� n | �|t� | �dt|�� |�� }| j�rn| �||� n|d u �r�| �||� |�|�} | j�r�| �| |� n | �| |� |�|d �}
| j�s�|d u �r�| �|
|� n | �|
|� d S ) z .disable() / .enable() methods�disable�enabler z#disable() must return native stringr� z0identify() didn't recognize disable() result: %rrX z cannot restore original hashNz"enable() must return native stringr� )rM rJ r� rH rx r� ra r� rw rI r] r rF r ZassertRaisesRegexr� rb r� r� ry ) rj rM Zdisabled_defaultrt Z
disabled_stubr� rA �eZdisabled_default2Zdisabled_stub2Zdisabled_otherr. r. r/ �test_disable_and_enable sd
� �
� ��
�
z#HandlerCase.test_disable_and_enable)NF)FNN)N)NN)F)F)F)nr� r� r� r� rM rU r> r? r@ r r r r rw r� r rx r r" r= Z_HandlerCase__unittest_skip�propertyr� r� rE rG rL rM rT rU r[ rH r_ ra rc rd re rf rk rg rm r� rs ru rv r| r} r~ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r r r# r r r r$ r5 rD r, r? rK r- rH r� r/ rd r� r. r. r� r/ r& � s�
�
! )
7#,)
6
2 +8<&)34! m& ,#&0'
YB
$
r& c s� e Zd ZdZg ZdZdZdZ� fdd�Ze dd� �Z
e d d
� �Z d d � Z
e � fd
d��Zdd� Zdd� Zdd� Zedd� �Zdd� Zdd� Z� ZS )rh a� helper used by create_backend_case() which adds additional features
to test the os_crypt backend.
* if crypt support is missing, inserts fake crypt support to simulate
a working safe_crypt, to test passlib's codepath as fully as possible.
* extra tests to verify non-conformant crypt implementations are handled
correctly.
* check that native crypt support is detected correctly for known platforms.
Tr; Fc s& | j �d�s| �� tt| ��� d S )Nr; )rM rZ �_patch_safe_cryptr� rh r� r� r� r. r/ r� � s zOsCryptMixin.setUpc C s$ t | j�}|�� t|d�}||fS )z�
return (handler, backend) pair to use for faking crypt.crypt() support for hash.
backend will be None if none availabe.
r; )rQ rM rS ra )r� rM � alt_backendr. r. r/ � _get_safe_crypt_handler_backend� s
z,OsCryptMixin._get_safe_crypt_handler_backendc C s | � � d duS )z�
test if there's a fallback handler to test against if os_crypt can't support
a specified secret (may be explicitly set to False for some subclasses)
r N)rh r� r. r. r/ �has_os_crypt_fallback� s z"OsCryptMixin.has_os_crypt_fallbackc sZ | � � \}}|std��|�� � � �|� � fdd�}ddlm} | �|d|� d| _dS )z�if crypt() doesn't support current hash alg, this patches
safe_crypt() so that it transparently uses another one of the handler's
backends, so that we can go ahead and test as much of code path
as possible.
z,handler has no available alternate backends!c s � � | |�}|S r1 )rb �rA rB �Z alt_handlerr. r/ �
crypt_stub� s z2OsCryptMixin._patch_safe_crypt.<locals>.crypt_stubr N�_cryptT)rh r� rW rT r� �utilsr� �using_patched_crypt)rj rM rg rl �modr. rk r/ rf � s
z OsCryptMixin._patch_safe_cryptc sJ t t| ��|�}ddlm} || jkrF|rFtd�rB| �� d rBdS dS |S )z|
make sure os_crypt backend is tested
when it's known os_crypt will be faked by _patch_safe_crypt()
r )� has_cryptrA rX Nz hash not supported by os crypt())r� rh rf r� rq re r# rh )r� rU �reasonrq r� r. r/ rf � s z%OsCryptMixin._get_skip_backend_reasonc s8 ddl m} � fdd�� |j� _d� _| �|d� � � S )z�
patch passlib.utils.safe_crypt() so it returns mock value for duration of test.
returns function whose .return_value controls what's returned.
this defaults to None.
r Nc s | dkr� � | |�S � jS d S )Nr: )� __wrapped__� return_value)rA rC ��
mock_cryptr. r/ rv � s z0OsCryptMixin._use_mock_crypt.<locals>.mock_cryptrm )r� rn rm rs rt r� )rj rp r. ru r/ �_use_mock_crypt� s z OsCryptMixin._use_mock_cryptc sb �� � d �tjf� ��� �� ���fdd�}|d�dd� � |�dd� � |�d � dS ) ztest with faulty crypt()rX c s> | �_ ��� �jd�� ��� �jd� ��� �jd�� d S r� )rt r� rc r[ rH r� �Z exc_typesrB rv rj r. r/ r: � s z/OsCryptMixin.test_80_faulty_crypt.<locals>.testz$xr� Nr� r� )rG r �InternalBackendErrorrw )rj r: r. rx r/ �test_80_faulty_crypt� s z!OsCryptMixin.test_80_faulty_cryptc C s� | � � }d|_| jrJ| �d�}| �d|�}| �||� | �| �d|�� nLddlm } | �
� d }| � || jd� | � || jd|� | � || jd|� dS )z test per-call crypt() fallbackNrt r )ry rX ) rw rt ri r[ rc r� rI rH r ry rG r� )rj rv r� r� Zerr_typerB r. r. r/ �test_81_crypt_fallback
s
z#OsCryptMixin.test_81_crypt_fallbackc C s� t | jd�r| �d��| j }| jj}tj}| jD ]\}}t� ||�r2 q^q2| �d||f ��|du rx| �d||f ��||kr�n*|r�| �
d||f � n| �
d||f � dS )a'
test platform-specific crypt() support detection
NOTE: this is mainly just a sanity check to ensure the runtime
detection is functioning correctly on some known platforms,
so that we can feel more confident it'll work right on unknown ones.
rF znot applicable to wrappersz3no data for %r platform (current host support = %r)Nz9varied support on %r platform (current host support = %r)z5expected %r platform would have native support for %rz;did not expect %r platform would have native support for %r) rH rM r� ro r� �sys�platform�platform_crypt_supportr~ rr r" )rj Z
using_backendr� r} �patternZexpectedr. r. r/ �test_82_crypt_support
s0
����z"OsCryptMixin.test_82_crypt_supportc sP �j }�jst|d�rdS ddlm� ddlm� �jj�� ���fdd�}|S )z test results against OS crypt()rb Nr )�crypt)�_safe_crypt_lockc sN �� |�sdS t| ��} � � �| |�|kW d � S 1 s@0 Y dS )z stdlib-cryptr N)�crypt_supports_variantr rj �r� r� �encodingrj r. r/ � check_cryptS
s
z5OsCryptMixin.fuzz_verifier_crypt.<locals>.check_crypt)rM ro rH r� r� r� r/ rZ )rj rM r� r. r� r/ �fuzz_verifier_cryptE
s z OsCryptMixin.fuzz_verifier_cryptc C s dS )z~
fuzzy_verified_crypt() helper --
used to determine if os crypt() supports a particular hash variant.
Tr. r^ r. r. r/ r� ^
s z#OsCryptMixin.crypt_supports_variant)r� r� r� r� r~ Z _OsCryptMixin__unittest_skiprU ro r� r� rh re ri rf rf rw rz r{ r9 r� r� r� r� r. r. r� r/ rh f s(
/rh c @ sR e Zd ZdZdZdZdZdZdd� Zdd� Z d d
� Z
d d � Z G d
d� de j
�Z
dS )�UserHandlerMixina( helper for handlers w/ 'user' context kwd; mixin for HandlerCase
this overrides the HandlerCase test harness methods
so that a username is automatically inserted to hash/verify
calls. as well, passing in a pair of strings as the password
will be interpreted as (secret,user)
�userTFc C s| | j }d}|j|| jd�}| jrV| �t|j|� | �t|j||� | �t|j||� n"|�|� |�||� |�||� dS )ztest user context keywordrt �r� N)rM rB � default_user�
requires_userr� r� rb r\ )rj rM �passwordrB r. r. r/ � test_80_user�
s
z UserHandlerMixin.test_80_userc C sb | j �� }|�� }| jdt|d�d�}| jrF| �| jd||d�d� n| �| jd||d�d� dS )ztest user case sensitivityrt r� )rY z!user should not be case sensitivez user should be case sensitiveN) r� r� r� r[ r� �user_case_insensitiverI rH r� )rj r� r� rB r. r. r/ �test_81_user_case�
s
��z"UserHandlerMixin.test_81_user_casec C sT | � � }| jd|dd�}| jd|dd�}| �||� | jd|dd�}| �||� dS )ztest user used as saltrt Zadminr� �rootN)rd rc r� ry )rj rC r� r� Zh3r. r. r/ �test_82_user_salt�
s z"UserHandlerMixin.test_82_user_saltc C s8 t |t�r|\}}n| js |S | j}d|vr4||d< |S )zinsert username into kwdsr� )rc r� r� r� )rj rA r` r� r. r. r/ rU �
s
z!UserHandlerMixin.populate_contextc @ s4 e Zd Zejj�� Zejdd� ed�Z dd� Z
dS )z"UserHandlerMixin.FuzzHashGenerator� random_userr� Z asdQWE123c C s4 | j }| jjs |�� dk r d S t|| j|�dd��S )Nr' r� r� )r r: r� r� r �
user_alphabetrY )rj r r. r. r/ r� �
s z.UserHandlerMixin.FuzzHashGenerator.random_userN) r� r� r� r& r/ rT r rV r r� r� r. r. r. r/ r/ �
s r/ N)r� r� r� r� r� r� r� Z _UserHandlerMixin__unittest_skipr� r� r� rU r& r/ r. r. r. r/ r� i
s
r� c @ s@ e Zd ZdZdZed�ded�gZG dd� dej�Zdd � Z d
S ) �EncodingHandlerMixina helper for handlers w/ 'encoding' context kwd; mixin for HandlerCase
this overrides the HandlerCase test harness methods
so that an encoding can be inserted to hash/verify
calls by passing in a pair of strings as the password
will be interpreted as (secret,encoding)
Tr: s testu ¬ºc @ s e Zd Zed�ZdS )z&EncodingHandlerMixin.FuzzHashGeneratoru qwerty1234<>.@*#! ¬N)r� r� r� r r_ r. r. r. r/ r/ �
s r/ c C s" t |t�r |\}}|�d|� |S )zinsert encoding into kwdsr� )rc r� �
setdefault)rj rA r` r� r. r. r/ rU �
s
z%EncodingHandlerMixin.populate_contextN)
r� r� r� r� Z$_EncodingHandlerMixin__unittest_skipr rw r& r/ rU r. r. r. r/ r� �
s
�r� c s: e Zd ZdZd
� fdd� Z� fdd�Z� fdd �Z� ZS ) r� z@catch_warnings() wrapper which clears warning registry & filters�always�.*c s4 t t| �jf i |�� || _|r*t�|�nd | _d S r1 )r� r� r� �
_reset_filterr~ �compile�_reset_registry)rj Z reset_filterZreset_registryr` r� r. r/ r� �
s zreset_warnings.__init__c s� t t| ��� }| jr(t�� t�| j� | j}|r�i }| _t t
j � � �D ]@\}}|d u sJ|�
|�sfqJt|dd �}|rJ|�� ||< |�� qJ|S �NZ__warningregistry__)r� r� r� r� r� �
resetwarnings� simplefilterr� �_orig_registryr� r| �modulesr rr r� r �clear)rj r� r �backupr� rp �regr� r. r/ r� �
s
zreset_warnings.__enter__c s� | j }|r�| j}ttj�� �D ]b\}}|d u s |�|�s:q t|dd �}|rR|�� |� |�}|r |d u rvt
|d|� q |� |� q t t
| �j|� d S r� )r� r� r� r| r� r rr r� r� r r- rV r� r� r� )rj r� r r� r� rp r� rV r� r. r/ r� s
zreset_warnings.__exit__)r� r� r� r. r. r� r/ r� �
s r� )NN)N)NF)NrX r� )r� r� )jr� Z
__future__r Zbinasciir r5 � functoolsr r r r0 r r� r� r� r~ r( r| r! r2 r+ r r r r r r r� r
Zpasslibr r Zpasslib.registry�registryZpasslib.tests.backportsr
r4 r r r r r� r r r r r r r r r r r r r r r r r! Zpasslib.utils.decorr" Zpasslib.utils.handlersrn rn rK �__all__Zgoogle.appengineZgoogle� ImportErrorr r0 r> ZTICK_RESOLUTIONrC rD r r r r� rB r# rN rR rW r^ ra rQ rh r6 rm r$ r% r| r� r� r� r� r� r� r9 r& rh r� r� r1 r� r. r. r. r/ �<module> s� 0
�
F y a&