kkeyroost

Learn · Storage

Large blobs

Inspect and edit a key's large-blob array — view stored entries as hex and ASCII, keep your own plaintext notes, and pull an SSH certificate back out — over the standard CTAP 2.1 authenticatorLargeBlobs command.

What it is

CTAP 2.1 keys can hold a small, key-global large-blob array: a place where relying parties stash data that is too big to live inside a credential ID (an SSH certificate, for example). keyroost surfaces it in the Storage sub-view of the FIDO2 tab, showing every stored entry and letting you keep your own text notes alongside.

k

The array is readable by anyone holding the key — no PIN is needed to read it — and it is meant for relying-party-encrypted data, not a place for plaintext secrets. Treat it as a convenience scratchpad, not a vault.

Where to find it

Open the FIDO2 tab, unlock with your PIN, then choose the Storage tab. It appears only when the key reports largeBlobs support in its getInfo options. The array loads automatically when you open the tab; Reload refreshes it on demand. Reading needs no PIN, but adding, editing, or deleting entries does — those are writes.

What you can do

View entries. Each stored entry is shown as a card. View bytes expands a side-by-side hex + ASCII dump of its contents. Genuine relying-party entries are labelled relying-party data and cannot be edited — they are encrypted by the website that created them, so keyroost never rewrites them.

Add a note. The Add button opens a composer; type text and save it. keyroost stores it as its own entry, marked so it can be recognised and read back here later. This is not encryption — the text is stored in the clear.

Edit a note. keyroost's own notes have an Edit button that replaces the text in place. Relying-party entries cannot be edited.

Delete an entry. Any entry can be deleted, and every delete needs an explicit --yes on the CLI (the desktop app asks you to confirm). Deleting an entry a relying party owns may break the service that stored it, so that case is refused with a stronger message and, once you pass --yes, warns before it proceeds. keyroost then rewrites the array without the entry.

Erase everything. A separate wipe-all action clears the entire array — relying-party data included, not just keyroost notes. It is irreversible, needs your PIN, and is double-confirmed in the app (--yes on the CLI).

How writes stay safe

The large-blob array is not a flat byte buffer: it is a CBOR array of entries followed by a 16-byte truncated SHA-256 checksum over the whole serialization. A naive raw edit that left a stale checksum would make the key reject the array, and could break future credential writes until a reset.

keyroost therefore edits the array structurally — it parses the entries, applies your add / edit / delete, then re-serializes and recomputes the checksum before writing. Each write re-reads the key's current array first, so concurrent relying-party entries are preserved. Writes are authenticated with a Large-Blob-Write token derived from your PIN.

Command line

keyroostctl fido large-blob list
keyroostctl fido large-blob get 0
keyroostctl fido large-blob add "spare key in the desk drawer" --pin-stdin
keyroostctl fido large-blob edit 2 "moved to the safe" --pin-stdin
keyroostctl fido large-blob export 1 entry.bin              # raw bytes, no PIN
keyroostctl fido large-blob export 1 id_ecdsa_sk-cert.pub --as-cert
keyroostctl fido large-blob delete 1 --pin-stdin --yes      # --yes is required for every delete; RP-owned entries also print a warning
keyroostctl fido large-blob clear --pin-stdin --yes         # wipes the whole array

Reading (list, get, export) needs no PIN — the array is world-readable. Note that add and edit take the note text as an argument, so it is visible to other local processes in the process list while the command runs; that is fine for a note and unacceptable for a secret, which is another reason not to put one here.

SSH certificates

The commonest real occupant of the large-blob array is an OpenSSH certificate: tools like ssh-keygen and fido2-token store the certificate for a resident SSH credential here so it travels with the key instead of living in a file you have to carry. keyroost can read one back out.

Each such entry is encrypted under a per-credential largeBlobKey that only the key can hand over, so extraction goes through credential management and needs your PIN (no touch). It is read-only — keyroost never writes or rewrites a relying party's certificate.

keyroostctl fido ssh-cert list --pin-stdin
keyroostctl fido ssh-cert extract --credential ssh:demo --out id_ecdsa_sk-cert.pub --pin-stdin

--credential is needed only to disambiguate when the key holds several SSH credentials, and --out defaults to a sanitised <rp-id>-cert.pub; pass --force to overwrite an existing file. In the desktop app the same thing is Save certificate… on the Passkeys tab, next to the SSH credential it belongs to.

Cautions

Nothing here is secret. Anyone who plugs in the key can read the array, including your notes. Don't store passwords, recovery codes, or anything sensitive. If a write is rejected, the key may be out of large-blob storage or busy; keyroost reports the CTAP status with a readable hint, and the array is left unchanged.

Authoritative resources

FIDOCTAP2 authenticatorLargeBlobs FIDOLarge blob storage

Next: OpenPGP →