
    &g                         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ZddlmZ dd	lmZ dd
lmZ dZdZdZdZ e            Zd Z G d dej                  Z G d dej        ej                  ZdS )zPure-Python RSA cryptography implementation.

Uses the ``rsa``, ``pyasn1`` and ``pyasn1_modules`` packages
to parse PEM files storing PKCS#1 or PKCS#8 keys as well as
certificates. There is no support for p12 files.
    )absolute_importN)decoder)pem)Certificate)PrivateKeyInfo)_helpers)
exceptions)base)   @                      s   -----BEGIN CERTIFICATE-----)z-----BEGIN RSA PRIVATE KEY-----z-----END RSA PRIVATE KEY-----)z-----BEGIN PRIVATE KEY-----z-----END PRIVATE KEY-----c                    t          |           }t                      }t          d|d          D ]P}| ||dz            }t          d t	          t
          |          D                       }|                    |           Qt          |          S )zConverts an iterable of 1s and 0s to bytes.

    Combines the list 8 at a time, treating each group of 8 bits
    as a single byte.

    Args:
        bit_list (Sequence): Sequence of 1s and 0s.

    Returns:
        bytes: The decoded bytes.
    r   r   c              3   &   K   | ]\  }}||z  V  d S N ).0valdigits      O/var/www/api/venv/lib/python3.11/site-packages/google/auth/crypt/_python_rsa.py	<genexpr>z%_bit_list_to_bytes.<locals>.<genexpr>;   s*      KKzsEsU{KKKKKK    )len	bytearrayrangesumzip_POW2appendbytes)bit_listnum_bits	byte_valsstart	curr_bitschar_vals         r   _bit_list_to_bytesr+   +   s     8}}HIq(A&& # #UUQY./	KKS	5J5JKKKKK""""r   c                   j    e Zd ZdZd Z ej        ej                  d             Z	e
d             ZdS )RSAVerifierzVerifies RSA cryptographic signatures using public keys.

    Args:
        public_key (rsa.key.PublicKey): The public key used to verify
            signatures.
    c                     || _         d S r   )_pubkey)self
public_keys     r   __init__zRSAVerifier.__init__H   s    !r   c                     t          j        |          }	 t          j                            ||| j                  S # t          t          j        j        f$ r Y dS w xY w)NF)r   to_bytesrsapkcs1verifyr/   
ValueErrorVerificationError)r0   message	signatures      r   r7   zRSAVerifier.verifyK   s_    #G,,	9##GYEEECI78 	 	 	55	s   %< AAc                    t          j        |          }t          |v }|rt          j                            |d          }t          j        |t                                \  }}|dk    rt          j
        d|          |d         d         }t          |d                   }t          j                            |d          }n t          j                            |d	          } | |          S )
a  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:
            google.auth.crypt._python_rsa.RSAVerifier: The constructed verifier.

        Raises:
            ValueError: If the public_key can't be parsed.
        CERTIFICATEasn1Specr   Unused bytestbsCertificatesubjectPublicKeyInfosubjectPublicKeyDERPEM)r   r4   _CERTIFICATE_MARKERr5   r   load_pemr   decoder   r	   InvalidValuer+   	PublicKey
load_pkcs1)	clsr1   is_x509_certder	asn1_cert	remaining	cert_info	key_bytespubkeys	            r   from_stringzRSAVerifier.from_stringS   s     &z22
*j8  
	A'"":}==C#*>##N#N#N IyC -niHHH!"234JKI*95G+HIII]--i??FF]--j%@@Fs6{{r   N)__name__
__module____qualname____doc__r2   r   copy_docstringr
   Verifierr7   classmethodrT   r   r   r   r-   r-   @   ss         " " " XT]++  ,+   [  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S )	RSASignera?  Signs messages with an RSA private key.

    Args:
        private_key (rsa.key.PrivateKey): 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                 "    || _         || _        d S r   )_key_key_id)r0   private_keykey_ids      r   r2   zRSASigner.__init__~   s    	r   c                     | j         S r   )r`   )r0   s    r   rb   zRSASigner.key_id   s     |r   c                 v    t          j        |          }t          j                            || j        d          S )NzSHA-256)r   r4   r5   r6   signr_   )r0   r:   s     r   re   zRSASigner.sign   s,    #G,,y~~gty)<<<r   c                 J   t          j        |          }t          j        t	          j        |          t          t                    \  }}|dk    r't          j	        j
                            |d          }n|dk    rt          j        |t                    \  }}|dk    rt          j        d|          |                    d          }t          j	        j
                            |                                d          }nt          j        d	           | ||
          S )a  Construct an Signer instance from a private key in PEM format.

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

        Returns:
            google.auth.crypt.Signer: The constructed signer.

        Raises:
            ValueError: If the key cannot be parsed as PKCS#1 or PKCS#8 in
                PEM format.
        r   rD   )formatr   r>   r   r@   
privateKeyzNo key could be detected.)rb   )r   
from_bytesr   readPemBlocksFromFileioStringIO_PKCS1_MARKER_PKCS8_MARKERr5   key
PrivateKeyrK   r   rH   _PKCS8_SPECr	   rI   getComponentByNameasOctetsMalformedError)	rL   ro   rb   	marker_idrR   ra   key_inforP   private_key_infos	            r   rT   zRSASigner.from_string   s    !#&&"8Km] 
  
	9
 >>',77	%7PPKK!^^").["Q"Q"QHiC -niHHH'::<HH',77 ))++E 8  KK +,GHHHs;v....r   r   )rU   rV   rW   rX   r2   propertyr   rY   r
   Signerrb   re   r[   rT   r   r   r   r]   r]   t   s             XT[))  *) X XT[))= = *)= "/ "/ "/ ["/ "/ "/r   r]   )rX   
__future__r   rk   pyasn1.codec.derr   pyasn1_modulesr   pyasn1_modules.rfc2459r   pyasn1_modules.rfc5208r   r5   google.authr   r	   google.auth.cryptr
   r"   rF   rm   rn   rq   r+   rZ   r-   ry   FromServiceAccountMixinr]   r   r   r   <module>r      sL    ' & & & & & 				 $ $ $ $ $ $       . . . . . . 1 1 1 1 1 1 



             " " " " " " " " " " " "%4 TLn  *1 1 1 1 1$- 1 1 1h;/ ;/ ;/ ;/ ;/T9 ;/ ;/ ;/ ;/ ;/r   