Asymmetric in Practice: RSA Sign & Verify

By the end of this lesson you can:

• Sign data with a private key and verify with the matching public key.
• Explain what a signature proves: authenticity, integrity, non-repudiation.
• Distinguish signing from encryption (opposite key directions).
• Relate signatures to TLS certificates, software updates, and git commits.

ENCRYPT:  encrypt with PUBLIC key  → only PRIVATE decrypts   (for privacy)
SIGN:     sign with PRIVATE key     → anyone verifies w/ PUBLIC (for proof)

A signature is like a wax seal only YOU can make (private key) but
ANYONE can recognise as yours (public key) — and it breaks if the
message is altered.

How signing actually works

SIGN:    hash the message → encrypt the hash with the PRIVATE key = signature
VERIFY:  hash the message yourself → decrypt the signature with the PUBLIC key
         → do the two hashes match? yes = valid; no = forged or altered

You sign the hash of the message (small, fast), not the whole thing. Verification recomputes the hash and checks it against the signature using the public key. If even one byte of the message changed, the recomputed hash differs and verification fails.

Sign with the private key

from cryptography.hazmat.primitives.asymmetric import rsa, padding
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 = b"I authorise payment of RM500 to Aisha."

signature = private_key.sign(
    message,
    padding.PSS(                              # PSS = the modern signature padding
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH),
    hashes.SHA256())

Verify with the public key

from cryptography.exceptions import InvalidSignature

def verify(public_key, message, signature) -> bool:
    try:
        public_key.verify(
            signature, message,
            padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
                        salt_length=padding.PSS.MAX_LENGTH),
            hashes.SHA256())
        return True
    except InvalidSignature:
        return False

print(verify(public_key, message, signature))                 # True
print(verify(public_key, b"...RM5000 to Mallory.", signature)) # False — altered!

Use PSS padding for signatures (the modern, randomised scheme). Change the message and verification fails — that's integrity. Use the wrong public key and it fails — that's authenticity.

The three guarantees

• Authenticity — only the holder of the private key could have produced a signature that verifies with the public key.
• Integrity — any change to the message breaks the signature (the hash won't match).
• Non-repudiation — the signer can't credibly deny it, since only they have the private key. (This is why "protect your private key" is paramount.)

Signing ≠ encryption

Where you already rely on signatures

TLS certificates   a CA SIGNS a site's cert; your browser verifies it (L8-09)
software updates   the vendor signs the package; your OS verifies before install
package managers   pip/apt verify signatures to detect tampered packages (L8-35)
git               signed commits/tags prove who authored them
JWTs              signed tokens prove the server issued them (L8-38)

Goal: a publisher signs a release file; a downloader verifies it's authentic and untampered before trusting it — the exact mechanism behind secure software updates and the Lesson 35 supply-chain defence.

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.exceptions import InvalidSignature
from pathlib import Path

# --- publisher side (has the PRIVATE key) ---
def sign_release(file_path: str, private_key) -> bytes:
    data = Path(file_path).read_bytes()
    return private_key.sign(
        data,
        padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
                    salt_length=padding.PSS.MAX_LENGTH),
        hashes.SHA256())

# --- downloader side (has only the publisher's PUBLIC key) ---
def verify_release(file_path: str, signature: bytes, public_key) -> bool:
    data = Path(file_path).read_bytes()
    try:
        public_key.verify(
            signature, data,
            padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
                        salt_length=padding.PSS.MAX_LENGTH),
            hashes.SHA256())
        return True
    except InvalidSignature:
        return False

# demo
priv = rsa.generate_private_key(public_exponent=65537, key_size=2048)
pub = priv.public_key()

Path("release.bin").write_bytes(b"v2.0 application binary contents")
sig = sign_release("release.bin", priv)            # publisher signs, ships sig + file
Path("release.bin.sig").write_bytes(sig)

# downloader verifies BEFORE running the file:
if verify_release("release.bin", sig, pub):
    print("✓ signature valid — safe to install")
else:
    print("✗ INVALID — do NOT install (tampered or fake)")

# attacker tampers with the file after signing:
Path("release.bin").write_bytes(b"v2.0 application + hidden backdoor")
print("after tampering:",
      "valid" if verify_release("release.bin", sig, pub) else "REJECTED")

✓ signature valid — safe to install
after tampering: REJECTED

Read the code

This is how your computer protects you from malicious updates. The publisher signs the release with their private key (which never leaves them); you verify with their public key (widely distributed, e.g. baked into your OS). If an attacker swaps in a backdoored binary after signing, the signature no longer matches the file's hash — verification fails, and you refuse to install. No secret had to be shared, yet authenticity and integrity are guaranteed. The whole trust chain of software distribution runs on exactly this.

A digital signature uses the key pair in reverse: you sign a message's hash with your private key, and anyone verifies with your public key (use PSS padding). It proves three things — authenticity (only you could sign), integrity (any change breaks it), and non-repudiation (you can't deny it). Signing is not encryption: it proves origin and integrity but doesn't hide the message; combine both when you need secrecy too. Signatures are the trust layer behind TLS certificates, software updates, package managers, git, and JWTs — guard your private key accordingly.