o
    T۷i                     @  sL  U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZm	Z	 d dl
mZmZmZmZmZmZmZmZmZ ddlmZ ddlmZmZ ddlmZmZmZmZmZmZm Z m!Z!m"Z" zd d	l#m$Z$m%Z% d d
l&m'Z' d dl(m)Z) d dl*m+Z+ d dl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 d dl7m8Z8m9Z9 d dl:m;Z;m<Z< d dl=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZE d dlFmGZGmHZHmIZImJZJmKZKmLZLmMZM ejNdkrd dl
mOZO nd dlPmOZO ee>e@f ZQdeRd< ee3e5f ZSdeRd< ee;e<e8e9f ZTdeRd< eeQeSeTf ZUdeRd< ee>e3e;e8f ZVdeRd< ee@e5e<e9f ZWdeRd< es'eXeYddr/d dlZm[Z[m\Z\ dZ]W n+ e^y]   ejNdkrGd d l
m_Z_ nd d lPm_Z_ e_ZQe_ZSe_ZTe_ZUe_ZVe_ZWd!Z]Y nw h d"Z`d5d%d&ZaG d'd( d(eZbG d)d* d*ebZcG d+d, d,ebZde]rG d-d. d.ebZeG d/d0 d0ebZfG d1d2 d2eeZgG d3d4 d4ebZhdS dS )6    )annotationsN)ABCabstractmethod)	TYPE_CHECKINGAnyClassVarLiteralNoReturnUnioncastget_argsoverload   InvalidKeyError)HashlibHashJWKDict)	base64url_decodebase64url_encodeder_to_raw_signatureforce_bytesfrom_base64url_uintis_pem_format
is_ssh_keyraw_to_der_signatureto_base64url_uint)InvalidSignatureUnsupportedAlgorithm)default_backend)hashes)padding)
ECDSA	SECP256K1	SECP256R1	SECP384R1	SECP521R1EllipticCurveEllipticCurvePrivateKeyEllipticCurvePrivateNumbersEllipticCurvePublicKeyEllipticCurvePublicNumbers)Ed448PrivateKeyEd448PublicKey)Ed25519PrivateKeyEd25519PublicKey)RSAPrivateKeyRSAPrivateNumbersRSAPublicKeyRSAPublicNumbersrsa_crt_dmp1rsa_crt_dmq1rsa_crt_iqmprsa_recover_prime_factors)EncodingNoEncryptionPrivateFormatPublicFormatload_pem_private_keyload_pem_public_keyload_ssh_public_key)   
   )	TypeAliasr@   AllowedRSAKeysAllowedECKeysAllowedOKPKeysAllowedKeysAllowedPrivateKeysAllowedPublicKeysSPHINX_BUILD )PrivateKeyTypesPublicKeyTypesT)r>      )NeverF>   ES256ES384ES512ES521EdDSAPS256PS384PS512RS256RS384RS512ES256Kreturndict[str, Algorithm]c                  C  s   t  ttjttjttjd} trL| ttjttjttjttjt	ttjt
ttjtttjtttjtttjttjttjt d | S )zE
    Returns the algorithms that are implemented by the library.
    )noneHS256HS384HS512)rU   rV   rW   rM   rX   rN   rP   rO   rR   rS   rT   rQ   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmr#   r"   r$   r%   RSAPSSAlgorithmOKPAlgorithm)default_algorithms rk   D/home/ubuntu/vllm_env/lib/python3.10/site-packages/jwt/algorithms.pyget_default_algorithms   s0   



rm   c                   @  s   e Zd ZU dZdZded< d,dd	Zd-ddZed.ddZ	ed/ddZ
ed0ddZeeed1ddZeee	d2d3d"dZeed2d4d$dZeed5d'd(Zd6d*d+ZdS )7	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    Nz$tuple[type[AllowedKeys], ...] | None_crypto_key_typesbytestrbytesrY   c                 C  sj   t | dd}|du rttr-t|tr-t|tjr-tj| t	 d}|
| t| S t|| S )z
        Compute a hash digest using the specified algorithm's hash algorithm.

        If there is no hash algorithm, raises a NotImplementedError.
        hash_algN)backend)getattrNotImplementedErrorrd   
isinstancetype
issubclassr   HashAlgorithmHashr   re   rq   finalizedigest)selfrp   rr   r|   rk   rk   rl   compute_hash_digest   s   

