Ë
|
¬`iìY ã ó2 d dl Z d dlZd dlmZ d dlmZmZmZmZm Z m
|
Z
|
m Z d dl m Z mZmZmZmZ d dlmZ d dlmZ d dlmZmZmZ d dlm Z m Z m Z m Z e d d
|
« Z e d d « Z!dd Z"d dZ# G d de$« Z%d Z&d Z'd dZ(d dZ)d Z*d Z+d Z,d dZ-d Z.d dZ/y)!é N)Úreduce)ÚtobytesÚbordÚ _copy_bytesÚ
|
iter_rangeÚtostrÚbchrÚbstr)ÚSHA1ÚSHA256ÚHMACÚCMACÚBLAKE2s)Ústrxor)Úget_random_bytes)ÚsizeÚ long_to_bytesÚ bytes_to_long)Úload_pycryptodome_raw_libÚcreate_string_bufferÚget_raw_bufferÚc_size_tzCrypto.Cipher._Salsa20z
|
int Salsa20_8_core(const uint8_t *x, const uint8_t *y,
|
uint8_t *out);
|
zCrypto.Protocol._scrypta
|
typedef int (core_t)(const uint8_t [64], const uint8_t [64], uint8_t [64]);
|
int scryptROMix(const uint8_t *data_in, uint8_t *data_out,
|
size_t data_len, unsigned N, core_t *core);
|
c ób |st }t | « } |j | |z « }|j }||kD rt d|z « t |« dk7 rt dt |« z « t |dz
|
« D ]! }|j |j « « }# |j « d| S )aM Derive one key from a password (or passphrase).
|
|
This function performs key derivation according to an old version of
|
the PKCS#5 standard (v1.5) or `RFC2898
|
<https://www.ietf.org/rfc/rfc2898.txt>`_.
|
|
Args:
|
password (string):
|
The secret password to generate the key from.
|
salt (byte string):
|
An 8 byte string to use for better protection from dictionary attacks.
|
This value does not need to be kept secret, but it should be randomly
|
chosen for each derivation.
|
dkLen (integer):
|
The length of the desired key. The default is 16 bytes, suitable for
|
instance for :mod:`Crypto.Cipher.AES`.
|
count (integer):
|
The number of iterations to carry out. The recommendation is 1000 or
|
more.
|
hashAlgo (module):
|
The hash algorithm to use, as a module or an object from the :mod:`Crypto.Hash` package.
|
The digest length must be no shorter than ``dkLen``.
|
The default algorithm is :mod:`Crypto.Hash.SHA1`.
|
|
Return:
|
A byte string of length ``dkLen`` that can be used as key.
|
z:Selected hash algorithm has a too short digest (%d bytes).é z,Salt is not 8 bytes long (%d bytes instead).é N) r r ÚnewÚ digest_sizeÚ TypeErrorÚlenÚ
|
ValueErrorr Údigest)ÚpasswordÚsaltÚdkLenÚcountÚhashAlgoÚpHashr! Úis õf H:\项ç®\archive\æµè¯ç»\èæ¬\Change_password\venv_build\Lib\site-packages\Crypto/Protocol/KDF.pyÚPBKDF1r* 9 s« ñ: ÜÜxÓ HØ LL $ Ó 'EØ × Ñ FØ v~ÜÐTÐW]Ñ]Ó^Ð^Ü
|
4yA~ÜÐGÌ#ÈdË)ÑSÓTÐTÜ aÓ ò *Ø %,,.Ó)ð*à <<>&5Ð !Ð!ó c ó¸
|
t « t |« }r r t d« t s t d« s~fd fd
|
d}d}t |« |k rõ |t j d|« z « gd z |t t
|
fd
|
t |« D « « z }|dz }t |« |k r^nd}d}t |« |k rt j d« }|j « j |t j d|« z « j « } ||j | |« z }|dz }t |« |k r|d| S ) a² Derive one or more keys from a password (or passphrase).
|
|
This function performs key derivation according to the PKCS#5 standard (v2.0).
|
|
Args:
|
password (string or byte string):
|
The secret password to generate the key from.
|
|
Strings will be encoded as ISO 8859-1 (also known as Latin-1),
|
which does not allow any characters with codepoints > 255.
|
salt (string or byte string):
|
A (byte) string to use for better protection from dictionary attacks.
|
This value does not need to be kept secret, but it should be randomly
|
chosen for each derivation. It is recommended to use at least 16 bytes.
|
|
Strings will be encoded as ISO 8859-1 (also known as Latin-1),
|
which does not allow any characters with codepoints > 255.
|
dkLen (integer):
|
The cumulative length of the keys to produce.
|
|
Due to a flaw in the PBKDF2 design, you should not request more bytes
|
than the ``prf`` can output. For instance, ``dkLen`` should not exceed
|
20 bytes in combination with ``HMAC-SHA1``.
|
count (integer):
|
The number of iterations to carry out. The higher the value, the slower
|
and the more secure the function becomes.
|
|
You should find the maximum number of iterations that keeps the
|
key derivation still acceptable on the slowest hardware you must support.
|
|
Although the default value is 1000, **it is recommended to use at least
|
1000000 (1 million) iterations**.
|
prf (callable):
|
A pseudorandom function. It must be a function that returns a
|
pseudorandom byte string from two parameters: a secret and a salt.
|
The slower the algorithm, the more secure the derivation function.
|
If not specified, **HMAC-SHA1** is used.
|
hmac_hash_module (module):
|
A module from ``Crypto.Hash`` implementing a Merkle-Damgard cryptographic
|
hash, which PBKDF2 must use in combination with HMAC.
|
This parameter is mutually exclusive with ``prf``.
|
|
Return:
|
A byte string of length ``dkLen`` that can be used as key material.
|
If you want multiple keys, just break up this string into segments of the desired length.
|
z2'prf' and 'hmac_hash_module' are mutually exlusiveNÚ_pbkdf2_hmac_assistc óN t j | |« j « S ©N©r r r! )ÚpÚsÚhmac_hash_modules r) ú<lambda>zPBKDF2.<locals>.<lambda>¡ s ø txx¨¨1Ð.>Ó ?× FÑ FÓ H r+ c ó> | d | d « c| d< | d< | d S )Nr r © )r2 r" Úprfs r) ÚlinkzPBKDF2.<locals>.link£ s. ø Ø1s 8¨Q¨q©TÓ 2JAaD!A$ØQ4Kr+ r+ r z>Ié c 3 ó. K | ] } « y wr/ r6 )Ú.0Újr8 r2 s r) ú <genexpr>zPBKDF2.<locals>.<genexpr>« s øè ø Ò"A¨q¡4¨§7Ñ"Aùs )r r r Úhasattrr ÚstructÚpackr r Úranger r ÚcopyÚupdater! r- ) r" r# r$ r% r7 r3 Úkeyr( ÚbaseÚ first_digestr8 r2 s ` `` @@r) ÚPBKDF2rG d s_ ü ô` xÓ HÜ 4=Dá
|
Ñ ÜÐMÓNÐNà
|
{Ð'Ð/Ü Ðá
|
'Ð*Ð,AÔBð ;ÛHCõ ð Ø Ü#hÒ ÙXt¤f§k¡k°$¸Ó&:Ñ :Ó;Ð<¸qÑ@AØ 6&Ô"A´E¸%³LÔ"AÓBÑ BCØ FAô #hÔ ð Ø Ü#hÒ Ü88H cÐ+;Ó<DØ 99;×-Ñ-¨d´V·[±[ÀÀqÓ5IÑ.IÓJ×QÑQÓSLØ 4×+Ñ+¨L¸%Ó@Ñ @CØ FAô #hÓ ð v;Ðr+ c ó: e Zd ZdZddZed « Zd Zd Zd Z y) Ú_S2VzÝString-to-vector PRF as defined in `RFC5297`_.
|
|
This class implements a pseudorandom function family
|
based on CMAC that takes as input a vector of strings.
|
|
.. _RFC5297: http://tools.ietf.org/html/rfc5297
|
Nc óÎ t dd|« | _ || _ d|j z x| _ | _ |j dz dz
|
| _ |i | _ yt |« | _ y)a~ Initialize the S2V PRF.
|
|
:Parameters:
|
key : byte string
|
A secret that can be used as key for CMACs
|
based on ciphers from ``ciphermod``.
|
ciphermod : module
|
A block cipher module from `Crypto.Cipher`.
|
cipher_params : dictionary
|
A set of extra parameters to use to create a cipher instance.
|
Nó r r ) r Ú_keyÚ
|
_ciphermodÚ
|
block_sizeÚ _last_stringÚ_cacheÚ
|
_n_updatesÚ_cipher_paramsÚdict)ÚselfrD Ú ciphermodÚ cipher_paramss r) Ú__init__z _S2V.__init__Ä si ô d¨CÓ0 Ø#Ø*1°I×4HÑ4HÑ*HÐHÔDKð $×.Ñ.°Ñ2°QÑ6à Ð Ø"$DÕ ä"& }Ó"5DÕ r+ c ó t | |« S )a Create a new S2V PRF.
|
|
:Parameters:
|
key : byte string
|
A secret that can be used as key for CMACs
|
based on ciphers from ``ciphermod``.
|
ciphermod : module
|
A block cipher module from `Crypto.Cipher`.
|
)rI )rD rU s r) r z_S2V.newÝ s ô CÓ#Ð#r+ c ó t |« dz }t |d « dz r|dz }t |t |« « t |« d S )Nr r é é )r r r r )rT ÚbsÚdoubleds r) Ú_doublez _S2V._doubleê sH Ü Ó# qÑ(Ü 1;Ò Ø tOGÜ W¤c¨"£gÓ.´°B³¨x¨yÐ9Ð9r+ c óx | j dk( r t d« | xj dz c_ t j | j | j
|
| j | j ¬« }t | j | j « |j « « | _
|
t dd|« | _ y)ad Pass the next component of the vector.
|
|
The maximum number of components you can pass is equal to the block
|
length of the cipher (in bits) minus 1.
|
|
:Parameters:
|
item : byte string
|
The next component of the vector.
|
:Raise TypeError: when the limit on the number of components has been reached.
|
r z!Too many components passed to S2Vr ©ÚmsgrU rV N) rQ r r r rL rO rM rR r r^ rP r! r )rT ÚitemÚmacs r) rC z _S2V.updateð s ð ??aÒ ÜÐ ?Ó@Ð @Ø 1Ñ ähhtyyØ ×,Ñ,Ø!%§ ¡ Ø%)×%8Ñ%8ô:ô T\\¨$¯+©+Ó 6¸¿
|
¹
|
» ÓE Ü '¨¨d°DÓ 9Õr+ c ó t | j « dk\ r4| j dd t | j dd | j « z }n:| j dz dz dd }t || j | j « « }t j | j || j | j ¬« }|j « S )z"Derive a secret from the vector of components.
|
|
:Return: a byte string, as long as the block length of the cipher.
|
é Niðÿÿÿó s r` ) r rO r rP r^ r r rL rM rR r! )rT ÚfinalÚpaddedrc s r) Úderivez _S2V.derive s² ô t× Ñ Ó ! RÒ 'à×%Ñ% d sÐ+¬f°T×5FÑ5FÀsÀtÐ5LÈdÏkÉkÓ.ZÑZEð ×'Ñ'¨'Ñ1°LÑ@À#À2ÐFFÜ6 4§<¡<°· ± Ó#<Ó=EÜhhtyyØ Ø!%§ ¡ Ø%)×%8Ñ%8ô:ð zz|Ðr+ r/ )
|
Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__rW Ú staticmethodr r^ rC ri r6 r+ r) rI rI » s/ ñó6ð2 ñ
|
$ó ð
|
$ò:ò :ó. r+ rI c óR t j | ||¬« j « }|S )N©Ú digestmodr0 )r# ÚikmÚhashmodÚprks r) Ú _HKDF_extractru s" Ü
|
((4¨Ô
|
0×
|
7Ñ
|
7Ó
|
9CØ Jr+ c ó" dg}d}d}||k rnt j | |d |z t j d|« z |¬« }|j |j « « ||j z }|dz }||k rndj |« }|d | S )Nr+ r r éÿÿÿÿÚBrp )r r r? r@ Úappendr! r Újoin) rt ÚinfoÚLrs ÚtÚnÚtlenÚhmacÚokms r) Ú _HKDF_expandr s Ø AØ AØ DØ
|
(ÜxxQrU T\¬F¯K©K¸¸QÓ,?Ñ ?È7ÔSØ Ô Ø ×#Ñ#Ñ#Ø Qð (ð
|
((1+CØ r7Nr+ c ó ||z }|d|j z kD r t d« |sd|j z }|d}t || |« }t ||||« }|dk( r|d| S t d||« D cg c]
|
} || | |z }
|
} t |
|
d| « S c c} w )a Derive one or more keys from a master secret using
|
the HMAC-based KDF defined in RFC5869_.
|
|
Args:
|
master (byte string):
|
The unguessable value used by the KDF to generate the other keys.
|
It must be a high-entropy secret, though not necessarily uniform.
|
It must not be a password.
|
key_len (integer):
|
The length in bytes of every derived key.
|
salt (byte string):
|
A non-secret, reusable value that strengthens the randomness
|
extraction step.
|
Ideally, it is as long as the digest size of the chosen hash.
|
If empty, a string of zeroes in used.
|
hashmod (module):
|
A cryptographic hash algorithm from :mod:`Crypto.Hash`.
|
:mod:`Crypto.Hash.SHA512` is a good choice.
|
num_keys (integer):
|
The number of keys to derive. Every key is :data:`key_len` bytes long.
|
The maximum cumulative length of all keys is
|
255 times the digest size.
|
context (byte string):
|
Optional identifier describing what the keys are used for.
|
|
Return:
|
A byte string or a tuple of byte strings.
|
|
.. _RFC5869: http://tools.ietf.org/html/rfc5869
|
éÿ z Too much secret data to deriverK Nr+ r r )r r ru r r Úlist) ÚmasterÚkey_lenr# rs Únum_keysÚcontextÚ
|
output_lenrt r ÚidxÚkols r) ÚHKDFr - sà ð@ 8Ñ#JØS7×.Ñ.Ñ.Ò/ÜÐ9Ó:Ð:Ù Ø×,Ñ,Ñ,ØØä
|
f gÓ
|
.CÜ
|
sG Z°Ó
|
9Cà1}Ø8G}Ð ä J°Ó8ö :Øð s3=Ò !ð :Cð :ä IXÓ Ð ùò :s Á,B c ót dt |« dz
|
z |k7 r t d« |dk\ r t d« |dd|z z kD r t d« d }t | ||dz |z d|¬
|
« }t j } t
|
j }
|
g } t |« D ]X } | dz |z } t d|z « } | || | d|z z |t d|z « ||
|
« }|rt d |z « | t |« gz } Z t | d j | « ||z d|¬
|
« }|dk( r|S t d ||z |« D cg c]
|
} || | |z }} |S c c} w )uG Derive one or more keys from a passphrase.
|
|
Args:
|
password (string):
|
The secret pass phrase to generate the keys from.
|
salt (string):
|
A string to use for better protection from dictionary attacks.
|
This value does not need to be kept secret,
|
but it should be randomly chosen for each derivation.
|
It is recommended to be at least 16 bytes long.
|
key_len (integer):
|
The length in bytes of each derived key.
|
N (integer):
|
CPU/Memory cost parameter. It must be a power of 2 and less
|
than :math:`2^{32}`.
|
r (integer):
|
Block size parameter.
|
p (integer):
|
Parallelization parameter.
|
It must be no greater than :math:`(2^{32}-1)/(4r)`.
|
num_keys (integer):
|
The number of keys to derive. Every key is :data:`key_len` bytes long.
|
By default, only 1 key is generated.
|
The maximum cumulative length of all keys is :math:`(2^{32}-1)*32`
|
(that is, 128TB).
|
|
A good choice of parameters *(N, r , p)* was suggested
|
by Colin Percival in his `presentation in 2009`__:
|
|
- *( 2¹â´, 8, 1 )* for interactive logins (â¤100ms)
|
- *( 2²â°, 8, 1 )* for file encryption (â¤5s)
|
|
Return:
|
A byte string or a tuple of byte strings.
|
|
.. __: http://www.tarsnap.com/scrypt/scrypt-slides.pdf
|
r9 r zN must be a power of 2l z N is too bigl àÿ rZ zp or r are too bigc óT t j | |t « j « S r/ )r r r r! )r1 r2 s r) r4 zscrypt.<locals>.<lambda> s ¤4§8¡8¨A¨q´&Ó#9×#@Ñ#@Ó#B r+ )r7 z Error %X while running scryptr+ r ) Úbit_sizer rG Ú_raw_scrypt_libÚ scryptROMixÚ_raw_salsa20_libÚSalsa20_8_corer r r r rz )r" r# r ÚNÚrr1 r Úprf_hmac_sha256Ústage_1r ÚcoreÚdata_outÚflowr Ú
|
buffer_outÚresultÚdkr s r) Úscryptr _ s ðN Xa[1_Ñ Ò"ÜÐ1Ó2Ð2ØG|Ü Ó(Ð(ØÐ C¨!¡GÑ ,Ò,ÜÐ-Ó.Ð.áBOäXt Q¨¡W¨q¡[°!¸ ÔIGä!×-Ñ-KÜ × *Ñ *Dð HÜ1 ò
|
1ØSj1nÜ)¨#°©'Ó2
|
Ù W S¨#°°a±©-Ð 8Ø 'Ü % c¨A¡gÓ .Ø Ø !ó #ñ
|
Ü Ð <¸vÑ EÓFÐ FØ^ JÓ/Ð0Ñ0ð
|
1ô
|
ØÓ"Ø(Ñ" AØ#ô
|
%Bð
|
1}Ø ô ! G¨hÑ$6¸Ó@ö BØð c#-Ò ð BCð Bà Jùò Bs Ä"D5c ó d}g }| D ]B }t t |« « dd j d« }|j t |« « D dj |« }t dt |« d« D cg c]
|
}|||dz }}g }|d d D ]" }t |d« }|j || « $ |d }t |d« dt |« z
|
z }|j || « dj |« }t |« S c c}w ) Nú@./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789r9 r r+ r é rw Ú )
|
Úbinr Úzfillry r
|
rz rA r Úintr ) Údatar2 ÚbitsÚcÚbits_cr Úbits6r Úgs r) Ú_bcrypt_encoder ¯ s ØJAà DØ ò "ÜT!W abÐ!×'Ñ'¨Ó*Ø DLÕ!ð"ð 88D>Dä(-¨a´°T³¸AÓ(>Ö ? T#c!e_Ð ?EÐ ?à FØ 3BZò Ü!QiØ afÕ ð ð b AÜ
|
a)C F
|
Ñ
|
#CØ
|
MM!C&ÔØ WWV_Fä 6?Ðùò @s Á5Dc ó d}g }t | « D ]A }|j |« }t |« dd j d« }|j |« C dj |« }t | « dz }|dk( r t d« |dk( r|d d }n
|
|d k( r|d d
|
}t d t |« d « D cg c]
|
}|||d z }}g }|D ]& } |j t t | d« « « ( d j |« }|S c c}w )Nr¡ r9 r¢ r£ é r zIncorrect lengthéüÿÿÿé éþÿÿÿr r r+ ) r Úfindr¤ r¥ ry rz r r rA r r¦ )
|
r§ r2 r¨ r© r r« Úmodulo4Úbits8r r¬ s
|
r) Ú_bcrypt_decoder¶ Ç s ØJAà DÜ 4[ò ØffQiÜC ×"Ñ" 1Ó%Ø EÕðð 774=Dä$i!mGØ!|ÜÐ+Ó,Ð,Ø A ØCRyØ A ØCRyä(-¨a´°T³¸AÓ(>Ö ? T#c!e_Ð ?EÐ ?à FØ ò 'Ø d3q !9oÕ&ð'à XXfÓ Fà Mùò @s Â0Dc ó ddl m} t | « dkD r t d« d|cxk rdk st d« t d« |j | |j
|
|||« }|}t d« D ] }|j |« } |S ) Nr )Ú _EKSBlowfishéH z6The password is too long. It must be 72 bytes at most.r¯ é z-bcrypt cost factor must be in the range 4..31é@ )Ú Crypto.Cipherr¸ r r r ÚMODE_ECBrA Úencrypt) r" Úcostr# ÚconstantÚinvertr¸ ÚcipherÚctextÚ_s r) Ú _bcrypt_hashrÅ ã s Ý*ä
|
8}rÒÜÐQÓRÐRà OOÜÐHÓIÐIð ÜÐHÓIÐIà × Ñ h¨ ×(=Ñ(=¸tÀTÈ6Ó RFØ EÜ 2Yò &ØuÓ%ð&à Lr+ c ó t | d« } | j t d« d « dk7 r t d« t | « dk r| dz } | t d« }t |« dk7 r t d « t | ||d
|
d « }d t t |« j d « « z }d t |« z }t |dd « }d|z |z |z S )a> Hash a password into a key, using the OpenBSD bcrypt protocol.
|
|
Args:
|
password (byte string or string):
|
The secret password or pass phrase.
|
It must be at most 72 bytes long.
|
It must not contain the zero byte.
|
Unicode strings will be encoded as UTF-8.
|
cost (integer):
|
The exponential factor that makes it slower to compute the hash.
|
It must be in the range 4 to 31.
|
A value of at least 12 is recommended.
|
salt (byte string):
|
Optional. Random byte string to thwarts dictionary and rainbow table
|
attacks. It must be 16 bytes long.
|
If not passed, a random value is generated.
|
|
Return (byte string):
|
The bcrypt hash
|
|
Raises:
|
ValueError: if password is longer than 72 bytes or if it contains the zero byte
|
|
zutf-8r rw z#The password contains the zero byter¹ rK Nre z!bcrypt salt must be 16 bytes longs OrpheanBeholderScryDoubtTó $r9 s $2a) r r³ r r r r rÅ r
|
Ústrr¥ r )r" r¿ r# rà Úcost_encÚsalt_encÚhash_encs r) ÚbcryptrÌ ó sÔ ô4 x Ó)Hà}}T!WQZÓ BÒ&ÜÐ>Ó?Ð?ä
|
8}rÒØGÑà |Ü Ó#Ü
|
4yBÜÐ<Ó=Ð=ä 4¨Ð/JÈDÓ QEàd3t9??¨1Ó-Ó.Ñ.HØn TÓ*Ñ*HÜ e C RjÓ)HØ HÑ xÑ '¨(Ñ 2Ð2r+ c ó t |« }t |« dk7 rt dt |« z « |dd dk7 r t d« t j d« }|j |« }|s t d« t |j d « « }d|cxk rd
|
k st d « t d « t |j d « « }t | ||« }t d « }t j d||¬« j « }t j d||¬« j « } || k7 r t d« y)aé Verify if the provided password matches the given bcrypt hash.
|
|
Args:
|
password (byte string or string):
|
The secret password or pass phrase to test.
|
It must be at most 72 bytes long.
|
It must not contain the zero byte.
|
Unicode strings will be encoded as UTF-8.
|
bcrypt_hash (byte string, bytearray):
|
The reference bcrypt hash the password needs to be checked against.
|
|
Raises:
|
ValueError: if the password does not match
|
é< z;Incorrect length of the bcrypt hash: %d bytes instead of 60Nr¯ s $2a$zUnsupported prefixs@ \$2a\$([0-9][0-9])\$([A-Za-z0-9./]{22,22})([A-Za-z0-9./]{31,31})z Incorrect bcrypt hash formatr rº zIncorrect costr9 re é )Ú digest_bitsrD r§ zIncorrect bcrypt hash)r r r ÚreÚcompileÚmatchr¦ Úgroupr¶ rÌ r r r r! )
|
r" Ú bcrypt_hashr1 r r¿ r# Ú bcrypt_hash2ÚsecretÚmac1Úmac2s
|
r) Ú bcrypt_checkrÚ " s* ô +Ó&Kä
|
;Ó2Ò ÜÐVÔY\Ð]hÓYiÑiÓjÐjà2A'Ò!ÜÐ-Ó.Ð.ä
|
|
|
ÐWÓXAØ Ó AÙ ÜÐ7Ó8Ð8ä qwwqz?DØ OOÜÐ)Ó*Ð*ð ÜÐ)Ó*Ð*ä !'' !*Ó %Dä( D¨$Ó/Lä bÓ !Fä ;; 3¨F¸Ô E× LÑ LÓ NDÜ ;; 3¨F¸ Ô F× MÑ MÓ ODØ t|ÜÐ0Ó1Ð1ð r+ c ó |d}|j d« dk7 r t d« t ||z dz d« }||z }d}d} t | « |k rHt |d« |z dz |z |z }
|
| || |
|
« z } |dz }|d kD r t d
|
« t | « |k rH|dk( r| d| S t d ||« D cg c]
|
} | | | |z } } | S c c} w ) aJ Derive one or more keys from a master secret using
|
a pseudorandom function in Counter Mode, as specified in
|
`NIST SP 800-108r1 <https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1.pdf>`_.
|
|
Args:
|
master (byte string):
|
The secret value used by the KDF to derive the other keys.
|
It must not be a password.
|
The length on the secret must be consistent with the input expected by
|
the :data:`prf` function.
|
key_len (integer):
|
The length in bytes of each derived key.
|
prf (function):
|
A pseudorandom function that takes two byte strings as parameters:
|
the secret and an input. It returns another byte string.
|
num_keys (integer):
|
The number of keys to derive. Every key is :data:`key_len` bytes long.
|
By default, only 1 key is derived.
|
label (byte string):
|
Optional description of the purpose of the derived keys.
|
It must not contain zero bytes.
|
context (byte string):
|
Optional information pertaining to
|
the protocol that uses the keys, such as the identity of the
|
participants, nonces, session IDs, etc.
|
It must not contain zero bytes.
|
|
Return:
|
- a byte string (if ``num_keys`` is not specified), or
|
- a tuple of byte strings (if ``num_key`` is specified).
|
Nr rK rw zNull byte found in contextr r¯ r+ l ÿÿ z Overflow in SP800 108 counterr )r³ r r r r ) r r r7 r Úlabelr Ú key_len_encr r( r r{ r r s r) ÚSP800_108_CounterrÞ O s ðB ÐØà||GÓ Ò"ÜÐ5Ó6Ð6ä ¨(Ñ 2°QÑ 6¸Ó:KØ8Ñ#Jà AØ BÜ
|
b'JÒ
|
Ü Q Ó" UÑ*¨WÑ4°wÑ>ÀÑLØ
|
c&$Ó Ñ Ø QØ z>Ü Ð <Ó=Ð =ô b'JÓ
|
ð 1}Ø(7|Ðô % Q¨
|
°GÓ<ö>Øð #cGmÒ$ð >ð >à
|
ùò>s Â.C)éè N)re rß NN)r N)r r/ )Nr+ r+ )0rÑ r? Ú functoolsr ÚCrypto.Util.py3compatr r r r r r r
|
Ú Crypto.Hashr r r r r ÚCrypto.Util.strxorr Ú Crypto.Randomr ÚCrypto.Util.numberr r r r ÚCrypto.Util._raw_apir r r r r r r* rG ÚobjectrI ru r r r r r¶ rÅ rÌ rÚ rÞ r6 r+ r) ú<module>rè s¹ ðó2
|
Û Ý ÷6÷ 6ñ 6÷ :Õ 9Ý %Ý *ß MÑ M÷<ó <ñ -Ø,ðóÐ ñ ,Ø-ðóó("óVTôn] 6ô ] ò@ò
|
|
ó/ ódMò`ò0ò8 ó ,3ò^*2ôZ8r+
|
