HEX

File: //usr/local/CyberPanel/lib64/python3.10/site-packages/google/auth/__pycache__/jwt.cpython-310.pyc
o

��hxy�@s`dZzddlmZWneyddlmZYnwddlZddlZddlZddlZddl	Z	ddl
mZddl
mZddl
m
Z
ddl
mZddlZzddlmZWney]dZYnwd	Zd
Zde
jiZedg�Zeduruejed<dd
d�Zdd�Zdd�Zdd�Zddd�Zd dd�ZGdd�dej j!j"ej j!j#�Z$Gdd�dej j!j"ej j!j#�Z%dS)!a�JSON Web Tokens

Provides support for creating (encoding) and verifying (decoding) JWTs,
especially JWTs generated and consumed by Google infrastructure.

See `rfc7519`_ for more details on JWTs.

To encode a JWT use :func:`encode`::

    from google.auth import crypt
    from google.auth import jwt

    signer = crypt.Signer(private_key)
    payload = {'some': 'payload'}
    encoded = jwt.encode(signer, payload)

To decode a JWT and verify claims use :func:`decode`::

    claims = jwt.decode(encoded, certs=public_certs)

You can also skip verification::

    claims = jwt.decode(encoded, verify=False)

.. _rfc7519: https://tools.ietf.org/html/rfc7519

�)�MappingN)�_helpers)�_service_account_info)�crypt)�
exceptions)�es256i�
�RS256�ES256cCs�|duri}|dur
|j}|�ddi�d|vr1tdur*t|tj�r*|�ddi�n|�ddi�|dur9||d<t�t�|��	d��t�t�|��	d��g}d	�
|�}|�|�}|�t�|��d	�
|�S)
a�Make a signed JWT.

    Args:
        signer (google.auth.crypt.Signer): The signer used to sign the JWT.
        payload (Mapping[str, str]): The JWT payload.
        header (Mapping[str, str]): Additional JWT header payload.
        key_id (str): The key id to add to the JWT header. If the
            signer has a key id it will be used as the default. If this is
            specified it will override the signer's key id.

    Returns:
        bytes: The encoded JWT.
    N�typ�JWT�algr
r	�kid�utf-8�.)
�key_id�updater�
isinstance�ES256Signerr�unpadded_urlsafe_b64encode�json�dumps�encode�join�sign�append)�signer�payload�headerr�segments�
signing_input�	signature�r"�E/usr/local/CyberPanel/lib/python3.10/site-packages/google/auth/jwt.pyrKs$�


rc
CsLt�|�}z	t�|�d��WSty%}zt�d�|��}||�d}~ww)zDecodes a single JWT segment.rzCan't parse segment: {0}N)	r�padded_urlsafe_b64decoder�loads�decode�
ValueErrorr�MalformedError�format)�encoded_section�
section_bytes�
caught_exc�new_excr"r"r#�_decode_jwt_segmentvs
���r.cCs�t�|�}|�d�dkrt�d�|���|�d�\}}}|d|}t�|�}t|�}t|�}t	|t
�s<t�d�|���t	|t
�sIt�d�|���||||fS)awDecodes a token and does no verification.

    Args:
        token (Union[str, bytes]): The encoded JWT.

    Returns:
        Tuple[Mapping, Mapping, str, str]: header, payload, signed_section, and
            signature.

    Raises:
        google.auth.exceptions.MalformedError: if there are an incorrect amount of segments in the token or segments of the wrong type.
    r�z&Wrong number of segments in token: {0}z+Header segment should be a JSON object: {0}z,Payload segment should be a JSON object: {0})r�to_bytes�countrr(r)�splitr$r.rr)�token�encoded_header�encoded_payloadr!�signed_sectionrrr"r"r#�_unverified_decode�s&

�

�
�r7cCst|�\}}}}|S)a@Return the decoded header of a token.

    No verification is done. This is useful to extract the key id from
    the header in order to acquire the appropriate certificate to verify
    the token.

    Args:
        token (Union[str, bytes]): the encoded JWT.

    Returns:
        Mapping: The decoded JWT header.
    )r7)r3r�_r"r"r#�
decode_header�s
r9cCs�t�t���}dD]}||vrt�d�|���q	|d}||}||kr-t�d�||���|d}||}||krBt�d�||���dS)a�Verifies the ``iat`` (Issued At) and ``exp`` (Expires) claims in a token
    payload.

    Args:
        payload (Mapping[str, str]): The JWT payload.
        clock_skew_in_seconds (int): The clock skew used for `iat` and `exp`
            validation.

    Raises:
        google.auth.exceptions.InvalidValue: if value validation failed.
        google.auth.exceptions.MalformedError: if schema validation failed.
    )�iat�expz(Token does not contain required claim {}r:zQToken used too early, {} < {}. Check that your computer's clock is set correctly.r;zToken expired, {} < {}N)r�datetime_to_secs�utcnowrr(r)�InvalidValue)r�clock_skew_in_seconds�now�keyr:�earliestr;�latestr"r"r#�_verify_iat_and_exp�s(
�����rDTc
Cs"t|�\}}}}|s|S|�d�}	|�d�}
zt|	}Wn"ty>}z|	tvr1t�d�|	��|�t�d�|	��|�d}~wwt|t	�r]|
rX|
|vrRt�
d�|
���||
g}
n|��}
n|}
t�
|||
|�slt�
d��t||�|dur�|�d�}t|t�r�|g}||vr�t�d	�||���|S)
a�Decode and verify a JWT.

    Args:
        token (str): The encoded JWT.
        certs (Union[str, bytes, Mapping[str, Union[str, bytes]]]): The
            certificate used to validate the JWT signature. If bytes or string,
            it must the the public key certificate in PEM format. If a mapping,
            it must be a mapping of key IDs to public key certificates in PEM
            format. The mapping must contain the same key ID that's specified
            in the token's header.
        verify (bool): Whether to perform signature and claim validation.
            Verification is done by default.
        audience (str or list): The audience claim, 'aud', that this JWT should
            contain. Or a list of audience claims. If None then the JWT's 'aud'
            parameter is not verified.
        clock_skew_in_seconds (int): The clock skew used for `iat` and `exp`
            validation.

    Returns:
        Mapping[str, str]: The deserialized JSON payload in the JWT.

    Raises:
        google.auth.exceptions.InvalidValue: if value validation failed.
        google.auth.exceptions.MalformedError: if schema validation failed.
    r
rzGThe key algorithm {} requires the cryptography package to be installed.z"Unsupported signature algorithm {}Nz$Certificate for key id {} not found.z!Could not verify token signature.�audz/Token has wrong audience {}, expected one of {})r7�get�_ALGORITHM_TO_VERIFIER_CLASS�KeyError�_CRYPTOGRAPHY_BASED_ALGORITHMSrr>r)rrr(�valuesr�verify_signaturerD�str)r3�certs�verify�audiencer?rrr6r!�key_algr�verifier_cls�exc�certs_to_check�claim_audiencer"r"r#r&�s`

