
    iu                      d    S r S/rSSKJrJrJrJrJrJrJ	r	J
r
  \" SS5      r " S S\5      rS rg)	z"
Electronic Code Book (ECB) mode.
EcbMode    )load_pycryptodome_raw_libVoidPointercreate_string_bufferget_raw_bufferSmartPointerc_size_tc_uint8_ptris_writeable_bufferzCrypto.Cipher._raw_ecbak  
                    int ECB_start_operation(void *cipher,
                                            void **pResult);
                    int ECB_encrypt(void *ecbState,
                                    const uint8_t *in,
                                    uint8_t *out,
                                    size_t data_len);
                    int ECB_decrypt(void *ecbState,
                                    const uint8_t *in,
                                    uint8_t *out,
                                    size_t data_len);
                    int ECB_stop_operation(void *state);
                    c                   2    \ rS rSrSrS rSS jrSS jrSrg)	r   3   a  *Electronic Code Book (ECB)*.

This is the simplest encryption mode. Each of the plaintext blocks
is directly encrypted into a ciphertext block, independently of
any other block.

This mode is dangerous because it exposes frequency of symbols
in your plaintext. Other modes (e.g. *CBC*) should be used instead.

See `NIST SP800-38A`_ , Section 6.1.

.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf

:undocumented: __init__
c                 t   UR                   U l         [        5       U l        [        R	                  UR                  5       U R                  R                  5       5      nU(       a  [        SU-  5      e[        U R                  R                  5       [        R                  5      U l        UR                  5         g)zCreate a new block cipher, configured in ECB mode.

:Parameters:
  block_cipher : C pointer
    A smart pointer to the low-level block cipher instance.
z)Error %d while instantiating the ECB modeN)
block_sizer   _stateraw_ecb_libECB_start_operationget
address_of
ValueErrorr   ECB_stop_operationrelease)selfblock_cipherresults      R/var/www/html/trading/venv/lib/python3.13/site-packages/Crypto/Cipher/_mode_ecb.py__init__EcbMode.__init__D   s     '11!m001A1A1C151G1G1IKH%& ' ' #4;;??#4#.#A#AC
 	    Nc           
         Uc  [        [        U5      5      nOLUn[        U5      (       d  [        S5      e[        U5      [        U5      :w  a  [	        S[        U5      -  5      e[
        R                  U R                  R                  5       [        U5      [        U5      [        [        U5      5      5      nU(       a  US:X  a  [	        S5      e[	        SU-  5      eUc  [        U5      $ g)a  Encrypt data with the key set at initialization.

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.
    The length must be multiple of the cipher block 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``.
N4output must be a bytearray or a writeable memoryview9output must have the same length as the input  (%d bytes)   2Data must be aligned to block boundary in ECB modez%Error %d while encrypting in ECB mode)r   lenr   	TypeErrorr   r   ECB_encryptr   r   r
   r	   r   )r   	plaintextoutput
ciphertextr   s        r   encryptEcbMode.encrypt^   s    : >-c)n=JJ&v.. VWW9~V,  "025i."A B B (():)4Y)?)4Z)@)1#i.)AC { !UVVDvMNN>!*--r   c           
         Uc  [        [        U5      5      nOLUn[        U5      (       d  [        S5      e[        U5      [        U5      :w  a  [	        S[        U5      -  5      e[
        R                  U R                  R                  5       [        U5      [        U5      [        [        U5      5      5      nU(       a  US:X  a  [	        S5      e[	        SU-  5      eUc  [        U5      $ g)a  Decrypt data with the key set at initialization.

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.
    The length must be multiple of the cipher block 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``.
Nr    r!   r"   r#   z%Error %d while decrypting in ECB mode)r   r$   r   r%   r   r   ECB_decryptr   r   r
   r	   r   )r   r)   r(   r'   r   s        r   decryptEcbMode.decrypt   s    : >,S_=II&v.. VWW:#f+-  "025i."A B B (():)4Z)@)4Y)?)1#j/)BD { !UVVDvMNN>!),,r   )r   r   )N)	__name__
__module____qualname____firstlineno____doc__r   r*   r.   __static_attributes__ r   r   r   r   3   s     45n5r   c                     U R                  U5      nU R                  Ul        U(       a  [        S[        U5      -  5      e[	        U5      $ )a5  Instantiate a cipher object that performs ECB encryption/decryption.

:Parameters:
  factory : module
    The underlying block cipher, a module from ``Crypto.Cipher``.

All keywords are passed to the underlying block cipher.
See the relevant documentation for details (at least ``key`` will need
to be presentzUnknown parameters for ECB: %s)_create_base_cipherr   r%   strr   )factorykwargscipher_states      r   _create_ecb_cipherr=      sE     ..v6L%00L83v;FGG<  r   N)r4   __all__Crypto.Util._raw_apir   r   r   r   r   r	   r
   r   r   objectr   r=   r6   r   r   <module>rA      sK   . -7 7 7 ((@ C * Wf Wt!r   