Playground

"""Token service - the cryptography a typical Python backend actually uses."""

import hashlib
import secrets

import jwt
from cryptography.hazmat.primitives.asymmetric import ec, rsa, x25519
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC


def issue_signing_key():
    # Quantum-vulnerable: Shor breaks RSA outright, whatever the modulus.
    return rsa.generate_private_key(public_exponent=65537, key_size=2048)


def legacy_signing_key():
    # Below the NIST floor, so this one is breakable today without a quantum
    # computer at all.
    return rsa.generate_private_key(public_exponent=65537, key_size=1024)


def sign(payload, key):
    # RS256 is RSASSA-PKCS1-v1_5: a signature. Forging it later reveals nothing
    # that was recorded earlier, so it is not harvest-now-decrypt-later.
    return jwt.encode(payload, key, algorithm="RS256")


def session_key():
    # Key agreement. Traffic recorded today is readable once this falls, which
    # is why it is ranked above the signature above.
    return x25519.X25519PrivateKey.generate()


def device_key():
    # The curve is the key size: P-384 is a 384-bit key.
    return ec.generate_private_key(ec.SECP384R1())


def content_id(blob):
    # Already broken, and not because of quantum computing.
    return hashlib.md5(blob).hexdigest()


def stretch(password, salt):
    # Not weakened by a quantum computer. Reported so the inventory is complete.
    return PBKDF2HMAC(algorithm=hashlib.sha256, length=32, salt=salt,
                      iterations=600_000)


def nonce():
    return secrets.token_bytes(32)


def cipher_from_config(name):
    # The algorithm is chosen while the program runs, so a scan cannot say what
    # it ends up being. The finding says so instead of guessing.
    return jwt.encode({}, "k", algorithm=name)
One file, up to 64 KB. The language decides which rules apply, the same way a file extension does in a real scan. Switching it loads that language's example.
Results appear here.