
    ,hu                      d    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y)	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                   &    e Zd ZdZd ZddZddZy)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   |j                   | _         t               | _        t        j	                  |j                         | j                  j                               }|rt        d|z        t        | j                  j                         t        j                        | _        |j                          y)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      Y/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/Crypto/Cipher/_mode_ecb.py__init__zEcbMode.__init__D   s     '11!m001A1A1C151G1G1IKH%& ' ' #4;;??#4#.#A#AC
 	    Nc           
         |t        t        |            }nF|}t        |      st        d      t        |      t        |      k7  rt	        dt        |      z        t
        j                  | j                  j                         t        |      t        |      t        t        |                  }|r|dk(  rt	        d      t	        d|z        |t        |      S y)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)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           
         |t        t        |            }nF|}t        |      st        d      t        |      t        |      k7  rt	        dt        |      z        t
        j                  | j                  j                         t        |      t        |      t        t        |                  }|r|dk(  rt	        d      t	        d|z        |t        |      S y)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_=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   )N)__name__
__module____qualname____doc__r   r(   r+    r   r   r   r   3   s     45n5r   c                     | j                  |      }| j                  |_        |rt        dt        |      z        t	        |      S )aM  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_cipherr7      sE     ..v6L%00L83v;FGG<  r   N)r/   __all__Crypto.Util._raw_apir   r   r   r   r   r	   r
   r   r   objectr   r7   r0   r   r   <module>r;      sK   . -7 7 7 ((@ C * Wf Wt!r   