Generate an SSH key pair in the OpenSSH format ssh-keygen writes: Ed25519, ECDSA or RSA, with the fingerprint and randomart it prints.
Initializing in your browser…
Build a PKCS#10 certificate signing request with subject alternative names, RSA, ECDSA or Ed25519. Signed and verified in the page before you send it to a CA.
Generate .gitignore files for any project. Pre-built templates for Node.js, Python, React, Java, Go, Rust, and 50+ more technologies.
Generate passwords from the Web Crypto generator by rejection sampling, with the entropy stated exactly from the alphabet, the cost of every rule computed, and crack times against four named attacker models
You need an SSH key for a new laptop, and you want to know before you paste it anywhere that ssh-keygen will actually read it.
Chosen
Algorithm RSA 2048 Comment you@yourmachine
The public key blob, field by field, and what ssh-keygen makes of it
7 bytes algorithm name
3 bytes public exponent e, as an mpint
257 bytes modulus n, as an mpint
279 bytes in the blob
$ ssh-keygen -l -f id_rsa.pub
2048 SHA256:Fkcn+QNTyPlp6EAhxwMmZqmdUycKmin017WkckJbXhI you@yourmachine (RSA)The number to look at is 257. A 2048-bit modulus is 256 bytes, and the field holding it is 257, because RFC 4251 section 5 says an integer in the SSH wire format is two's complement: a value whose top bit is set gets a leading zero octet so it is not read as negative. An RSA modulus always has its top bit set, so that octet is always there.
Drop it and nothing tells you. The line still looks like an SSH key, the base64 still decodes, and the three fields still parse. What happens is that `ssh-keygen -l` answers "is not a public key file" without naming the reason, the server rejects the key, and any fingerprint computed from the blob is a fingerprint of the wrong bytes, so comparing it against the server tells you nothing either.
The private key half has its own version of this. A key exported as PKCS#8, the "BEGIN PRIVATE KEY" form, works for RSA because OpenSSH happens to read it, and fails for Ed25519 with "invalid format", because an Ed25519 private key exists only in OpenSSH's own container. That container is not in any RFC; it is documented in the PROTOCOL.key file in the OpenSSH source, and it is what this tool writes. The project tests put every key type through `ssh-keygen -l`, `-lv`, `-y` and `-Y sign`, so the check is that the key authenticates, not that it looks plausible.
Generate an SSH key pair in your browser, in the exact formats ssh-keygen writes: an authorized_keys line for the public key and an OpenSSH private key file. Ed25519, ECDSA over three curves, or RSA. The fingerprint and the randomart picture shown are the ones ssh-keygen -l and -lv print for the same key.
An SSH key pair is two files, and both have to be in a format OpenSSH actually reads. The public one is a single line: an algorithm name, then base64 of a wire-format blob, then an optional comment. The blob is a run of length-prefixed fields defined by RFC 4251 section 5, and one rule inside it is the usual reason a hand-built key does not work. Integers travel as mpints, which are two's complement, so a value whose top bit is set gets a leading zero octet. An RSA modulus always has its top bit set, so for a 2048-bit key the modulus field is 257 bytes, not 256. Leave that byte out and ssh-keygen answers "is not a public key file" and says nothing about why, and any fingerprint you computed is a fingerprint of the wrong bytes.
The private key is the other half, and PKCS#8 is not it. OpenSSH will read a PKCS#8 RSA key, so RSA appears to work, but it refuses a PKCS#8 Ed25519 key outright with "invalid format": Ed25519 private keys exist only in OpenSSH's own container, which is documented in the PROTOCOL.key file in the OpenSSH source rather than in any RFC. This tool writes that container: the openssh-key-v1 magic, the cipher and KDF names, the public key, then the private fields, the comment and the padding, wrapped at 70 characters the way OpenSSH wraps it. The result is a file ssh-keygen -y reads and derives the same public key from, and that ssh-keygen -Y sign will actually sign with.
Seven key types are offered. Ed25519 is the default and what ssh-keygen has produced by default since OpenSSH 8.5. ECDSA over P-256, P-384 and P-521 is there for policies that name a NIST curve. RSA is at 2048, 3072 (which is ssh-keygen's own RSA default since OpenSSH 8.0) and 4096. Each option carries a note saying who accepts it, including the point that OpenSSH 8.8 disabled the ssh-rsa signature algorithm by default while the same key keeps working through rsa-sha2-256 and rsa-sha2-512. Anything your browser cannot generate is shown greyed out rather than failing when clicked. Keys come from crypto.subtle.generateKey, so the private key is drawn from the platform's own generator.
The page shows more than the two files. The SHA-256 fingerprint is the one ssh-keygen -l prints, and the MD5 one that some hosting panels still display is there too. The randomart is the drunken-bishop picture ssh-keygen -lv draws, computed the same way, so you can recognise a key by shape instead of comparing 43 base64 characters. The public key blob is broken out field by field with the byte count of each, and the tool parses its own output back and says whether every field is well formed, so what you see is read rather than asserted. One thing is stated plainly rather than glossed: the private key has no passphrase, anyone who reads the file can use it, and the command to add one is on the page.
Generate a key and paste the public line into your account so pushes and pulls stop asking for a password.
Put the public line in ~/.ssh/authorized_keys on the server, or use the ssh-copy-id command the page prints.
A dedicated key per pipeline, with the comment naming which one it is so an authorized_keys file stays readable.
Generate a replacement, compare the randomart of the old and new keys, and remove the old public line.
Ed25519 unless something specific requires otherwise. It is the ssh-keygen default since OpenSSH 8.5 and is accepted by every server released since 2014 and by every major Git host. ECDSA is offered for policies that name a NIST curve, and RSA for old servers.
The OpenSSH format, the one beginning "BEGIN OPENSSH PRIVATE KEY". That matters: OpenSSH will read a PKCS#8 RSA key, but it refuses a PKCS#8 Ed25519 key with "invalid format", because Ed25519 private keys exist only in this container.
Not here; the key comes out unencrypted and the page says so next to it. Run ssh-keygen -p -f ~/.ssh/id_ed25519 after saving to add one. Encrypting the container needs bcrypt_pbkdf, which is not something worth reimplementing when the tool that does it correctly is already on your machine.
The key comes from crypto.subtle.generateKey, which is the platform generator, and nothing is uploaded. That said, a key generated in a browser is only as private as the machine and the browser profile it was generated in. For a key protecting something that matters, ssh-keygen on the machine that will use it is the more conservative choice.
Run ssh-keygen -l -f ~/.ssh/id_ed25519.pub. The page prints the exact line you should see, fingerprint and all. ssh-keygen -lv adds the randomart, which should match the picture shown here.
Recognising a key by shape. Comparing two 43-character base64 fingerprints by eye is unreliable; comparing two small pictures is not. It is the same drunken-bishop walk OpenSSH uses, so the picture here is the picture ssh-keygen -lv draws.
The key works. OpenSSH 8.8 disabled the ssh-rsa SIGNATURE algorithm, which is RSA with SHA-1, by default. The same RSA key authenticates through rsa-sha2-256 and rsa-sha2-512, and the key type name written in the file is still ssh-rsa. Only a server too old to offer those is affected.
This runs as client-side JavaScript. Keys, tokens, payloads, and other inputs never leave your device.