
    gk                     B   d Z ddl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 G d dej2                        Z G d dej6                  ej8                        Zy)zIECDSA (ES256) verifier and signer that use the ``cryptography`` library.
    )utilsN)backends)hashes)serialization)ec)padding)decode_dss_signature)encode_dss_signature)_helpers)bases   -----BEGIN CERTIFICATE-----c                   j    e Zd ZdZd Z ej                  ej                        d        Z	e
d        Zy)ES256VerifierzVerifies ECDSA cryptographic signatures using public keys.

    Args:
        public_key (
                cryptography.hazmat.primitives.asymmetric.ec.ECDSAPublicKey):
            The public key used to verify signatures.
    c                     || _         y N)_pubkey)self
public_keys     T/var/www/django_project/virt/lib/python3.12/site-packages/google/auth/crypt/es256.py__init__zES256Verifier.__init__/   s	    !    c                    t        j                  |      }t        |      dk7  ryt        j                         rt        j                  |d d d      nt        j                  |d d d      }t        j                         rt        j                  |dd  d      nt        j                  |dd  d      }t        ||      }t        j                  |      }	 | j                  j                  ||t        j                  t        j                                      y# t        t         j"                  j$                  f$ r Y yw xY w)N@   F    big	byteorderT)r   to_byteslenis_python_3int
from_bytesr   int_from_bytesr
   r   verifyr   ECDSAr   SHA256
ValueErrorcryptography
exceptionsInvalidSignature)r   message	signature	sig_bytesrsasn1_sigs          r   r#   zES256Verifier.verify2   s    %%i0	y>R ##% NN9Sb>UN;%%inF 	
 ##% NN9RS>UN;%%inF 	

 (1-##G,	LL'288FMMO3LML33DDE 		s   AD #E ?E c                     t        j                  |      }t        |v r5t        j                  j                  |t              }|j                         }nt        j                  |t              } | |      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.
        )
r   r   _CERTIFICATE_MARKERr'   x509load_pem_x509_certificate_BACKENDr   r   load_pem_public_key)clsr   public_key_datacertpubkeys        r   from_stringzES256Verifier.from_stringK   sc     #++J7/1$$>>D __&F #66QF6{r   N)__name__
__module____qualname____doc__r   r   copy_docstringr   Verifierr#   classmethodr:    r   r   r   r   &   sE    " XT]]+ ,0  r   r   c                       e Zd ZdZd	dZe ej                  ej                        d               Z
 ej                  ej                        d        Zed	d       Zd Zd Zy)
ES256Signera  Signs messages with an ECDSA private key.

    Args:
        private_key (
                cryptography.hazmat.primitives.asymmetric.ec.ECDSAPrivateKey):
            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.
    Nc                      || _         || _        y r   )_key_key_id)r   private_keykey_ids      r   r   zES256Signer.__init__t   s    	r   c                     | j                   S r   )rG   )r   s    r   rI   zES256Signer.key_idx   s     ||r   c                    t        j                  |      }| j                  j                  |t	        j
                  t        j                                     }t        |      \  }}t        j                         r'|j                  dd      |j                  dd      z   S t        j                  |d      t        j                  |d      z   S )Nr   r   r   )r   r   rF   signr   r$   r   r%   r	   r   r   int_to_bytes)r   r*   asn1_signaturer-   r.   s        r   rL   zES256Signer.sign}   s    ##G,&--/1JK &n5A ##% ZZeZ,qzz"z/NN	
 $$Q+e.@.@B.GG	
r   c                 x    t        j                  |      }t        j                  |dt              } | ||      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backend)rI   )r   r   r   load_pem_private_keyr4   )r6   keyrI   rH   s       r   r:   zES256Signer.from_string   s:    $ $#88$
 ;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ES256Signer.__getstate__   sb    ""$		//"++// ..44!.!;!;!= 0 
f
 r   c                 r    t        j                  |d   d      |d<   | j                  j                  |       y)z3Pickle helper that deserializes the _key attribute.rF   N)r   rR   rX   updater`   s     r   __setstate__zES256Signer.__setstate__   s.    %::5=$OfU#r   r   )r;   r<   r=   r>   r   propertyr   r?   r   SignerrI   rL   rA   r:   rb   re   rB   r   r   rD   rD   h   s|    	 XT[[) *  XT[[)

 *

 / /.$r   rD   )r>   r'   r   cryptography.exceptionscryptography.hazmatr   cryptography.hazmat.primitivesr   r   )cryptography.hazmat.primitives.asymmetricr   r   /cryptography.hazmat.primitives.asymmetric.utilsr	   r
   cryptography.x509google.authr   google.auth.cryptr   r1   default_backendr4   PKCS1v15_PADDINGr@   r   rg   FromServiceAccountMixinrD   rB   r   r   <module>rt      s      ( 1 8 8 = P P    " 5 #8##%7?DMM ?DG$$++t;; G$r   