
    ddht                       d dl m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 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 ej@                  d	k\  rd d
l	m!Z! n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,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z; d dl<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZGmHZHmIZImJZJmKZKmLZL dZMe
r3e=e?z  ZOe2e4z  ZPe:e;z  e7z  e8z  ZQeOePz  eQz  ZRe=e2z  e:z  e7z  ZSe?e4z  e;z  e8z  ZTh dZUd&dZV G d de      ZW G d deW      ZX G d deW      ZYeMr- G d deW      ZZ G d  d!eW      Z[ G d" d#eZ      Z\ G d$ d%eW      Z]yy# eN$ r dZMY w xY w)'    )annotationsN)ABCabstractmethod)TYPE_CHECKINGAnyClassVarNoReturnUnioncast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)      )Literal)InvalidSignature)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_keyTF>   ES256ES384ES512ES521EdDSAPS256PS384PS512RS256RS384RS512ES256Kc                    t               t        t        j                        t        t        j                        t        t        j                        d} t
        r#| j                  t        t        j                        t        t        j                        t        t        j                        t        t        j                        t        t        j                        t        t        j                        t        t        j                        t        t        j                        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)rG   rH   rI   r?   rJ   r@   rB   rA   rD   rE   rF   rC   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmRSAPSSAlgorithmOKPAlgorithm)default_algorithmss    0/usr/lib/python3/dist-packages/jwt/algorithms.pyget_default_algorithmsr]   p   s    
 }334}334}334	 !!%l&9&9:%l&9&9:%l&9&9:$[%7%78%k&8&89$[%7%78$[%7%78$&& ))?)?@()?)?@()?)?@%	
&     c                      e Zd ZdZddZedd       Zedd       Zedd       Ze	e
edd                     Ze	e
eddd                     Ze
eddd              Ze
edd	              Zy
)	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    c                f   t        | dd      }|t        t        rxt        |t              rht        |t        j                        rNt        j                   |       t                     }|j                  |       t        |j                               S t         ||      j                               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NotImplementedErrorrU   
isinstancetype
issubclassr    HashAlgorithmHashr   rV   bytesfinalizedigest)selfbytestrrb   rm   s       r\   compute_hash_digestzAlgorithm.compute_hash_digest   s     4T2%% 8T*8V%9%9:[[_5FGFMM'"*++'*11344r^   c                     y)z
        Performs necessary validation and conversions on the key and returns
        the key value in the proper format for sign() and verify().
        N rn   keys     r\   prepare_keyzAlgorithm.prepare_key       r^   c                     y)zn
        Returns a digital signature for the specified message
        using the specified key value.
        Nrr   rn   msgrt   s      r\   signzAlgorithm.sign   rv   r^   c                     y)zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        Nrr   rn   ry   rt   sigs       r\   verifyzAlgorithm.verify   rv   r^   c                     y Nrr   key_objas_dicts     r\   to_jwkzAlgorithm.to_jwk        	r^   c                     y r   rr   r   s     r\   r   zAlgorithm.to_jwk   r   r^   c                     y)z3
        Serializes a given key into a JWK
        Nrr   r   s     r\   r   zAlgorithm.to_jwk   rv   r^   c                     y)zJ
        Deserializes a given key from JWK back into a key object
        Nrr   jwks    r\   from_jwkzAlgorithm.from_jwk   rv   r^   N)ro   rk   returnrk   )rt   r   r   r   )ry   rk   rt   r   r   rk   )ry   rk   rt   r   r}   rk   r   bool)r   Literal[True]r   r   F)r   Literal[False]r   str)r   r   r   Union[JWKDict, str])r   str | JWKDictr   r   )__name__
