Generi coppie di chiavi RSA nel browser, cifri e decifri con RSA-OAEP, firmi con RSA-PSS o PKCS#1 v1.5, e converta le chiavi tra i formati PEM SPKI, PKCS#8 e PKCS#1. Tutto funziona localmente con il motore WebCrypto — nessuna chiave né messaggio lascia mai questa pagina.
A cosa serve RSA: piccoli messaggi e firme, non dati di grandi dimensioni. RSA cifra al massimo k−2·hashLen−2 byte per chiamata (190 byte per una chiave a 2048 bit con SHA-256) ed è circa 1000× più lento di AES. I sistemi reali usano la cifratura ibrida: RSA incapsula una chiave AES casuale, AES cifra i dati (veda lo strumento AES). Questa pagina serve per l'apprendimento, i test e le verifiche di interoperabilità.
1. Generi una coppia di chiavi(WebCrypto, locale; i quattro formati PEM vengono prodotti insieme)
Dimensione del modulo:
Chiave pubblica — SPKI(-----BEGIN PUBLIC KEY-----, il comune formato «chiave pubblica RSA»)
Chiave pubblica — PKCS#1(-----BEGIN RSA PUBLIC KEY-----, solo modulo ed esponente)
Chiave privata — PKCS#8(-----BEGIN PRIVATE KEY-----, non cifrata; trattela come una password)
Generare una chiave nel browser non la cifra. Per conservarla, la sposti in un vero archivio di chiavi o la cifri offline.
2. Oppure importi una chiave esistente(incolli uno qualsiasi dei quattro formati PEM)
3. Cifra / decifra (RSA-OAEP)- la direzione segue la chiave corrente: pubblica = cifra, privata = decifra
Hash:Etichetta:
La cifratura PKCS#1 v1.5 non è implementata di proposito: non ha integrità del ciphertext e cede agli attacchi padding-oracle (Bleichenbacher). OAEP è l'unica modalità di cifratura che un nuovo progetto dovrebbe usare.
4. Firmi (richiede la chiave privata)- PSS (randomizzato, moderno) oppure PKCS#1 v1.5 (deterministico, compatibile con il legacy)
Schema:Hash:
5. Verifica (richiede la chiave pubblica)- incolli il messaggio e la firma
Schema:Hash:
Quanto può contenere una singola chiamata RSA?Limite del messaggio OAEP = byte della chiave − 2×byte dell'hash − 2:
Modulo
SHA-256
SHA-384
SHA-512
1024 bit
62 byte
30 byte
0 byte
2048 bit
190 byte
126 byte
62 byte
3072 bit
318 byte
254 byte
190 byte
4096 bit
446 byte
382 byte
318 byte
Le firme non hanno limite di messaggio — il messaggio viene prima sottoposto ad hash; la firma è sempre esattamente della dimensione della chiave (256 byte per 2048 bit).
Robustezza e durata della chiave(NIST SP 800-57 Parte 1 Rev. 5): il 1024 bit è vietato per nuovi usi dal 2013; il 2048 bit è il minimo oggi e resta accettabile fino al 2030; 3072 bit e oltre sono la scelta sicura per il 2031 e oltre. L'8192 bit funziona qui, ma la generazione può richiedere un minuto o più nel browser e offre una sicurezza che oggi nessuno richiede — preferisca 3072/4096.
Interoperabilità con OpenSSL — i PEM prodotti da questa pagina fanno il giro completo da riga di comando: openssl pkeyutl -encrypt -pubin -inkey pub.pem -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:sha256 -pkeyopt rsa_mgf1_md:sha256 openssl pkeyutl -decrypt -inkey priv.pem -pkeyopt rsa_padding_mode:oaep ... openssl dgst -sha256 -sign priv.pem -out msg.sig msg.txt (PKCS#1 v1.5) / openssl dgst -sha256 -verify pub.pem -signature msg.sig msg.txt PSS: aggiunga -sigopt rsa_padding_mode:pss -sigopt rsa_pss_saltlen:32 a entrambe le chiamate dgst. Conversione del formato della chiave: openssl rsa -in key.pem -RSAPublicKey -out pubkey.pem converte su disco SPKI ↔ PKCS#1; questa pagina lo fa nel browser.
Autotest Esegue il motore della pagina su ancore indipendenti: generazione di chiavi con tre dimensioni di modulo, andate e ritorno di cifratura/decifratura OAEP, firma e verifica PSS e PKCS#1 v1.5 con diversi hash, un vettore di firma v1.5 deterministico byte per byte (generato da un'implementazione nativa indipendente), un ciphertext OAEP e una firma PSS fissi prodotti da OpenSSL che questa pagina deve decifrare/verificare (interoperabilità tra implementazioni), andate e ritorni di conversione dei formati PEM, e test negativi (firma alterata, chiave errata devono fallire). Nulla viene inviato da nessuna parte.
Cifratura e firme RSA spiegate da zero
In una frase: RSA è crittografia a chiave pubblica — chiunque può cifrare per lei con la chiave pubblica o verificare le sue firme, ma solo la chiave privata può decifrare o firmare — e la sua sicurezza si basa sul fatto che fattorizzare un numero a 2048 bit in due primi è al di là di qualunque computer esistente.
Che cosa calcola davvero RSA
Due primi e una botola. Una chiave RSA parte da due grandi primi casuali p e q; il loro prodotto n (il modulo, da cui «chiave a 2048 bit») è pubblicato nella chiave pubblica insieme a un esponente e (quasi sempre 65537). La chiave privata è la coppia d, l'inverso modulare di e − calcolato da p e q — più scorciatoie derivate dai primi che accelerano le operazioni con la chiave privata di 4×.
Cifrare e firmare sono la stessa esponenziazione. Cifrare un blocco di messaggio m significa calcolare me mod n; decifrare è cd mod n. Firmare un blocco già formattato con l'esponente privato e verificare con quello pubblico è la stessa operazione nell'altro verso. Tutto il resto di questa pagina — OAEP, PSS, PKCS#1 — riguarda la formattazione sicura di quel blocco, così che l'esponenziazione grezza non sia mai esposta.
Perché è lento. Un'operazione RSA su una chiave a 2048 bit costa dell'ordine di un milione di volte più CPU che cifrare un blocco con AES. Per questo TLS usa RSA (o ECC) solo per concordare una chiave AES casuale, poi passa ad AES. La stessa regola vale per tutto ciò che costruisce: RSA per la chiave, AES per i dati.
Dimensione della chiave. La lunghezza del modulo è la manopola della sicurezza: il 1024 bit è «rotto» per policy (la fattorizzazione è alla portata degli stati), il 2048 bit ≈ robustezza simmetrica a 112 bit, il 3072 bit ≈ 128 bit, una chiave a 15360 bit eguaglierebbe una chiave simmetrica a 256 bit. Nota sul post-quantistico: l'algoritmo di Shor rompe RSA senza appello su un grande computer quantistico — un motivo in più per tenere finita la durata delle chiavi.
OAEP: l'unico padding di cifratura che dovrebbe usare
Il problema dell'RSA grezzo. L'RSA da manuale (me mod n sul messaggio grezzo) è deterministico e malleabile: messaggi identici si cifrano allo stesso modo, un attaccante può moltiplicare un ciphertext per la cifratura di 2 per raddoppiare il testo in chiaro, e i messaggi brevi cadono con l'attacco meet-in-the-middle. Non va mai usato direttamente.
Cosa fa OAEP. OAEP (PKCS#1 v2, RFC 8017) mescola il messaggio con un seme casuale tramite una rete di Feistel basata su hash prima dell'esponenziazione. Il risultato: la cifratura è randomizzata (lo stesso testo in chiaro dà un ciphertext diverso ogni volta — provi due volte l'esempio OAEP e confronti), le manomissioni vengono rilevate in fase di decifratura, e il messaggio deve entrare nel modulo lasciando spazio per l'hash — il limite k−2·hashLen−2 tabellato sopra.
L'etichetta. Una stringa pubblica facoltativa legata nel padding. Entrambe le parti devono fornire esattamente la stessa etichetta o la decifratura fallisce — come l'AAD in AES-GCM, permette di legare il ciphertext al contesto (un nome di file, un identificatore di algoritmo). Vuota è normale.
La cifratura PKCS#1 v1.5 è assente di proposito. Il padding dell'epoca del 1993 non ha integrità e perde informazioni attraverso il comportamento degli errori di decifratura (l'attacco di Bleichenbacher del 1998 trasforma un padding oracle in decifratura completa con qualche milione di ciphertext costruiti; rompe ancora sistemi reali come ROBOT, 2017). WebCrypto rifiuta di implementarlo; lo rifiuta anche questa pagina.
Firme PSS contro PKCS#1 v1.5
Firmare = hash, poi padding, poi esponenziazione. Entrambi gli schemi fanno l'hash del messaggio (SHA-256/384/512 qui), formattano il digest in un blocco e applicano l'esponente privato. La verifica riformatta il blocco con la chiave pubblica e confronta. La differenza sta nella formattazione:
Schema
Contenuto del blocco
Proprietà
RSASSA-PKCS1-v1_5
digest + intestazione digest-info, deterministico
Ogni firma dello stesso messaggio è identica byte per byte (controlli l'autotest: il suo vettore v1.5 è fisso). Supporto legacy universale: certificati X.509, JWT RS*, TLS prima della 1.3. Nessuna falsificazione nota se la verifica è implementata correttamente.
RSA-PSS
digest + salt casuale della lunghezza dell'hash, mascheramento MGF1
Randomizzata — ogni firma è diversa. Provabilmente sicura nel modello dell'oracolo casuale; richiesta nei certificati TLS 1.3 futuri e nei protocolli più recenti. Il verificatore deve conoscere la lunghezza del salt (questa pagina usa la lunghezza dell'hash, il default comune).
Quale scegliere. Nuovi progetti: PSS. Interoperabilità con certificati esistenti, JWT (RS256) o sistemi vecchi: v1.5. Entrambi sono sicuri come schemi di firma — la storia del disastro v1.5 riguarda il padding di cifratura, una costruzione diversa nonostante il nome simile.
PKCS#1 contro PKCS#8 contro SPKI: perché la stessa chiave ha quattro PEM
Il PEM è solo DER codificato in base64. Un file PEM è un'etichetta più il base64 di una struttura DER (ASN.1 binaria). L'etichetta indica quale struttura — ed è questa l'intera differenza tra i quattro formati che questa pagina genera:
Etichetta PEM
Struttura DER
Contiene
-----BEGIN PUBLIC KEY-----
SubjectPublicKeyInfo (SPKI)
OID dell'algoritmo + chiave pubblica (n, e). La «chiave pubblica» predefinita ovunque.
-----BEGIN RSA PUBLIC KEY-----
PKCS#1 RSAPublicKey
Solo (n, e). OpenSSL vecchi e alcuni stack embedded.
-----BEGIN PRIVATE KEY-----
PKCS#8 PrivateKeyInfo
OID dell'algoritmo + chiave privata. Contenitore indipendente dall'algoritmo, il default moderno.
-----BEGIN RSA PRIVATE KEY-----
PKCS#1 RSAPrivateKey
n, e, d, p, q, …. L'output classico di genrsa di OpenSSL.
Stessa chiave, involucri diversi. Tutti e quattro i riquadri sopra, dopo la generazione, contengono la stessa coppia di chiavi — SPKI e PKCS#1 pubblica contengono gli stessi n, e; PKCS#8 e PKCS#1 privata contengono gli stessi valori privati. Questa pagina converte tra loro senza perdite nel browser (il suo autotest verifica le conversioni all'andata e al ritorno). Confondere i formati è la causa più comune di errori «chiave non valida» quando si incollano chiavi tra strumenti diversi.
I PEM cifrati (-----BEGIN ENCRYPTED PRIVATE KEY-----) sono PKCS#8 con uno strato di cifratura basato su password. Questa pagina non li accetta — li decifri prima offline (openssl pkcs8 -in enc.pem -out plain.pem).
Errori comuni
Cifrare dati di grandi dimensioni con RSA. Oltre il limite rigido di OAEP è assurdamente lento. Lo schema è: generare una chiave AES casuale, cifrare la chiave AES con RSA-OAEP, cifrare i dati con AES-GCM, inviare entrambe le parti.
Distribuire la chiave privata perché «è un test». Le chiavi di esempio incorporate nei vettori di questa pagina sono pubblicate di proposito — possono firmare solo dati di prova. Le sue chiavi non sono così.
Verificare con la chiave privata. Di solito «funziona» matematicamente e alcuni strumenti lo consentono, ma distribuire una chiave privata ai verificatori vanifica l'intero modello. Verifichi con la chiave pubblica (questa pagina lo impone).
Confrontare le firme byte per byte per controllare il codice. PSS (e OAEP) sono randomizzate: due esecuzioni corrette producono output diversi. Confronti verificando, non per uguaglianza — solo le firme v1.5 sono deterministiche.
Chiavi a 1024 bit «perché sono più veloci». Sono anche alla portata di una fattorizzazione finanziata. L'argomento della velocità è morto con la cifratura ibrida: RSA gira una volta per sessione, non per byte.
Fissare per PSS una lunghezza del salt diversa da quella dell'hash. Il verificatore deve essere d'accordo; la lunghezza dell'hash (la scelta di questa pagina e l'opzione -sigopt rsa_pss_saltlen:32 di OpenSSL) è il default interoperabile.
FAQ
Perché la decifratura è fallita con «chiave errata, hash errato o ciphertext corrotto»? La decifratura OAEP fallisce se: non è la chiave privata corrispondente, l'hash è diverso da quello del lato che cifra, l'etichetta è diversa, o un byte del ciphertext è cambiato. L'errore è volutamente identico per tutti i casi — rivelare quale controllo è fallito sarebbe già una perdita da padding oracle.
Posso ricavare la chiave pubblica dalla chiave privata? Sì — anche i formati privati contengono n ed e. Questa pagina mostra entrambi dopo la generazione; OpenSSL lo fa con openssl pkey -in priv.pem -pubout.
Perché 65537 come esponente? È primo, ha solo due bit a 1 (esponenziazione veloce), ed è abbastanza grande da evitare gli attacchi ad esponente basso che colpiscono e=3. È la scelta standard dagli anni Novanta; un esponente «strano» di solito indica una chiave debole o non standard.
L'RSA è morto a causa dei computer quantistici? Non ancora — non esiste una macchina capace di eseguire l'algoritmo di Shor su un modulo a 2048 bit. Ma i dati che devono restare segreti fino agli anni 2030 e oltre sono già in migrazione; gli schemi ibridi post-quantistici sono la risposta ingegneristica.
E openssl rsautl? È l'antenato obsoleto di pkeyutl. Usa di default il padding di cifratura v1.5 — un motivo in più per cui è stato ritirato.