o
    n~b"                     @   sX   d dl T d dlmZmZmZmZ d dlmZmZm	Z	 ddgZ
		d	ddZd
ddZdS )    )*)DerNullDerSequenceDerObjectIdDerOctetString)PBES1PBES2	PbesErrorwrapunwrapNc           	      C   sr   |du rt  }tdtt||gt| g}| }|du r |S |s&tdt|}|du r0d}t|||||S )a
  Wrap a private key into a PKCS#8 blob (clear or encrypted).

    Args:

      private_key (byte string):
        The private key encoded in binary form. The actual encoding is
        algorithm specific. In most cases, it is DER.

      key_oid (string):
        The object identifier (OID) of the private key to wrap.
        It is a dotted string, like ``1.2.840.113549.1.1.1`` (for RSA keys).

      passphrase (bytes string or string):
        The secret passphrase from which the wrapping key is derived.
        Set it only if encryption is required.

      protection (string):
        The identifier of the algorithm to use for securely wrapping the key.
        The default value is ``PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC``.

      prot_params (dictionary):
        Parameters for the protection algorithm.

        +------------------+-----------------------------------------------+
        | Key              | Description                                   |
        +==================+===============================================+
        | iteration_count  | The KDF algorithm is repeated several times to|
        |                  | slow down brute force attacks on passwords    |
        |                  | (called *N* or CPU/memory cost in scrypt).    |
        |                  | The default value for PBKDF2 is 1000.         |
        |                  | The default value for scrypt is 16384.        |
        +------------------+-----------------------------------------------+
        | salt_size        | Salt is used to thwart dictionary and rainbow |
        |                  | attacks on passwords. The default value is 8  |
        |                  | bytes.                                        |
        +------------------+-----------------------------------------------+
        | block_size       | *(scrypt only)* Memory-cost (r). The default  |
        |                  | value is 8.                                   |
        +------------------+-----------------------------------------------+
        | parallelization  | *(scrypt only)* CPU-cost (p). The default     |
        |                  | value is 1.                                   |
        +------------------+-----------------------------------------------+

      key_params (DER object):
        The algorithm parameters associated to the private key.
        It is required for algorithms like DSA, but not for others like RSA.

      randfunc (callable):
        Random number generation function; it should accept a single integer
        N and return a string of random data, N bytes long.
        If not specified, a new RNG will be instantiated
        from :mod:`Cryptodome.Random`.

    Return:
      The PKCS#8-wrapped private key (possibly encrypted), as a byte string.
    Nr   zEmpty passphrasez"PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC)	r   r   r   r   encode
ValueErrortobytesr   encrypt)	private_keyZkey_oid
passphraseZ
protectionZprot_paramsZ
key_paramsZrandfuncpk_infoZpk_info_der r   >/usr/local/lib/python3.10/dist-packages/Cryptodome/IO/PKCS8.pyr
   2   s*   ;
c           
   
   C   s  |rpt |}d}z
t| |} d}W n" ty* } zdt| }W Y d}~nd}~w ty4   d}Y nw |shz
t| |} d}W n& ty[ } z|dt| 7 }W Y d}~nd}~w tyg   |d7 }Y nw |sptd| t j| d	d
}t	|dkr|std|d dkrtdt j|d dd
}t
 |d j}t	|dkrd}nzt |d  d}W n   |d }Y t |d j}	||	|fS )aH  Unwrap a private key from a PKCS#8 blob (clear or encrypted).

    Args:
      p8_private_key (byte string):
        The private key wrapped into a PKCS#8 blob, DER encoded.
      passphrase (byte string or string):
        The passphrase to use to decrypt the blob (if it is encrypted).

    Return:
      A tuple containing

       #. the algorithm identifier of the wrapped key (OID, dotted string)
       #. the private key (byte string, DER encoded)
       #. the associated parameters (byte string, DER encoded) or ``None``

    Raises:
      ValueError : if decoding fails
    FTz	PBES1[%s]NzPBES1[Invalid]z
,PBES2[%s]z,PBES2[Invalid]zError decoding PKCS#8 (%s))         )Znr_elementsr   z;Not a valid clear PKCS#8 structure (maybe it is encrypted?)r   z#Not a valid PrivateKeyInfo SEQUENCE   )r   r   )r   r   decryptr	   strr   r   r   decodelenr   valuer   r   payload)
Zp8_private_keyr   foundeZ	error_strr   algoZalgo_oidZalgo_paramsr   r   r   r   r      sP   

)NNNNN)N)ZCryptodome.Util.py3compatZCryptodome.Util.asn1r   r   r   r   ZCryptodome.IO._PBESr   r   r	   __all__r
   r   r   r   r   r   <module>   s   "
^