Ë
|
¬`iM? ã ó d Z dgZddlZddlmZmZmZmZmZm Z m
|
Z
|
m Z ddl m Z ddlmZmZ ddlmZ edd « Z G d
|
de« Zd Zy) z
|
Counter (CTR) mode.
|
ÚCtrModeé N)Úload_pycryptodome_raw_libÚ VoidPointerÚcreate_string_bufferÚget_raw_bufferÚ SmartPointerÚc_size_tÚ c_uint8_ptrÚis_writeable_buffer)Úget_random_bytes)Ú _copy_bytesÚ is_native_int)Ú long_to_byteszCrypto.Cipher._raw_ctra¾
|
int CTR_start_operation(void *cipher,
|
uint8_t initialCounterBlock[],
|
size_t initialCounterBlock_len,
|
size_t prefix_len,
|
unsigned counter_len,
|
unsigned littleEndian,
|
void **pResult);
|
int CTR_encrypt(void *ctrState,
|
const uint8_t *in,
|
uint8_t *out,
|
size_t data_len);
|
int CTR_decrypt(void *ctrState,
|
const uint8_t *in,
|
uint8_t *out,
|
size_t data_len);
|
int CTR_stop_operation(void *ctrState);c ó& e Zd ZdZd ZddZddZy)r a* *CounTeR (CTR)* mode.
|
|
This mode is very similar to ECB, in that
|
encryption of one block is done independently of all other blocks.
|
|
Unlike ECB, the block *position* contributes to the encryption
|
and no information leaks about symbol frequency.
|
|
Each message block is associated to a *counter* which
|
must be unique across all messages that get encrypted
|
with the same key (not just within the same message).
|
The counter is as big as the block size.
|
|
Counters can be generated in several ways. The most
|
straightword one is to choose an *initial counter block*
|
(which can be made public, similarly to the *IV* for the
|
other modes) and increment its lowest **m** bits by one
|
(modulo *2^m*) for each block. In most cases, **m** is
|
chosen to be half the block size.
|
|
See `NIST SP800-38A`_, Section 6.5 (for the mode) and
|
Appendix B (for how to manage the *initial counter block*).
|
|
.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
|
:undocumented: __init__
|
c
|
ó t |« ||z k( rt d||« | _ t « | _ t
|
j |j « t |« t t |« « t |« ||| j j « « }|rt d|z « t | j j « t
|
j « | _ |j « t |« | _ ddg| _ y)aB Create a new block cipher, configured in CTR mode.
|
|
:Parameters:
|
block_cipher : C pointer
|
A smart pointer to the low-level block cipher instance.
|
|
initial_counter_block : bytes/bytearray/memoryview
|
The initial plaintext to use to generate the key stream.
|
|
It is as large as the cipher block, and it embeds
|
the initial value of the counter.
|
|
This value must not be reused.
|
It shall contain a nonce or a random component.
|
Reusing the *initial counter block* for encryptions
|
performed with the same key compromises confidentiality.
|
|
prefix_len : integer
|
The amount of bytes at the beginning of the counter block
|
that never change.
|
|
counter_len : integer
|
The length in bytes of the counter embedded in the counter
|
block.
|
|
little_endian : boolean
|
True if the counter in the counter block is an integer encoded
|
in little endian mode. If False, it is big endian.
|
Nz)Error %X while instantiating the CTR modeÚencryptÚdecrypt)Úlenr Únoncer Ú_stateÚ raw_ctr_libÚCTR_start_operationÚgetr
|
r Ú
|
address_ofÚ
|
ValueErrorr ÚCTR_stop_operationÚreleaseÚ
|
block_sizeÚ_next)ÚselfÚ block_cipherÚinitial_counter_blockÚ
|
prefix_lenÚ counter_lenÚ little_endianÚresults õj H:\项ç®\archive\æµè¯ç»\èæ¬\Change_password\venv_build\Lib\site-packages\Crypto/Cipher/_mode_ctr.pyÚ__init__zCtrMode.__init__Y sò ô@ Ð$Ó %¨°kÑ)AÒ AÜ$ T¨:Ð7LÓMDJØ Aä!m Ü ×0Ñ0° ×1AÑ1AÓ1CÜ1<Ð=RÓ1SÜ19¼#Ð>SÓ:TÓ1UÜ19¸*Ó1EØ1<Ø1>Ø15·±×1GÑ1GÓ1Ió Kñ Ü Ð HØ %ñ &ó 'ð 'ô
|
# 4§;¡;§?¡?Ó#4Ü#.×#AÑ#AóC ð
|
× Ñ Ô ä Ð 3Ó4Ø@à Ð+
|
ó Nc
|
ó d| j vr t d« dg| _ |t t |« « }nF|}t |« s t d« t |« t |« k7 rt dt |« z « t j | j j « t |« t |« t t |« « « }|r |dk( r t d« t d|z « | t |« S y) aõ Encrypt data with the key and the parameters set at initialization.
|
|
A cipher object is stateful: once you have encrypted a message
|
you cannot encrypt (or decrypt) another message using the same
|
object.
|
|
The data to encrypt can be broken up in two or
|
more pieces and `encrypt` can be called multiple times.
|
|
That is, the statement:
|
|
>>> 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()Nú4output must be a bytearray or a writeable memoryviewú9output must have the same length as the input (%d bytes)é ú*The counter has wrapped around in CTR modez%Error %X while encrypting in CTR mode)r Ú TypeErrorr r r r r Ú CTR_encryptr r r
|
r Ú OverflowErrorr )r Ú plaintextÚoutputÚ
|
ciphertextr& s r' r zCtrMode.encrypt s ðB DJJÑ &ÜÐ HÓIÐ IØ [
|
à >Ü-¬c°)«nÓ=Jà Jä& vÔ.Ü Ð VÓWÐWä9~¤ V£Ò,Ü ð "0Ü25°i³.ñ"Aó Bð Bô ×(Ñ(¨¯©¯ © Ó):Ü)4°YÓ)?Ü)4°ZÓ)@Ü)1´#°i³.Ó)AóCñ ØÒ Ü#ð %0ó 1ð 1ä Ð DÀvÑ MÓNÐ Nà >Ü! *Ó-Ð -àr) c
|
ó d| j vr t d« dg| _ |t t |« « }nF|}t |« s t d« t |« t |« k7 rt dt |« z « t j | j j « t |« t |« t t |« « « }|r |dk( r t d« t d|z « | t |« S y) 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, r- r. z%Error %X while decrypting in CTR mode)r r/ r r r r r Ú CTR_decryptr r r
|
r r1 r )r r4 r3 r2 r& s r' r zCtrMode.decrypt× s ðB DJJÑ &ÜÐ HÓIÐ IØ [
|
à >Ü,¬S°«_Ó=Ià Iä& vÔ.Ü Ð VÓWÐWä:¤# f£+Ò-Ü ð "0Ü25°i³.ñ"Aó Bð Bô ×(Ñ(¨¯©¯ © Ó):Ü)4°ZÓ)@Ü)4°YÓ)?Ü)1´#°j³/Ó)BóDñ ØÒ Ü#ð %0ó 1ð 1ä Ð DÀvÑ MÓNÐ Nà >Ü! )Ó,Ð ,àr) )N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r( r r © r) r' r r < s ñò8<,ó|>ô@>r) c ób | j |« }|j dd« }|j dd« }|j dd« }|rt dt |« z « |||fdk7 r t d« |ì|3| j dk r t d « t | j d
|
z « }n#t |« | j k\ r t d « | j t |« z
|
}|d }t |« r)d |dz z d z
|
|k r t d« |t ||« z }n,t |« |k7 rt dt |« |fz « ||z }t ||t |« |d« S t |« } |j d« }|j d« } |j d« }
|
|j d« }|j d« } g } |d kD r3| j t j d|dz « « |dz }|d kD r3| dgt! d |t | « z
|
« z z } | s| j# « | dj% | « z |
|
z }t |« | j k7 r#t dt |« | j fz « t ||t | « || « S # t $ r t d« w xY w) a4 Instantiate a cipher object that performs CTR encryption/decryption.
|
|
:Parameters:
|
factory : module
|
The underlying block cipher, a module from ``Crypto.Cipher``.
|
|
:Keywords:
|
nonce : bytes/bytearray/memoryview
|
The fixed part at the beginning of the counter block - the rest is
|
the counter number that gets increased when processing the next block.
|
The nonce must be such that no two messages are encrypted under the
|
same key and the same nonce.
|
|
The nonce must be shorter than the block size (it can have
|
zero length; the counter is then as long as the block).
|
|
If this parameter is not present, a random nonce will be created with
|
length equal to half the block size. No random nonce shorter than
|
64 bits will be created though - you must really think through all
|
security consequences of using such a short block size.
|
|
initial_value : posive integer or bytes/bytearray/memoryview
|
The initial value for the counter. If not present, the cipher will
|
start counting from 0. The value is incremented by one for each block.
|
The counter number is encoded in big endian mode.
|
|
counter : object
|
Instance of ``Crypto.Util.Counter``, which allows full customization
|
of the counter block. This parameter is incompatible to both ``nonce``
|
and ``initial_value``.
|
|
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).
|
ÚcounterNr Ú initial_valuez#Invalid parameters for CTR mode: %s)NNz<'counter' and 'nonce'/'initial_value' are mutually exclusiveé z7Impossible to create a safe nonce for short block sizesé zNonce is too longr é é z"Initial counter value is too largez@Incorrect length for counter byte string (%d bytes, expected %d)Fr$ ÚprefixÚsuffixr% z6Incorrect counter object (use Crypto.Util.Counter.new)ÚBéÿ ó r) z?Size of the counter block (%d bytes) must match block size (%d))Ú_create_base_cipherÚpopr/ Ústrr r r r r r r ÚdictÚKeyErrorÚappendÚstructÚpackÚmaxÚreverseÚjoin) ÚfactoryÚkwargsÚ cipher_stater= r r> r$ r" Ú_counterrC rD r% Úwordss r' Ú_create_ctr_cipherrX sý ðJ ×.Ñ.¨vÓ6Làjj DÓ)GØ JJw Ó %EØJJ°Ó5MÙ ÜÐ=ÄÀFà ÑKÓLÐLàÐ }Ð 5¸ Ò EÜð 2ó 3ð 3ð à =Ø×!Ñ! BÒ&Ü ð !/ó 0ð 0ä$ W×%7Ñ%7¸1Ñ%<Ó=Eä5zW× /Ñ /Ò/Ü Ð!4Ó5Ð5ð ×(Ñ(¬3¨u«:Ñ5 à Ð Ø Mä Ô 'Øk AoÑ&¨!Ñ+¨mÒ;Ü Ð!EÓFÐFØ$)¬M¸-ÈÓ,UÑ$UÑ !ä=Ó! [Ò0Ü Ð!cÜ"% mÓ"4°kÐ!Bñ"Có Dð Dà$)¨MÑ$9Ð !ä|Ø,Ü5zØ"Ø ó ð ô G}Hð:Ø ll =Ó1 Ø hÓ'Ø hÓ'Ø _Ó5 Ø _Ó5 ð EØ
|
!Ò
|
Ø V[[ m°cÑ&9Ó:Ô;Ø!Ñ ð !Ó
|
ð
|
gYQ ¬c°%«jÑ 8Ó9Ñ 9Ñ9EÙ Ø Ø " S§X¡X¨e£_Ñ 4°vÑ =Ðä
|
Ð Ó! W×%7Ñ%7Ò7Üð ,Ü/2Ð3HÓ/IØ/6×/AÑ/Að/CñCó Dð Dô <Ð!6Üv; ¨]ó <ð <øô' ò :Üð 9ó :ð :ð:ús Å/AJ ÊJ.)r: Ú__all__rN ÚCrypto.Util._raw_apir r r r r r r
|
r Ú Crypto.Randomr ÚCrypto.Util.py3compatr r ÚCrypto.Util.numberr r Úobjectr rX r; r) r' ú<module>r_ sX ðñ.ð +ã ÷7÷ 7ó 7õ
|
+ß <Ý ,á'Ð(@ð C?ó * ô(Yfô Yóxq<r)
|
