
    gv                       d dl m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 	 d 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+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 d dl3m4Z4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA d dlBmCZCmDZDmEZEmFZFmGZGmHZHmIZI dZJe	r3e:e<z  ZLe/e1z  ZMe7e8z  e4z  e5z  ZNeLeMz  eNz  ZOe:e/z  e7z  e4z  ZPe<e1z  e8z  e5z  ZQh dZRd$dZS G d de      ZT G d deT      ZU G d deT      ZVeJr- G d deT      ZW G d deT      ZX G d  d!eW      ZY G d" d#eT      ZZyy# eK$ r dZJY w xY w)%    )annotationsN)ABCabstractmethod)TYPE_CHECKINGAnyClassVarLiteralNoReturn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)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_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)rE   rF   rG   r=   rH   r>   r@   r?   rB   rC   rD   rA   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmRSAPSSAlgorithmOKPAlgorithm)default_algorithmss    N/var/www/api/v1/venv_getwork_v1/lib/python3.12/site-packages/jwt/algorithms.pyget_default_algorithmsr[   i   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NotImplementedErrorrS   
isinstancetype
issubclassr   HashAlgorithmHashr   rT   bytesfinalizedigest)selfbytestrr`   rk   s       rZ   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 rl   keys     rZ   prepare_keyzAlgorithm.prepare_key       r\   c                     y)zn
        Returns a digital signature for the specified message
        using the specified key value.
        Nrp   rl   msgrr   s      rZ   signzAlgorithm.sign   rt   r\   c                     y)zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        Nrp   rl   rw   rr   sigs       rZ   verifyzAlgorithm.verify   rt   r\   c                     y Nrp   key_objas_dicts     rZ   to_jwkzAlgorithm.to_jwk   s     =@r\   c                     y r~   rp   r   s     rZ   r   zAlgorithm.to_jwk   s	     BEr\   c                     y)z3
        Serializes a given key into a JWK
        Nrp   r   s     rZ   r   zAlgorithm.to_jwk   rt   r\   c                     y)zJ
        Deserializes a given key from JWK back into a key object
        Nrp   jwks    rZ   from_jwkzAlgorithm.from_jwk   rt   r\   N)rm   ri   returnri   )rr   r   r   r   )rw   ri   rr   r   r   ri   )rw   ri   rr   r   r{   ri   r   bool)r   Literal[True]r   r   F)r   Literal[False]r   str)r   r   r   JWKDict | str)r   str | JWKDictr   r   )__name__
__module____qualname____doc__rn   r   rs   rx   r|   r   staticmethodr   r   rp   r\   rZ   r^   r^      s    5,       ?    @D    E  
   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)rN   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   rq   s     rZ   rs   zNoneAlgorithm.prepare_key   s$    "9C?!"NOO
r\   c                     y)Nr\   rp   rv   s      rZ   rx   zNoneAlgorithm.sign   s    r\   c                     y)NFrp   rz   s       rZ   r|   zNoneAlgorithm.verify   s    r\   c                    t               r~   rc   r   s     rZ   r   zNoneAlgorithm.to_jwk       !##r\   c                    t               r~   r   r   s    rZ   r   zNoneAlgorithm.from_jwk   r   r\   N)rr   z
str | Noner   None)rw   ri   rr   r   r   ri   )rw   ri   rr   r   r{   ri   r   r   r   )r   r   r   r   r   r
   )r   r   r   r
   )
r   r   r   r   rs   rx   r|   r   r   r   rp   r\   rZ   rN   rN      s>    
 $ $ $ $r\   rN   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)rO   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]rP   rQ   rR   c                    || _         y r~   r`   rl   r`   s     rZ   __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   rl   rr   	key_bytess      rZ   rs   zHMACAlgorithm.prepare_key   s5    $	#z)'<!9 
 r\   c                     y r~   rp   r   s     rZ   r   zHMACAlgorithm.to_jwk
       r\   c                     y r~   rp   r   s     rZ   r   zHMACAlgorithm.to_jwk  s     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      rZ   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      d w xY w)NKey is not valid JSONr   r   zNot an HMAC keyr   )	rd   r   r   loadsdict
ValueErrorr   getr   )r   objs     rZ   r   zHMACAlgorithm.from_jwk"  s    	E#s##zz#C&   775>U"!"344C))  	E!"9:D	Es   ?A. .Bc                `    t        j                  ||| j                        j                         S r~   )hmacnewr`   rk   rv   s      rZ   rx   zHMACAlgorithm.sign3  s"    xxS$--07799r\   c                N    t        j                  || j                  ||            S r~   )r   compare_digestrx   rz   s       rZ   r|   zHMACAlgorithm.verify6  s     ""3		#s(;<<r\   N)r`   r   r   r   )rr   str | bytesr   ri   )r   r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   ri   )rw   ri   rr   ri   r   ri   )rw   ri   rr   ri   r{   ri   r   r   )r   r   r   r   hashlibsha256rP   __annotations__sha384rQ   sha512rR   r   rs   r   r   r   r   rx   r|   rp   r\   rZ   rO   rO      s    
 %,NNF!2$+NNF!2$+NNF!2!	 '4	   8='5	   	# 	# * * :=r\   rO   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)rU   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]rP   rQ   rR   c                    || _         y r~   r   r   s     rZ   r   zRSAAlgorithm.__init__F  	    $DMr\   c                   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 # t        t        f$ r t        d      d w xY ww xY w)NExpecting a PEM-formatted key.s   ssh-rsapasswordz(Could not parse the provided public key.)rd   r.   r0   ri   r   	TypeErrorr   
startswithr   r<   r:   r   r;   r   r   r   s      rZ   rs   zRSAAlgorithm.prepare_keyI  s    #|<=
cE3<0 @AA#C(I ''
3.A).LMM%';IPT'U     .A).LMM"$89  )B   s*   )B 0B 	CB0-C0CCc                     y r~   rp   r   s     rZ   r   zRSAAlgorithm.to_jwka       r\   c                     y r~   rp   r   s     rZ   r   zRSAAlgorithm.to_jwkg  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RSArx   )
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       rZ   r   zRSAAlgorithm.to_jwkm  sb   )-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                :   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      d d|v rTd|v rOd|v rJd|v rt        d	      g d
}|D cg c]  }||v  }}t        |      }|rt        |      st        d      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      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   )rd   r   r   r   r   r   r   r   anyallr1   r   r/   r5   r   r   r2   r3   r4   private_key
public_key)r   r   other_propspropprops_foundany_props_foundr   r   r   r   r   s              rZ   r   zRSAAlgorithm.from_jwk  s;   Ic3'**S/CT*C$$ wwu~&%&67TAczcSjSCZC<)O  ;7BC{tts{{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{  I%&=>DHI Ds   ?G? H?Hc                h    |j                  |t        j                         | j                               S r~   )rx   r   PKCS1v15r`   rv   s      rZ   rx   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   r`   r   rz   s       rZ   r|   zRSAAlgorithm.verify  s=    

3W%5%5%7I# s   47 	AANr`   ztype[hashes.HashAlgorithm]r   r   )rr   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   rw   ri   rr   r.   r   ri   rw   ri   rr   r0   r{   ri   r   r   )r   r   r   r   r   rP   r   rQ   rR   r   rs   r   r   r   r   rx   r|   rp   r\   rZ   rU   rU   <  s    	
 8>}}4D7=}}4D7=}}4D	%	 0 
		#	.;		 
 
	 
	?D	#	.<		 
 
	 
$	' 
$	'L 
E	E 
E	EN	F	r\   rU   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)rV   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   rP   rQ   rR   c                    || _         y r~   r   r   s     rZ   r   zECAlgorithm.__init__  r   r\   c                \   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      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)rd   r&   r(   ri   r   r   r   r   r<   r;   r   r:   r   )rl   rr   r   
crypto_keys       rZ   rs   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~   )rx   r    r`   r   curve)rl   rw   rr   der_sigs       rZ   rx   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   rd   r&   r   r|   r    r`   r   )rl   rw   rr   r{   r   r   s         rZ   r|   zECAlgorithm.verify  s    .sCII>	 "#'>? NN$ 
 !!'3dmmo0FG   $ s#   A& AA5 &	A21A25	B Bc                     y r~   rp   r   s     rZ   r   zECAlgorithm.to_jwk'  r   r\   c                     y r~   rp   r   s     rZ   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                  j                        j                         t        |j                  | j                  j                        j                         d	}t        | t              rJt        | j!                         j"                  | j                  j                        j                         |d
<   |r|S t%        j&                  |      S )Nr   P-256P-384P-521	secp256k1Invalid curve: EC)
bit_length)r   crvxyr   )rd   r&   r   r   r(   r   r   r"   r#   r$   r!   r   r  key_sizer   r	  r   private_valuer   r   )r   r   r   r  r   s        rZ   r   zECAlgorithm.to_jwk3  sf   '#:;!(!3!3!5!D!D!FG%;<!(!7!7!9%&CDD'--3GMM95GMM95GMM95!%&GHH &"$$&}}55 &(&"$$&}}55 &(#C '#:;,++-;;&}}55 &( C
 
zz#&r\   c                8   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      d d|vsd|vrt        d      d t        |j                  d            }t        |j                  d            }|j                  d      }|dk(  r7t        |      t        |      cxk(  rd	k(  rn nt               }nt        d
      d |dk(  r7t        |      t        |      cxk(  rdk(  rn nt               }nt        d      d |dk(  r7t        |      t        |      cxk(  rdk(  rn nt               }n_t        d      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      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 {})rd   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           rZ   r   zECAlgorithm.from_jwk_  sr   Ic3'**S/CT*C$$ wwu~%%&ABL#~C%&ABL .A .AGGENE q6SV)r) )I)C  '!q6SV)r) )I)C  '!q6SV)r) )I)C  +%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{  I%&=>DHIs   ?J JNr   )rr   zAllowedECKeys | str | bytesr   AllowedECKeys)rw   ri   rr   r&   r   ri   )rw   ri   rr   r  r{   ri   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   rP   r   rQ   rR   r   rs   rx   r|   r   r   r   r   rp   r\   rZ   rV   rV     s    	
 8>}}4D7=}}4D7=}}4D	%	<	<
	" 
		"	-:		 
 
	 
	>C	"	-;		 
 
	 
)	' 
)	'V 
G	 
G	r\   rV   c                       e Zd ZdZddZddZy)rW   zA
        Performs a signature using RSASSA-PSS with MGF1
        c           	         |j                  |t        j                  t        j                  | j	                               | j	                         j
                        | j	                               S )Nmgfsalt_length)rx   r   PSSMGF1r`   digest_sizerv   s      rZ   rx   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  r`   r  r   rz   s       rZ   r|   zRSAPSSAlgorithm.verify  sh    

KK#LL9$(MMO$?$? MMO # s   A0A3 3	A?>A?Nr   r   )r   r   r   r   rx   r|   rp   r\   rZ   rW   rW     s    			r\   rW   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
)rX   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        c                     y r~   rp   )rl   kwargss     rZ   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)rd   ri   r   r   encoder;   r:   r<   r,   r-   r*   r+   r   )rl   rr   key_strr   s       rZ   rs   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$  )rd   r   r&  rx   )rl   rw   rr   	msg_bytess       rZ   rx   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)rd   r   r&  r,   r*   r   r|   r   )rl   rw   rr   r{   r)  	sig_bytesr   s          rZ   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~   rp   rr   r   s     rZ   r   zOKPAlgorithm.to_jwk  r   r\   c                     y r~   rp   r-  s     rZ   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  )r0  r1  encryption_algorithm)r  r   r   r  r   )rd   r-   r+   public_bytesr6   Rawr9   r   r   r   r   r   r,   r*   private_bytesr8   r7   r   r   )rr   r   r  r  r   r   s         rZ   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      d w xY w# t
        $ r}t        d      |d }~ww xY w)Nr   r   r4  zNot an Octet Key Pairr  r2  r3  r  r  zOKP should have "x" parameterr   zInvalid key parameter)rd   r   r   r   r   r   r   r   r   r-   from_public_bytesr+   r,   from_private_bytesr*   )r   r   r   r  r   errs         rZ   r   zOKPAlgorithm.from_jwkJ  sZ   I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!<<-  I%&=>DHI.  H%&=>CGHs5   ?D/ 3E E &3E E /E	E"EE"N)r"  r   r   r   )rr   zAllowedOKPKeys | str | bytesr   AllowedOKPKeys)rw   r   rr   z#Ed25519PrivateKey | Ed448PrivateKeyr   ri   )rw   r   rr   r=  r{   r   r   r   )rr   r=  r   r   r   r   r   )rr   r=  r   r   r   r   )rr   r=  r   r   r   r   )r   r   r   r=  )r   r   r   r   r   rs   rx   r|   r   r   r   r   rp   r\   rZ   rX   rX     s    			.	'"	')L	'	'	"	)7	>I		4 
			*7		 
 
	 
	;@		*8		 
 
	 
,	A 
,	A\ 
 	H 
 	Hr\   rX   )r   zdict[str, Algorithm])[
__future__r   r   r   r   abcr   r   typingr   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.   r/   r0   r1   r2   r3   r4   r5   ,cryptography.hazmat.primitives.serializationr6   r7   r8   r9   r:   r;   r<   rS   ModuleNotFoundErrorr   r  r=  AllowedKeysAllowedPrivateKeysAllowedPublicKeysrequires_cryptographyr[   r^   rN   rO   rU   rV   rW   rX   rp   r\   rZ   <module>rR     s   "    # R R R ' '
 
 
/N<5A  	 	 	   J
 "\1N+.DDM,,>O  !=0>AK//2CCoU  	--0@@>Q 
  DF FR$I $<E=I E=P hy hTAi AF, <dHy dH[ k  Js   A*E
 
EE