Skip to content

Generatore di coppie di chiavi RSA — ECDSA e Ed25519

Genera chiavi RSA online: la chiave privata non lascia il browser. RSA 2048/4096, ECDSA, Ed25519, PEM PKCS#8 o PKCS#1, JWK e impronta SHA-256.

Niente tracciamento Funziona nel browser Gratuito
Le coppie di chiavi sono generate dentro il tuo browser con l'API Web Crypto, e durante la generazione non viene inviata alcuna richiesta di rete. Stacca la connessione e questa pagina funziona lo stesso.

PKCS#8 (BEGIN PRIVATE KEY) è il valore predefinito moderno ed è ciò che si aspetta il JDK. PKCS#1 (BEGIN RSA PRIVATE KEY) è la forma tradizionale di OpenSSL, ancora richiesta da alcuni gateway. Cambiare ricodifica la stessa chiave.

Tienila segreta. Chiunque la possieda può spacciarsi per te.

Impronta della chiave pubblica — SHA-256 del DER SPKI
JWK (JSON Web Key)
JWK privata — da non pubblicare mai 
 
 
 
 JWK pubblica  
 
 
 
 
  
 
Genera lo stesso tipo di coppia di chiavi con OpenSSL
 
 
    
 
  
  
  
  Verificato per la correttezza rispetto a RFC 5958/5208 (PKCS#8), RFC 8017 (PKCS#1), RFC 8410 (Ed25519) e alla codifica PEM della RFC 7468, e per il comportamento dell'API Web Crypto su RSA, ECDSA ed Ed25519. — Team Strumenti di Sicurezza di Go Tools · Aug 10, 2026  
 Il nostro team verifica byte per byte la conversione da PKCS#8 a PKCS#1 rispetto all'output di riferimento del modulo crypto di Node, così una chiave esportata qui è identica a quella che OpenSSL produrrebbe per lo stesso materiale. 
 
 
      
 
Cos'è un generatore di chiavi RSA?
 
 
Un generatore di chiavi RSA produce una coppia legata matematicamente: una chiave privata che tieni per te e una chiave pubblica che distribuisci. Tutto ciò che firmi con la metà privata si verifica con la metà pubblica, e solo la metà pubblica puoi pubblicarla senza rischi. Questa asimmetria è il punto centrale: permette a chi verifica di controllare le tue firme senza acquisire la capacità di falsificarle, cosa che un segreto condiviso non potrà mai offrire.
Questo generatore lavora dentro il tuo browser tramite l'API Web Crypto, quindi la chiave privata nasce nella scheda e la pagina non invia alcuna richiesta di rete durante la generazione. Oltre a RSA produce anche coppie ECDSA ed Ed25519, che servono allo stesso scopo con chiavi molto più corte: una chiave privata Ed25519 occupa 48 byte in PKCS#8, mentre una chiave RSA da 2048 bit supera 1,2 KB.
Ciò che manda in confusione non è la matematica ma la confezione. La stessa chiave puoi scriverla come PKCS#8, PKCS#1, SPKI o JWK, e una libreria che rifiuta l'una spesso accetta l'altra senza messaggi più chiari di un errore di parsing. La tabella più sotto associa ogni contenitore agli ecosistemi che se lo aspettano.
 
 
// Verify a downloaded key pair matches, using OpenSSL:
openssl pkey -in rsa-2048-private.pem -pubout | diff - rsa-2048-public.pem
// No output means the public key really belongs to that private key.
 
  
 
Caratteristiche principali
 
 
 
Generato nel tuo browser
 
Le chiavi arrivano dall'API Web Crypto nella tua scheda, e la pagina non invia alcuna richiesta di rete durante la generazione. Stacca la connessione e continua a funzionare, il che dimostra che allo strumento non serve alcun server per fare il suo lavoro.
 
 
RSA, ECDSA ed Ed25519
 
RSA 2048, 3072 e 4096; ECDSA su P-256, P-384 e P-521; ed Ed25519, tutto da una sola pagina e con le stesse opzioni di esportazione.
 
 
Output PKCS#8 e PKCS#1
 
Passa da BEGIN PRIVATE KEY alla disposizione tradizionale BEGIN RSA PRIVATE KEY senza toccare OpenSSL. Il selettore ricodifica la chiave già a schermo, quindi resta la stessa chiave.
 
 
Esportazione JWK
 
Entrambe le metà sono disponibili come JSON Web Key. La JWK pubblica è quella che finisce in un documento JWKS o in un verificatore JOSE; la JWK privata è solo per il tuo firmatario e non va mai pubblicata.
 
 
Impronta SHA-256
 
Ogni coppia arriva con un'impronta della sua chiave pubblica, così puoi verificare su un canale separato che le due parti abbiano la stessa chiave.
 
 
Comandi OpenSSL corrispondenti
 
Sotto l'output trovi i comandi equivalenti per generare in locale lo stesso tipo di chiave, per passare alla riga di comando quando preferisci.
 
 
Download con nomi sensati
 
I file vengono salvati come rsa-2048-private.pem e rsa-2048-public.pem, non con un nome generico da rinominare a mano.
 
 
Nessun account, nessun limite d'uso
 
Non c'è alcun server di mezzo, quindi non devi registrarti e non esiste una quota da esaurire.
 
 
 
      
 
Esempi pratici
 
 
 
Coppia Ed25519, mostrata per intero
 
 
Algoritmo: Ed25519
 
-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIA2HJVU1qChbOJN8XksXVhyD0IjYVt0UU6Mwz814rOFf
-----END PRIVATE KEY-----

-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAV5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU=
-----END PUBLIC KEY-----
 
 
Una chiave privata Ed25519 occupa 48 byte in PKCS#8 e la chiave pubblica 44 byte, quindi ogni PEM sta in una sola riga di base64. Questa coppia è una dimostrazione usa e getta: genera la tua invece di copiare questa.
 
 
Le intestazioni PKCS#8 e PKCS#1 sono diverse
 
 
Algoritmo: RSA 2048, struttura commutata
 
PKCS#8:  -----BEGIN PRIVATE KEY-----
PKCS#1:  -----BEGIN RSA PRIVATE KEY-----
 
 
Stessa chiave, due involucri. PKCS#8 aggiunge un identificatore di algoritmo attorno alla struttura RSA, ed è per questo che vale per ogni algoritmo mentre PKCS#1 esiste solo per RSA. Azionare il selettore ricodifica la chiave già a schermo, quindi l'impronta non cambia.
 
 
Chiave pubblica RSA 2048
 
 
Algoritmo: RSA 2048
 
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni
eSccN1uleXFRBb1g2TN6bk/fbpPCGDyh71m73oB9Bk8+fKVkSThXyWTtpgblB7pX
iQBtTvSWVZGHprkLgMGkU2Yw8Z43m1WpoRuYyXNFe92S5viIdVuKTj/VEUuEpzHd
ffWMIUw70LaUdTP04iQdkNVeS3M6VHkpTwsPSQfsFSwObtLVNy2Lf+ODwJRqCk2r
C749hgKqBdJqkcIj49R7UP4SMQ/9V3yy8DFMrIcgsjC4tHwlQSCGeXNxTNlapGSa
ke55LUR83FASryVJRbUs678SCZSFkyGcT0qLZ/olu/e7Jj2lB0Qy/SJawkrs9hPE
4QIDAQAB
-----END PUBLIC KEY-----
 
 
Il prefisso MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A è l'identificatore dell'algoritmo rsaEncryption: è così che riconosci a colpo d'occhio una chiave SPKI di tipo RSA.
 
 
Chiave pubblica come JWK
 
 
Algoritmo: Ed25519, pannello JWK
 
{
  "key_ops": [
    "verify"
  ],
  "ext": true,
  "alg": "Ed25519",
  "crv": "Ed25519",
  "x": "V5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU",
  "kty": "OKP"
}
 
 
Questa è l'esportazione testuale, membri key_ops ed ext inclusi, che Web Crypto aggiunge sempre. Una voce JWKS non li vuole: eliminali entrambi e aggiungi invece kid e use, così chi verifica può selezionare la chiave giusta durante una rotazione. Ed25519 ricade nel tipo di chiave OKP; le chiavi RSA compaiono con kty RSA e i membri n ed e.
 
 
Impronta SHA-256
 
 
Algoritmo: Ed25519
 
SHA256(SPKI) = KAXVxapxpG4zLsTVMpPafovT+X1NLWc8fsOXqtrb59o=
 
 
Un digest SHA-256 della struttura della chiave pubblica, abbastanza corto da leggerlo al telefono. Attenzione: non è il valore che stampa ssh-keygen, perché OpenSSH calcola l'hash del proprio formato di trasporto e i due non coincidono mai per la stessa chiave.
 
 
 
      
 
Come usare il generatore di chiavi RSA
 
     
  1.  1 
     
    Scegli l'algoritmo
     
    RSA copre la gamma più ampia di sistemi datati. ECDSA offre una robustezza equivalente con chiavi molto più piccole. Ed25519 è la scelta predefinita moderna per ogni nuovo lavoro di firma.
     
     
  2.  2 
     
    Scegli la dimensione della chiave
     
    RSA 2048 soddisfa le indicazioni attuali; 3072 e 4096 aggiungono margine per chiavi di lunga durata. ECDSA propone P-256, P-384 e P-521. Ed25519 ha un'unica dimensione fissa.
     
     
  3.  3 
     
    Seleziona la struttura PEM
     
    PKCS#8 emette BEGIN PRIVATE KEY e funziona quasi ovunque, JDK compreso. Passa a PKCS#1 solo quando qualcosa richiede espressamente BEGIN RSA PRIVATE KEY.
     
     
  4.  4 
     
    Copia o scarica entrambe le metà
     
    La chiave privata finisce nel tuo gestore di segreti. La chiave pubblica va a chi verifica le tue firme. Non inviare mai la metà privata da nessuna parte.
     
     
  5.  5 
     
    Verifica l'impronta
     
    Confronta l'impronta SHA-256 su un canale separato per avere conferma che l'altra parte abbia installato proprio la chiave pubblica che hai generato.
     
     
    6.  
 
  
 
Errori comuni sul formato delle chiavi
 
 
 
Incollare la chiave pubblica dove serve quella privata
 
Per firmare serve la metà privata. Una libreria che riceve BEGIN PUBLIC KEY dove si aspettava una chiave privata di solito restituisce un errore di parsing poco chiaro invece di nominare il problema reale.
 
 
 ✗ Errato 
-----BEGIN PUBLIC KEY-----
 
 
 ✓ Corretto 
-----BEGIN PRIVATE KEY-----
 
 
 
 
Struttura PEM sbagliata per la libreria
 
Pochi ecosistemi leggono solo la disposizione RSA tradizionale: l'output -traditional di OpenSSL stesso, alcuni SDK di gateway di pagamento, strumenti Ruby e Perl datati. La maggior parte delle librerie moderne, e il JDK in particolare, si aspetta PKCS#8. Cambia il selettore della struttura PEM invece di cercare un comando di conversione.
 
 
 ✗ Errato 
-----BEGIN RSA PRIVATE KEY-----
 
 
 ✓ Corretto 
-----BEGIN PRIVATE KEY-----
 
 
 
 
Perdere l'a capo finale
 
I file PEM terminano con un a capo dopo l'ultimo delimitatore. Una copia che passa da un campo di modulo che elimina gli spazi produce un file che alcuni parser rifiutano del tutto, e siccome il carattere mancante è invisibile il file sembra corretto in un editor.
 
 
 ✗ Errato 
-----END PRIVATE KEY-----[EOF]
 
 
 ✓ Corretto 
-----END PRIVATE KEY-----↵[EOF]
 
 
 
 
Un carattere perso per strada
 
Ciò che rompe un PEM è un carattere perso, inserito o sostituito, non la larghezza delle righe: quasi tutti i parser accettano qualsiasi andata a capo. Una copia che passa da un client di chat o da un campo di modulo può trasformare in silenzio un a capo in uno spazio, e il base64 non dà alcun indizio su quale carattere sia andato storto; la chiave semplicemente non si carica. Usa il pulsante di copia invece di selezionare a mano.
 
 
 ✗ Errato 
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni eSccN1uleXFRBb1g2TN6bk
 
 
 ✓ Corretto 
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni
eSccN1uleXFRBb1g2TN6bk
 
 
 
 
Usare un segreto HS256 dove è configurato RS256
 
HS256 prende un solo segreto condiviso; RS256 prende una coppia di chiavi. Dare una stringa casuale a un firmatario RS256 fallisce già in fase di parsing. Genera la coppia qui, oppure usa il nostro Generatore di segreti JWT se intendevi HS256.
 
 
 ✗ Errato 
alg: RS256, key: 8f3a9c2e1b7d
 
 
 ✓ Corretto 
alg: RS256, key: -----BEGIN PRIVATE KEY-----
 
 
 
 
Incollare un PEM in authorized_keys
 
Una chiave pubblica SSH è nel formato OpenSSH su una riga, ssh-ed25519 AAAA…, non un blocco PEM: incollare la chiave pubblica di questa pagina in authorized_keys non funziona. Per una chiave RSA puoi ricavare la riga giusta in locale con ssh-keygen -y; per l'accesso SSH in generale, generare sulla macchina di destinazione resta la scelta migliore.
 
 
 ✗ Errato 
-----BEGIN PUBLIC KEY-----
 
 
 ✓ Corretto 
ssh-keygen -y -f rsa-2048-private.pem > id_rsa.pub
 
 
 
 
 
  
 
Chi usa questo strumento
 
 
 
Firmare JWT con RS256 o EdDSA
 
Gli algoritmi JWT asimmetrici richiedono una coppia di chiavi anziché un segreto condiviso. Firmi con la chiave privata, pubblichi la chiave pubblica e chi verifica non ha mai in mano nulla che gli permetta di coniare token. Il nostro Codificatore JWT accetta le chiavi prodotte in questa pagina.
 
 
Firmare webhook e release
 
Pubblica la chiave pubblica una volta sola, firma ogni payload con la chiave privata e chi consuma il servizio può verificarne l'autenticità senza una credenziale condivisa che possa trapelare.
 
 
Sviluppo locale e test
 
Le suite di test che esercitano la verifica delle firme hanno bisogno di una coppia usa e getta. Generarne una qui è più rapido che ricordare l'invocazione di OpenSSL.
 
 
Capire com'è fatta una coppia di chiavi
 
Passare tra algoritmi e strutture PEM affiancati rende concrete le differenze in un modo che la lettura di una specifica non ottiene.
 
 
Preparare un endpoint JWKS
 
La JWK pubblica entra direttamente nell'array keys di un documento di discovery OpenID Connect. Aggiungi un kid così chi verifica può selezionarla durante una rotazione, e tieni la JWK privata fuori da quel file.
 
 
Migrare via da RSA
 
Genera la sostituzione Ed25519 accanto all'originale RSA e confronta le dimensioni prima di impegnarti nel cambiamento.
 
 
Risolvere un formato incompatibile
 
Quando una libreria rifiuta una chiave con un errore di parsing, riemetterla nell'altra struttura PEM è di solito l'intera soluzione.
 
 
 
  
 
I formati PEM e come funziona il generatore
 
 
 
Quale contenitore serve dove
 
Una chiave, cinque confezioni. Sbagliare confezione è il motivo più frequente per cui una chiave viene rifiutata, e il messaggio d'errore raramente è più specifico di un fallimento di parsing.


ContenitoreIntestazione PEMContieneDove lo incontri
PKCS#8BEGIN PRIVATE KEYQualsiasi algoritmoWeb Crypto, JDK, Go, .NET — la maggior parte delle librerie moderne
PKCS#1BEGIN RSA PRIVATE KEYSolo RSAOutput tradizionale di OpenSSL, alcuni gateway di pagamento, strumenti Ruby e Perl datati
SPKI / X.509BEGIN PUBLIC KEYQualsiasi algoritmo, metà pubblicaLa chiave pubblica che quasi ogni libreria si aspetta
PKCS#1 pubblicaBEGIN RSA PUBLIC KEYSolo RSA, metà pubblicaStrumenti RSA legacy
JWKnessuna — è JSONQualsiasi algoritmoEndpoint JWKS, discovery OIDC, librerie JOSE


Per convertire file che hai già, openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem converte in una direzione e openssl rsa -traditional -in pkcs8.pem -out pkcs1.pem nell'altra.
 
 
La casualità arriva dal sistema operativo
 
Web Crypto alimenta la generazione delle chiavi dalla sorgente di entropia della piattaforma: getrandom su Linux, e il CSPRNG di sistema su Windows e macOS. È la stessa classe di sorgente da cui attinge OpenSSL, non un generatore pseudo-casuale JavaScript.
 
 
La generazione non congela la pagina
 
crypto.subtle.generateKey è asincrona e, nei principali motori di browser, la ricerca dei numeri primi avviene fuori dal thread principale: l'interfaccia resta reattiva mentre viene cercato un modulo da 4096 bit. La pagina mostra comunque un indicatore di attesa, perché quanto duri quella ricerca dipende dalla fortuna del sorteggio.
 
 
PKCS#8 avvolge PKCS#1
 
Un PrivateKeyInfo PKCS#8 è un numero di versione, un identificatore di algoritmo e un OCTET STRING. Per una chiave rsaEncryption non cifrata, quell'OCTET STRING contiene una RSAPrivateKey PKCS#1 completa, ed è esattamente così che questa pagina converte tra i due senza riderivare nulla.
 
 
Le chiavi pubbliche usano SubjectPublicKeyInfo
 
BEGIN PUBLIC KEY è un SubjectPublicKeyInfo X.509: un identificatore di algoritmo più un BIT STRING. Cosa ci sia dentro quei bit dipende dall'algoritmo: per RSA è una RSAPublicKey PKCS#1, ed è per questo che BEGIN RSA PUBLIC KEY risulta più corta; per ECDSA è il punto di curva non compresso, e per Ed25519 la chiave grezza da 32 byte.
 
 
L'esponente pubblico è 65537
 
Ogni chiave RSA qui usa e = 65537, scritto 0x010001. È abbastanza grande da evitare gli attacchi a esponente piccolo e ha solo due bit a uno, quindi la verifica costa 16 elevamenti al quadrato e una sola moltiplicazione.
 
 
Le impronte digeriscono il DER, non il PEM
 
L'impronta SHA-256 viene calcolata sul SubjectPublicKeyInfo binario. Calcolarla sul testo base64 la farebbe cambiare ogni volta che cambia l'andata a capo delle righe. L'equivalente in locale è openssl pkey -in private.pem -pubout -outform DER | openssl dgst -sha256 -binary | openssl base64.
 
 
 
  
 
Buone pratiche di gestione delle chiavi
 
 
 
Genera le chiavi dove verranno usate
 
Una chiave privata che attraversa una rete è stata esposta a ogni salto del percorso. Generarla nel browser tiene la chiave stessa fuori dalla rete, anche se il codice della pagina arriva comunque da lì; generarla sull'host di destinazione elimina perfino il passaggio di copia. Per una chiave che protegge sistemi di produzione, preferisci l'host.
 
 
Preferisci Ed25519 se nulla impone RSA
 
Ed25519 offre sicurezza solida in una chiave da 32 byte, con firma rapida e nessun parametro da sbagliare. Ricorri a RSA quando una controparte o una libreria datata non ti lascia alternative.
 
 
Considera i 2048 bit come soglia minima
 
Il NIST SP 800-131A vieta RSA sotto i 2048 bit per la generazione di firme dal 2013, e nessuna certification authority pubblica emette contro una chiave più corta. Scegli 3072 o 4096 per chiavi destinate a restare in servizio per molti anni.
 
 
Non mettere mai una chiave privata sotto controllo di versione
 
Conserva le chiavi private in un gestore di segreti o in una variabile d'ambiente caricata a runtime. Una volta che una chiave finisce in un repository, ruotarla è l'unica risposta sicura.
 
 
Ruota a calendario, non solo dopo un incidente
 
Pubblica le nuove chiavi pubbliche con un identificatore di chiave prima di ritirare le vecchie, così chi verifica può accettare entrambe durante la sovrapposizione. Una rotazione praticata di routine è una rotazione che regge sotto pressione.
 
 
 
  
 
Domande frequenti
 
 
 È sicuro generare una chiave privata su un sito web? 
 La chiave viene generata dall'API Web Crypto nel tuo browser, e questa pagina non invia alcuna richiesta di rete durante la generazione: puoi guardare il pannello Network, oppure staccare la connessione e vedere che la generazione funziona lo stesso. Vale la pena essere precisi su cosa questo dimostra e cosa no: dimostra che alla pagina non serve un server, ma non è una prova contro uno script compromesso, dato che il JavaScript viene riscaricato dal nostro server a ogni visita. I rischi che restano sono quelli del browser, non della rete: un'estensione malevola può leggere la pagina e i tuoi appunti, e chiunque abbia accesso alla macchina può leggere il file scaricato. Per una chiave che protegge sistemi di produzione, generala sull'host che la userà; i comandi OpenSSL qui sotto fanno esattamente questo. Questa pagina è lo strumento giusto per sviluppo, test, studio e ovunque una chiave generata nel browser sia accettabile. 
 
 Qual è la differenza tra PKCS#8 e PKCS#1? 
 Sono due contenitori per la stessa chiave RSA. PKCS#1, marcato BEGIN RSA PRIVATE KEY, contiene direttamente i numeri di RSA ed esiste solo per RSA. PKCS#8, marcato BEGIN PRIVATE KEY, avvolge quegli stessi numeri in un identificatore di algoritmo, così un unico formato può trasportare RSA, ECDSA ed Ed25519 allo stesso modo. La maggior parte delle librerie moderne si aspetta PKCS#8 — il JDK, in particolare, legge solo PKCS#8 senza una libreria aggiuntiva — mentre diversi gateway di pagamento e strumenti dell'era OpenSSL richiedono ancora PKCS#1. Azionare il selettore di questa pagina ricodifica la chiave già a schermo: nulla viene aggiunto o perso e l'impronta resta la stessa. 
 
 Come converto una chiave PKCS#1 in PKCS#8, o viceversa? 
 Aziona il selettore della struttura PEM su questa pagina e la stessa chiave viene riemessa nell'altro contenitore. Per un file che hai già, OpenSSL converte in locale: openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem trasforma un file BEGIN RSA PRIVATE KEY in BEGIN PRIVATE KEY, e openssl rsa -traditional -in pkcs8.pem -out pkcs1.pem fa il percorso inverso. Nessuna delle due direzioni aggiunge o toglie materiale crittografico; cambia solo l'involucro, ed è per questo che entrambi i file descrivono la stessa identica chiave e producono la stessa impronta. 
 
 Come ricavo la chiave pubblica da una chiave privata RSA? 
 La chiave pubblica si ricava dalla chiave privata, mai il contrario. Questa pagina mostra entrambe le metà insieme, quindi non c'è nulla da ricavare. Per una chiave privata che hai già su disco, openssl pkey -in private.pem -pubout -out public.pem scrive il file BEGIN PUBLIC KEY corrispondente. È anche il modo per controllare se una coppia sta insieme: rigenera la metà pubblica e confrontala con il file che ti hanno consegnato. 
 
 Meglio scegliere RSA o Ed25519? 
 Scegli Ed25519 quando nulla ti obbliga. Raggiunge una sicurezza paragonabile a RSA 3072 con una chiave da 32 byte, firma più in fretta e non ha parametri da configurare male. Scegli RSA quando lo impone una controparte, una certification authority o una libreria datata, cosa ancora frequente nei sistemi aziendali e di pagamento. ECDSA sta a metà strada tra i due ed è ampiamente supportato in TLS. 
 
 RSA a 2048 bit è ancora abbastanza robusto? 
 Sì, per la maggior parte degli usi di oggi. Il NIST valuta RSA a 2048 bit a 112 bit di robustezza di sicurezza e lo porta fino al 2030 nella SP 800-57; 3072 bit raggiungono 128 bit di robustezza ed è a quel livello che il NIST punta oltre. Quindi: 2048 per tutto ciò che ruoterai entro pochi anni, 3072 o 4096 per una chiave che prevedi ancora in servizio negli anni Trenta o quando lo richiede una certification authority. Il costo della chiave più grande è una firma più lenta e firme più grandi, non una sicurezza inferiore. 
 
 Posso usare queste chiavi per firmare i JWT? 
 Sì. Le chiavi RSA funzionano con RS256, RS384 e RS512 oltre che con le varianti PSS; ECDSA P-256 si abbina a ES256; ed Ed25519 corrisponde all'algoritmo EdDSA. Firma con la chiave privata e pubblica la chiave pubblica, così chi verifica può controllare le firme senza poterle creare. Una precisazione se usi il pannello JWK anziché il PEM: Web Crypto marca una JWK RSA con alg RS256, e le librerie rigorose si rifiutano di caricarla per PS256 o RS512 — elimina il membro alg, oppure usa il PEM. Il nostro Codificatore JWT accetta queste chiavi, e il decodificatore mostra cosa contiene il token risultante. 
 
 Questo strumento può generare una chiave SSH? 
 Non direttamente. Il file di chiave privata proprio di OpenSSH è un contenitore diverso, che questa pagina non scrive. Una chiave RSA generata qui resta comunque utilizzabile: ssh-keygen -y -f rsa-2048-private.pem > id_rsa.pub ricava la riga per authorized_keys dal file che hai scaricato. Le chiavi Ed25519 generate qui no, perché OpenSSH rifiuta la forma PKCS#8. Per l'accesso SSH la risposta migliore resta ssh-keygen -t ed25519 sulla macchina che ha bisogno della chiave, così eviti del tutto di spostare una chiave privata. Per la firma di JWT, la firma delle release in CI e la verifica dei webhook, la chiave PKCS#8 prodotta da questa pagina è esattamente ciò che quegli strumenti vogliono. 
 
 Posso proteggere la chiave privata con una passphrase? 
 Non qui. Il PKCS#8 cifrato richiede un passaggio di derivazione della chiave che l'API Web Crypto non espone, quindi implementarlo significherebbe scrivere crittografia artigianale in JavaScript. Aggiungi la passphrase in locale: openssl pkcs8 -topk8 -in private.pem -out encrypted.pem legge il file che hai scaricato e te la chiede. 
 
 A cosa serve l'impronta? 
 È un digest SHA-256 della struttura della chiave pubblica, abbastanza corto da confrontarlo a voce o in un messaggio di chat. Quando invii una chiave pubblica a qualcuno, confrontare le impronte su un canale separato conferma che ciò che è arrivato è ciò che hai spedito. Identifica solo la chiave pubblica e non rivela nulla della metà privata. Nota che non è il numero stampato da ssh-keygen -l: OpenSSH calcola l'hash del proprio formato di trasporto anziché della struttura SPKI, quindi i due non coincidono mai per la stessa chiave. 
 
 
 
 
   
  
 
 
Strumenti correlati
  Vedi tutti gli strumenti →
 
 
  
 
  
  
  
 
 
Strumento di Decifratura AES — OpenSSL e CryptoJS
 
 
Strumenti di sicurezza
 
Decifra AES online — GCM/CBC/CTR, passphrase o chiave grezza, rileva "U2FsdGVkX1" (OpenSSL/CryptoJS). 100% nel browser, le chiavi restano sul dispositivo.
 
 
   
  
 
  
  
  
 
 
Strumento di Crittografia AES — GCM, CBC e CTR
 
 
Strumenti di sicurezza
 
Crittografia AES online gratuita — AES-128/192/256, GCM/CBC/CTR, passphrase (PBKDF2) o chiave grezza. Funziona al 100% nel browser; nulla viene caricato.
 
 
   
  
 
  
  
  
 
 
Generatore e verificatore di hash Bcrypt
 
 
Strumenti di sicurezza
 
Genera e verifica hash bcrypt delle password online: costo regolabile, prefissi $2b$/$2a$/$2y$. 100% nel tuo browser; la password non viene mai caricata.
 
 
   
  
 
  
  
  
 
 
Generatore HMAC e Verificatore di Firma
 
 
Strumenti di sicurezza
 
Generatore e verificatore HMAC online e gratuito. Calcola HMAC-SHA256/SHA1/SHA384/SHA512 con chiavi in Testo, Hex o Base64 e output Hex/Base64/Base64URL. 100% nel tuo browser — le chiavi non lasciano mai la pagina.
 
 
   
  
 
  
  
  
 
 
Decodificatore JWT
 
 
Strumenti di sicurezza
 
Decodifica token JWT online con il nostro decodificatore JWT gratis. Ispeziona intestazione, payload, firma, scadenza e attestazioni. 100% browser — token mai fuori dal dispositivo. Nessuna registrazione, nessun tracciamento.
 
 
   
  
 
  
  
  
 
 
Codificatore e Generatore JWT
 
 
Strumenti di sicurezza
 
Generatore JWT online gratis. Costruisci header e payload, firma con HS256, RS256 o ES256 all'istante nel browser; segreto e chiave non lasciano il dispositivo.