+
    '(ju                      f    R t R.t^ RIHtHtHtHtHtHtH	t	H
t
 ]! RR4      t ! R R]4      tR tR# )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                   >   a  ] tR t^3t o RtR tRR ltRR ltRtV t	R# )r   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                   VP                   V n         \        4       V n        \        P	                  VP                  4       V P                  P                  4       4      pV'       d   \        RV,          4      h\        V P                  P                  4       \        P                  4      V n        VP                  4        R# )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   && L/home/ubuntu/cf-venv/lib/python3.14/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           
        Vf   \        \        V4      4      pMRTp\        V4      '       g   \        R4      h\        V4      \        V4      8w  d   \	        R\        V4      ,          4      h\
        P                  V P                  P                  4       \        V4      \        V4      \        \        V4      4      4      pV'       d%   V^8X  d   \	        R4      h\	        RV,          4      hVf   \        V4      # R# )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           
        Vf   \        \        V4      4      pMRTp\        V4      '       g   \        R4      h\        V4      \        V4      8w  d   \	        R\        V4      ,          4      h\
        P                  V P                  P                  4       \        V4      \        V4      \        \        V4      4      4      pV'       d%   V^8X  d   \	        R4      h\	        RV,          4      hVf   \        V4      # R# )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    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____classdictcell__)__classdict__s   @r   r   r   3   s      45n5 5r   c                    V P                  V4      pV P                  Vn        V'       d   \        R\        V4      ,          4      h\	        V4      # )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)r1   __all__Crypto.Util._raw_apir   r   r   r   r   r   r	   r
   r   objectr   r;    r   r   <module>r@      sK   . -7 7 7 ((@ C * Wf Wt!r   