zAlgorithm.compute_hash_digestkey PublicKeyTypes | PrivateKeyTypesNonec                 C  s`   t r| jdu rtdt|| js.dd | jD }|jj}| jj}td| d| d| dS )ac  Check that the key belongs to the right cryptographic family.

        Note that this method only works when ``cryptography`` is installed.

        :param key: Potentially a cryptography key
        :type key: :py:data:`PublicKeyTypes <cryptography.hazmat.primitives.asymmetric.types.PublicKeyTypes>` | :py:data:`PrivateKeyTypes <cryptography.hazmat.primitives.asymmetric.types.PrivateKeyTypes>`
        :raises ValueError: if ``cryptography`` is not installed, or this method is called by a non-cryptography algorithm
        :raises InvalidKeyError: if the key doesn't match the expected key classes
        NzhThis method requires the cryptography library, and should only be used by cryptography-based algorithms.c                 s  s    | ]}|j V  qd S N)__name__).0clsrk   rk   rl   	<genexpr>   s    z2Algorithm.check_crypto_key_type.<locals>.<genexpr>zExpected one of z, got: z. Invalid Key type for )rd   ro   
ValueErrorrv   	__class__r   r   )r}   r   valid_classesactual_class
self_classrk   rk   rl   check_crypto_key_type   s   
zAlgorithm.check_crypto_key_typer   c                 C     dS )z
        Performs necessary validation and conversions on the key and returns
        the key value in the proper format for sign() and verify().
        Nrk   r}   r   rk   rk   rl   prepare_key       zAlgorithm.prepare_keymsgc                 C  r   )zn
        Returns a digital signature for the specified message
        using the specified key value.
        Nrk   r}   r   r   rk   rk   rl   sign   r   zAlgorithm.signsigboolc                 C  r   )zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        Nrk   r}   r   r   r   rk   rk   rl   verify   r   zAlgorithm.verifykey_objas_dictLiteral[True]r   c                 C     d S r   rk   r   r   rk   rk   rl   to_jwk   s   zAlgorithm.to_jwkFLiteral[False]strc                 C  r   r   rk   r   rk   rk   rl   r         JWKDict | strc                 C  r   )z3
        Serializes a given key into a JWK
        Nrk   r   rk   rk   rl   r     r   jwkstr | JWKDictc                 C  r   )zJ
        Deserializes a given key from JWK back into a key object
        Nrk   r   rk   rk   rl   from_jwk  r   zAlgorithm.from_jwk
str | Nonec                 C  r   )z
        Return a warning message if the key is below the minimum
        recommended length for this algorithm, or None if adequate.
        Nrk   r   rk   rk   rl   check_key_length  r   zAlgorithm.check_key_length)rp   rq   rY   rq   )r   r   rY   r   )r   r   rY   r   )r   rq   r   r   rY   rq   )r   rq   r   r   r   rq   rY   r   )r   r   r   r   rY   r   F)r   r   r   r   rY   r   )r   r   r   r   rY   r   )r   r   rY   r   )r   r   rY   r   )r   
__module____qualname____doc__ro   __annotations__r~   r   r   r   r   r   r   staticmethodr   r   r   rk   rk   rk   rl   rn      s6   
 

rn   c                   @  sL   e Zd ZdZdddZdd
dZdddZedd ddZed!ddZ	dS )"r_   zZ
    Placeholder for use when no signing or verification
    operations are required.
    r   r   rY   r   c                 C  s    |dkrd }|d urt d|S )NrH   z*When alg = "none", key value must be None.r   r   rk   rk   rl   r      s
   zNoneAlgorithm.prepare_keyr   rq   c                 C  r   )N    rk   r   rk   rk   rl   r   )     zNoneAlgorithm.signr   r   c                 C  r   )NFrk   r   rk   rk   rl   r   ,  r   zNoneAlgorithm.verifyFr   r   r   r	   c                 C     t  r   ru   r   rk   rk   rl   r   /     zNoneAlgorithm.to_jwkr   r   c                 C  r   r   r   r   rk   rk   rl   r   3  r   zNoneAlgorithm.from_jwkN)r   r   rY   r   )r   rq   r   r   rY   rq   )r   rq   r   r   r   rq   rY   r   r   )r   r   r   r   rY   r	   )r   r   rY   r	   )
r   r   r   r   r   r   r   r   r   r   rk   rk   rk   rl   r_     s    

	
r_   c                   @  s   e Zd ZU dZejZded< ejZ	ded< ej
Zded< d,d
dZd-ddZeed.ddZeed/d0ddZed/d1ddZed2d d!Zd3d#d$Zd4d&d'Zd5d)d*Zd+S )6r`   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]ra   rb   rc   rr   r   rY   r   c                 C  
   || _ d S r   rr   r}   rr   rk   rk   rl   __init__B     
