/var/opt/nydus/ops/oscrypto/_win/__pycache__
Edit: /var/opt/nydus/ops/oscrypto/_win/__pycache__/symmetric.cpython-312.pyc (31697B)
N jx R d dl mZmZmZmZ ddlmZ ddlmZm Z m
Z
m Z m Z m
Z
mZmZmZmZ ddlmZ ddlmZ ddlmZmZ e Zed k( rdd
lmZm Z m Z m Z m Z ndd l m!Z!m"Z"m Z m#Z#m$Z$ g d Z%d
Z&d Z'd Z(d Z)d Z*d Z+d Z,d Z-d Z.d Z/d Z0d Z1d Z2d Z3d Z4d Z5d Z6d Z7d Z8d Z9y!)" )unicode_literalsdivisionabsolute_importprint_function )pretty_message)
buffer_from_bytesbytes_from_bufferderefnewnull pointer_setstruct struct_bytesunwrapwrite_to_buffer )
rand_bytes)backend) type_namebyte_cls winlegacy)advapi32
Advapi32Const handle_erroropen_context_handleclose_context_handle)bcrypt BcryptConstr open_alg_handleclose_alg_handle) aes_cbc_no_padding_decryptaes_cbc_no_padding_encryptaes_cbc_pkcs7_decryptaes_cbc_pkcs7_encryptdes_cbc_pkcs5_decryptdes_cbc_pkcs5_encryptrc2_cbc_pkcs5_decryptrc2_cbc_pkcs5_encrypt rc4_decrypt rc4_encrypttripledes_cbc_pkcs5_decrypttripledes_cbc_pkcs5_encryptc L t | dvr t t dt | |s t d }n,t | dk7 r t t dt | t | dz dk7 r t t dt | |t d| ||d fS ) a
Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and
no padding. This means the ciphertext must be an exact multiple of 16 bytes
long.
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The plaintext - a byte string
:param iv:
The initialization vector - either a byte string 16-bytes long or None
to generate an IV
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A tuple of two byte strings (iv, ciphertext)
o
key must be either 16, 24 or 32 bytes (128, 192 or 256 bits)
long - is %s
r0 :
iv must be 16 bytes long - is %s
r zJ
data must be a multiple of 16 bytes long - is %s
aesFlen
ValueErrorr r _encryptkeydataivs H/opt/nydus/tmp/pip-target-a90h98xg/lib/python/oscrypto/_win/symmetric.pyr# r# - s 2 3x|#
H
^ RB
G
4y2~
I
T2u5 66 c t | dvr t t dt | t | dk7 r t t dt | t d| ||d S )a[
Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key and no
padding.
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string 16-bytes long
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
r/ r3 r0 r4 r5 Fr7 r8 r _decryptr: s r> r" r" d sv . 3x|#
H
2w"}
G
E3b% 00r? c t | dvr t t dt | |s t d }n,t | dk7 r t t dt | |t d| ||d fS )a
Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and
PKCS#7 padding.
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The plaintext - a byte string
:param iv:
The initialization vector - either a byte string 16-bytes long or None
to generate an IV
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A tuple of two byte strings (iv, ciphertext)
r/ r3 r0 r4 r5 Tr6 r: s r> r% r% s 0 3x|#
H
^ RB
G
T2t4 55r? c t | dvr t t dt | t | dk7 r t t dt | t d| ||d S )aG
Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string 16-bytes long
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
r/ r3 r0 r4 r5 TrA r: s r> r$ r$ sv , 3x|#
H
2w"}
G
E3b$ //r? c t | dk st | dkD r t t dt | t d| |dd S )a
Encrypts plaintext using RC4 with a 40-128 bit key
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The plaintext - a byte string
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the ciphertext
r0 Q
key must be 5 to 16 bytes (40 to 128 bits) long - is %s
rc4N)r7 r8 r r9 r; r< s r> r+ r+ P & 3x!|s3x"}
H
E3dD 11r? c t | dk st | dkD r t t dt | t d| |dd S )a
Decrypts RC4 ciphertext using a 40-128 bit key
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The ciphertext - a byte string
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
rF r0 rG rH NrA rI s r> r* r* rJ r? c t | dk st | dkD r t t dt | |s t d }n,t | dk7 r t t dt | |t d| ||d fS )ab
Encrypts plaintext using RC2 with a 64 bit key
:param key:
The encryption key - a byte string 8 bytes long
:param data:
The plaintext - a byte string
:param iv:
The 8-byte initialization vector to use - a byte string - set as None
to generate an appropriate one
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A tuple of two byte strings (iv, ciphertext)
rF r0 rG 9
iv must be 8 bytes long - is %s
rc2Tr6 r: s r> r) r) # s . 3x!|s3x"}
H
] RA
G
T2t4 55r? c t | dk st | dkD r t t dt | t | dk7 r t t dt | t d| ||d S )a"
Decrypts RC2 ciphertext using a 64 bit key
:param key:
The encryption key - a byte string 8 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector used for encryption - a byte string
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
rF r0 rG rM rN rO TrA r: s r> r( r( O s , 3x!|s3x"}
H
2w!|
G
E3b$ //r? c 0 t | dk7 r,t | dk7 r t t dt | |s t d }n,t | dk7 r t t dt | d}t | dk( rd}|t || ||d fS ) a
Encrypts plaintext using 3DES in either 2 or 3 key mode
:param key:
The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)
:param data:
The plaintext - a byte string
:param iv:
The 8-byte initialization vector to use - a byte string - set as None
to generate an appropriate one
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A tuple of two byte strings (iv, ciphertext)
r0 r1 W
key must be 16 bytes (2 key) or 24 bytes (3 key) long - is %s
rM rN tripledes_3keytripledes_2keyTr6 r; r< r= ciphers r> r- r- x s . 3x2~#c(b.
H
] RA
G
F
3x2~! dB5 66r? c t | dk7 r,t | dk7 r t t dt | t | dk7 r t t dt | d}t | dk( rd}t || ||d S ) aC
Decrypts 3DES ciphertext in either 2 or 3 key mode
:param key:
The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector used for encryption - a byte string
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
r0 r1 rR rM rN rS rT TrA rU s r> r, r, s , 3x2~#c(b.
H
2w!|
G
F
3x2~! FCr4 00r? c t | dk7 r t t dt | |s t d }n,t | dk7 r t t dt | |t d| ||d fS )a
Encrypts plaintext using DES with a 56 bit key
:param key:
The encryption key - a byte string 8 bytes long (includes error
correction bits)
:param data:
The plaintext - a byte string
:param iv:
The 8-byte initialization vector to use - a byte string - set as None
to generate an appropriate one
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A tuple of two byte strings (iv, ciphertext)
rM T
key must be 8 bytes (56 bits + 8 parity bits) long - is %s
rN desTr6 r: s r> r' r' s 0 3x1}
H
] RA
G
T2t4 55r? c t | dk7 r t t dt | t | dk7 r t t dt | t d| ||d S )aK
Decrypts DES ciphertext using a 56 bit key
:param key:
The encryption key - a byte string 8 bytes long (includes error
correction bits)
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector used for encryption - a byte string
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
rM rY rN rZ TrA r: s r> r& r& su . 3x1}
H
2w!|
G
E3b$ //r? c d}| dk( r=t j t j t j dt | }nQt j
t j t j t j t j d| }t j }t |d }t t d }t | }t j |_ t j" |_ d|_ ||_ t t d }t | } || _ t | | _ t/ | |z }
d} | t1 d
d g v r t | d k( rt j2 } t5 t d
} t j6 ||
t |
t9 | | }
t; |
t | }| d
k( rNt5 t dt | dz }t j< |t j> |d }
t; |
| d k7 rt j< |t j@ |d }
t; |
t5 t dt jB }t j< |t jD |d }
t; |
t5 t dt jF }t j< |t jH |d }
t; |
||fS )a
Creates an HCRYPTPROV and HCRYPTKEY for symmetric encryption/decryption. The
HCRYPTPROV must be released by close_context_handle() and the
HCRYPTKEY must be released by advapi32.CryptDestroyKey() when done.
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
A byte string of the symmetric key
:param iv:
The initialization vector - a byte string - unused for RC4
:return:
A tuple of (HCRYPTPROV, HCRYPTKEY)
Nr5 r/ )rZ rT rS rO rH F) verify_only
BLOBHEADERr PLAINTEXTKEYBLOBrO rH rF z HCRYPTKEY *DWORD *rM )%r CALG_AES_128 CALG_AES_192 CALG_AES_256r7 CALG_DES
CALG_3DES_112 CALG_3DESCALG_RC2CALG_RC4MS_ENH_RSA_AES_PROVr r r r r_ bTypeCUR_BLOB_VERSIONbVersionreservedaiKeyAlghdr dwKeySizer set
CRYPT_NO_SALTr CryptImportKeyr
r CryptSetKeyParamKP_EFFECTIVE_KEYLENKP_IVCRYPT_MODE_CBCKP_MODE
PKCS5_PADDING
KP_PADDING)rV r; r= context_handle algorithm_idproviderblob_header_pointer blob_headerblob_struct_pointer blob_structblobflagskey_handle_pointerres
key_handlebufs r> _advapi32_create_handlesr , s ( N
** ** **
c( !)) + 9 9 + 5 5 )) ))
00H(uEN <8,-K%66K(99K K'K +=>,-K!KO HK + ,s 2D
E
eU^$$SQ ++ X}5
!
! D
C *+J
(Is3x!|4'' - -
S
''
S(I}'C'CD'' ! !
S(I}'B'BC'' $ $
S J ''r? c f d}t j t j t j t j t j
t j d| } t | }t j }t t d }t | }t j |_
t j |_ t! | |_ t% | |z }| dk( rOt' t dt! | dz }t j( |t j* |dd } t- | t' t d }
t j. |t1 ||
t1 d|t! | d } t- | t |
|r t3 | S S # |r t3 | w w xY w)
ao
Creates a BCRYPT_KEY_HANDLE for symmetric encryption/decryption. The
handle must be released by bcrypt.BCryptDestroyKey() when done.
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
A byte string of the symmetric key
:return:
A BCRYPT_KEY_HANDLE
N)r5 rZ rT rS rO rH BCRYPT_KEY_DATA_BLOB_HEADERrO r` rM r zBCRYPT_KEY_HANDLE *)r BCRYPT_AES_ALGORITHMBCRYPT_DES_ALGORITHMBCRYPT_3DES_112_ALGORITHMBCRYPT_3DES_ALGORITHMBCRYPT_RC2_ALGORITHMBCRYPT_RC4_ALGORITHMr BCRYPT_KEY_DATA_BLOBr r r BCRYPT_KEY_DATA_BLOB_MAGICdwMagic BCRYPT_KEY_DATA_BLOB_VERSION1 dwVersionr7 cbKeyDatar r BCryptSetPropertyBCRYPT_EFFECTIVE_KEY_LENGTHr BCryptImportKeyr
r! ) rV r;
alg_handle alg_constant blob_typer r r r r r s r> _bcrypt_create_key_handler s J ////%??%;;////
L))$\2
44 $V-J K 01 ) D D + I I #C /036 U?fiSA 6C**77 C
)> ?$$ F F
I
S() Z ( : Z ( s
$D-F F0c t |t s t t dt | t |t s t t dt | | dk7 r.t |t s t t dt | | dk7 r#|s!| dk( rt | dz dk( s t
d t d k( rt | |||| S t | |||| S )
a
Encrypts plaintext
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The plaintext - a byte string
:param iv:
The initialization vector - a byte string - unused for RC4
:param padding:
Boolean, if padding should be used - unused for RC4
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the ciphertext
;
key must be a byte string, not %s
<
data must be a byte string, not %s
rH :
iv must be a byte string, not %s
r5 r0 r padding must be specifiedr )
isinstancer TypeErrorr r r7 r8 _backend_advapi32_encrypt_bcrypt_encryptrV r; r< r= paddings r> r9 r9 s : c8 $
cN
dH %
dO
z"h 7
bM
w %CINa$7 89 9; dB@@ 63b' ::r? c d}d} t | || \ }}t t dt | }t j |t ddt |d }t
| t | } t | }
t |
| t |t | t j |t dd|
|| }t
| t |
t | } | dk( r!|s t | t | dz k( r| dd } | |rt j | |r t | S S # |rt j | |r t | w w xY w)a
Encrypts plaintext via CryptoAPI
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The plaintext - a byte string
:param iv:
The initialization vector - a byte string - unused for RC4
:param padding:
Boolean, if padding should be used - unused for RC4
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the ciphertext
Nr` Tr r5 r0 i)r r r r7 CryptEncryptr
r r r r r r
CryptDestroyKeyr ) rV r; r< r= r r{ r out_lenr
buffer_lenbufferoutputs r> r r " sK : NJ,1%=fc2%N"
h 3t95## F
F
S7^
":.%GSY'## F
S"65>: U?7s6{c$i"n/LDS\F $ $Z 0 0 $ $Z 0 0 s DD- -'Ec d} t | | }|d}n t | }d}|du rt j }t t
d }t j ||t | t t dt d||
} t | t | }
t |
} |r t | n t } t j ||t | t | || |
||
} t | t | t | |rt j | S S # |rt j | w w xY w)a
Encrypts plaintext via CNG
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The plaintext - a byte string
:param iv:
The initialization vector - a byte string - unused for RC4
:param padding:
Boolean, if padding should be used - unused for RC4
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the ciphertext
Nr TULONG *)
r r7 r BCRYPT_BLOCK_PADDINGr r
BCryptEncryptr
r r r r
BCryptDestroyKey
rV r; r< r= r r iv_lenr r r r r iv_buffers
r> r r q 1 : J10.vs;
:FWF d? 44Efi("" I F F
F
S7^
":.-/%b)TV "" I F
S w 8 # #J / : # #J / DD$ $D>c t |t s t t dt | t |t s t t dt | | dk7 r.t |t s t t dt | | t ddg vr
|s t
d t dk( rt | |||| S t | |||| S )a
Decrypts AES/RC4/RC2/3DES/DES ciphertext
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string - unused for RC4
:param padding:
Boolean, if padding should be used - unused for RC4
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
r r rH r r5 r r )
r r r r r rq r8 r _advapi32_decrypt_bcrypt_decryptr s r> rB rB s : c8 $
cN
dH %
dO
z"h 7
bM
S% ((455; dB@@ 63b' ::r? c d}d} t | || \ }}| dk( r |s t | dz dk7 r t d t | }t t
dt | }t j |t | dk( r|sdndd|| } t | t |t | |rt j | |r t | S S # |rt j | |r t | w w xY w) a
Decrypts AES/RC4/RC2/3DES/DES ciphertext via CryptoAPI
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string - unused for RC4
:param padding:
Boolean, if padding should be used - unused for RC4
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
Nr5 r0 r z9Invalid data - ciphertext length must be a multiple of 16r` FT)
r r7 r8 r r r CryptDecryptr
r r
r r r )
rV r; r< r= r r{ r r r r s
r> r r s : NJ1%=fc2%N"
U?7s4y2~/B XY Y"4(h 3t95## F u_WE$
S w 8 $ $Z 0 0 $ $Z 0 0 s B"C 'C5c d} t | | }|d}n t | }d}|du rt j }t t
d }t j ||t | t t dt d||
} t | t | }
t |
} |r t | n t } t j ||t | t | || |
||
} t | t | t | |rt j | S S # |rt j | w w xY w)a
Decrypts AES/RC4/RC2/3DES/DES ciphertext via CNG
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The ciphertext - a byte string
:param iv:
The initialization vector - a byte string - unused for RC4
:param padding:
Boolean, if padding should be used - unused for RC4
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
OSError - when an error is returned by the OS crypto library
:return:
A byte string of the plaintext
Nr Tr )
r r7 r r r r
BCryptDecryptr
r r r r
r r s
r> r r > r r N):
__future__r r r r _errorsr _ffir r
r r r
r r r r r utilr r _typesr r r _advapi32r r r r r _cngr r r r! __all__r# r" r% r$ r+ r* r) r( r- r, r' r& r r r9 r r rB r r r? r>
r s R R $ ( 9 {kkZZ
47n(1V+6\'0T2<2<)6X&0R-7`*1Z*6Z'0Tl(^D)N=;@L1^P0f:;z:1zP0r?