
    iS                     l   d Z ddlmZ ddlmZmZmZmZ ddlZ	ddl
mZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlZ	ddlmZ ddlmZ dZ ej                    Z ej                    Ze G d d                      Z G d dej                   Z! G d dej"        ej#                  Z$dS )zAECDSA verifier and signer that use the ``cryptography`` library.
    )	dataclass)AnyDictOptionalUnionN)backends)hashes)serialization)ec)padding)decode_dss_signature)encode_dss_signature)_helpers)bases   -----BEGIN CERTIFICATE-----c                       e Zd ZU dZeed<   ej        ed<   eed<   e	de
ej        ej        f         fd            Ze	dej        fd            Zd	S )
_ESAttributeszA class that models ECDSA attributes.

    Attributes:
        rs_size (int): Size for ASN.1 r and s size.
        sha_algo (hashes.HashAlgorithm): Hash algorithm.
        algorithm (str): Algorithm name.
    rs_sizesha_algo	algorithmkeyc                 6    |                      |j                  S N)
from_curvecurve)clsr   s     O/root/projects/butler/venv/lib/python3.11/site-packages/google/auth/crypt/es.pyfrom_keyz_ESAttributes.from_key6   s     ~~ci(((    r   c                     t          |t          j                  r | dt          j                    d          S  | dt          j                    d          S )N0   ES384    ES256)
isinstancer   	SECP384R1r	   SHA384SHA256)r   r   s     r   r   z_ESAttributes.from_curve<   sN     eR\** 	53r6=??G444 3r6=??G444r   N)__name__
__module____qualname____doc__int__annotations__r	   HashAlgorithmstrclassmethodr   r   EllipticCurvePublicKeyEllipticCurvePrivateKeyr   EllipticCurver    r   r   r   r   (   s           LLL""""NNN)123MMN) ) ) [)
 	5r/ 	5 	5 	5 [	5 	5 	5r   r   c                       e Zd ZdZdej        ddfdZ ej        e	j
                  dededefd            Zedeeef         dd fd	            ZdS )

EsVerifierzVerifies ECDSA cryptographic signatures using public keys.

    Args:
        public_key (
                cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePublicKey):
            The public key used to verify signatures.
    
public_keyreturnNc                 R    || _         t                              |          | _        d S r   )_pubkeyr   r   _attributes)selfr7   s     r   __init__zEsVerifier.__init__R   s%    !(11*==r   message	signaturec                 (   t          j        |          }t          |          | j        j        dz  k    rdS t
                              |d | j        j                 d          }t
                              || j        j        d          d          }t          ||          }t          j        |          }	 | j        	                    ||t          j        | j        j                             dS # t          t          j        j        f$ r Y dS w xY w)N   Fbig	byteorderT)r   to_byteslenr;   r   r,   
from_bytesr   r:   verifyr   ECDSAr   
ValueErrorcryptography
exceptionsInvalidSignature)r<   r>   r?   	sig_bytesrsasn1_sigs          r   rH   zEsVerifier.verifyV   s    %i00	y>>T-59995NN9%?t'7'?%?@ENRRNN9T%5%=%?%?@ENRR'1--#G,,	L'28D<L<U3V3VWWW4L3DE 	 	 	55	s   88C2 2DDc                 L   t          j        |          }t          |v r:t          j                            |t                    }|                                }nt          j	        |t                    }t          |t          j                  st          d           | |          S )a  Construct a Verifier instance from a public key or public
        certificate string.

        Args:
            public_key (Union[str, bytes]): The public key in PEM format or the
                x509 public key certificate.

        Returns:
            google.auth.crypt.Verifier: The constructed verifier.

        Raises:
            ValueError: If the public key can't be parsed.
        z2Expected public key of type EllipticCurvePublicKey)r   rE   _CERTIFICATE_MARKERrK   x509load_pem_x509_certificate_BACKENDr7   r
   load_pem_public_keyr$   r   r1   	TypeError)r   r7   public_key_datacertpubkeys        r   from_stringzEsVerifier.from_stringg   s     #+J77/11$>> D __&&FF #6QQF&"";<< 	RPQQQs6{{r   )r(   r)   r*   r+   r   r1   r=   r   copy_docstringr   VerifierbytesboolrH   r0   r   r/   r\   r4   r   r   r6   r6   I   s         >2#< > > > > > XT]++e  $    ,+  U3:%6 <    [  r   r6   c                      e Zd ZdZ	 ddej        dee         ddfdZe	defd            Z
e	 ej        ej                  dee         fd                        Z ej        ej                  d	edefd
            Ze	 ddeeef         dee         dd fd            Zdeeef         fdZdeeef         ddfdZdS )EsSignera  Signs messages with an ECDSA private key.

    Args:
        private_key (
                cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePrivateKey):
            The private key to sign with.
        key_id (str): Optional key ID used to identify this private key. This
            can be useful to associate the private key with its associated
            public key or certificate.
    Nprivate_keykey_idr8   c                 `    || _         || _        t                              |          | _        d S r   )_key_key_idr   r   r;   )r<   rc   rd   s      r   r=   zEsSigner.__init__   s.      	(11+>>r   c                     | j         j        S )zkName of the algorithm used to sign messages.
        Returns:
            str: The algorithm name.
        )r;   r   r<   s    r   r   zEsSigner.algorithm   s     ))r   c                     | j         S r   )rg   ri   s    r   rd   zEsSigner.key_id   s     |r   r>   c                 B   t          j        |          }| j                            |t	          j        | j        j                            }t          |          \  }}|                    | j        j	        d          |                    | j        j	        d          z   S )NrB   rC   )
r   rE   rf   signr   rI   r;   r   r   r   )r<   r>   asn1_signaturerO   rP   s        r   rl   zEsSigner.sign   s    #G,,$:J:S1T1TUU &n55Azz$*2ezDDqzz$ HR H
 H
 
 	
r   r   c                     t          j        |          }t          j        |dt                    }t          |t          j                  st          d           | ||          S )al  Construct a RSASigner from a private key in PEM format.

        Args:
            key (Union[bytes, str]): Private key in PEM format.
            key_id (str): An optional key id used to identify the private key.

        Returns:
            google.auth.crypt._cryptography_rsa.RSASigner: The
            constructed signer.

        Raises:
            ValueError: If ``key`` is not ``bytes`` or ``str`` (unicode).
            UnicodeDecodeError: If ``key`` is ``bytes`` but cannot be decoded
                into a UTF-8 ``str``.
            ValueError: If ``cryptography`` "Could not deserialize key data."
        N)passwordbackendz4Expected private key of type EllipticCurvePrivateKey)rd   )	r   rE   r
   load_pem_private_keyrV   r$   r   r2   rX   )r   r   rd   	key_bytesrc   s        r   r\   zEsSigner.from_string   sn    ( %c**	#8h
 
 
 +r'ABB 	TRSSSs;v....r   c                     | j                                         }| j                            t          j        j        t          j        j        t	          j	                              |d<   |S )z1Pickle helper that serializes the _key attribute.)encodingformatencryption_algorithmrf   )
__dict__copyrf   private_bytesr
   EncodingPEMPrivateFormatPKCS8NoEncryptionr<   states     r   __getstate__zEsSigner.__getstate__   sZ    ""$$	//"+/ .4!.!;!=!= 0 
 
f
 r   r   c                 v    t          j        |d         d          |d<   | j                            |           dS )z3Pickle helper that deserializes the _key attribute.rf   N)r
   rq   rw   updater   s     r   __setstate__zEsSigner.__setstate__   s8    %:5=$OOfU#####r   r   )r(   r)   r*   r+   r   r2   r   r/   r=   propertyr   r   r]   r   Signerrd   r_   rl   r0   r   r\   r   r   r   r   r4   r   r   rb   rb      s       	 	 PT? ?5??G}?	? ? ? ? *3 * * * X* XT[))    *) X XT[))
E 
e 
 
 
 *)
 =A/ /s
#/-5c]/	/ / / [/:d38n    $$sCx. $T $ $ $ $ $ $r   rb   )%r+   dataclassesr   typingr   r   r   r   cryptography.exceptionsrK   cryptography.hazmatr   cryptography.hazmat.primitivesr	   r
   )cryptography.hazmat.primitives.asymmetricr   r   /cryptography.hazmat.primitives.asymmetric.utilsr   r   cryptography.x509google.authr   google.auth.cryptr   rS   default_backendrV   PKCS1v15_PADDINGr   r^   r6   r   FromServiceAccountMixinrb   r4   r   r   <module>r      s    " ! ! ! ! ! - - - - - - - - - - - -     ( ( ( ( ( ( 1 1 1 1 1 1 8 8 8 8 8 8 8 8 8 8 8 8 = = = = = = P P P P P P P P P P P P                 " " " " " " 5 #8#%%7 5 5 5 5 5 5 5 5@; ; ; ; ; ; ; ;|V$ V$ V$ V$ V$t{D8 V$ V$ V$ V$ V$r   