Ɛk d dgZ ddlmZ ddlmZmZ ddlmZmZm Z ddl
m Z m Z m
Z
e dd Zd Z G d
d Zd
d Zd S )newPKCS115_Cipher )Random)
bytes_to_long
long_to_bytes)bordis_bytes _copy_bytes)load_pycryptodome_raw_libc_size_t c_uint8_ptrzCrypto.Cipher._pkcs1_decodea7
int pkcs1_decode(const uint8_t *em, size_t len_em,
const uint8_t *sentinel, size_t len_sentinel,
size_t expected_pt_len,
uint8_t *output);
c
r t | t | k rt d t t | t t | t | t t | t | t | }|S )NzIncorrect output length)len
ValueError_raw_pkcs1_decode pkcs1_decoder
r )emsentinelexpected_pt_lenoutputrets z/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib64/python3.11/site-packages/Crypto/Cipher/PKCS1_v1_5.py
_pkcs1_decoder * s
2ww#f++ 2333
(
(R )1#b''):):)4X)>)>)1#h--)@)@)1/)B)B)4V)<)< > >C J c 2 e Zd ZdZd Zd Zd Zd Zd dZdS )
r zThis cipher can perform PKCS#1 v1.5 RSA encryption or decryption.
Do not instantiate directly. Use :func:`Crypto.Cipher.PKCS1_v1_5.new` instead.c " || _ || _ dS )aJ Initialize this PKCS#1 v1.5 cipher object.
:Parameters:
key : an RSA key object
If a private half is given, both encryption and decryption are possible.
If a public half is given, only encryption is possible.
randfunc : callable
Function that returns random bytes.
N)_key _randfunc)selfkeyrandfuncs r __init__zPKCS115_Cipher.__init__; s !r c 4 | j S )z=Return True if this cipher object can be used for encryption.)r can_encryptr s r r$ zPKCS115_Cipher.can_encryptI y$$&&&r c 4 | j S )z=Return True if this cipher object can be used for decryption.)r can_decryptr% s r r( zPKCS115_Cipher.can_decryptM r& r c | | j }t | }||dz
k rt d g }t | ||z
dz
k r]| d }t |d dk rH| | t | ||z
dz
k ]d | }t | ||z
dz
k sJ d|z dz t d d | z }t | }| j
| }t || } | S )
a Produce the PKCS#1 v1.5 encryption of a message.
This function is named ``RSAES-PKCS1-V1_5-ENCRYPT``, and it is specified in
`section 7.2.1 of RFC8017
`_.
:param message:
The message to encrypt, also known as plaintext. It can be of
variable length, but not longer than the RSA modulus (in bytes) minus 11.
:type message: bytes/bytearray/memoryview
:Returns: A byte string, the ciphertext in which the message is encrypted.
It is as long as the RSA modulus (in bytes).
:Raises ValueError:
If the RSA key length is not sufficiently long to deal with the given
message.
zPlaintext is too long. r r s N) r
size_in_bytesr r r r appendjoinr
r _encryptr )
r messagekmLenpsnew_byter em_intm_intcs
r encryptzPKCS115_Cipher.encryptQ s< *
I # # % %7|| !b&== 566 6
"ggTA %%~~a((HHQK D(( IIh "ggTA %%
XXb\\2ww!d(Q,&&&&
2
'+dD'*J*J
J r"" ""6** % # #r r c | j }t | |k rt d|z t | }| j | }t
|| }t t | }t | rt | |k r$t |d|| } | dk r|S || d S t |||| } || d S )a Decrypt a PKCS#1 v1.5 ciphertext.
This is the function ``RSAES-PKCS1-V1_5-DECRYPT`` specified in
`section 7.2.2 of RFC8017
`_.
Args:
ciphertext (bytes/bytearray/memoryview):
The ciphertext that contains the message to recover.
sentinel (any type):
The object to return whenever an error is detected.
expected_pt_len (integer):
The length the plaintext is known to have, or 0 if unknown.
Returns (byte string):
It is either the original message or the ``sentinel`` (in case of an error).
.. warning::
PKCS#1 v1.5 decryption is intrinsically vulnerable to timing
attacks (see `Bleichenbacher's`__ attack).
**Use PKCS#1 OAEP instead**.
This implementation attempts to mitigate the risk
with some constant-time constructs.
However, they are not sufficient by themselves: the type of protocol you
implement and the way you handle errors make a big difference.
Specifically, you should make it very hard for the (malicious)
party that submitted the ciphertext to quickly understand if decryption
succeeded or not.
To this end, it is recommended that your protocol only encrypts
plaintexts of fixed length (``expected_pt_len``),
that ``sentinel`` is a random byte string of the same length,
and that processing continues for as long
as possible even if ``sentinel`` is returned (i.e. in case of
incorrect decryption).
.. __: https://dx.doi.org/10.1007/BFb0055716
z/Ciphertext with incorrect length (not %d bytes)r r N) r r. r r r _decryptr bytes bytearrayr r )
r
ciphertextr r r3 ct_intr8 r r sizes
r decryptzPKCS115_Cipher.decrypt s V
I # # % % z??a NQR RSS S z** ""6** 5!
$
$ y||$$!! %S]]Q%6%6 S/6BBDaxx dee}$ R?FCCdee} r N)r ) __name__
__module__ __qualname____doc__r" r$ r( r: rB r r r r 7 sw V V " " " ' ' '' ' ', , ,\E E E E E E r Nc > | t j }t | | S )a Create a cipher for performing PKCS#1 v1.5 encryption or decryption.
:param key:
The key to use to encrypt or decrypt the message. This is a `Crypto.PublicKey.RSA` object.
Decryption is only possible if *key* is a private RSA key.
:type key: RSA key object
:param randfunc:
Function that return random bytes.
The default is :func:`Crypto.Random.get_random_bytes`.
:type randfunc: callable
:returns: A cipher object `PKCS115_Cipher`.
)r get_random_bytesr )r r! s r r r s" * #x ( ((r )N)__all__Cryptor Crypto.Util.numberr r Crypto.Util.py3compatr r r
Crypto.Util._raw_apir r r
r r r r rG r r rO s . "
# ; ; ; ; ; ; ; ; = = = = = = = = = =/ / / / / / / / / / .-.K
M M M M M M M M `) ) ) ) ) )r