�������

�
�



��r&cs�eZdZdZdedf�fdd�	Zedd��Zedd��Zed	d
��Z	edd��Z
	dd
d�Ze�
ejjj�dd��Zdd�Zdd�Ze�
ejjj�dd��Zee�
ejjj�dd���Zee�
ejjj�dd���Zedd��Z�ZS)�Credentialsa.Credentials that use a JWT as the bearer token.

    These credentials require an "audience" claim. This claim identifies the
    intended recipient of the bearer token.

    The constructor arguments determine the claims for the JWT that is
    sent with requests. Usually, you'll construct these credentials with
    one of the helper constructors as shown in the next section.

    To create JWT credentials using a Google service account private key
    JSON file::

        audience = 'https://pubsub.googleapis.com/google.pubsub.v1.Publisher'
        credentials = jwt.Credentials.from_service_account_file(
            'service-account.json',
            audience=audience)

    If you already have the service account file loaded and parsed::

        service_account_info = json.load(open('service_account.json'))
        credentials = jwt.Credentials.from_service_account_info(
            service_account_info,
            audience=audience)

    Both helper methods pass on arguments to the constructor, so you can
    specify the JWT claims::

        credentials = jwt.Credentials.from_service_account_file(
            'service-account.json',
            audience=audience,
            additional_claims={'meta': 'data'})

    You can also construct the credentials directly if you have a
    :class:`~google.auth.crypt.Signer` instance::

        credentials = jwt.Credentials(
            signer,
            issuer='your-issuer',
            subject='your-subject',
            audience=audience)

    The claims are considered immutable. If you want to modify the claims,
    you can easily create another instance using :meth:`with_claims`::

        new_audience = (
            'https://pubsub.googleapis.com/google.pubsub.v1.Subscriber')
        new_credentials = credentials.with_claims(audience=new_audience)
    NcsHtt|���||_||_||_||_||_||_|duri}||_	dS)a|
        Args:
            signer (google.auth.crypt.Signer): The signer used to sign JWTs.
            issuer (str): The `iss` claim.
            subject (str): The `sub` claim.
            audience (str): the `aud` claim. The intended audience for the
                credentials.
            additional_claims (Mapping[str, str]): Any additional claims for
                the JWT payload.
            token_lifetime (int): The amount of time in seconds for
                which the token is valid. Defaults to 1 hour.
            quota_project_id (Optional[str]): The project ID used for quota
                and billing.
        N)
