Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

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

DefaultLengthUnlocks
User PIN (PW1)1234566–127signing, decryption, authentication
Admin PIN (PW3)123456788–127key import/generation, card settings
Reset Code (RC)unset8–127unblocking 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-retries gave 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 hand 123456 to 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 passwd option 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 RETRY then answers 6A80 whatever 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):

FamilyChoicesNotes
ECC (sign/auth)Ed25519, NIST P-256 / P-384 / P-521, secp256k1, brainpoolP256r1 / P384r1EdDSA on Ed25519; ECDSA on the Weierstrass curves
ECC (encrypt)Cv25519 (X25519), NIST P-256 / P-384 / P-521, secp256k1, brainpoolP256r1 / P384r1ECDH; the DEC slot only
RSA2048 / 3072 / 4096, plus 1024exponent 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:

SizeTypical on-card keygen
RSA-2048≈ 4–6 s
RSA-3072≈ 22 s
RSA-4096≈ 50 s
any EC curveinstant

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’s disable-ccid, then gpgconf --kill scdaemon.
  • ykman stops seeing the device after gpg used it → same fix; gpg’s scdaemon holds the reader. gpgconf --kill scdaemon releases it.
  • A card refusal on keytocard / generate (gpg may report “Function not supported”, “Wrong data”, or “Security status not satisfied”) → the slot’s key-attr doesn’t match the key, or you skipped admin (no PW3 session).
  • gpg --card-status shows PIN retry counter : 0 … → that PIN is blocked; see Recovery and reset.
  • RSA generate seems 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-in VIDPID=Yubikey5 build: ykman only sees the device when the reader name contains “Yubico YubiKey”) → ERROR: Incorrect TLV length on firmware before 0x0759: the GET DATA 6E reply was missing its constructed-DO wrapper, which ykman’s strict parser requires (gpg tolerated it). Fixed in 0x0759; flash it and re-run. See the GET DATA reproduction.