
    4P@iB                     x   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j6                         Z ej:                         Ze G d d             Z G d dej@                        Z! G d dejD                  ejF                        Z$y)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y	)
_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                 8    | j                  |j                        S N)
from_curvecurve)clsr   s     ^/home/www/lebenam.kofcorporation.com/venv/lib/python3.12/site-packages/google/auth/crypt/es.pyfrom_keyz_ESAttributes.from_key6   s     ~~cii((    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<   s>     eR\\*r6==?G44 r6==?G44r   N)__name__
__module____qualname____doc__int__annotations__r	   HashAlgorithmstrclassmethodr   r   EllipticCurvePublicKeyEllipticCurvePrivateKeyr   EllipticCurver    r   r   r   r   (   sp     L"""N)1123M3MMN) )
 	5r// 	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y)

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                 F    || _         t        j                  |      | _        y r   )_pubkeyr   r   _attributes)selfr7   s     r   __init__zEsVerifier.__init__R   s    !(11*=r   message	signaturec                 P   t        j                  |      }t        |      | j                  j                  dz  k7  ryt
        j                  |d | j                  j                   d      }t
        j                  || j                  j                  d  d      }t        ||      }t        j                  |      }	 | j                  j                  ||t        j                  | j                  j                               y# t        t        j                  j                   f$ r Y y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	y>T--5599NN9%?t'7'7'?'?@ENRNN9T%5%5%=%=%?@ENR'1-##G,	LL'288D<L<L<U<U3VWL33DDE 		s   :AC? ?#D%$D%c                 4   t        j                  |      }t        |v r5t        j                  j                  |t              }|j                         }nt        j                  |t              }t        |t        j                        st        d       | |      S )ay  Construct an 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:
            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/1$$>>D __&F #66QF&"";";<PQQ6{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                   b   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y)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    || _         || _        t        j                  |      | _        y 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                 l   t        j                  |      }| j                  j                  |t	        j
                  | j                  j                              }t        |      \  }}|j                  | j                  j                  d      |j                  | 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:J:S:S1TU &n5Azz$**22ezDqzz$$ HR 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   sV    ( %%c*	#88h
 +r'A'ABRSS;v..r   c                     | j                   j                         }| 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__   sb    ""$		//"++// ..44!.!;!;!= 0 
f
 r   r   c                 r    t        j                  |d   d      |d<   | j                  j                  |       y)z3Pickle helper that deserializes the _key attribute.rf   N)r
   rq   rw   updater   s     r   __setstate__zEsSigner.__setstate__   s.    %::5=$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5??G}?	? *3 * * XT[[)  *  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 8 8 = P P    " 5 #8##%7 5 5 5@; ;|V$t{{D88 V$r   