__module____qualname____doc__rp   r   ru   rz   r~   r   staticmethodr   r   rr   r^   r\   r`   r`      s    5,                 
   r^   r`   c                  N    e Zd ZdZddZd	dZd
dZeddd       Zedd       Z	y)rP   zZ
    Placeholder for use when no signing or verification
    operations are required.
    c                .    |dk(  rd }|t        d      |S )N z*When alg = "none", key value must be None.r   rs   s     r\   ru   zNoneAlgorithm.prepare_key   s$    "9C?!"NOO
r^   c                     y)Nr^   rr   rx   s      r\   rz   zNoneAlgorithm.sign   s    r^   c                     y)NFrr   r|   s       r\   r~   zNoneAlgorithm.verify   s    r^   c                    t               r   re   r   s     r\   r   zNoneAlgorithm.to_jwk       !##r^   c                    t               r   r   r   s    r\   r   zNoneAlgorithm.from_jwk   r   r^   N)rt   z
str | Noner   None)ry   rk   rt   r   r   rk   )ry   rk   rt   r   r}   rk   r   r   r   )r   r   r   r   r   r	   )r   r   r   r	   )
r   r   r   r   ru   rz   r~   r   r   r   rr   r^   r\   rP   rP      s>    
 $ $ $ $r^   rP   c                      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ZddZeedd              Zeeddd	              Zeddd
       Zedd       ZddZddZy)rQ   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]rR   rS   rT   c                    || _         y r   rb   rn   rb   s     r\   __init__zHMACAlgorithm.__init__  s	     r^   c                ^    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   rn   rt   	key_bytess      r\   ru   zHMACAlgorithm.prepare_key  s5    $	#z)'<!9 
 r^   c                     y r   rr   r   s     r\   r   zHMACAlgorithm.to_jwk       	r^   c                     y r   rr   r   s     r\   r   zHMACAlgorithm.to_jwk  r   r^   c                ~    t        t        |             j                         dd}|r|S t        j                  |      S )Noct)kkty)r   r   decodejsondumps)r   r   r   s      r\   r   zHMACAlgorithm.to_jwk  s<     "+g"67>>@

 J::c?"r^   c                   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      t        |d         S # t
        $ r t        d      w xY w)NKey is not valid JSONr   r   zNot an HMAC keyr   )	rf   r   r   loadsdict
ValueErrorr   getr   )r   objs     r\   r   zHMACAlgorithm.from_jwk)  s}    	;#s##zz#C&   775>U"!"344C))  	;!"9::	;s   ?A. .Bc                `    t        j                  ||| j                        j                         S r   )hmacnewrb   rm   rx   s      r\   rz   zHMACAlgorithm.sign:  s"    xxS$--07799r^   c                N    t        j                  || j                  ||            S r   )r   compare_digestrz   r|   s       r\   r~   zHMACAlgorithm.verify=  s     ""3		#s(;<<r^   N)rb   r   r   r   )rt   str | bytesr   rk   )r   r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   rk   )ry   rk   rt   rk   r   rk   )ry   rk   rt   rk   r}   rk   r   r   )r   r   r   r   hashlibsha256rR   __annotations__sha384rS   sha512rT   r   ru   r   r   r   r   rz   r~   rr   r^   r\   rQ   rQ      s    
 %,NNF!2$+NNF!2$+NNF!2!	       	# 	# * * :=r^   rQ   c                     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Z	ddZ
eedd              Zeeddd	              Ze	 d	 	 	 	 	 dd
       Zedd       ZddZddZy)rW   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]rR   rS   rT   c                    || _         y r   r   r   s     r\   r   zRSAAlgorithm.__init__M  	    $DMr^   c                f   t        |t        t        f      r|S t        |t        t        f      st        d      t        |      }	 |j                  d      rt        t        t        |            S t        t        t        |d             S # t        $ r t        t        t        |            cY S w xY w)NExpecting a PEM-formatted key.s   ssh-rsapassword)rf   r0   r2   rk   r   	TypeErrorr   
startswithr   r>   r<   r   r=   r   s      r\   ru   zRSAAlgorithm.prepare_keyP  s    #|<=
cE3<0 @AA#C(IJ''
3.A).LMM%';IPT'U   JL*=i*HIIJs   )B 0B "B0/B0c                     y r   rr   r   s     r\   r   zRSAAlgorithm.to_jwkc       r^   c                     y r   rr   r   s     r\   r   zRSAAlgorithm.to_jwkh  r   r^   c                   d }t        | d      r;| j                         }ddgt        |j                  j                        j                         t        |j                  j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         d
}nrt        | d      r[| j                         }ddgt        |j                        j                         t        |j                        j                         d}nt        d      |r|S t        j                  |      S )Nprivate_numbersRSArz   )
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   numberss       r\   r   zRSAAlgorithm.to_jwkm  sd    *.Cw 12!113 ! &x*7+A+A+C+CDKKM*7+A+A+C+CDKKM*7995<<>*7995<<>*7995<<>+GLL9@@B+GLL9@@B+GLL9@@B (+!002 ! (z*7995<<>*7995<<>	 &&CDD
zz#&r^   c                4   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      d|v rSd|v rNd|v rId|v rt        d	      g d
}|D cg c]  }||v  }}t        |      }|rt        |      st        d      t        t        |d         t        |d               }|rjt        t        |d         t        |d         t        |d         t        |d         t        |d         t        |d         |      }|j'                         S t        |d         }t        |j                  ||j                        \  }	}
t        ||	|
t!        ||	      t#        ||
      t%        |	|
      |      }|j'                         S d|v r6d|v r2t        t        |d         t        |d               j)                         S t        d      # t
        $ r t        d      w xY wc c}w )Nr   r   r   zNot an RSA keyr   r   r   othz5Unsupported RSA private key: > 2 primes not supported)r   r   r   r   r   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   )rf   r   r   r   r   r   r   r   anyallr3   r   r1   r7   r   r   r4   r5   r6   private_key