�superrU�__init__�_signer�_issuer�_subject�	_audience�_token_lifetime�_quota_project_id�_additional_claims)�selfr�issuer�subjectrO�additional_claims�token_lifetime�quota_project_id��	__class__r"r#rWss
zCredentials.__init__cK�0|�d|d�|�d|d�||fi|��S)a�Creates a Credentials instance from a signer and service account
        info.

        Args:
            signer (google.auth.crypt.Signer): The signer used to sign JWTs.
            info (Mapping[str, str]): The service account info.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.Credentials: The constructed credentials.

        Raises:
            google.auth.exceptions.MalformedError: If the info is not in the expected format.
        ra�client_emailr`��
setdefault��clsr�info�kwargsr"r"r#�_from_signer_and_info��z!Credentials._from_signer_and_infocK�$tj|dgd�}|j||fi|��S)a�Creates an Credentials instance from a dictionary.

        Args:
            info (Mapping[str, str]): The service account info in Google
                format.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.Credentials: The constructed credentials.

        Raises:
            google.auth.exceptions.MalformedError: If the info is not in the expected format.
        rh��require�r�	from_dictro�rlrmrnrr"r"r#�from_service_account_info��z%Credentials.from_service_account_infocK�(tj|dgd�\}}|j||fi|��S)aWCreates a Credentials instance from a service account .json file
        in Google format.

        Args:
            filename (str): The path to the service account .json file.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.Credentials: The constructed credentials.
        rhrr�r�
from_filenamero�rl�filenamernrmrr"r"r#�from_service_account_file��
�z%Credentials.from_service_account_filecKs2|�d|j�|�d|j�||jfd|i|��S)a;Creates a new :class:`google.auth.jwt.Credentials` instance from an
        existing :class:`google.auth.credentials.Signing` instance.

        The new instance will use the same signer as the existing instance and
        will use the existing instance's signer email as the issuer and
        subject by default.

        Example::

            svc_creds = service_account.Credentials.from_service_account_file(
                'service_account.json')
            audience = (
                'https://pubsub.googleapis.com/google.pubsub.v1.Publisher')
            jwt_creds = jwt.Credentials.from_signing_credentials(
                svc_creds, audience=audience)

        Args:
            credentials (google.auth.credentials.Signing): The credentials to
                use to construct the new credentials.
            audience (str): the `aud` claim. The intended audience for the
                credentials.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.Credentials: A new Credentials instance.
        r`rarO�rj�signer_emailr)rl�credentialsrOrnr"r"r#�from_signing_credentials�sz$Credentials.from_signing_credentialscCs^t�|j�}|�|pi�|j|j|dur|n|j|dur|n|j|dur'|n|j||j	d�S)a�Returns a copy of these credentials with modified claims.

        Args:
            issuer (str): The `iss` claim. If unspecified the current issuer
                claim will be used.
            subject (str): The `sub` claim. If unspecified the current subject
                claim will be used.
            audience (str): the `aud` claim. If unspecified the current
                audience claim will be used.
            additional_claims (Mapping[str, str]): Any additional claims for
                the JWT payload. This will be merged with the current
                additional claims.

        Returns:
            google.auth.jwt.Credentials: A new credentials instance.
        N�r`rarOrbrd)
�copy�deepcopyr^rrfrXrYrZr[r])r_r`rarOrb�new_additional_claimsr"r"r#�with_claims�s�zCredentials.with_claimscCs |j|j|j|j|j|j|d�S)Nr�)rfrXrYrZr[r^�r_rdr"r"r#�with_quota_projects�zCredentials.with_quota_projectcCslt��}tj|jd�}||}|j|jt�|�t�|�d�}|jr&|j|d<|�	|j
�t|j|�}||fS)zuMake a signed JWT.

        Returns:
            Tuple[bytes, datetime]: The encoded JWT and the expiration.
        ��seconds)�iss�subr:r;rE)
