Skip to content

Gratis online RSA-sleutelgenerator — ECDSA, Ed25519

RSA-sleutelpaar online genereren — de privésleutel blijft in je browser. RSA 2048/4096, ECDSA en Ed25519, als PKCS#8- of PKCS#1-PEM, met JWK en fingerprint.

Geen tracking Draait in je browser Gratis
Sleutelparen worden in je browser gegenereerd met de Web Crypto API, en tijdens het genereren gaat er geen enkel netwerkverzoek uit. Verbreek je verbinding en deze pagina werkt gewoon door.

PKCS#8 (BEGIN PRIVATE KEY) is de moderne standaard en wat de JDK verwacht. PKCS#1 (BEGIN RSA PRIVATE KEY) is de traditionele vorm van OpenSSL, die sommige gateways nog steeds vereisen. Omschakelen encodeert dezelfde sleutel opnieuw.

Houd deze geheim. Iedereen die hem heeft, kan zich voor je uitgeven.

Fingerprint van de publieke sleutel — SHA-256 van de SPKI-DER
JWK (JSON Web Key)
Privé-JWK — publiceer deze nooit 
 
 
 
 Publieke JWK  
 
 
 
 
  
 
Hetzelfde soort sleutelpaar genereren met OpenSSL
 
 
    
 
  
  
  
  Gecontroleerd op correctheid volgens RFC 5958/5208 (PKCS#8), RFC 8017 (PKCS#1), RFC 8410 (Ed25519) en RFC 7468 (PEM-codering), en op het gedrag van de Web Crypto API bij RSA, ECDSA en Ed25519. — Go Tools Security Tooling Team · Aug 10, 2026  
 Ons team controleert de omzetting van PKCS#8 naar PKCS#1 byte voor byte tegen de referentie-uitvoer van de crypto-module van Node, zodat een sleutel die je hier exporteert identiek is aan wat OpenSSL uit hetzelfde materiaal zou produceren. 
 
 
      
 
Wat is een RSA-sleutelgenerator?
 
 
Een RSA-sleutelgenerator maakt een wiskundig gekoppeld paar: een privésleutel die je bewaart en een publieke sleutel die je uitdeelt. Alles wat met de privéhelft is ondertekend, is met de publieke helft te verifiëren, en alleen de publieke helft is veilig om te publiceren. Precies die asymmetrie is waar het om draait — daardoor kan een verifieerder jouw handtekeningen controleren zonder ze zelf te kunnen vervalsen, iets wat een gedeeld secret nooit kan bieden.
Deze generator draait in je browser via de Web Crypto API, dus de privésleutel ontstaat in het tabblad en de pagina doet tijdens het genereren geen enkel netwerkverzoek. Naast RSA maakt hij ook ECDSA- en Ed25519-paren, die hetzelfde doel dienen met veel kortere sleutels: een Ed25519-privésleutel is 48 bytes in PKCS#8, terwijl een RSA-sleutel van 2048 bits ruim over 1,2 KB gaat.
Wat mensen laat struikelen is niet de wiskunde maar de verpakking. Dezelfde sleutel kan worden geschreven als PKCS#8, PKCS#1, SPKI of JWK, en een bibliotheek die de ene weigert accepteert vaak de andere, zonder duidelijker melding dan een verwerkingsfout. De tabel verderop koppelt elke container aan de ecosystemen die hem verwachten.
 
 
// 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.
 
  
 
Belangrijkste functies
 
 
 
Gegenereerd in je browser
 
De sleutels komen uit de Web Crypto API in je eigen tabblad, en de pagina doet tijdens het genereren geen enkel netwerkverzoek. Zet je verbinding uit en het blijft werken, wat laat zien dat de tool geen server nodig heeft om zijn werk te doen.
 
 
RSA, ECDSA en Ed25519
 
RSA 2048, 3072 en 4096; ECDSA op P-256, P-384 en P-521; en Ed25519, allemaal vanaf één pagina met dezelfde exportopties.
 
 
Uitvoer in PKCS#8 en PKCS#1
 
Wissel tussen BEGIN PRIVATE KEY en de traditionele indeling BEGIN RSA PRIVATE KEY zonder OpenSSL aan te raken. De schakelaar encodeert de sleutel die al op het scherm staat opnieuw, dus het blijft dezelfde sleutel.
 
 
JWK-export
 
Beide helften zijn beschikbaar als JSON Web Key. De publieke JWK is wat in een JWKS-document of een JOSE-verifieerder hoort; de private JWK is alleen voor je ondertekenaar en mag nooit worden gepubliceerd.
 
 
SHA-256-fingerprint
 
Bij elk paar hoort een fingerprint van de publieke sleutel, zodat je via een apart kanaal kunt controleren dat beide kanten dezelfde sleutel hebben.
 
 
Bijpassende OpenSSL-commando's
 
Onder de uitvoer staan de commando's waarmee je hetzelfde soort sleutel lokaal maakt, zodat je op elk moment naar de commandoregel kunt overstappen.
 
 
Downloads met begrijpelijke namen
 
Bestanden worden opgeslagen als rsa-2048-private.pem en rsa-2048-public.pem in plaats van onder een algemene downloadnaam die je nog moet hernoemen.
 
 
Geen account nodig, geen limiet
 
Er komt geen server aan te pas, dus er is niets om je voor aan te melden en geen quotum dat op kan raken.
 
 
 
      
 
Uitgewerkte voorbeelden
 
 
 
Een Ed25519-paar, volledig getoond
 
 
Algoritme: Ed25519
 
-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIA2HJVU1qChbOJN8XksXVhyD0IjYVt0UU6Mwz814rOFf
-----END PRIVATE KEY-----

-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAV5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU=
-----END PUBLIC KEY-----
 
 
Een Ed25519-privésleutel is 48 bytes in PKCS#8 en de publieke sleutel 44 bytes, dus elk PEM bevat één regel base64. Dit is een wegwerpvoorbeeld — genereer je eigen paar in plaats van dit te kopiëren.
 
 
PKCS#8 en PKCS#1 verschillen in de header
 
 
Algoritme: RSA 2048, structuur omgeschakeld
 
PKCS#8:  -----BEGIN PRIVATE KEY-----
PKCS#1:  -----BEGIN RSA PRIVATE KEY-----
 
 
Dezelfde sleutel, twee verpakkingen. PKCS#8 legt een algoritme-identificator om de RSA-structuur heen, en daarom werkt het voor elk algoritme terwijl PKCS#1 alleen voor RSA bestaat. De schakelaar encodeert de sleutel die al op het scherm staat opnieuw, dus de fingerprint verandert niet.
 
 
Publieke RSA 2048-sleutel
 
 
Algoritme: RSA 2048
 
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni
eSccN1uleXFRBb1g2TN6bk/fbpPCGDyh71m73oB9Bk8+fKVkSThXyWTtpgblB7pX
iQBtTvSWVZGHprkLgMGkU2Yw8Z43m1WpoRuYyXNFe92S5viIdVuKTj/VEUuEpzHd
ffWMIUw70LaUdTP04iQdkNVeS3M6VHkpTwsPSQfsFSwObtLVNy2Lf+ODwJRqCk2r
C749hgKqBdJqkcIj49R7UP4SMQ/9V3yy8DFMrIcgsjC4tHwlQSCGeXNxTNlapGSa
ke55LUR83FASryVJRbUs678SCZSFkyGcT0qLZ/olu/e7Jj2lB0Qy/SJawkrs9hPE
4QIDAQAB
-----END PUBLIC KEY-----
 
 
Het voorvoegsel MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A is de rsaEncryption-algoritme-identificator; daaraan herken je een RSA-SPKI-sleutel in één oogopslag.
 
 
Publieke sleutel als JWK
 
 
Algoritme: Ed25519, JWK-paneel
 
{
  "key_ops": [
    "verify"
  ],
  "ext": true,
  "alg": "Ed25519",
  "crv": "Ed25519",
  "x": "V5uB7UaPJrtncx3SXNtNzn1ZXjF1ApwvzBZ8nFzT5eU",
  "kty": "OKP"
}
 
 
Dit is de export woordelijk, inclusief de velden key_ops en ext die Web Crypto er altijd bij zet. Een JWKS-vermelding wil die niet — verwijder ze allebei en voeg in plaats daarvan kid en use toe, zodat verifieerders tijdens een rotatie de juiste sleutel kunnen kiezen. Ed25519 komt terecht in het sleuteltype OKP; RSA-sleutels verschijnen als kty RSA met de velden n en e.
 
 
SHA-256-fingerprint
 
 
Algoritme: Ed25519
 
SHA256(SPKI) = KAXVxapxpG4zLsTVMpPafovT+X1NLWc8fsOXqtrb59o=
 
 
Een SHA-256-digest van de structuur van de publieke sleutel, kort genoeg om telefonisch voor te lezen. Let op: dit is niet de waarde die ssh-keygen toont — OpenSSH berekent de hash over zijn eigen wire-formaat, dus die twee komen voor dezelfde sleutel nooit overeen.
 
 
 
      
 
Zo gebruik je de RSA-sleutelgenerator
 
     
  1.  1 
     
    Kies het algoritme
     
    RSA dekt het breedste scala aan oudere systemen. ECDSA geeft dezelfde sterkte in veel kortere sleutels. Ed25519 is de moderne standaard voor nieuw ondertekeningswerk.
     
     
  2.  2 
     
    Kies de sleutellengte
     
    RSA 2048 voldoet aan de huidige richtlijnen; 3072 en 4096 geven marge voor sleutels die lang meegaan. ECDSA biedt P-256, P-384 en P-521. Ed25519 heeft één vaste maat.
     
     
  3.  3 
     
    Kies de PEM-structuur
     
    PKCS#8 geeft BEGIN PRIVATE KEY en werkt vrijwel overal, ook in de JDK. Schakel alleen naar PKCS#1 wanneer iets uitdrukkelijk om BEGIN RSA PRIVATE KEY vraagt.
     
     
  4.  4 
     
    Kopieer of download beide helften
     
    De privésleutel gaat naar je secrets manager. De publieke sleutel gaat naar wie jouw handtekeningen verifieert. Stuur de privéhelft nooit ergens heen.
     
     
  5.  5 
     
    Controleer de fingerprint
     
    Vergelijk de SHA-256-fingerprint via een apart kanaal om te bevestigen dat de andere kant precies de publieke sleutel heeft geïnstalleerd die jij hebt gegenereerd.
     
     
    6.  
 
  
 
Veelvoorkomende fouten met sleutelformaten
 
 
 
De publieke sleutel geplakt waar de privésleutel hoort
 
Ondertekenen vraagt om de privéhelft. Een bibliotheek die BEGIN PUBLIC KEY krijgt waar ze een privésleutel verwachtte, meldt meestal een nietszeggende verwerkingsfout in plaats van het echte probleem te benoemen.
 
 
 ✗ Fout 
-----BEGIN PUBLIC KEY-----
 
 
 ✓ Correct 
-----BEGIN PRIVATE KEY-----
 
 
 
 
Verkeerde PEM-structuur voor de bibliotheek
 
Slechts een paar ecosystemen lezen alleen de traditionele RSA-indeling — de -traditional-uitvoer van OpenSSL zelf, sommige SDK’s van betaalgateways, oudere Ruby- en Perl-tools. De meeste moderne bibliotheken, en de JDK in het bijzonder, verwachten PKCS#8. Zet de schakelaar voor de PEM-structuur om in plaats van naar een conversiecommando te zoeken.
 
 
 ✗ Fout 
-----BEGIN RSA PRIVATE KEY-----
 
 
 ✓ Correct 
-----BEGIN PRIVATE KEY-----
 
 
 
 
De afsluitende regelovergang kwijtgeraakt
 
PEM-bestanden eindigen met een regelovergang na de laatste scheidingsregel. Kopiëren via een formulierveld dat witruimte weghaalt, levert een bestand op dat sommige parsers ronduit weigeren — en omdat het ontbrekende teken onzichtbaar is, ziet het bestand er in een editor correct uit.
 
 
 ✗ Fout 
-----END PRIVATE KEY-----[EOF]
 
 
 ✓ Correct 
-----END PRIVATE KEY-----↵[EOF]
 
 
 
 
Een teken onderweg kwijtgeraakt
 
Wat een PEM breekt is een verdwenen, ingevoegd of vervangen teken, niet de regelbreedte — de meeste parsers accepteren elke afbreking. Een kopie via een chatprogramma of een formulierveld kan een regelovergang stilletjes in een spatie veranderen, en base64 geeft geen enkele hint welk teken misging; de sleutel laadt gewoon niet. Gebruik de kopieerknop in plaats van met de hand te selecteren.
 
 
 ✗ Fout 
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni eSccN1uleXFRBb1g2TN6bk
 
 
 ✓ Correct 
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtuvUHLjyK9zje2aaNIni
eSccN1uleXFRBb1g2TN6bk
 
 
 
 
Een HS256-secret gebruikt waar RS256 is ingesteld
 
HS256 neemt één gedeeld secret; RS256 neemt een sleutelpaar. Een willekeurige tekenreeks aan een RS256-ondertekenaar geven strandt al bij het inlezen. Genereer hier het paar, of gebruik onze JWT-secretgenerator als je HS256 bedoelde.
 
 
 ✗ Fout 
alg: RS256, key: 8f3a9c2e1b7d
 
 
 ✓ Correct 
alg: RS256, key: -----BEGIN PRIVATE KEY-----
 
 
 
 
Een PEM in authorized_keys geplakt
 
Een publieke SSH-sleutel is de eenregelige OpenSSH-vorm ssh-ed25519 AAAA…, geen PEM-blok, dus de publieke sleutel van deze pagina in authorized_keys plakken werkt niet. Bij een RSA-sleutel leid je de juiste regel lokaal af met ssh-keygen -y; voor SSH-toegang in het algemeen is genereren op de doelmachine nog beter.
 
 
 ✗ Fout 
-----BEGIN PUBLIC KEY-----
 
 
 ✓ Correct 
ssh-keygen -y -f rsa-2048-private.pem > id_rsa.pub
 
 
 
 
 
  
 
Wie gebruikt deze tool
 
 
 
JWT's ondertekenen met RS256 of EdDSA
 
Asymmetrische JWT-algoritmen hebben een sleutelpaar nodig in plaats van een gedeeld secret. Onderteken met de privésleutel, publiceer de publieke sleutel, en verifieerders hebben nooit iets in handen waarmee ze zelf tokens kunnen maken. Onze JWT-encoder accepteert de sleutels die deze pagina maakt.
 
 
Webhooks en releases ondertekenen
 
Publiceer de publieke sleutel één keer, onderteken elke payload met de privésleutel, en afnemers kunnen de echtheid controleren zonder gedeelde inloggegevens die kunnen lekken.
 
 
Lokale ontwikkeling en tests
 
Testsuites die handtekeningverificatie doorlopen, hebben een wegwerpsleutelpaar nodig. Er hier een genereren gaat sneller dan de OpenSSL-aanroep uit je hoofd opdiepen.
 
 
Leren hoe een sleutelpaar eruitziet
 
Naast elkaar wisselen tussen algoritmen en PEM-structuren maakt de verschillen concreet op een manier die het lezen van een specificatie niet doet.
 
 
Een JWKS-endpoint voorbereiden
 
De publieke JWK past rechtstreeks in een keys-array van een OpenID Connect-discoverydocument. Voeg een kid toe zodat verifieerders hem tijdens een rotatie kunnen kiezen, en houd de private JWK buiten dat bestand.
 
 
Weg migreren van RSA
 
Genereer de Ed25519-vervanger naast het RSA-origineel en vergelijk de groottes voordat je je aan de overstap vastlegt.
 
 
Een verschil in formaat oplossen
 
Wanneer een bibliotheek een sleutel met een verwerkingsfout weigert, is hem opnieuw uitgeven in de andere PEM-structuur meestal de hele oplossing.
 
 
 
  
 
PEM-formaten en hoe de generator werkt
 
 
 
Welke container waar hoort
 
Eén sleutel, vijf verpakkingen. De verkeerde kiezen is de meest voorkomende reden dat een sleutel wordt geweigerd, en de foutmelding is zelden specifieker dan een mislukte verwerking.


ContainerPEM-headerBevatWaar je hem tegenkomt
PKCS#8BEGIN PRIVATE KEYElk algoritmeWeb Crypto, de JDK, Go, .NET — de meeste moderne bibliotheken
PKCS#1BEGIN RSA PRIVATE KEYAlleen RSATraditionele OpenSSL-uitvoer, sommige betaalgateways, oudere Ruby- en Perl-tools
SPKI / X.509BEGIN PUBLIC KEYElk algoritme, publieke helftDe publieke sleutel die vrijwel elke bibliotheek verwacht
PKCS#1 publiekBEGIN RSA PUBLIC KEYAlleen RSA, publieke helftOudere RSA-tools
JWKgeen — het is JSONElk algoritmeJWKS-endpoints, OIDC-discovery, JOSE-bibliotheken


Om bestanden die je al hebt om te zetten, gaat openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem de ene kant op en openssl rsa -traditional -in pkcs8.pem -out pkcs1.pem de andere.
 
 
De willekeurigheid komt van het besturingssysteem
 
Web Crypto voedt de sleutelgeneratie vanuit de entropiebron van het platform — getrandom op Linux, en de CSPRNG van het systeem op Windows en macOS. Het is dezelfde soort bron waaruit OpenSSL put, geen pseudowillekeurige generator in JavaScript.
 
 
Genereren laat de pagina niet vastlopen
 
crypto.subtle.generateKey is asynchroon, en in de grote browser-engines gebeurt het zoeken naar priemgetallen buiten de hoofdthread, dus de interface blijft reageren terwijl een modulus van 4096 bits wordt gevonden. Er verschijnt hoe dan ook een spinner, want hoe lang dat zoeken duurt hangt van geluk af.
 
 
PKCS#8 omhult PKCS#1
 
Een PKCS#8-PrivateKeyInfo bestaat uit een versienummer, een algoritme-identificator en een OCTET STRING. Bij een onversleutelde rsaEncryption-sleutel bevat die OCTET STRING een volledige PKCS#1-RSAPrivateKey, en precies zo zet deze pagina de twee naar elkaar om zonder iets opnieuw af te leiden.
 
 
Publieke sleutels gebruiken SubjectPublicKeyInfo
 
BEGIN PUBLIC KEY is een X.509-SubjectPublicKeyInfo: een algoritme-identificator plus een BIT STRING. Wat er in die bits zit hangt af van het algoritme — bij RSA is het een PKCS#1-RSAPublicKey, en daarom is BEGIN RSA PUBLIC KEY korter; bij ECDSA is het het ongecomprimeerde curvepunt en bij Ed25519 de kale sleutel van 32 bytes.
 
 
De publieke exponent is 65537
 
Elke RSA-sleutel hier gebruikt e = 65537, geschreven als 0x010001. Die is groot genoeg om aanvallen op kleine exponenten uit te sluiten en heeft maar twee gezette bits, zodat verificatie 16 kwadrateringen en één vermenigvuldiging kost.
 
 
Fingerprints gaan over de DER, niet over de PEM
 
De SHA-256-fingerprint gaat over de binaire SubjectPublicKeyInfo. Over de base64-tekst zou hij veranderen zodra de regelafbreking verandert. Lokaal komt dat neer op openssl pkey -in private.pem -pubout -outform DER | openssl dgst -sha256 -binary | openssl base64.
 
 
 
  
 
Aanbevolen aanpak voor sleutelbeheer
 
 
 
Genereer sleutels waar ze gebruikt worden
 
Een privésleutel die over een netwerk reist, is aan elke tussenstap blootgesteld geweest. Genereren in de browser houdt de sleutel zelf van het netwerk af, al komt de code van de pagina er nog steeds overheen; genereren op de doelmachine haalt zelfs de kopieerstap weg. Voor een sleutel die productiesystemen beschermt, kies je de doelmachine.
 
 
Kies Ed25519 tenzij iets RSA vereist
 
Ed25519 geeft sterke beveiliging in een sleutel van 32 bytes, ondertekent snel en heeft geen parameters die je verkeerd kunt kiezen. Grijp naar RSA wanneer een tegenpartij of een oude bibliotheek je geen keuze laat.
 
 
Behandel 2048 bits als ondergrens
 
NIST SP 800-131A verbiedt RSA onder 2048 bits voor het maken van handtekeningen sinds 2013, en geen enkele publieke certificaatautoriteit geeft uit op een kleinere sleutel. Kies 3072 of 4096 voor sleutels die naar verwachting jarenlang in gebruik blijven.
 
 
Zet nooit een privésleutel in versiebeheer
 
Bewaar privésleutels in een secrets manager of in een omgevingsvariabele die je bij het starten inleest. Zodra een sleutel in een repository belandt, is vervangen het enige veilige antwoord.
 
 
Roteer volgens schema, niet pas na een incident
 
Publiceer nieuwe publieke sleutels met een sleutel-identificator voordat je de oude intrekt, zodat verifieerders er tijdens de overlap twee accepteren. Rotatie die je routineus oefent, is rotatie die het onder druk doet.
 
 
 
  
 
Veelgestelde vragen
 
 
 Is het veilig om een privésleutel op een website te genereren? 
 De sleutel wordt gemaakt door de Web Crypto API in je eigen browser, en deze pagina doet tijdens het genereren geen enkel netwerkverzoek — je kunt het netwerkpaneel bekijken, of de verbinding verbreken en zien dat genereren gewoon blijft werken. Wees duidelijk over wat dat wel en niet aantoont: het laat zien dat de pagina geen server nodig heeft, maar het is geen bewijs tegen een gecompromitteerd script, want de JavaScript wordt bij elk bezoek opnieuw van onze server gehaald. De risico’s die overblijven zijn die van de browser, niet die van het netwerk — een kwaadaardige extensie kan de pagina en je klembord lezen, en iedereen met toegang tot de machine kan het gedownloade bestand lezen. Voor een sleutel die productiesystemen beschermt, genereer je hem op de machine die hem gaat gebruiken; de OpenSSL-commando’s hieronder doen precies dat. Deze pagina is de juiste tool voor ontwikkeling, tests, leren, en overal waar een in de browser gegenereerde sleutel acceptabel is. 
 
 Wat is het verschil tussen PKCS#8 en PKCS#1? 
 Het zijn twee verpakkingen voor dezelfde RSA-sleutel. PKCS#1, herkenbaar aan BEGIN RSA PRIVATE KEY, bevat de RSA-getallen rechtstreeks en bestaat alleen voor RSA. PKCS#8, herkenbaar aan BEGIN PRIVATE KEY, legt een algoritme-identificator om diezelfde getallen heen, waardoor één formaat RSA, ECDSA en Ed25519 kan dragen. De meeste moderne bibliotheken verwachten PKCS#8 — de JDK leest zonder extra bibliotheek zelfs uitsluitend PKCS#8 — terwijl een aantal betaalgateways en oudere tools uit het OpenSSL-tijdperk nog om PKCS#1 vragen. De schakelaar op deze pagina encodeert de sleutel die al op het scherm staat opnieuw, dus er gaat geen informatie bij of af en de fingerprint blijft hetzelfde. 
 
 Hoe zet ik een PKCS#1-sleutel om naar PKCS#8, of terug? 
 Zet de schakelaar voor de PEM-structuur op deze pagina om en dezelfde sleutel wordt opnieuw uitgegeven in de andere container. Voor een bestand dat je al hebt, converteert OpenSSL lokaal: openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem maakt van een BEGIN RSA PRIVATE KEY-bestand een BEGIN PRIVATE KEY, en openssl rsa -traditional -in pkcs8.pem -out pkcs1.pem gaat de andere kant op. Geen van beide richtingen voegt sleutelmateriaal toe of haalt het weg; alleen de verpakking verandert, en daarom beschrijven beide bestanden dezelfde sleutel en leveren ze dezelfde fingerprint op. 
 
 Hoe haal ik de publieke sleutel uit een RSA-privésleutel? 
 De publieke sleutel is af te leiden uit de privésleutel, nooit andersom. Deze pagina toont beide helften tegelijk, dus hier valt niets af te leiden. Voor een privésleutel die al op schijf staat, schrijft openssl pkey -in private.pem -pubout -out public.pem het bijbehorende BEGIN PUBLIC KEY-bestand. Zo controleer je ook of een paar bij elkaar hoort — genereer de publieke helft opnieuw en vergelijk die met het bestand dat je hebt gekregen. 
 
 Moet ik RSA of Ed25519 kiezen? 
 Kies Ed25519 wanneer niets je hand dwingt. Het haalt met een sleutel van 32 bytes een beveiligingsniveau vergelijkbaar met RSA 3072, ondertekent sneller en heeft geen parameters om verkeerd in te stellen. Kies RSA wanneer een tegenpartij, een certificaatautoriteit of een oude bibliotheek het vereist, wat in bedrijfs- en betaalsystemen nog steeds vaak zo is. ECDSA zit ertussenin en wordt breed ondersteund in TLS. 
 
 Is RSA met 2048 bits nog sterk genoeg? 
 Ja, voor de meeste doeleinden vandaag. NIST waardeert RSA met 2048 bits op een beveiligingsniveau van 112 bits en voert het in SP 800-57 door tot 2030; 3072 bits haalt 128 bits en is waar NIST daarna naar wijst. Dus: 2048 voor alles wat je binnen een paar jaar roteert, 3072 of 4096 voor een sleutel die je in de jaren 2030 nog in dienst verwacht of waar een certificaatautoriteit het eist. De prijs van de grotere sleutel is trager ondertekenen en grotere handtekeningen, geen zwakkere beveiliging. 
 
 Kan ik deze sleutels gebruiken om JWT's te ondertekenen? 
 Ja. RSA-sleutels werken met RS256, RS384 en RS512 en met de PSS-varianten; ECDSA P-256 hoort bij ES256; en Ed25519 is het EdDSA-algoritme. Onderteken met de privésleutel en publiceer de publieke sleutel, zodat verifieerders handtekeningen kunnen controleren zonder ze te kunnen maken. Eén kanttekening als je het JWK-paneel gebruikt in plaats van het PEM: Web Crypto stempelt een RSA-JWK af met alg RS256, en strikte bibliotheken weigeren hem dan te laden voor PS256 of RS512 — verwijder het veld alg, of gebruik het PEM. Onze JWT-encoder accepteert deze sleutels, en de decoder laat zien wat er in het token komt te staan. 
 
 Kan dit een SSH-sleutel genereren? 
 Niet rechtstreeks. OpenSSH heeft een eigen bestand voor privésleutels, en deze pagina schrijft dat niet. Een RSA-sleutel van hier is wel bruikbaar: ssh-keygen -y -f rsa-2048-private.pem > id_rsa.pub leidt de authorized_keys-regel af uit het bestand dat je hebt gedownload. Ed25519-sleutels van hier zijn dat niet, omdat OpenSSH de PKCS#8-vorm weigert. Voor SSH-toegang blijft ssh-keygen -t ed25519 op de machine die de sleutel nodig heeft het betere antwoord, want dan verplaats je helemaal geen privésleutel. Voor JWT-ondertekening, het ondertekenen van CI-releases en webhookverificatie is de PKCS#8-sleutel van deze pagina precies wat die tools willen. 
 
 Kan ik de privésleutel met een wachtwoordzin beschermen? 
 Hier niet. Versleuteld PKCS#8 vraagt om een sleutelafleidingsstap die de Web Crypto API niet aanbiedt, dus het inbouwen zou betekenen dat we cryptografie in JavaScript zelf in elkaar zetten. Voeg de wachtwoordzin lokaal toe: openssl pkcs8 -topk8 -in private.pem -out encrypted.pem leest het bestand dat je hebt gedownload en vraagt erom. 
 
 Waar dient de fingerprint voor? 
 Het is een SHA-256-digest van de structuur van de publieke sleutel, kort genoeg om per telefoon of in een chatbericht te vergelijken. Wanneer je iemand een publieke sleutel stuurt, bevestigt het vergelijken van fingerprints via een apart kanaal dat wat er aankwam ook is wat je verstuurde. Hij identificeert alleen de publieke sleutel en verraadt niets over de privéhelft. Let op dat het niet het getal is dat ssh-keygen -l toont: OpenSSH berekent de hash over zijn eigen wire-formaat in plaats van over de SPKI-structuur, dus die twee komen voor dezelfde sleutel nooit overeen. 
 
 
 
 
   
  
 
 
Gerelateerde tools
  Alle tools bekijken →
 
 
  
 
  
  
  
 
 
AES-ontsleutelingstool — OpenSSL- & CryptoJS-compatibel
 
 
Beveiligingstools
 
Ontsleutel AES online — GCM/CBC/CTR, wachtwoordzin of ruwe sleutel, detecteert automatisch het OpenSSL- & CryptoJS-formaat "U2FsdGVkX1". 100% in de browser, sleutels verlaten de pagina nooit.
 
 
   
  
 
  
  
  
 
 
AES-versleutelingstool — GCM, CBC & CTR
 
 
Beveiligingstools
 
Gratis AES-versleuteling online — AES-128/192/256, GCM/CBC/CTR, wachtwoordzin (PBKDF2) of ruwe sleutel. Draait 100% in je browser; niets wordt geüpload.
 
 
   
  
 
  
  
  
 
 
Bcrypt-hashgenerator & -verifier
 
 
Beveiligingstools
 
Genereer en verifieer bcrypt-wachtwoordhashes online — instelbare kostenfactor, $2b$/$2a$/$2y$-prefixes. 100% in je browser; je wachtwoord wordt nooit geüpload.
 
 
   
  
 
  
  
  
 
 
HMAC-generator en handtekeningverificatie
 
 
Beveiligingstools
 
Gratis online HMAC-generator en -verificator. Bereken HMAC-SHA256/SHA1/SHA384/SHA512 met sleutels in Tekst, Hex of Base64 en Hex/Base64/Base64URL-uitvoer. 100% in je browser — sleutels verlaten nooit de pagina.
 
 
   
  
 
  
  
  
 
 
JWT decoderen — online JWT-decoder
 
 
Beveiligingstools
 
Decodeer JWT-tokens direct in je browser. Inspecteer header, payload, signature, vervaldatum en claims. 100% privé — je token verlaat je apparaat nooit.
 
 
   
  
 
  
  
  
 
 
JWT-encoder & generator
 
 
Beveiligingstools
 
Gratis online JWT-generator & encoder. Bouw de header en payload en onderteken direct met HS256, RS256 of ES256. 100% in de browser — je secret en sleutel verlaten je apparaat nooit.