public_key)r   r   other_propspropprops_foundany_props_foundr   r   r   r   r   s              r\   r   zRSAAlgorithm.from_jwk  s0   ?c3'**S/CT*C$$ wwu~&%&677czcSjSCZC<)O  ;7BCtts{CC"%k"2"3{+;)Z  "2'C1'C1"
 #/-c#h7-c#h7-c#h70T;0T;0T;'5G2 **,, ,CH5A4&((!^-=-=DAq 0)!Q/)!Q/)!Q/'5G **,,s
''C1'C1 *,
 &&CDD{  ?%&=>>? Ds   ?G= H=Hc                h    |j                  |t        j                         | j                               S r   )rz   r!   PKCS1v15rb   rx   s      r\   rz   zRSAAlgorithm.sign  s$    88C!1!1!3T]]_EEr^   c                    	 |j                  ||t        j                         | j                                y# t        $ r Y yw xY w)NTF)r~   r!   r   rb   r   r|   s       r\   r~   zRSAAlgorithm.verify  s=    

3W%5%5%7I# s   47 	AANrb   ztype[hashes.HashAlgorithm]r   r   )rt   zAllowedRSAKeys | str | bytesr   AllowedRSAKeys)r   r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   ry   rk   rt   r0   r   rk   ry   rk   rt   r2   r}   rk   r   r   )r   r   r   r   r    rR   r   rS   rT   r   ru   r   r   r   r   rz   r~   rr   r^   r\   rW   rW   C  s    	
 8>}}4D7=}}4D7=}}4D	%	J& 
		 
 
	 
		 
 
	 
5:&	'#&	'.2&	' &	' 
&	'P 
E	E 
E	EN	F	r^   rW   c                     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Z	ddZ
ddZdd	Zeedd
              Zeeddd              Ze	 d	 	 	 	 	 dd       Zedd       Zy)rX   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   rR   rS   rT   c                    || _         y r   r   r   s     r\   r   zECAlgorithm.__init__  r   r^   c                Z   t        |t        t        f      r|S t        |t        t        f      st        d      t        |      }	 |j                  d      rt        |      }nt        |      }t        |t        t        f      st        d      |S # t        $ r t        |d       }Y ;w xY w)Nr   s   ecdsa-sha2-r   zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for ECDSA algorithms)rf   r(   r*   rk   r   r   r   r   r>   r=   r   r<   r   )rn   rt   r   
crypto_keys       r\   ru   zECAlgorithm.prepare_key  s    # 79OPQ
cE3<0 @AA#C(I
L''7!4Y!?J!4Y!?J
 46LM &y    L1)dK
Ls   (B B*)B*c                    |j                  |t        | j                                     }t        ||j                        S r   )rz   r"   rb   r   curve)rn   ry   rt   der_sigs       r\   rz   zECAlgorithm.sign  s.    hhsE$--/$:;G';;r^   c                   	 t        ||j                        }	 t        |t              r|j                         n|}|j                  ||t        | j                                      y# t        $ r Y yw xY w# t        $ r Y yw xY w)NFT)
r   r   r   rf   r(   r   r~   r"   rb   r   )rn   ry   rt   r}   r   r   s         r\   r~   zECAlgorithm.verify  s    .sCII>	 "#'>? NN$ 
 !!'3dmmo0FG   $ s#   A& AA5 &	A21A25	B Bc                     y r   rr   r   s     r\   r   zECAlgorithm.to_jwk)  r   r^   c                     y r   rr   r   s     r\   r   zECAlgorithm.to_jwk.  r   r^   c                   t        | t              r| j                         j                         }n,t        | t              r| j                         }nt        d      t        | j                  t              rd}not        | j                  t              rd}nRt        | j                  t              rd}n5t        | j                  t              rd}nt        d| j                         d|t        |j                        j                         t        |j                        j                         d}t        | t              r4t        | j                         j                         j                         |d	<   |r|S t#        j$                  |      S )
Nr   P-256P-384P-521	secp256k1Invalid curve: EC)r   crvxyr   )rf   r(   r   r   r*   r   r   r$   r%   r&   r#   r   r
  r   r  r   private_valuer   r   )r   r   r   r	  r   s        r\   r   zECAlgorithm.to_jwk3  s9    '#:;!(!3!3!5!D!D!FG%;<!(!7!7!9%&CDD'--3GMM95GMM95GMM95!%&GHH &~'7'78??A&~'7'78??A	#C '#:;,++-;;&( C 
