
    ,h                     B    d Z dgZddlmZ ddlmZ  G d de      Zd Zy)z
OpenPGP mode.
OpenPgpMode    )_copy_bytes)get_random_bytesc                   "    e Zd ZdZd Zd Zd Zy)r   az  OpenPGP mode.

    This mode is a variant of CFB, and it is only used in PGP and
    OpenPGP_ applications. If in doubt, use another mode.

    An Initialization Vector (*IV*) is required.

    Unlike CFB, the *encrypted* IV (not the IV itself) is
    transmitted to the receiver.

    The IV is a random data block. For legacy reasons, two of its bytes are
    duplicated to act as a checksum for the correctness of the key, which is now
    known to be insecure and is ignored. The encrypted IV is therefore 2 bytes
    longer than the clean IV.

    .. _OpenPGP: http://tools.ietf.org/html/rfc4880

    :undocumented: __init__
    c                    |j                   | _         d| _         |j                  ||j                  fd| j                   z  | j                   dz  d|}t	        d d |      }t        |      | j                   k(  r|j                  ||dd  z         | _        n^t        |      | j                   dz   k(  r|| _        |j                  |      d d }n't        d| j                   | j                   dz   fz        |x| _
        | _         |j                  ||j                  f| j                  | j                    d  | j                   dz  d|| _        y )NF       )IVsegment_size   z4Length of IV must be %d or %d bytes for MODE_OPENPGP)
block_size_done_first_blocknewMODE_CFBr   lenencrypt_encrypted_IVdecrypt
ValueErrorivr
   _cipher)selffactorykeyr   cipher_params	IV_ciphers         ]/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/Crypto/Cipher/_mode_openpgp.py__init__zOpenPgpMode.__init__=   si    ",,!&  GKK(() #T__4%)__q%8	)
 ()	 tR( r7doo%!*!2!2223<!@DW!++!#D ""2&s+B 1 $11DEF G G $' #w{{#,,-  $114??2B2CD)-1)<	-
 ,-    c                     | j                   j                  |      }| j                  s| j                  |z   }d| _        |S )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.

        :Return:
            the encrypted data, as a byte string.
            It is as long as *plaintext* with one exception:
            when encrypting the first message chunk,
            the encypted IV is prepended to the returned ciphertext.
        T)r   r   r   r   )r   	plaintextress      r   r   zOpenPgpMode.encryptg   s>    > ll""9-%%$$s*C%)D"
r    c                 8    | j                   j                  |      S )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.

        :Return: the decrypted data (byte string).
        )r   r   )r   
ciphertexts     r   r   zOpenPgpMode.decrypt   s    6 ||##J//r    N)__name__
__module____qualname____doc__r   r   r    r    r   r   r   (   s    ((-T#J0r    c                 4   |j                  dd      }|j                  dd      }d||fk(  rt        | j                        }||t        d      |}	 |j                  d      }t        | |||      S # t        $ r}t        dt        |      z         d}~ww xY w)a#  Create a new block cipher, configured in OpenPGP mode.

    :Parameters:
      factory : module
        The module.

    :Keywords:
      key : bytes/bytearray/memoryview
        The secret key to use in the symmetric cipher.

      IV : bytes/bytearray/memoryview
        The initialization vector to use for encryption or decryption.

        For encryption, the IV must be as long as the cipher block size.

        For decryption, it must be 2 bytes longer (it is actually the
        *encrypted* IV which was prefixed to the ciphertext).
    r
   Nr   )NNz*You must either use 'iv' or 'IV', not bothr   zMissing component: )popr   r   	TypeErrorKeyErrorstrr   )r   kwargsr   r
   r   es         r   _create_openpgp_cipherr2      s    ( 
D$	B	D$	BBxg001	~>HII8jj wR00  8-A6778s   A2 2	B;BBN)	r)   __all__Crypto.Util.py3compatr   Crypto.Randomr   objectr   r2   r*   r    r   <module>r7      s-   > / - *0& 0D$1r    