解密

python -m pip install cryptography

import base64
import binascii
import json
from typing import Any

from cryptography.exceptions import InvalidTag, UnsupportedAlgorithm
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding, rsa
from cryptography.hazmat.primitives.ciphers.aead import AESGCM


def _decode_base64(value: str) -> bytes:
    if not isinstance(value, str):
        raise TypeError("Expected a Base64 string")
    return base64.b64decode("".join(value.split()), validate=True)


def decrypt_credential(
    private_key_pem: bytes, key: str, payload: str
) -> dict[str, Any]:
    try:
        private_key = serialization.load_pem_private_key(
            private_key_pem, password=None
        )
        if not isinstance(private_key, rsa.RSAPrivateKey):
            raise ValueError("Expected an RSA private key")

        aes_key_text = private_key.decrypt(
            _decode_base64(key),
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA1()),
                algorithm=hashes.SHA256(),
                label=b"",
            ),
        )
        aes_key = _decode_base64(aes_key_text.decode("ascii"))
        if len(aes_key) != 32:
            raise ValueError("Expected a 32-byte AES key")

        envelope = _decode_base64(payload)
        if len(envelope) <= 12 + 16:
            raise ValueError("Invalid payload length")
        iv = envelope[:12]
        ciphertext_and_tag = envelope[12:]
        plaintext = AESGCM(aes_key).decrypt(iv, ciphertext_and_tag, None)
        body = json.loads(plaintext.decode("utf-8"))
        if not isinstance(body, dict):
            raise ValueError("Expected a JSON object")
        return body
    except (
        ValueError,
        TypeError,
        binascii.Error,
        InvalidTag,
        UnsupportedAlgorithm,
    ):
        raise ValueError("Credential decryption failed") from None

def read_dynamic_data(signed_payload: str) -> dict[str, Any]:
    # Decodes JWT claims; does not verify the JWT signature.
    try:
        parts = signed_payload.split(".")
        if len(parts) != 3:
            raise ValueError("Expected a JWT")
        claims_bytes = base64.b64decode(
            parts[1] + "=" * (-len(parts[1]) % 4),
            altchars=b"-_",
            validate=True,
        )
        claims = json.loads(claims_bytes.decode("utf-8"))
        dynamic_data = claims["dynamicData"][0]
        if not isinstance(dynamic_data, dict):
            raise ValueError("Expected dynamicData")
        return dynamic_data
    except (ValueError, TypeError, KeyError, IndexError, binascii.Error):
        raise ValueError("Invalid credential claims") from None