zz#&r^   c                h   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      d|vsd|vrt        d      t        |j                  d            }t        |j                  d            }|j                  d      }|dk(  r@t        |      t        |      cxk(  rd	k(  rn t        d
      t               }nt        d
      |dk(  r@t        |      t        |      cxk(  rdk(  rn t        d      t               }nt        d      |dk(  r@t        |      t        |      cxk(  rdk(  rn t        d      t               }n^t        d      |dk(  r@t        |      t        |      cxk(  rd	k(  rn t        d      t               }nt        d      t        d|       t        t        j!                  |d      t        j!                  |d      |      }d|vr|j#                         S t        |j                  d            }t        |      t        |      k7  rt        dt        |      |      t%        t        j!                  |d      |      j'                         S # t
        $ r t        d      w xY w)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 {})rf   r   r   r   r   r   r   r   r   lenr$   r%   r&   r#   r+   int
from_bytesr   r)   r   )r   r   r
  r  r   	curve_objr   r   s           r\   r   zECAlgorithm.from_jwkZ  s~   ?c3'**S/CT*C$$ wwu~%%&ABB#~C%&ABB .A .AGGENE q6SV)r) **UVV !*I)*UVV'!q6SV)r) **UVV !*I)*UVV'!q6SV)r) **UVV !*I)*UVV+%q6SV)r) *G  !*I)G  &w&?@@7..e.4..e.4N #~%0022 .A1vQ%7Q  /qE2Nkmo  ?%&=>>?s   ?J J1Nr   )rt   zAllowedECKeys | str | bytesr   AllowedECKeys)ry   rk   rt   r(   r   rk   )ry   rk   rt   z'AllowedECKeys'r}   rk   r   r   )r   r  r   r   r   r   r   )r   r  r   r   r   r   )r   r  r   r   r   r   )r   r   r   r  )r   r   r   r   r    rR   r   rS   rT   r   ru   rz   r~   r   r   r   r   rr   r^   r\   rX   rX     s    	
 8>}}4D7=}}4D7=}}4D	%	<	<
	" 
		 
 
	 
		 
 
	 
49$	'"$	'-1$	' $	' 
$	'L 
A	 
A	r^   rX   c                       e Zd ZdZddZddZy)rY   zA
        Performs a signature using RSASSA-PSS with MGF1
        c           	         |j                  |t        j                  t        j                  | j	                               | j	                         j
                        | j	                               S )Nmgfsalt_length)rz   r!   PSSMGF1rb   digest_sizerx   s      r\   rz   zRSAPSSAlgorithm.sign  sN    88T]]_5 $ ; ;  r^   c           
        	 |j                  ||t        j                  t        j                  | j	                               | j	                         j
                        | j	                                y# t        $ r Y yw xY w)Nr  TF)r~   r!   r  r  rb   r  r   r|   s       r\   r~   zRSAPSSAlgorithm.verify  sh    

KK#LL9$(MMO$?$? MMO # s   A0A3 3	A?>A?Nr   r   )r   r   r   r   rz   r~   rr   r^   r\   rY   rY     s    			r^   rY   c                      e Zd ZdZddZddZ	 	 	 	 	 	 ddZ	 	 	 	 	 	 	 	 ddZee	dd              Z
ee	ddd              Z
e	ddd       Z
e	dd	       Zy
)rZ   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        c                     y r   rr   )rn   kwargss     r\   r   zOKPAlgorithm.__init__  s    r^   c                ~   t        |t        t        f      r{t        |t              r|j                  d      n|}t        |t              r|j	                  d      n|}d|v rt        |      }n%d|v rt        |d       }n|dd dk(  rt        |      }t        |t        t        t        t        f      st        d      |S )	Nutf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr   r      zssh-zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for EdDSA algorithms)rf   rk   r   r   encoder=   r<   r>   r.   r/   r,   r-   r   )rn   rt   key_strr   s       r\   ru   zOKPAlgorithm.prepare_key  s    #s|,1;C1G#**W-S3=c33GCJJw/S	&'1-i8C)W4.y4HCQq\V+-i8C "$4o~V &y  Jr^   c                j    t        |t              r|j                  d      n|}|j                  |      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%  )rf   r   r'  rz   )rn   ry   rt   	msg_bytess       r\   rz   zOKPAlgorithm.sign  s,     0:#s/C

