f'mlK d Z dgZddlmZ ddlmZmZmZmZm Z m
Z
m Z m Z ddl
mZ edd Z G d de Zd Zd
S ) z
Counter Feedback (CFB) mode.
CfbMode ) _copy_bytes)load_pycryptodome_raw_lib VoidPointercreate_string_bufferget_raw_buffer SmartPointerc_size_t c_uint8_ptris_writeable_buffer)get_random_byteszCrypto.Cipher._raw_cfba
int CFB_start_operation(void *cipher,
const uint8_t iv[],
size_t iv_len,
size_t segment_len, /* In bytes */
void **pResult);
int CFB_encrypt(void *cfbState,
const uint8_t *in,
uint8_t *out,
size_t data_len);
int CFB_decrypt(void *cfbState,
const uint8_t *in,
uint8_t *out,
size_t data_len);
int CFB_stop_operation(void *state);c ( e Zd ZdZd ZddZddZdS )r a *Cipher FeedBack (CFB)*.
This mode is similar to CFB, but it transforms
the underlying block cipher into a stream cipher.
Plaintext and ciphertext are processed in *segments*
of **s** bits. The mode is therefore sometimes
labelled **s**-bit CFB.
An Initialization Vector (*IV*) is required.
See `NIST SP800-38A`_ , Section 6.3.
.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
:undocumented: __init__
c b t | _ t | t | t
t | t
| | j }|rt d|z t | j t j | _ | t | | _
t dd| | _ | j | _ ddg| _ dS )a Create a new block cipher, configured in CFB mode.
:Parameters:
block_cipher : C pointer
A smart pointer to the low-level block cipher instance.
iv : bytes/bytearray/memoryview
The initialization vector to use for encryption or decryption.
It is as long as the cipher block.
**The IV must be unpredictable**. Ideally it is picked randomly.
Reusing the *IV* for encryptions performed with the same key
compromises confidentiality.
segment_size : integer
The number of bytes the plaintext and ciphertext are segmented in.
z)Error %d while instantiating the CFB modeNencryptdecrypt)r _state raw_cfb_libCFB_start_operationgetr r
len
address_of
ValueErrorr CFB_stop_operationrelease
block_sizer ivIV_next)self block_cipherr segment_sizeresults y/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib64/python3.11/site-packages/Crypto/Cipher/_mode_cfb.py__init__zCfbMode.__init__J s ( "mm 00 1A1A1C1C1>> c.encrypt(a) + c.encrypt(b)
is equivalent to:
>>> c.encrypt(a+b)
This function does not add any padding to the plaintext.
:Parameters:
plaintext : bytes/bytearray/memoryview
The piece of data to encrypt.
It can be of any length.
:Keywords:
output : bytearray/memoryview
The location where the ciphertext must be written to.
If ``None``, the ciphertext is returned.
:Return:
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
Otherwise, ``None``.
r z*encrypt() cannot be called after decrypt()N4output must be a bytearray or a writeable memoryview9output must have the same length as the input (%d bytes)z%Error %d while encrypting in CFB mode)
r TypeErrorr r r r r CFB_encryptr r r r
r )r plaintextoutput
ciphertextr" s r# r zCfbMode.encrypt| s. B DJ & & HII I [
>-c)nn==JJ J&v..
X VWWW9~~V,, "025i.."A B B B (( ):):)4Y)?)?)4Z)@)@)1#i..)A)AC C O Dv MNN N >!*-- -4r% c
\ d| j vrt d dg| _ | t t | }n_|}t | st d t | t | k r t dt | z t | j t | t | t t | }|rt d|z |t | S dS )a Decrypt data with the key and the parameters set at initialization.
A cipher object is stateful: once you have decrypted a message
you cannot decrypt (or encrypt) another message with the same
object.
The data to decrypt can be broken up in two or
more pieces and `decrypt` can be called multiple times.
That is, the statement:
>>> c.decrypt(a) + c.decrypt(b)
is equivalent to:
>>> c.decrypt(a+b)
This function does not remove any padding from the plaintext.
:Parameters:
ciphertext : bytes/bytearray/memoryview
The piece of data to decrypt.
It can be of any length.
:Keywords:
output : bytearray/memoryview
The location where the plaintext must be written to.
If ``None``, the plaintext is returned.
:Return:
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
Otherwise, ``None``.
r z*decrypt() cannot be called after encrypt()Nr' r( z%Error %d while decrypting in CFB mode)
r r) r r r r r CFB_decryptr r r r
r )r r- r, r+ r" s r# r zCfbMode.decrypt s. B DJ & & HII I [
>,S__==II I&v..
X VWWW:#f++-- "025i.."A B B B (( ):):)4Z)@)@)4Y)?)?)1#j//)B)BD D O Dv MNN N >!),, ,4r% )N)__name__
__module__ __qualname____doc__r$ r r r% r# r r 7 sW $0, 0, 0,d; ; ; ;z; ; ; ; ; ;r% c . | | }| dd }| dd }d||fk rt | j }||t d n|}t | | j k rt
d| j z t | dd d \ }}|d k s|d k rt
d
|r t d t | z t ||| S ) a Instantiate a cipher object that performs CFB encryption/decryption.
:Parameters:
factory : module
The underlying block cipher, a module from ``Crypto.Cipher``.
:Keywords:
iv : bytes/bytearray/memoryview
The IV to use for CFB.
IV : bytes/bytearray/memoryview
Alias for ``iv``.
segment_size : integer
The number of bit the plaintext and ciphertext are segmented in.
If not present, the default is 8.
Any other keyword will be passed to the underlying block cipher.
See the relevant documentation for details (at least ``key`` will need
to be present).
r Nr )NNz*You must either use 'iv' or 'IV', not bothz.Incorrect IV length (it must be %d bytes long)r! r z6'segment_size' must be positive and multiple of 8 bitsz Unknown parameters for CFB: %s)
_create_base_cipherpopr
r r) r r divmodstrr )factorykwargs cipher_stater r segment_size_bytesrems r# _create_cfb_cipherr@ s2 . ..v66L D$ B D$ BBx
g 0
1
1 ~
> HII I
2ww'$$$I"# $ $ $ %VZZ%B%BA F FQ #((QRRR
H83v;;FGGG <%7 8 88r% N)r3 __all__Crypto.Util.py3compatr Crypto.Util._raw_apir r r r r r
r r
Crypto.Randomr
r objectr r@ r4 r% r# rF s . + - - - - - -7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
+ * * * * *''(@ B< $} } } } }f } } }@.9 .9 .9 .9 .9r%