zHMACAlgorithm.__init__r   str | bytesrq   c                 C  s$   t |}t|st|rtd|S )NzdThe specified key is an asymmetric key or x509 certificate and should not be used as an HMAC secret.)r   r   r   r   )r}   r   	key_bytesrk   rk   rl   r   E  s   zHMACAlgorithm.prepare_keyr   r   r   r   c                 C  r   r   rk   r   rk   rk   rl   r   P     zHMACAlgorithm.to_jwkFr   r   c                 C  r   r   rk   r   rk   rk   rl   r   T  r   r   r   c                 C  s(   t t|  dd}|r|S t|S )Noct)kkty)r   r   decodejsondumps)r   r   r   rk   rk   rl   r   X  s   
r   r   c                 C  sj   zt | trt| }n
t | tr| }ntW n ty#   tdd w |ddkr/tdt|d S )NKey is not valid JSONr   r   zNot an HMAC keyr   )	rv   r   r   loadsdictr   r   getr   )r   objrk   rk   rl   r   d  s   


zHMACAlgorithm.from_jwkr   c                 C  s@   |   j}t||k rdt| d| d|   j  dS d S )NzThe HMAC key is z> bytes long, which is below the minimum recommended length of z bytes for z. See RFC 7518 Section 3.2.)rr   digest_sizelennameupper)r}   r   
min_lengthrk   rk   rl   r   u  s   
zHMACAlgorithm.check_key_lengthr   c                 C  s   t ||| j S r   )hmacnewrr   r|   r   rk   rk   rl   r        zHMACAlgorithm.signr   c                 C  s   t || ||S r   )r   compare_digestr   r   rk   rk   rl   r     r   zHMACAlgorithm.verifyN)rr   r   rY   r   )r   r   rY   rq   )r   r   r   r   rY   r   r   )r   r   r   r   rY   r   )r   r   r   r   rY   r   )r   r   rY   rq   )r   rq   rY   r   )r   rq   r   rq   rY   rq   )r   rq   r   rq   r   rq   rY   r   )r   r   r   r   hashlibsha256ra   r   sha384rb   sha512rc   r   r   r   r   r   r   r   r   r   rk   rk   rk   rl   r`   8  s(   
 



r`   c                   @  s   e Zd ZU dZejZded< ejZded< ejZded< e	e
ee df eeeef ZdZded	< d3ddZd4ddZd5ddZeed6ddZeed7d8d!dZed7d9d$dZed:d'd(Zd;d,d-Zd<d0d1Zd2S )=rf   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]ra   rb   rc   .i   zClassVar[int]_MIN_KEY_SIZErr   type[hashes.HashAlgorithm]rY   r   c                 C  r   r   r   r   rk   rk   rl   r     r   zRSAAlgorithm.__init__r   rA   r   c                 C  s&   |j | jk rd|j  d| j dS d S )NzThe RSA key is z; bits long, which is below the minimum recommended size of z bits. See NIST SP 800-131A.)key_sizer   r   rk   rk   rl   r     s   
zRSAAlgorithm.check_key_lengthAllowedRSAKeys | str | bytesc                 C  s   t || jrtt|S t |ttfstdt|}z%|dr/t	|}| 
| tt|W S t|d d}| 
| tt|W S  tyf   zt|}| 
| tt|W  Y S  ttfye   tdd w w )NExpecting a PEM-formatted key.s   ssh-rsapasswordz(Could not parse the provided public key.)rv   ro   r   rA   rq   r   	TypeErrorr   
startswithr=   r   r1   r;   r/   r   r<   r   r   )r}   r   r   
public_keyprivate_keyrk   rk   rl   r     s8   