7+I88I&&r^   c                $   	 t        |t              r|j                  d      n|}t        |t              r|j                  d      n|}t        |t        t        f      r|j                         n|}|j                  ||       y# t        $ r Y yw xY 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)rf   r   r'  r.   r,   r   r~   r   )rn   ry   rt   r}   r*  	sig_bytesr   s          r\   r~   zOKPAlgorithm.verify  s    3=c33GCJJw/S	3=c33GCJJw/S	 "#(9?'KL NN$ 
 !!)Y7# s   B B 	BBc                     y r   rr   rt   r   s     r\   r   zOKPAlgorithm.to_jwk  r   r^   c                     y r   rr   r.  s     r\   r   zOKPAlgorithm.to_jwk	  r   r^   c                F   t        | t        t        f      r| j                  t        j
                  t        j
                        }t        | t              rdnd}t        t        |            j                         d|d}|r|S t        j                  |      S t        | t        t        f      r| j                  t        j
                  t        j
                  t!                     }| j#                         j                  t        j
                  t        j
                        }t        | t              rdnd}t        t        |            j                         t        t        |            j                         d|d}|r|S t        j                  |      S t%        d      )	N)encodingformatEd25519Ed448OKP)r
  r   r	  )r1  r2  encryption_algorithm)r
  r   r   r	  r   )rf   r/   r-   public_bytesr8   Rawr;   r   r   r   r   r   r.   r,   private_bytesr:   r9   r   r   )rt   r   r
  r	  r   r   s         r\   r   zOKPAlgorithm.to_jwk  s\   # 0.AB$$%\\'++ %  $.c3C#Di' *+a.9@@B  J::c?*# 1?CD%%%\\(,,)5 &  NN$11%\\'++ 2 
 $.c3D#Ei7)+a.9@@B)+a.9@@B 	 J::c?*!"?@@r^   c                   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      |j                  d      }|dk7  r|dk7  rt        d|       d	|vrt        d
      t        |j                  d	            }	 d|vr/|dk(  rt        j                  |      S t        j                  |      S t        |j                  d            }|dk(  rt        j                  |      S t        j                  |      S # t
        $ r t        d      w xY w# t
        $ r}t        d      |d }~ww xY w)Nr   r   r5  zNot an Octet Key Pairr	  r3  r4  r  r
  zOKP should have "x" parameterr   zInvalid key parameter)rf   r   r   r   r   r   r   r   r   r/   from_public_bytesr-   r.   from_private_bytesr,   )r   r   r   r
  r   errs         r\   r   zOKPAlgorithm.from_jwk=  sU   ?c3'**S/CT*C$$ wwu~&%&=>>GGENE	!ew&6%w&?@@#~%&EFF .A
Hc>	)/AA!DD);;A>>$SWWS\2I%,??BB&99!<<-  ?%&=>>?.  H%&=>CGHs5   ?D/ 3E E &3E E /E	E!EE!N)r#  r   r   r   )rt   zAllowedOKPKeys | str | bytesr   AllowedOKPKeys)ry   r   rt   z#Ed25519PrivateKey | Ed448PrivateKeyr   rk   )ry   r   rt   r>  r}   r   r   r   )rt   r>  r   r   r   r   r   )rt   r>  r   r   r   r   )rt   r>  r   r   r   r   )r   r   r   r>  )r   r   r   r   r   ru   rz   r~   r   r   r   r   rr   r^   r\   rZ   rZ     s    			.	'"	')L	'	'	"	)7	>I		4 
		 
 
	 
		 
 
	 
,	A 
,	A\ 
 	H 
 	Hr^   rZ   )r   zdict[str, Algorithm])^
__future__r   r   r   r   sysabcr   r   typingr   r   r   r	   r
   r   r   
exceptionsr   typesr   r   utilsr   r   r   r   r   r   r   r   r   version_infor   typing_extensionscryptography.exceptionsr   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.rsar0   r1   r2   r3   r4   r5   r6   r7   ,cryptography.hazmat.primitives.serializationr8   r9   r:   r;   r<   r=   r>   rU   ModuleNotFoundErrorr   r  r>  AllowedKeysAllowedPrivateKeysAllowedPublicKeysrequires_cryptographyr]   r`   rP   rQ   rW   rX   rY   rZ   rr   r^   r\   <module>rV     s   "    
 # P P P ' '
 
 
 v)/8<5A  	 	 	   J
 "\1N+.DDM,,>O  !=0>AK//2CCoU  	--0@@>Q 
  DH HV$I $<C=I C=L cy cJti tl, <bHy bHw k  Js   2A(E( (E21E2