rr=�datetime�	timedeltar\rYrZr<r[rr^rrX)r_r@�lifetime�expiryr�jwtr"r"r#�	_make_jwts�
zCredentials._make_jwtcCs|��\|_|_dS)zVRefreshes the access token.

        Args:
            request (Any): Unused.
        N)r�r3r��r_�requestr"r"r#�refresh2szCredentials.refreshcC�|j�|�S�N�rXr�r_�messager"r"r#�
sign_bytes<�zCredentials.sign_bytescC�|jSr��rY�r_r"r"r#r�@�zCredentials.signer_emailcCr�r��rXr�r"r"r#rEr�zCredentials.signercCr�)z3 Additional claims the JWT object was created with.)r^r�r"r"r#rbJr�zCredentials.additional_claims)NNNN)�__name__�
__module__�__qualname__�__doc__�_DEFAULT_TOKEN_LIFETIME_SECSrW�classmethodrorwr~r�r�r�copy_docstring�google�authr��CredentialsWithQuotaProjectr�r�r��Signingr��propertyr�rrb�
__classcell__r"r"rer#rU?s<7�%



 
�



rUcs�eZdZdZdeedf�fdd�	Zedd��Zedd��Z	ed	d
��Z
edd��Zd!d
d�Ze
�ejjj�dd��Zedd��Zdd�Zdd�Zdd�Zdd�Ze
�ejjj�dd��Zee
�ejjj�dd���Zee
�ejjj�dd ���Z�ZS)"�OnDemandCredentialsaOn-demand JWT credentials.

    Like :class:`Credentials`, this class uses a JWT as the bearer token for
    authentication. However, this class does not require the audience at
    construction time. Instead, it will generate a new token on-demand for
    each request using the request URI as the audience. It caches tokens
    so that multiple requests to the same URI do not incur the overhead
    of generating a new token every time.

    This behavior is especially useful for `gRPC`_ clients. A gRPC service may
    have multiple audience and gRPC clients may not know all of the audiences
    required for accessing a particular service. With these credentials,
    no knowledge of the audiences is required ahead of time.

    .. _grpc: http://www.grpc.io/
    NcsPtt|���||_||_||_||_||_|duri}||_t	j
|d�|_dS)a�
        Args:
            signer (google.auth.crypt.Signer): The signer used to sign JWTs.
            issuer (str): The `iss` claim.
            subject (str): The `sub` claim.
            additional_claims (Mapping[str, str]): Any additional claims for
                the JWT payload.
            token_lifetime (int): The amount of time in seconds for
                which the token is valid. Defaults to 1 hour.
            max_cache_size (int): The maximum number of JWT tokens to keep in
                cache. Tokens are cached using :class:`cachetools.LRUCache`.
            quota_project_id (Optional[str]): The project ID used for quota
                and billing.

        N)�maxsize)rVr�rWrXrYrZr\r]r^�
cachetools�LRUCache�_cache)r_rr`rarbrc�max_cache_sizerdrer"r#rWdszOnDemandCredentials.__init__cKrg)aCreates an OnDemandCredentials instance from a signer and service
        account info.

        Args:
            signer (google.auth.crypt.Signer): The signer used to sign JWTs.
            info (Mapping[str, str]): The service account info.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.OnDemandCredentials: The constructed credentials.

        Raises:
            google.auth.exceptions.MalformedError: If the info is not in the expected format.
        rarhr`rirkr"r"r#ro�rpz)OnDemandCredentials._from_signer_and_infocKrq)a�Creates an OnDemandCredentials instance from a dictionary.

        Args:
            info (Mapping[str, str]): The service account info in Google
                format.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.OnDemandCredentials: The constructed credentials.

        Raises:
            google.auth.exceptions.MalformedError: If the info is not in the expected format.
        rhrrrtrvr"r"r#rw�rxz-OnDemandCredentials.from_service_account_infocKry)ahCreates an OnDemandCredentials instance from a service account .json
        file in Google format.

        Args:
            filename (str): The path to the service account .json file.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.OnDemandCredentials: The constructed credentials.
        rhrrrzr|r"r"r#r~�rz-OnDemandCredentials.from_service_account_filecKs.|�d|j�|�d|j�||jfi|��S)akCreates a new :class:`google.auth.jwt.OnDemandCredentials` instance
        from an existing :class:`google.auth.credentials.Signing` instance.

        The new instance will use the same signer as the existing instance and
        will use the existing instance's signer email as the issuer and
        subject by default.

        Example::

            svc_creds = service_account.Credentials.from_service_account_file(
                'service_account.json')
            jwt_creds = jwt.OnDemandCredentials.from_signing_credentials(
                svc_creds)

        Args:
            credentials (google.auth.credentials.Signing): The credentials to
                use to construct the new credentials.
            kwargs: Additional arguments to pass to the constructor.

        Returns:
            google.auth.jwt.Credentials: A new Credentials instance.
        r`rar�)rlr�rnr"r"r#r��sz,OnDemandCredentials.from_signing_credentialscCsTt�|j�}|�|pi�|j|j|dur|n|j|dur|n|j||jj	|j
d�S)aJReturns a copy of these credentials with modified claims.

        Args:
            issuer (str): The `iss` claim. If unspecified the current issuer
                claim will be used.
            subject (str): The `sub` claim. If unspecified the current subject
                claim will be used.
            additional_claims (Mapping[str, str]): Any additional claims for
                the JWT payload. This will be merged with the current
                additional claims.

        Returns:
            google.auth.jwt.OnDemandCredentials: A new credentials instance.
        N�r`rarbr�rd)r�r�r^rrfrXrYrZr�r�r])r_r`rarbr�r"r"r#r��s�zOnDemandCredentials.with_claimscCs"|j|j|j|j|j|jj|d�S)Nr�)rfrXrYrZr^r�r�r�r"r"r#r��s�z&OnDemandCredentials.with_quota_projectcCsdS)z�Checks the validity of the credentials.

        These credentials are always valid because it generates tokens on
        demand.
        Tr"r�r"r"r#�validszOnDemandCredentials.validcCs^t��}tj|jd�}||}|j|jt�|�t�|�|d�}|�|j	�t
|j|�}||fS)z�Make a new JWT for the given audience.

        Args:
            audience (str): The intended audience.

        Returns:
            Tuple[bytes, datetime]: The encoded JWT and the expiration.
        r�)r�r�r:r;rE)rr=r�r�r\rYrZr<rr^rrX)r_rOr@r�r�rr�r"r"r#�_make_jwt_for_audience
s	�z*OnDemandCredentials._make_jwt_for_audiencecCsF|j�|d�\}}|dus|t��kr!|�|�\}}||f|j|<|S)aGGet a JWT For a given audience.

        If there is already an existing, non-expired token in the cache for
        the audience, that token is used. Otherwise, a new token will be
        created.

        Args:
            audience (str): The intended audience.

        Returns:
            bytes: The encoded JWT.
        �NNN)r�rFrr=r�)r_rOr3r�r"r"r#�_get_jwt_for_audience(s

z)OnDemandCredentials._get_jwt_for_audiencecCs
t�d��)z�Raises an exception, these credentials can not be directly
        refreshed.

        Args:
            request (Any): Unused.

        Raises:
            google.auth.RefreshError
        z2OnDemandCredentials can not be directly refreshed.)r�RefreshErrorr�r"r"r#r�=s�zOnDemandCredentials.refreshcCsDtj�|�}tj�|j|j|jddf�}|�|�}|j||d�dS)a�Performs credential-specific before request logic.

        Args:
            request (Any): Unused. JWT credentials do not need to make an
                HTTP request to refresh.
            method (str): The request's HTTP method.
            url (str): The request's URI. This is used as the audience claim
                when generating the JWT.
            headers (Mapping): The request's headers.
        �)r3N)	�urllib�parse�urlsplit�
urlunsplit�scheme�netloc�pathr��apply)r_r��method�url�headers�partsrOr3r"r"r#�before_requestMs
�
z"OnDemandCredentials.before_requestcCr�r�r�r�r"r"r#r�br�zOnDemandCredentials.sign_bytescCr�r�r�r�r"r"r#r�fr�z OnDemandCredentials.signer_emailcCr�r�r�r�r"r"r#rkr�zOnDemandCredentials.signer)NNN)r�r�r�r�r��_DEFAULT_MAX_CACHE_SIZErWr�rorwr~r�r�rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r"r"rer#r�Ps@�&







r�r�)r)NTNr)&r��collections.abcr�ImportError�collectionsr�r�rr�r��google.authrrrr�google.auth.credentialsr��google.auth.cryptrr�r��RSAVerifierrG�	frozensetrI�
ES256Verifierrr.r7r9rDr&r�r�r�r�rUr�r"r"r"r#�<module>sR��



+)

+
X�
