o
    shv                     @  sp  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 zld 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ZJW n eKy   dZJY nw e	re:e<B ZLe/e1B ZMe7e8B e4B e5B ZNeLeMB eNB ZOe:e/B e7B e4B ZPe<e1B e8B e5B ZQh dZRd'ddZSG dd deZTG dd deTZUG dd deTZVeJr6G dd  d eTZWG d!d" d"eTZXG d#d$ d$eWZYG d%d& d&eTZZdS dS )(    )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ES256Kreturndict[str, Algorithm]c                  C  s   t  ttjttjttjd} trG| 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)rD   rE   rF   r<   rG   r=   r?   r>   rA   rB   rC   r@   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmRSAPSSAlgorithmOKPAlgorithm)default_algorithms rZ   b/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/jwt/algorithms.pyget_default_algorithmsi   s0   r\   c                   @  s   e Zd ZdZd"ddZed#d	d
Zed$ddZed%ddZe	e
ed&ddZe	e
ed'd(ddZe
ed'd)ddZe
ed*dd Zd!S )+	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    bytestrbytesrH   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NotImplementedErrorrS   
isinstancetype
issubclassr   HashAlgorithmHashr   rT   r_   finalizedigest)selfr^   r`   rj   rZ   rZ   r[   compute_hash_digest   s   

zAlgorithm.compute_hash_digestkeyr   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().
        NrZ   rk   rm   rZ   rZ   r[   prepare_key       zAlgorithm.prepare_keymsgc                 C  rn   )zn
        Returns a digital signature for the specified message
        using the specified key value.
        NrZ   rk   rr   rm   rZ   rZ   r[   sign   rq   zAlgorithm.signsigboolc                 C  rn   )zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        NrZ   rk   rr   rm   ru   rZ   rZ   r[   verify   rq   zAlgorithm.verifyas_dictLiteral[True]r   c                 C     d S NrZ   key_objry   rZ   rZ   r[   to_jwk      zAlgorithm.to_jwkFLiteral[False]strc                 C  r{   r|   rZ   r}   rZ   rZ   r[   r      r   JWKDict | strc                 C  rn   )z3
        Serializes a given key into a JWK
        NrZ   r}   rZ   rZ   r[   r      rq   jwkstr | JWKDictc                 C  rn   )zJ
        Deserializes a given key from JWK back into a key object
        NrZ   r   rZ   rZ   r[   from_jwk   rq   zAlgorithm.from_jwkN)r^   r_   rH   r_   )rm   r   rH   r   )rr   r_   rm   r   rH   r_   )rr   r_   rm   r   ru   r_   rH   rv   )ry   rz   rH   r   F)ry   r   rH   r   )ry   rv   rH   r   )r   r   rH   r   )__name__
__module____qualname____doc__rl   r   rp   rt   rx   r   staticmethodr   r   rZ   rZ   rZ   r[   r]      s.    
r]   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 )"rN   zZ
    Placeholder for use when no signing or verification
    operations are required.
    rm   
str | NonerH   Nonec                 C  s    |dkrd }|d urt d|S )N z*When alg = "none", key value must be None.r   ro   rZ   rZ   r[   rp      s
   zNoneAlgorithm.prepare_keyrr   r_   c                 C  rn   )N    rZ   rs   rZ   rZ   r[   rt         zNoneAlgorithm.signru   rv   c                 C  rn   )NFrZ   rw   rZ   rZ   r[   rx      r   zNoneAlgorithm.verifyFr~   r   ry   r	   c                 C     t  r|   rc   r}   rZ   rZ   r[   r         zNoneAlgorithm.to_jwkr   r   c                 C  r   r|   r   r   rZ   rZ   r[   r      r   zNoneAlgorithm.from_jwkN)rm   r   rH   r   )rr   r_   rm   r   rH   r_   )rr   r_   rm   r   ru   r_   rH   rv   r   )r~   r   ry   rv   rH   r	   )r   r   rH   r	   )
r   r   r   r   rp   rt   rx   r   r   r   rZ   rZ   rZ   r[   rN      s    

	
rN   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,d-ddZed,d.ddZed/d d!Zd0d#d$Zd1d&d'Zd(S )2rO   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]rP   rQ   rR   r`   r   rH   r   c                 C  
   || _ d S r|   r`   rk   r`   rZ   rZ   r[   __init__      
zHMACAlgorithm.__init__rm   str | bytesr_   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   rk   rm   	key_bytesrZ   rZ   r[   rp      s   zHMACAlgorithm.prepare_keyr~   ry   rz   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   
     zHMACAlgorithm.to_jwkFr   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r     r   rv   r   c                 C  s(   t t|  dd}|r|S t|S )Noct)kkty)r   r   decodejsondumps)r~   ry   r   rZ   rZ   r[   r     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   )	rd   r   r   loadsdict
ValueErrorr   getr   )r   objrZ   rZ   r[   r   "  s   


zHMACAlgorithm.from_jwkrr   c                 C  s   t ||| j S r|   )hmacnewr`   rj   rs   rZ   rZ   r[   rt   3     zHMACAlgorithm.signru   c                 C  s   t || ||S r|   )r   compare_digestrt   rw   rZ   rZ   r[   rx   6  r   zHMACAlgorithm.verifyN)r`   r   rH   r   )rm   r   rH   r_   )r~   r   ry   rz   rH   r   r   )r~   r   ry   r   rH   r   )r~   r   ry   rv   rH   r   )r   r   rH   r_   )rr   r_   rm   r_   rH   r_   )rr   r_   rm   r_   ru   r_   rH   rv   )r   r   r   r   hashlibsha256rP   __annotations__sha384rQ   sha512rR   r   rp   r   r   r   r   rt   rx   rZ   rZ   rZ   r[   rO      s(   
 


rO   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d+S )5rU   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]rP   rQ   rR   r`   type[hashes.HashAlgorithm]rH   r   c                 C  r   r|   r   r   rZ   rZ   r[   r   F  r   zRSAAlgorithm.__init__rm   AllowedRSAKeys | str | bytesAllowedRSAKeysc                 C  s   t |ttfr	|S t |ttfstdt|}z|dr&ttt	|W S ttt
|d dW S  tyO   z
ttt|W  Y S  ttfyN   tdd w w )NExpecting a PEM-formatted key.s   ssh-rsapasswordz(Could not parse the provided public key.)rd   r-   r/   r_   r   	TypeErrorr   
startswithr
   r;   r9   r   r:   r   r   r   rZ   rZ   r[   rp   I  s,   
zRSAAlgorithm.prepare_keyr~   ry   rz   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   a  r   zRSAAlgorithm.to_jwkFr   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   g  r   rv   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RSArt   )
r   key_opsnedpqdpdqqirx   )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~   ry   r   numbersrZ   rZ   r[   r   m  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 rZ   rZ   ).0propr   rZ   r[   
<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   )rd   r   r   r   r   r   r   r   anyallr0   r   r.   r4   r   r   r1   r2   r3   private_key
public_key)	r   other_propsprops_foundany_props_foundr   r   r   r   r   rZ   r   r[   r     s~   















zRSAAlgorithm.from_jwkrr   r_   r-   c                 C  s   | |t |  S r|   )rt   r   PKCS1v15r`   rs   rZ   rZ   r[   rt     s   zRSAAlgorithm.signr/   ru   c                 C  s4   z| ||t |   W dS  ty   Y dS w )NTF)rx   r   r   r`   r   rw   rZ   rZ   r[   rx     s   zRSAAlgorithm.verifyNr`   r   rH   r   )rm   r   rH   r   )r~   r   ry   rz   rH   r   r   )r~   r   ry   r   rH   r   )r~   r   ry   rv   rH   r   )r   r   rH   r   rr   r_   rm   r-   rH   r_   rr   r_   rm   r/   ru   r_   rH   rv   )r   r   r   r   r   rP   r   rQ   rR   r   rp   r   r   r   r   rt   rx   rZ   rZ   rZ   r[   rU   <  s(   
 

&
GrU   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
d-ddZd.ddZeed/ddZee	 d0d1d#dZed0d2d%dZed3d(d)Zd*S )4rV   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   rP   rQ   rR   r`   r   rH   r   c                 C  r   r|   r   r   rZ   rZ   r[   r     r   zECAlgorithm.__init__rm   AllowedECKeys | str | bytesAllowedECKeysc                 C  s   t |ttfr	|S t |ttfstdt|}z|dr#t|}nt	|}W n t
y7   t|d d}Y nw t |ttfsDtdd |S )Nr   s   ecdsa-sha2-r   zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for ECDSA algorithms)rd   r%   r'   r_   r   r   r   r   r;   r:   r   r9   r   )rk   rm   r   
crypto_keyrZ   rZ   r[   rp     s,   

zECAlgorithm.prepare_keyrr   r_   r%   c                 C  s    | |t|  }t||jS r|   )rt   r   r`   r   curve)rk   rr   rm   der_sigrZ   rZ   r[   rt     s   zECAlgorithm.signru   rv   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   rd   r%   r   rx   r   r`   r   )rk   rr   rm   ru   r   r   rZ   rZ   r[   rx     s   
zECAlgorithm.verifyr~   ry   rz   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   '  r   zECAlgorithm.to_jwkFr   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   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   )rd   r%   r   r   r'   r   r   r!   r"   r#   r    r   r   key_sizer   r   r   private_valuer   r   )r~   ry   r   r   r   rZ   rZ   r[   r   3  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 {})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   rZ   rZ   r[   r   _  s   





   
zECAlgorithm.from_jwkNr   )rm   r   rH   r   )rr   r_   rm   r%   rH   r_   )rr   r_   rm   r   ru   r_   rH   rv   )r~   r   ry   rz   rH   r   r   )r~   r   ry   r   rH   r   )r~   r   ry   rv   rH   r   )r   r   rH   r   )r   r   r   r   r   rP   r   rQ   rR   r   rp   rt   rx   r   r   r   r   rZ   rZ   rZ   r[   rV     s(   
 



+rV   c                   @  s$   e Zd ZdZdddZdddZdS )rW   zA
        Performs a signature using RSASSA-PSS with MGF1
        rr   r_   rm   r-   rH   c                 C  s,   | |tjt|  |  jd|  S )Nmgfsalt_length)rt   r   PSSMGF1r`   digest_sizers   rZ   rZ   r[   rt     s   zRSAPSSAlgorithm.signr/   ru   rv   c              	   C  sJ   z| ||tjt|  |  jd|   W dS  ty$   Y dS w )Nr   TF)rx   r   r   r   r`   r   r   rw   rZ   rZ   r[   rx     s   	zRSAPSSAlgorithm.verifyNr   r   )r   r   r   r   rt   rx   rZ   rZ   rZ   r[   rW     s    

rW   c                   @  s~   e Zd Zd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	d/d$d%Zd&S )0rX   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        kwargsr   rH   r   c                 K  r{   r|   rZ   )rk   r   rZ   rZ   r[   r     r   zOKPAlgorithm.__init__rm   AllowedOKPKeys | str | bytesAllowedOKPKeysc                 C  s   t |ttfr?t |tr|dn|}t |tr|dn|}d|v r(t|}nd|v r3t|d d}n|dd dkr?t|}t |tt	t
tfsLtd|S )	Nutf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr   r      zssh-zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for EdDSA algorithms)rd   r_   r   r   encoder:   r9   r;   r+   r,   r)   r*   r   )rk   rm   key_strr   rZ   rZ   r[   rp     s"   

zOKPAlgorithm.prepare_keyrr   r   #Ed25519PrivateKey | Ed448PrivateKeyr_   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  )rd   r   r  rt   )rk   rr   rm   	msg_bytesrZ   rZ   r[   rt     s   

zOKPAlgorithm.signru   rv   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)rd   r   r  r+   r)   r   rx   r   )rk   rr   rm   ru   r  	sig_bytesr   rZ   rZ   r[   rx     s   
zOKPAlgorithm.verifyry   rz   r   c                 C  r{   r|   rZ   rm   ry   rZ   rZ   r[   r     r   zOKPAlgorithm.to_jwkFr   r   c                 C  r{   r|   rZ   r	  rZ   rZ   r[   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   )rd   r,   r*   public_bytesr5   Rawr8   r   r   r   r   r   r+   r)   private_bytesr7   r6   r   r   )rm   ry   r   r   r   r   rZ   rZ   r[   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   r  zNot an Octet Key Pairr   r  r  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   errrZ   rZ   r[   r   J  s>   




zOKPAlgorithm.from_jwkN)r   r   rH   r   )rm   r   rH   r  )rr   r   rm   r  rH   r_   )rr   r   rm   r  ru   r   rH   rv   )rm   r  ry   rz   rH   r   r   )rm   r  ry   r   rH   r   )rm   r  ry   rv   rH   r   )r   r   rH   r  )r   r   r   r   r   rp   rt   rx   r   r   r   r   rZ   rZ   rZ   r[   rX     s"    



.rX   )rH   rI   )[
__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.   r/   r0   r1   r2   r3   r4   ,cryptography.hazmat.primitives.serializationr5   r6   r7   r8   r9   r:   r;   rS   ModuleNotFoundErrorr   r   r  AllowedKeysAllowedPrivateKeysAllowedPublicKeysrequires_cryptographyr\   r]   rN   rO   rU   rV   rW   rX   rZ   rZ   rZ   r[   <module>   sb    $,0($


"IH + D   