zRSAAlgorithm.prepare_keyr   r   r   r   c                 C  r   r   rk   r   rk   rk   rl   r     r   zRSAAlgorithm.to_jwkFr   r   c                 C  r   r   rk   r   rk   rk   rl   r     r   r   r   c                 C  s   d }t | drD|  }ddgt|jj t|jj t|j t|j t|j	 t|j
 t|j t|j d
}n t | dr`|  }ddgt|j t|j d}ntd|rh|S t|S )Nprivate_numbersRSAr   )
r   key_opsnedpqdpdqqir   )r   r   r   r   Not a public or private key)hasattrr   r   public_numbersr   r   r   r   r   r   dmp1dmq1iqmpr   r   r   )r   r   r   numbersrk   rk   rl   r     s2   


r   r   c           	   	     s  zt | trt|  n
t | tr|  ntW n ty#   tdd w  ddkr0tdd d v rd v rd v rd v rDtd	g d
} fdd|D }t|}|r`t	|s`tdd t
t d t d }|rtt d t d t d t d t d t d |d}| S t d }t|j||j\}}t|||t||t||t|||d}| S d v rd v rt
t d t d  S td)Nr   r   r   zNot an RSA keyr   r   r   othz5Unsupported RSA private key: > 2 primes not supported)r   r   r   r   r   c                   s   g | ]}| v qS rk   rk   )r   propr   rk   rl   
<listcomp>	  s    z)RSAAlgorithm.from_jwk.<locals>.<listcomp>z@RSA key must include all parameters if any are present besides dr   r   r   r   r   )r   r   r   r   r   r   r   r   )rv   r   r   r   r   r   r   r   anyallr2   r   r0   r6   r   r   r3   r4   r5   r   r   )	r   other_propsprops_foundany_props_foundr   r   r   r   r   rk   r   rl   r     s~   















zRSAAlgorithm.from_jwkr   rq   r/   c                 C  s   | |t |  }|S r   )r   r    PKCS1v15rr   r}   r   r   	signaturerk   rk   rl   r   :  s   zRSAAlgorithm.signr1   r   c                 C  s4   z| ||t |   W dS  ty   Y dS w )NTF)r   r    r   rr   r   r   rk   rk   rl   r   >  s   zRSAAlgorithm.verifyN)rr   r   rY   r   )r   rA   rY   r   )r   r   rY   rA   )r   rA   r   r   rY   r   r   )r   rA   r   r   rY   r   )r   rA   r   r   rY   r   )r   r   rY   rA   r   rq   r   r/   rY   rq   r   rq   r   r1   r   rq   rY   r   )r   r   r   r   r   ra   r   rb   rc   r   tuplerw   rD   r   r
   r/   r1   ro   r   r   r   r   r   r   r   r   r   r   rk   rk   rk   rl   rf     s2   
 


	&
Grf   c                   @  s   e Zd ZU dZejZded< ejZded< ejZded< e	e
ee df eeeef Z	d0d1ddZd2ddZd3ddZd4ddZd5ddZeed6d$d%Zeed7d8d)d%Zed7d9d+d%Zed:d.d/ZdS );rg   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   ra   rb   rc   .Nrr   r   expected_curvetype[EllipticCurve] | NonerY   r   c                 C  s   || _ || _d S r   )rr   r   )r}   rr   r   rk   rk   rl   r   T  s   
zECAlgorithm.__init__r   rB   c                 C  s>   | j du rdS t|j| j std|jj d| j j ddS )z9Validate that the key's curve matches the expected curve.NzThe key's curve 'z%' does not match the expected curve 'z' for this algorithm)r   rv   curver   r   r   rk   rk   rl   _validate_curve\  s   
zECAlgorithm._validate_curveAllowedECKeys | str | bytesc                 C  s   t || jrtt|}| | |S t |ttfstdt|}z |	dr,t
|}nt|}| | tt|}| | |W S  tya   t|d d}| | tt|}| | | Y S w )Nr   s   ecdsa-sha2-r   )rv   ro   r   rB   r  rq   r   r   r   r   r=   r<   r   r)   r   r;   r'   )r}   r   ec_keyr   r   ec_public_keyr   ec_private_keyrk   rk   rl   r   g  s,   









zECAlgorithm.prepare_keyr   rq   r'   c                 C  s    | |t|  }t||jS r   )r   r!   rr   r   r  )r}   r   r   der_sigrk   rk   rl   r     s   zECAlgorithm.signr   r   c                 C  sn   zt ||j}W n
 ty   Y dS w zt|tr| n|}|||t|   W dS  t	y6   Y dS w )NFT)
r   r  r   rv   r'   r   r   r!   rr   r   )r}   r   r   r   r  r   rk   rk   rl   r     s   
zECAlgorithm.verifyr   r   r   r   c                 C  r   r   rk   r   rk   rk   rl   r     r   zECAlgorithm.to_jwkFr   r   c                 C  r   r   rk   r   rk   rk   rl   r     r   r   c                 C  s   t | tr|   }nt | tr|  }ntdt | jtr#d}n#t | jtr,d}nt | jt	r5d}nt | jt
r>d}ntd| j d|t|j| jjd t|j| jjd d	}t | trst|  j| jjd |d
< |rw|S t|S )Nr   P-256P-384P-521	secp256k1Invalid curve: EC)
bit_length)r   crvxyr   )rv   r'   r   r   r)   r   r  r#   r$   r%   r"   r   r  r   r   r  r   private_valuer   r   )r   r   r   r  r   rk   rk   rl   r     sJ   




r   r   c                 C  s  zt | trt| }n
t | tr| }ntW n ty#   tdd w |ddkr0tdd d|vs8d|vr=tdd t|d}t|d}|d}|dkrmt	|t	|  krbd	krhn nt
 }netd
d |dkrt	|t	|  krdkrn nt }nHtdd |dkrt	|t	|  krdkrn nt }n+tdd |dkrt	|t	|  krd	krn tdt }ntdtd| ttj|ddtj|dd|d}d|vr| S t|d}t	|t	|krtdt	||ttj|dd| S )Nr   r   r  zNot an Elliptic curve keyr  r  r  r	      z)Coords should be 32 bytes for curve P-256r
  0   z)Coords should be 48 bytes for curve P-384r  B   z)Coords should be 66 bytes for curve P-521r  z-Coords should be 32 bytes for curve secp256k1r  big)	byteorder)r  r  r  r   z!D should be {} bytes for curve {})rv   r   r   r   r   r   r   r   r   r   r#   r$   r%   r"   r*   int
from_bytesr   r(   r   )r   r   r  r  r  	curve_objr   r   rk   rk   rl   r     s   





   
zECAlgorithm.from_jwkr   )rr   r   r   r  rY   r   )r   rB   rY   r   )r   r  rY   rB   )r   rq   r   r'   rY   rq   )r   rq   r   rB   r   rq   rY   r   )r   rB   r   r   rY   r   r   )r   rB   r   r   rY   r   )r   rB   r   r   rY   r   )r   r   rY   rB   )r   r   r   r   r   ra   r   rb   rc   r   r   rw   rD   r   r
   r'   r)   ro   r   r  r   r   r   r   r   r   r   rk   rk   rk   rl   rg   E  s2   
 


 
+rg   c                   @  s$   e Zd ZdZdddZdddZdS )rh   zA
        Performs a signature using RSASSA-PSS with MGF1
        r   rq   r   r/   rY   c                 C  s0   | |tjt|  |  jd|  }|S )Nmgfsalt_length)r   r    PSSMGF1rr   r   r   rk   rk   rl   r      s   zRSAPSSAlgorithm.signr1   r   r   c              	   C  sJ   z| ||tjt|  |  jd|   W dS  ty$   Y dS w )Nr  TF)r   r    r  r   rr   r   r   r   rk   rk   rl   r   +  s   	zRSAPSSAlgorithm.verifyNr   r   )r   r   r   r   r   r   rk   rk   rk   rl   rh     s    
rh   c                   @  s   e Zd ZdZeeee df ee	e
eeef Zd(ddZd)ddZd*ddZd+ddZeed,ddZeed-d.d dZed-d/d"dZed0d%d&Zd'S )1ri   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        .kwargsr   rY   r   c                 K  r   r   rk   )r}   r!  rk   rk   rl   r   M  r   zOKPAlgorithm.__init__r   AllowedOKPKeys | str | bytesrC   c                 C  s   t |ttfs| | |S t |tr|dn|}t |tr$|dn|}d|v r/t|}nd|v r:t|d d}n|dd dkrGt|}nt	d| | t
d	|S )
Nutf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr   r      zssh-r   rC   )rv   r   rq   r   r   encoder<   r;   r=   r   r   )r}   r   key_strr   
loaded_keyrk   rk   rl   r   P  s   




zOKPAlgorithm.prepare_keyr   r   #Ed25519PrivateKey | Ed448PrivateKeyrq   c                 C  s&   t |tr
|dn|}||}|S )aS  
            Sign a message ``msg`` using the EdDSA private key ``key``
            :param str|bytes msg: Message to sign
            :param Ed25519PrivateKey}Ed448PrivateKey key: A :class:`.Ed25519PrivateKey`
                or :class:`.Ed448PrivateKey` isinstance
            :return bytes signature: The signature, as bytes
            r#  )rv   r   r%  r   )r}   r   r   	msg_bytesr   rk   rk   rl   r   f  s   

zOKPAlgorithm.signr   r   c                 C  sr   z.t |tr|dn|}t |tr|dn|}t |ttfr$| n|}||| W dS  ty8   Y dS w )a  
            Verify a given ``msg`` against a signature ``sig`` using the EdDSA key ``key``

            :param str|bytes sig: EdDSA signature to check ``msg`` against
            :param str|bytes msg: Message to sign
            :param Ed25519PrivateKey|Ed25519PublicKey|Ed448PrivateKey|Ed448PublicKey key:
                A private or public EdDSA key instance
            :return bool verified: True if signature is valid, False if not.
            r#  TF)rv   r   r%  r-   r+   r   r   r   )r}   r   r   r   r)  	sig_bytesr   rk   rk   rl   r   t  s   
zOKPAlgorithm.verifyr   r   r   c                 C  r   r   rk   r   r   rk   rk   rl   r     r   zOKPAlgorithm.to_jwkFr   r   c                 C  r   r   rk   r+  rk   rk   rl   r     r   r   c                 C  s   t | ttfr.| jtjtjd}t | trdnd}tt|	 d|d}|r)|S t
|S t | ttfrp| jtjtjt d}|  jtjtjd}t | trRdnd}tt|	 tt|	 d|d}|rk|S t
|S td)	N)encodingformatEd25519Ed448OKP)r  r   r  )r,  r-  encryption_algorithm)r  r   r   r  r   )rv   r.   r,   public_bytesr7   Rawr:   r   r   r   r   r   r-   r+   private_bytesr9   r8   r   r   )r   r   r  r  r   r   rk   rk   rl   r     sB   

r   r   c              
   C  s  zt | trt| }n
t | tr| }ntW n ty#   tdd w |ddkr/td|d}|dkrC|dkrCtd| d	|vrKtd
t|d	}z+d|vrg|dkrat	
|W S t
|W S t|d}|dkrxt|W S t|W S  ty } ztd|d }~ww )Nr   r   r0  zNot an Octet Key Pairr  r.  r/  r  r  zOKP should have "x" parameterr   zInvalid key parameter)rv   r   r   r   r   r   r   r   r   r.   from_public_bytesr,   r-   from_private_bytesr+   )r   r   r  r  r   errrk   rk   rl   r     s>   




zOKPAlgorithm.from_jwkN)r!  r   rY   r   )r   r"  rY   rC   )r   r   r   r(  rY   rq   )r   r   r   rC   r   r   rY   r   )r   rC   r   r   rY   r   r   )r   rC   r   r   rY   r   )r   rC   r   r   rY   r   )r   r   rY   rC   )r   r   r   r   r   r   rw   rD   r   r
   r-   r.   r+   r,   ro   r   r   r   r   r   r   r   r   rk   rk   rk   rl   ri   :  s8    



.ri   )rY   rZ   )i
__future__r   r   r   r   ossysabcr   r   typingr   r   r   r   r	   r
   r   r   r   
exceptionsr   typesr   r   utilsr   r   r   r   r   r   r   r   r   cryptography.exceptionsr   r   cryptography.hazmat.backendsr   cryptography.hazmat.primitivesr   )cryptography.hazmat.primitives.asymmetricr    ,cryptography.hazmat.primitives.asymmetric.ecr!   r"   r#   r$   r%   r&   r'   r(   r)   r*   /cryptography.hazmat.primitives.asymmetric.ed448r+   r,   1cryptography.hazmat.primitives.asymmetric.ed25519r-   r.   -cryptography.hazmat.primitives.asymmetric.rsar/   r0   r1   r2   r3   r4   r5   r6   ,cryptography.hazmat.primitives.serializationr7   r8   r9   r:   r;   r<   r=   version_infor@   typing_extensionsrA   r   rB   rC   rD   rE   rF   r   getenv/cryptography.hazmat.primitives.asymmetric.typesrI   rJ   rd   ModuleNotFoundErrorrL   requires_cryptographyrm   rn   r_   r`   rf   rg   rh   ri   rk   rk   rk   rl   <module>   s    ,,0($






"lO = W   