
    ¿ig                      r    d Z dgZddlmZmZmZmZmZmZm	Z	m
Z
  edd          Z G d de          Zd ZdS )	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Cryptodome.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                   (    e Zd ZdZd ZddZddZdS )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                    |j         | _         t                      | _        t                              |                                | j                                                  }|rt          d|z            t          | j                                        t          j	                  | _        |
                                 dS )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      W/var/www/html/afkarena/venv/lib/python3.11/site-packages/Cryptodome/Cipher/_mode_ecb.py__init__zEcbMode.__init__D   s     '1!mm001A1A1C1C151G1G1I1IK K 	'H%& ' ' ' #4;??#4#4#.#AC C
 	    Nc           
      F   |t          t          |                    }n_|}t          |          st          d          t          |          t          |          k    rt	          dt          |          z            t
                              | j                                        t          |          t          |          t          t          |                              }|r'|dk    rt	          d          t	          d|z            |t          |          S dS )ab  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   encryptzEcbMode.encrypt^   s    : >-c)nn==JJJ&v.. X VWWW9~~V,,  "025i.."A B B B (():):)4Y)?)?)4Z)@)@)1#i..)A)AC C  	O{{ !UVVVDvMNNN>!*---4r   c           
      F   |t          t          |                    }n_|}t          |          st          d          t          |          t          |          k    rt	          dt          |          z            t
                              | j                                        t          |          t          |          t          t          |                              }|r'|dk    rt	          d          t	          d|z            |t          |          S dS )ae  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   decryptzEcbMode.decrypt   s    : >,S__==III&v.. X VWWW:#f++--  "025i.."A B B B (():):)4Z)@)@)4Y)?)?)1#j//)B)BD D  	O{{ !UVVVDvMNNN>!),,,4r   )N)__name__
__module____qualname____doc__r   r(   r+    r   r   r   r   3   sV            45 5 5 5n5 5 5 5 5 5r   c                     |                      |          }| j        |_        |rt          dt          |          z            t	          |          S )aQ  Instantiate a cipher object that performs ECB encryption/decryption.

    :Parameters:
      factory : module
        The underlying block cipher, a module from ``Cryptodome.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_cipherr7      sS     ..v66L%0L H83v;;FGGG<   r   N)r/   __all__Cryptodome.Util._raw_apir   r   r   r   r   r	   r
   r   r   objectr   r7   r0   r   r   <module>r;      s   .  -7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 ('(D G * * W W W W Wf W W Wt! ! ! ! !r   