Programma Lezione 84 di 156 · Una cifratura che sai spiegare
Una cifratura che sai spiegare

Verifica una firma

Perché è importante Ogni aggiornamento software che installa il tuo telefono, ogni certificato dietro un lucchetto, e ogni accesso con passkey si basa su un controllo: "è stato davvero firmato dalla chiave giusta?" Fare quel controllo da solo, una volta, trasforma le firme da magia in qualcosa che sai spiegare.

Una firma funziona come un sigillo di ceralacca impresso con un anello che ha solo il proprietario. Chiunque sappia com'è il disegno dell'anello può controllare il sigillo, ma nessun altro può farlo. E se la lettera viene cambiata dopo la sigillatura, il sigillo non coincide più.

Firma digitale: un numero creato da un messaggio e da una chiave privata. Chiunque abbia la chiave pubblica corrispondente può verificare che l'ha creato il proprietario, e che il messaggio non è cambiato da allora.

Passo 1: prendi l'impronta del messaggio con un hash

Hash: una funzione che trasforma qualsiasi dato in una breve impronta di dimensione fissa. Lo stesso input dà sempre la stessa impronta, un minimo cambiamento ne dà una completamente diversa, e non puoi farla funzionare al contrario. SHA-256 è una delle più comuni.

import hashlib
print(hashlib.sha256(b"Lunch at 1pm").hexdigest()[:16])
print(hashlib.sha256(b"Lunch at 2pm").hexdigest()[:16])
# two completely different fingerprints

Firmare l'impronta invece dell'intero messaggio tiene le cose piccole e veloci. Per farci dei calcoli, trasforma i 32 byte in un unico grande numero intero con int.from_bytes(digest, "big"), poi prendi il resto della divisione per n con % n così entra nella chiave.

Passo 2: annulla la firma con la chiave pubblica

Nell'RSA giocattolo della lezione 81, il proprietario firma calcolando pow(fingerprint, d, n) con il d privato. Per verificare, calcoli pow(signature, e, n) con l'e pubblico. Se il risultato è uguale all'impronta che hai calcolato tu, la firma è autentica.

In Python una chiave è una coppia di numeri in una tupla, come public_key = (n, e). La riga n, e = public_key la spacchetta: mette il primo numero in n e il secondo in e.

signer:   signature = pow(fingerprint, d, n)      # needs the private key
checker:  pow(signature, e, n) == fingerprint ?   # needs only the public key

Se qualcuno cambia il messaggio, la sua impronta cambia e non coincide più. Se cambia la firma, annullarla dà un numero diverso. E se qualcuno firma con la propria chiave privata fingendosi Ana (la mittente in questo esercizio), il tuo controllo con la chiave pubblica di Ana fallisce. Tutti e tre vengono scoperti con un solo confronto.

Importante: questo è RSA giocattolo con chiavi minuscole e senza padding, solo per imparare. Le firme vere usano librerie verificate e schemi come Ed25519 o RSA con padding PSS. Non usare mai crittografia fatta in casa per proteggere dati veri.

Un equivoco comune: "una firma nasconde il messaggio". Non è così; il messaggio viaggia in chiaro. Una firma dimostra chi l'ha creato e che è invariato. Nasconderlo è il lavoro della cifratura.

In altri linguaggi

Il codice vero verifica con una libreria. Ogni chiamata restituisce vero o falso (o solleva un errore) invece di confrontare numeri a mano.

# Python, with the cryptography package (Ed25519)
from cryptography.exceptions import InvalidSignature
try:
    public_key.verify(signature, message)   # raises if it does not match
    ok = True
except InvalidSignature:
    ok = False
// JavaScript (browser Web Crypto, ECDSA)
const ok = await crypto.subtle.verify(
  { name: "ECDSA", hash: "SHA-256" }, publicKey, signature, messageBytes);
// Go (crypto/ed25519)
ok := ed25519.Verify(publicKey, message, signature)
// PHP (libsodium, built in)
$ok = sodium_crypto_sign_verify_detached($signature, $message, $publicKey);
// C# (.NET)
bool ok = ecdsa.VerifyData(message, signature, HashAlgorithmName.SHA256);

Riepilogo

  • Una firma dimostra chi ha creato un messaggio e che non è cambiato. Non lo nasconde.
  • Prima fai l'hash del messaggio, poi verifica la firma rispetto a quell'impronta.
  • Verificare richiede solo la chiave pubblica; firmare richiede la chiave privata.
  • L'RSA giocattolo serve a capire; il codice vero usa librerie verificate.
Tocca a te

Ana firma i suoi messaggi con l'RSA giocattolo. La sua chiave pubblica è PUBLIC_KEY = (n, e), e INBOX contiene coppie (message, signature), alcune manomesse. Scrivi tre funzioni:

  1. message_number(message, n): restituisci il digest SHA-256 del messaggio (byte UTF-8), come numero da int.from_bytes(digest, "big"), modulo n.
  2. verify(message, signature, public_key): spacchetta n, e, e restituisci True solo se pow(signature, e, n) è uguale a message_number(message, n), altrimenti False.
  3. genuine_messages(inbox, public_key): restituisci una lista dei testi dei messaggi le cui firme risultano valide, nell'ordine della casella.
Le ultime righe stampano i messaggi autentici. I test usano nuovi messaggi e nuove chiavi, quindi la risposta non si può scrivere fissa nel codice.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.