OpenPGP card
Build 0x0BE1 lets the background RSA prime search observe cancellation inside
its Lucas test after a key is complete. Prime acceptance, key formats and
authorization are unchanged; the abandoned candidate is wiped before core1 idles.
Build 0x0BD6 reduces Brainpool arithmetic and counter-rotation work.
Retry charging, durable restoration, migration and key cleanup are unchanged.
Build 0x0B45 sizes the TrustZone CCID reply scratch buffer to the existing
CCID response limit, reducing initialization and cleanup work on each APDU.
Maximum response sizes and complete buffer cleanup are unchanged.
Build 0x0B44 accelerates P-521 signatures, authentication and ECDH using
constant-time point arithmetic and Secure SRAM field routines. P-384 uses a
specialized field square on 32-bit targets. Existing keys need no migration;
peer validation, deterministic signatures, PIN checks and cleanup are retained.
TrustZone build 0x0ADF further reduces the initial GET DATA 6E response
latency. Existing OpenPGP keys and data objects upgrade without a reset.
TrustZone build 0x0ADE reduces latency for the initial GET DATA 6E response.
Existing OpenPGP keys and data objects remain compatible; no reset is required.
TrustZone build 0x0ADD skips unused zero-length USB packet bookkeeping during
CCID transfers. Session and epoch checks and complete buffer/stack cleanup remain
unchanged. Existing keys and records upgrade without a reset.
TrustZone build 0x0ADC further reduces authenticated read latency
while retaining full record verification and rollback protection. Existing keys
and records remain compatible; the upgrade does not require a reset.
Build 0x0AD8 also clears the complete Non-secure gateway reply buffer with
volatile word stores, including byte edges, on normal completion and abandonment.
The guard also clears it when a pending transport future is dropped.
Build 0x0AD7 clears both complete command response buffers with aligned
volatile word stores. Byte edges and remaining words are also cleared; every
command retains the same full-buffer cleanup and dead-stack sweep.
From build 0x0ACF, GET DATA uses the shared backend’s complete authenticated
main directory in protected RAM. Each requested value is still freshly read and
authenticated under a freshly derived root. The backend retains confirmed
publication progress across errors and remounts; it does not cache plaintext.
Full journal checks remain before mutations and directory reconstruction.
Unrelated journal damage is detected when those journals are consumed, rather
than on each warm GET DATA. See shared-storage behavior.
Existing objects, capacities and persistent layouts are unchanged. Occasional
mount-time history checkpointing still adds startup work and erases when due.
Build 0x0AD0 also avoids clearing unused storage scratch after warm GET DATA.
From 0x0AD6, a mounted read-tag miss uses full wiped scratch and seeds its
read tag without retrying a small buffer that encountered a larger neighbor.
Later tag hits keep bounded scratch and freshly authenticate the complete value.
Every byte a read can fill is still cleared on success and failure; recovery
retains full-buffer cleanup.
From build 0x0B66, signature-counter reads reuse authenticated journal
locations after freshly checking both complete banks, including their erased
tails. A change triggers full journal verification and recovery. Signatures
still require durable counter publication to both banks before success;
existing cards need no migration or reset.
Build 0x0B70 also avoids replaying old journal records after PIN and signature
counter writes. Both banks are freshly checked against the exact expected
publication before success, including all historical bytes and erased tails.
Value MACs, retry ordering and recovery after power loss are unchanged.
Build 0x0B83 reduces repeated directory HMAC setup during the storage checks behind
PIN updates. Attempts are still durably charged before comparison, and a
successful PIN restores its retry count before authorization is granted.
From 0x0BA8, retry bytes use the mirrored counter journal while the PIN
verifiers stay in their original records. Existing remaining attempts migrate
on the first update. Earlier v2 firmware then refuses the store; reinstalling this
build or later resumes it. No PIN or key reset is needed for the upgrade.
Build 0x0BB0 combines counter header and value programming for PIN retries
and signature counters. It preserves the 0x0BA8 format and durability checks.
From build 0x0AD1, key information reads the shared origin record once per
response. Later responses read it again; an unreadable or unrecorded slot still
reports imported.
A full OpenPGP card 3.4 over CCID: three key slots (signature, decryption, authentication), works with stock GnuPG. The same slots cover commit signing, SSH login (via gpg-agent), and end-to-end mail/file encryption.
Build 0x0ACB accelerates P-384 ECDH decryption with constant-time Jacobian
multiplication, retaining peer-point validation and the same shared secret.
Build 0x0ACC also accelerates the underlying P-384 field products on 32-bit
boards; existing keys and signatures remain compatible.
GET DATA returns 6581 if its output buffer cannot hold the complete data
object. An undersized buffer does not produce a successful partial template.
GET DATA 7A also returns 6581 when the signature counter is absent,
unreadable or not exactly three bytes; it never publishes a partial counter
template as a successful response.
Boot preserves present damaged security records rather than provisioning factory PINs or a new DEK over them. A malformed UIF record requires touch. Signing refuses a malformed signature counter without returning a signature; attestation refuses malformed subject fields instead of certifying zero padding.
Prereqs: on Linux, pcscd + the scdaemon.conf lines from
linux.md. Check the card is visible:
gpg --card-status # reader: RS-Key Security Key …, OpenPGP v3.4
From build 0x0ABF, card-status queries use fewer flash reads on authenticated
storage. Each request still reads the current values from the key.
Build 0x0AC4 also reads variable children and algorithm attributes once per
occurrence. Their lengths come from that same authenticated read; an unreadable
child refuses the complete response.
gpg works regardless of the reader name. scdaemon identifies the card by its
ATR and applet SELECT, not the USB identity. The default build reports the
reader as “RS-Key”; the opt-in VIDPID=Yubikey5 flavor reports it as “Yubico
YubiKey” (build.md).
PINs
| Default | Length | Unlocks | |
|---|---|---|---|
| User PIN (PW1) | 123456 | 6–127 | signing, decryption, authentication |
| Admin PIN (PW3) | 12345678 | 8–127 | key import/generation, card settings |
| Reset Code (RC) | unset | 8–127 | unblocking PW1 without PW3 |
Those columns are exclusive: the admin PIN authorises no key operation. It cannot sign, decrypt or authenticate, however recently it was entered — that is the card spec’s rule and what a YubiKey does. (Earlier RS-Key builds let PW3 stand in for PW1 here. If you have a script that unlocks signing with the admin PIN, it needs the user PIN now.)
The same split governs the four private-use data objects: 0101 and 0103 are
the cardholder’s and open to the user PIN, 0102 and 0104 are the admin’s.
There is no admin override on the cardholder’s pair — 0101 and 0103 answer
6982 to PW3, as a YubiKey does. (Earlier RS-Key builds took the admin PIN on
those two as well; a script that stashes data there needs the user PIN now.)
The card enforces those lengths itself: a CHANGE REFERENCE DATA or RESET RETRY COUNTER carrying a new value outside the range is refused with 6985,
whatever the host’s own policy is. gpg applies the same ≥ 6 / ≥ 8 minima
before it ever reaches the card. A shorter reference stored by an older firmware
keeps verifying; only new ones are checked.
A verify of a value outside the range is refused the same way, with 6A80 —
and it costs no retry and leaves an already-entered PIN standing, because a
password the reference could not be is a malformed request rather than a wrong
guess. On a card still holding a legacy out-of-range reference the check is off,
so that reference stays verifiable.
A fresh card has no Reset Code. It stays deactivated until an admin sets one
(passwd option 4, below), so RESET RETRY COUNTER in its RC form cannot run
against a known default.
Each PIN has its own retry counter, default 3. Every attempt is charged
against it before the card compares anything, and a correct entry gives the
charge back; a wrong one keeps it. The one visible consequence: pulling the key
out mid-VERIFY can cost a try the holder never used. That is the safe
direction — charging afterwards would mean an interrupted write leaves a wrong
guess free, and this counter is the only limit the card has. gpg --card-status prints them
as PIN retry counter : 3 3 3 (PW1, RC, PW3: all three default to 3).
The admin PIN can set how many tries each one gets, with the command a YubiKey takes for it:
ykman openpgp access set-retries 5 3 10 # PW1, Reset Code, PW3; asks for the admin PIN
Each number becomes that PIN’s limit and gives it that many tries at once, a blocked PIN included, which keeps its value. ykman takes 1 to 99; the card takes up to 255, and a 0 in the raw command leaves that PIN as it is. The Reset Code’s number waits until a Reset Code is set, which then starts with it. The limits survive a replug, and a factory reset (below) puts back 3, 3, 3. More tries is more guesses for whoever holds the key: the admin PIN can hand PW1 fresh tries without knowing it.
Change them first:
gpg --card-edit
gpg/card> admin
gpg/card> passwd # menu: 1 change PW1 · 3 change PW3 · 4 set Reset Code
The same menu sets the Reset Code (option 4, under admin), which lets a
holder who has forgotten PW1 reset it without the admin PIN. Useful when the
admin PIN lives somewhere offline.
Two ways admin operations lock:
- Three wrong PW3 (or as many as
set-retriesgave it) blocks the admin PIN. Unlike PW1, the admin PIN has no higher authority to unblock it. Recovery is a factory reset of the applet (below). Plan to keep PW3 written down somewhere offline. - Three wrong PW1 (likewise) blocks the user PIN. This one is recoverable: unblock it with the admin PIN or the Reset Code (see Unblocking PW1).
KDF (kdf-setup) — hashing the PIN before it leaves the host
The card supports the OpenPGP 3.4 KDF-DO, so gpg can salt-and-hash your
PINs on the host and send the hash instead of the passphrase:
gpg --card-edit
gpg/card> admin
gpg/card> kdf-setup # three salts (PW1, Reset Code, PW3)
gpg/card> kdf-setup single # or one salt shared by PW1 and PW3
gpg/card> kdf-setup off # back to sending the passphrase
gpg does not change the PINs afterwards — it just writes the DO and starts
sending KDF output. The DO carries the hashes of the factory PINs so the card
can follow, so kdf-setup puts both PINs back to their defaults: 123456
and 12345678, hashed. Turning it off does the same thing in reverse. So:
Run kdf-setup first, then change your PINs. In the other order you lose the
PINs you chose. This is how a YubiKey and a Gnuk behave too.
Two consequences worth knowing:
- A card that already holds a key refuses it, with
6985—gpg: error for setup KDF: Conditions of use not satisfied. Otherwise the DO would hand123456to whoever asked next, beside a key that is still there. To change the setting on a provisioned card, factory-reset the applet first. - An existing Reset Code is deactivated. The DO has a salt for it but no
initial hash, so there is nothing to carry it across; set a new one with
passwdoption 4 afterwards. (A YubiKey leaves the Reset Code in place here and goes on advertising three tries for it, but the code itself stops working — measured,RESET RETRYthen answers6A80whatever you send it. RS-Key deactivates it so the counter tells the truth.)
Both PIN retry counters go back to 3 with the PINs, and an admin PIN entered before the command stays valid after it — as on a YubiKey.
Generate keys on-card
gpg --card-edit
gpg/card> admin
gpg/card> key-attr # per slot, pick the algorithm (table below)
gpg/card> generate # makes all three keys + a gpg keyring entry
key-attr is asked once per slot (signature, then encryption, then
authentication), so you can mix: e.g. Ed25519 for signing and authentication,
Cv25519 for encryption (gpg’s default modern pair), or RSA across the board.
Supported per-slot attributes (advertised via DO 0xFA, the list ykman and
gpg read back):
| Family | Choices | Notes |
|---|---|---|
| ECC (sign/auth) | Ed25519, NIST P-256 / P-384 / P-521, secp256k1, brainpoolP256r1 / P384r1 | EdDSA on Ed25519; ECDSA on the Weierstrass curves |
| ECC (encrypt) | Cv25519 (X25519), NIST P-256 / P-384 / P-521, secp256k1, brainpoolP256r1 / P384r1 | ECDH; the DEC slot only |
| RSA | 2048 / 3072 / 4096, plus 1024 | exponent fixed at 65537 (what gpg imports) |
From build 0x0B23, P-521 and Brainpool P-256/P-384 signing and authentication skip the unused public-key
derivation before signing. RFC6979 nonce generation, raw signature encoding,
PIN and touch requirements remain unchanged; existing keys need no migration.
P-384 signing also omits the unused nonce-generator update after success; ECDH
uses equivalent coordinate formulas with fewer field additions.
From 0x0BD6, Brainpool signing and public-key generation use constant-time
fixed-base tables; ECDH uses Jacobian coordinates with the curve’s original
coefficient. Stored keys, deterministic signatures, peer-point validation and
PIN/touch requirements are unchanged. Counter rotation writes complete body
pages before publishing the checkpoint, reducing flash programs during PIN,
HOTP and signature-counter updates without a storage migration.
Changing a slot’s algorithm after a key exists invalidates that slot’s old private/public key pair. Re-select the intended attribute before generating or importing the replacement; writing the same attribute leaves the key intact.
RSA-1024 is advertised and it works — a YubiKey does not offer it at all. It is below every current guidance (NIST SP 800-131A retired it in 2013) and it is here only so a key generated under an older build keeps working. Do not pick it for a new key.
Not supported: X448, Ed448 and brainpoolP512r1. gpg will offer them;
the card advertises none of the three in DO 0xFA and refuses the key-attr
write with 0x6A80, so a slot cannot end up announcing a curve it will not use.
No mature no_std Rust arithmetic exists for those yet, so shipping them would
mean unaudited curve math.
On-card generation means the private keys never existed anywhere else, and cannot be backed up. gpg’s “make an off-card backup” prompt covers the encryption key only, and only if you say yes. (A lost signing or authentication key is regenerated, not recovered.) RSA generation is slow on this hardware. The firmware races both RP2350 cores for the two primes and streams CCID keepalives while gpg waits:
| Size | Typical on-card keygen |
|---|---|
| RSA-2048 | ≈ 4–6 s |
| RSA-3072 | ≈ 22 s |
| RSA-4096 | ≈ 50 s |
| any EC curve | instant |
The spread is wide because the prime search is random. RSA-4096 has been seen anywhere from ~17 s to ~120 s on the same board. See ../limitations.md for the measured dual-core numbers. EC is the pragmatic default unless a peer needs RSA.
Or import existing keys
If you already have a GnuPG key (and want a recoverable off-card copy), import the subkeys instead of generating:
gpg --expert --edit-key YOURKEY
gpg> toggle # show secret subkeys (ssb)
gpg> key 1 # select the subkey to move (repeat per subkey)
gpg> keytocard # pick the matching slot: 1 sig · 2 enc · 3 auth
gpg> save
keytocard moves the selected subkey onto the card, replacing the on-disk
copy with a stub that points at the device. Set key-attr to match the
incoming key’s algorithm before keytocard, or the card refuses the import.
The size counts as much as the family: a 2048-bit key offered to a slot
announcing RSA-4096 is refused, because the attribute is what gpg --card-status and every other host reads back as the truth about that slot.
A mismatched algorithm/curve/size returns “Wrong data” / “Function not supported”
and a missing admin (PW3) session returns “Security status not satisfied”. An RSA
key whose numbers make no working key (p = q, composite primes, a modulus
shorter than the attribute) returns “Memory failure”, a YubiKey’s answer there.
gpg surfaces each as a card refusal, and a refused import leaves the slot’s key
and its 0xDE origin as they were.
Importing keeps an off-card copy in your keyring until you delete it. Your call which way the trade-off goes. The usual recoverable setup: generate the master key offline, move only the three subkeys to the card, and store the master key material on encrypted offline media.
The card records which way each slot was filled and reports it in DO 0xDE,
because that is the difference between a key that can only exist here and one
that has a copy somewhere. A slot filled by a build older than this one, or one
whose GENERATE lost power partway, reads as imported: the card will not
claim on-card generation it cannot prove. Generate into the slot again if you
want the stronger claim back.
Daily use
Signing and decryption
echo hi | gpg --clearsign # PW1, then a touch if UIF is on
gpg --encrypt -r alice@example.com file # public-key op, no card needed
gpg --decrypt file.gpg # PW1 (PW2), card does the ECDH/RSA
gpg drives the slots automatically: the SIG slot signs, the DEC slot decrypts. Encryption to a recipient is a public-key operation and never touches the card. Only decryption does.
By default PW1 stays valid for the session after the first signature. That session ends when the key is unplugged or another application is selected on the card — a PIV or OATH tool reaching for the same key mid-session does exactly that. Selecting OpenPGP again does not end it (§4.2 spends its rule on “a SELECT to a different DF”), so a tool that re-selects before each command keeps the PIN it already gave. To force a PIN on every signature, flip the PW1 status byte:
gpg/card> admin
gpg/card> forcesig # toggles "PW1 valid for one signature only"
SSH authentication via gpg-agent
The AUT slot doubles as an SSH key through gpg-agent:
# one-time agent setup
echo enable-ssh-support >> ~/.gnupg/gpg-agent.conf
gpgconf --kill gpg-agent
# add the authentication subkey's keygrip to sshcontrol
gpg --list-keys --with-keygrip YOURKEY # find the [A] subkey's keygrip
echo <KEYGRIP> >> ~/.gnupg/sshcontrol
# export the public key in OpenSSH format and install it
gpg --export-ssh-key YOURKEY > ~/.ssh/id_rsk.pub
ssh-copy-id -f -i ~/.ssh/id_rsk.pub you@server
Then export SSH_AUTH_SOCK=$(gpgconf --list-dirs agent-ssh-socket) (in your
shell rc) and ssh you@server prompts for PW1 and logs in. This is the
standard gpg-agent recipe, nothing device-specific.
For FIDO-backed SSH (
ed25519-sk, no gpg) see ssh.md; for signing git commits and tags with the SIG slot see git.md.
Touch policies (UIF)
Each slot has an independent user-interaction flag. When on, every use of
that key additionally requires a button press. The firmware polls the BOOTSEL
button and fails the operation (0x6600) if it is not pressed in time. PIN
alone is no longer enough. A remote attacker holding your unlocked session
still cannot sign or decrypt without physical access.
gpg/card> admin
gpg/card> uif 1 on # 1 sig · 2 enc · 3 auth (off to disable)
gpg/card> uif 1 permanent # irreversible: only a factory reset clears it
UIF is per-slot, so you can require a touch for signing but not decryption, or any mix. On a board with no button configured the check is a no-op.
on is revocable with the admin PIN, so it protects against a stolen user PIN,
not a stolen admin PIN. permanent (the card’s UIF value 02) cannot be lowered
by any command — PUT DATA answers 6985 — so a host that learns PW3 still
cannot turn your signatures touchless. Clearing it takes TERMINATE DF +
ACTIVATE FILE, which wipes the applet. Set it only when you mean it.
Key attestation
The card can vouch that a key was generated on it, the way a YubiKey does. It signs an X.509 statement about the key with its own attestation key, which it minted at first boot and never lets out (a card an older firmware set up mints it at its first ATTEST). Only keys generated on the card are attested; an imported key is refused.
ykman openpgp keys attest sig sig-att.pem # PW1; sig · dec · aut
ykman openpgp certificates export att card-att.pem # the card's attestation root
openssl verify -CAfile card-att.pem sig-att.pem
The statement lands in the key’s certificate slot (the one gpg shows as the
cardholder certificate) and carries Yubico’s extensions: firmware version,
serial, touch policy, form factor, cardholder name, fingerprint and generation
time, the signature counter for the signing key, and the key source. Like a
YubiKey’s, it names no key usage. With
forcesig on, each ATTEST spends the PIN as a signature does. A YubiKey’s chain ends
at Yubico’s CA; this card’s attestation certificate is self-signed, so pin the
card-att.pem you read off your own device. A factory reset mints a new
attestation key, and no host can replace it or its certificate
(limitations). The att touch policy gates ATTEST like the
others gate their keys: ykman openpgp keys set-touch att on.
AES encryption (PSO)
The card carries one AES key, in DO D5. It belongs to the card, not to a key
slot — the spec names it by the commands it serves, and ENCIPHER uses no key
slot at all. The card seeds it as AES-256 the first time you generate an
encryption keypair, so the feature works out of the box. Tools that expose the
card’s symmetric PSO (e.g. gpg-card) can ENCIPHER / DECIPHER arbitrary
block-aligned data with it (raw AES-CBC, zero IV; output is 0x02 || cryptogram). It needs PW1 (PW2). Most users never touch this. Public-key
encryption is the normal path.
A host can also supply the key itself, with PUT DATA on DO D5 under the
admin PIN: 16 bytes for AES-128 or 32 for AES-256, and no other length.
Once a key is there nothing replaces it but another PUT DATA D5 — generating or
importing a keypair leaves it alone, on every slot. There is no way to remove
it short of TERMINATE DF + ACTIVATE FILE, which wipes the applet, and the card
cannot tell you a key is there: DO D5 is write-only.
Recovery and reset
Unblocking PW1
Three wrong user-PIN tries block PW1 but not the keys. Two ways back:
# with the admin PIN
gpg --card-edit
gpg/card> admin
gpg/card> unblock # verify PW3, set a new PW1
# or with the Reset Code, if one was set (no admin PIN needed)
gpg/card> passwd # menu option 2: "unblock PIN" via Reset Code
Both reset PW1’s retry counter and re-seal its key material under the new PIN.
A PIN change interrupted by unplugging the key
Changing a PIN rewrites two things: the PIN’s verifier, and the copy of the key
that PIN unwraps. Pull the key out of the port between the two — during
gpg --change-pin — and the card reports a memory error.
Since firmware 0x0889 the card finishes the interrupted change itself on the
next VERIFY, so there is nothing to do. On an older build the card comes back
in a state that looks fatal and is not: the affected PIN verifies, and every
operation that needs a key answers “Card error”. Do not factory-reset it.
The card keeps one copy of the key per PIN and only the copy belonging to the PIN you changed was damaged, so the repair is to reach the key through a different PIN. Which one depends on which PIN you were changing, and the two recipes are not interchangeable:
The admin PIN (PW3) was being changed — verify the user PIN first, in the same session, then change PW3 again:
gpg --card-edit
gpg/card> verify # PW1 — its copy of the key is untouched
gpg/card> admin
gpg/card> passwd # change PW3 again; the card is repaired
The user PIN (PW1) was being changed — use the admin unblock, and do not verify PW1 anywhere in that session:
gpg --card-edit
gpg/card> admin
gpg/card> passwd # menu option 1, "unblock PIN" — sets PW1 via PW3
The order matters for a reason worth knowing: the card reaches for PW1’s copy of
the key whenever PW1 is verified, ahead of the admin’s. So for a torn PW1 change,
verifying PW1 — even with the PIN that now works — puts the damaged copy back in
front and the repair fails. unblock never verifies PW1, which is why it is the
one that works there.
ATTEST repairs missing or mismatched root public records from the surviving attestation private key before issuing a statement. Repeating an interrupted repair preserves that key. If the private key itself is absent, ATTEST creates a replacement root after retiring the preceding FC certificate.
A restart also retries removal of a legacy DEK wrapper sealed under the public factory reset code after its verifier was removed. The firmware authenticates that orphan before deleting it; it preserves unidentified wrappers and an owner-set reset code. PW1/PW3 and the keys they open are unchanged.
Factory reset (OpenPGP only)
rsk openpgp reset # or: gpg --card-edit → admin → factory-reset
rsk openpgp reset blocks both PINs, however many tries they have, then
drives the spec-compliant TERMINATE (0xE6) + ACTIVATE (0x44) and reseeds
factory defaults (PW1 123456, PW3 12345678). It wipes the OpenPGP applet (keys, PINs, DOs,
reset code) and nothing else. FIDO / PIV / OATH / OTP survive (the
TERMINATE is scoped to the OpenPGP FIDs). This is also the only way out of a
PW3 that you have blocked: a blocked admin PIN cannot be unblocked, only reset
away, along with the keys it protected. It also works when the admin verifier
itself is unusable — a card provisioned by an older firmware with an empty PW3
could otherwise neither verify nor terminate, leaving a device-wide factory reset
as the only escape.
It is destructive but idempotent, so it is the clean way to clear non-default PINs a prior gpg session left behind (which otherwise block the test suite at VERIFY).
Between the two commands the applet is terminated, as a YubiKey’s is: every
command, SELECT included, answers 6285 until ACTIVATE FILE, across a replug
too. An interrupted reset leaves it there rather than half-wiped; run
rsk openpgp reset or gpg-card factory-reset again, or send ACTIVATE FILE
(00 44 00 00) yourself.
Troubleshooting
gpg: selecting card failed: No such device→ scdaemon vs pcscd fight; apply linux.md’sdisable-ccid, thengpgconf --kill scdaemon.ykmanstops seeing the device after gpg used it → same fix; gpg’s scdaemon holds the reader.gpgconf --kill scdaemonreleases it.- A card refusal on
keytocard/generate(gpg may report “Function not supported”, “Wrong data”, or “Security status not satisfied”) → the slot’skey-attrdoesn’t match the key, or you skippedadmin(no PW3 session). gpg --card-statusshowsPIN retry counter : 0 …→ that PIN is blocked; see Recovery and reset.- RSA
generateseems to hang → it isn’t; on-card RSA keygen takes the times above and gpg shows no progress bar. Wait it out, or use an EC curve. ykman openpgp info(needs the opt-inVIDPID=Yubikey5build:ykmanonly sees the device when the reader name contains “Yubico YubiKey”) →ERROR: Incorrect TLV lengthon firmware before0x0759: the GET DATA6Ereply was missing its constructed-DO wrapper, which ykman’s strict parser requires (gpgtolerated it). Fixed in0x0759; flash it and re-run. See the GET DATA reproduction.