import base64

from cryptography.hazmat.primitives.asymmetric import rsa, padding, utils
from cryptography.hazmat.primitives import hashes

private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
public_key = private_key.public_key()

message = "The quick brown fox jumps over the lazy dog"
hash_algorithm = hashes.SHA256()


def hash_function(msg_bytes):
    hasher = hashes.Hash(hash_algorithm)
    hasher.update(msg_bytes)
    return hasher.finalize()


sender_side_hash = hash_function(bytes(message, "utf-8"))


def sign(message_hash, private_key):
    return private_key.sign(
        message_hash,
        padding.PSS(
            mgf=padding.MGF1(hash_algorithm), salt_length=padding.PSS.MAX_LENGTH
        ),
        utils.Prehashed(hash_algorithm),
    )


signature = sign(sender_side_hash, private_key)

# At this point, the signature is sent to the recipient along with
# the message. The signature can be base64 encoded like below
# so that it can be safely transmitted across the network:
b64_signature = base64.b64encode(signature)

# and decoded like this on the receiving side:
signature = base64.b64decode(b64_signature)

recipient_side_hash = hash_function(bytes(message, "utf-8"))


def verify(public_key, signature, message_hash):
    public_key.verify(
        signature,
        message_hash,
        padding.PSS(
            mgf=padding.MGF1(hash_algorithm), salt_length=padding.PSS.MAX_LENGTH
        ),
        utils.Prehashed(hash_algorithm),
    )


# would raise an exception if verification fails
verify(public_key, signature, recipient_side_hash)

pip install cryptography

const { generateKeyPairSync, createSign, createVerify } = await import("node:crypto");

const { publicKey, privateKey } = generateKeyPairSync('rsa', {
    publicExponent: 65537,
    modulusLength: 2048,
});

const message = "The quick brown fox jumps over the lazy dog";

const sign = (messageBytes, privateKey) => {
    const signer = createSign("SHA256");
    signer.update(messageBytes);
    signer.end();
    return signer.sign(privateKey);
};

let signature = sign(Buffer.from(message), privateKey);

// At this point, the signature is sent to the recipient along with
// the message. The signature can be base64 encoded like below
// so that it can be safely transmitted across the network:
let b64Signature = signature.toString("base64");

// and decoded like this:
signature = Buffer.from(b64Signature, "base64");

const verify = (publicKey, signature, messageBytes) => {
    const verifier = createVerify("SHA256");
    verifier.update(messageBytes);
    verifier.end();
    return verifier.verify(publicKey, signature);
};

let isVerified = verify(publicKey, signature, Buffer.from(message));

console.assert(isVerified == true); // should pass