added patch to fix PIV slot error

feat(key): Trigger SSH agent reconnection after YubiKey release

.github/workflows/ci.yml

@@ -1,10 +1,13 @@
 name: CI checks
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches: main
 
 jobs:
-  test:
-    name: Test on ${{ matrix.name }}
+  test-msrv:
+    name: Test MSRV on ${{ matrix.name }}
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -22,131 +25,94 @@ jobs:
             os: macos-latest
 
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: 1.56.0
-          override: true
+      - uses: actions/checkout@v4
       - name: Install build dependencies
         run: sudo apt install ${{ matrix.build_deps }}
         if: matrix.build_deps != ''
-      - name: cargo fetch
-        uses: actions-rs/cargo@v1
-        with:
-          command: fetch
-      - name: Build tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --verbose --tests
+      - uses: dtolnay/rust-toolchain@stable
+        id: stable-toolchain
+      - name: Install test dependencies using latest stable Rust
+        run: cargo +${{steps.stable-toolchain.outputs.name}} install rage
       - name: Run tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --verbose
+        run: cargo test
+      - name: Verify working directory is clean
+        run: git diff --exit-code
 
-  clippy:
-    name: Clippy (1.56.0)
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: 1.56.0
-          components: clippy
-          override: true
-      - name: Install build dependencies
-        run: sudo apt install libpcsclite-dev
-      - name: Run clippy
-        uses: actions-rs/clippy-check@v1
-        with:
-          name: Clippy (1.56.0)
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features --all-targets -- -D warnings
+  test-latest:
+    name: Test latest stable on ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        name: [linux, windows, macos]
+        include:
+          - name: linux
+            os: ubuntu-latest
+            build_deps: >
+              libpcsclite-dev
+
+          - name: windows
+            os: windows-latest
+
+          - name: macos
+            os: macos-latest
 
-  clippy-nightly:
-    name: Clippy (nightly)
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    continue-on-error: true
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          components: clippy
-          override: true
+      - uses: actions/checkout@v4
       - name: Install build dependencies
-        run: sudo apt install libpcsclite-dev
-      - name: Run Clippy (nightly)
-        uses: actions-rs/clippy-check@v1
-        continue-on-error: true
-        with:
-          name: Clippy (nightly)
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features --all-targets
+        run: sudo apt install ${{ matrix.build_deps }}
+        if: matrix.build_deps != ''
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: dtolnay/rust-toolchain@stable
+        id: toolchain
+      - run: rustup override set ${{steps.toolchain.outputs.name}}
+      - name: Install test dependencies
+        run: cargo install rage
+      - name: Remove lockfile to build with latest dependencies
+        run: rm Cargo.lock
+      - name: Run tests
+        run: cargo test
+      - name: Verify working directory is clean (excluding lockfile)
+        run: git diff --exit-code ':!Cargo.lock'
 
   codecov:
     name: Code coverage
     runs-on: ubuntu-latest
+    container:
+      image: xd009642/tarpaulin:develop-nightly
+      options: --security-opt seccomp=unconfined
 
     steps:
-      - uses: actions/checkout@v3
-      # Use stable for this to ensure that cargo-tarpaulin can be built.
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
+      - uses: actions/checkout@v4
       - name: Install build dependencies
-        run: sudo apt install libpcsclite-dev
+        run: apt update && apt install -y libpcsclite-dev
       - name: Generate coverage report
-        uses: actions-rs/tarpaulin@v0.1
-        with:
-          args: --release --timeout 180 --out Xml
+        run: >
+          cargo tarpaulin
+          --engine llvm
+          --timeout 180
+          --out xml
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3.1.1
+        uses: codecov/codecov-action@v4.5.0
         with:
-          token: ${{secrets.CODECOV_TOKEN}}
+          fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}
 
   doc-links:
     name: Intra-doc links
     runs-on: ubuntu-latest
-
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: 1.56.0
-          override: true
+      - uses: actions/checkout@v4
       - name: Install build dependencies
         run: sudo apt install libpcsclite-dev
-      - name: cargo fetch
-        uses: actions-rs/cargo@v1
-        with:
-          command: fetch
-
-      # Ensure intra-documentation links all resolve correctly
-      # Requires #![deny(intra_doc_link_resolution_failure)] in crates.
+      - run: cargo fetch
+      # Requires #![deny(rustdoc::broken_intra_doc_links)] in crates.
       - name: Check intra-doc links
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --document-private-items
+        run: cargo doc --document-private-items
 
   fmt:
     name: Rustfmt
-    timeout-minutes: 30
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: 1.56.0
-          components: rustfmt
-          override: true
+      - uses: actions/checkout@v4
       - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: -- --check
+        run: cargo fmt -- --check

.github/workflows/lints-beta.yml

@@ -0,0 +1,22 @@
+name: Beta lints
+
+# We only run these lints on trial-merges of PRs to reduce noise.
+on: pull_request
+
+jobs:
+  clippy-beta:
+    name: Clippy (beta)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@beta
+        id: toolchain
+      - run: rustup override set ${{steps.toolchain.outputs.name}}
+      - name: Install build dependencies
+        run: sudo apt install libpcsclite-dev
+      - name: Clippy (beta)
+        uses: actions-rs/clippy-check@v1
+        with:
+          name: Clippy (beta)
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features --all-targets -- -W clippy::all

.github/workflows/lints-stable.yml

@@ -0,0 +1,19 @@
+name: Stable lints
+
+# We only run these lints on trial-merges of PRs to reduce noise.
+on: pull_request
+
+jobs:
+  clippy:
+    name: Clippy (MSRV)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install build dependencies
+        run: sudo apt install libpcsclite-dev
+      - name: Run clippy
+        uses: actions-rs/clippy-check@v1
+        with:
+          name: Clippy (MSRV)
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features --all-targets -- -D warnings

.github/workflows/release.yml

@@ -24,7 +24,7 @@ jobs:
           - windows
         include:
           - name: linux
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             build_deps: >
               libpcsclite-dev
             archive_name: age-plugin-yubikey.tar.gz
@@ -48,11 +48,10 @@ jobs:
             asset_suffix: x86_64-darwin.tar.gz
 
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        id: toolchain
+      - run: rustup override set ${{steps.toolchain.outputs.name}}
       - name: Add target
         run: rustup target add ${{ matrix.target }}
         if: matrix.target != ''
@@ -87,7 +86,7 @@ jobs:
         if: matrix.name == 'windows'
 
       - name: Upload archive to release
-        uses: svenstaro/upload-release-action@2.3.0
+        uses: svenstaro/upload-release-action@2.9.0
         with:
           file: ${{ matrix.archive_name }}
           asset_name: age-plugin-yubikey-$tag-${{ matrix.asset_suffix }}
@@ -96,7 +95,7 @@ jobs:
 
   deb:
     name: Debian ${{ matrix.name }}
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     strategy:
       matrix:
         name: [linux]
@@ -107,11 +106,10 @@ jobs:
               libpcsclite-dev
 
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        id: toolchain
+      - run: rustup override set ${{steps.toolchain.outputs.name}}
       - name: Add target
         run: rustup target add ${{ matrix.target }}
       - name: cargo install cargo-deb
@@ -146,7 +144,7 @@ jobs:
           args: --package age-plugin-yubikey --no-build --target ${{ matrix.target }}
 
       - name: Upload Debian package to release
-        uses: svenstaro/upload-release-action@2.3.0
+        uses: svenstaro/upload-release-action@2.9.0
         with:
           file: target/${{ matrix.target }}/debian/*.deb
           file_glob: true

CHANGELOG.md

@@ -8,6 +8,62 @@ to 0.3.0 are beta releases.
 
 ## [Unreleased]
 
+### Added
+- Support for the native non-hybrid tagged recipient type (`age1tag1..`).
+  - Encryption requires making the `age-plugin-yubikey` binary available on the
+    `PATH` as `age-plugin-tag`, or upgrading to a client version that builds in
+    support for this new native recipient type.
+
+### Changed
+- MSRV is now 1.70.0.
+- Encryption to an identity now uses the preferred recipient type supported for
+  that identity.
+- `age-plugin-yubikey` now prints `age1tag1..` recipients in its CLI and
+  identity files instead of `age1yubikey1..` recipients. The latter is now only
+  shown in comments for identities generated with `age-plugin-yubikey 0.5.0` or
+  earlier.
+
+## [0.3.4], [0.4.1], [0.5.1] - 2026-04-08
+### Fixed
+- `age-plugin-yubikey` now completely ignores any identity that has unrecognised
+  critical extensions in its certificate, to ensure it doesn't misuse a newer
+  identity type.
+
+## [0.5.0] - 2024-08-04
+### Fixed
+- `age-plugin-yubikey` can now be compiled with Rust 1.80 and above.
+
+### Changed
+- MSRV is now 1.67.0.
+
+## [0.4.0] - 2023-04-09
+### Changed
+- MSRV is now 1.65.0.
+- The YubiKey PIV PIN and touch caches are now preserved across processes in
+  most cases. See [README.md](README.md#agent-support) for exceptions. This has
+  several usability effects (not applicable to YubiKey 4 series):
+  - If a YubiKey's PIN is cached by an agent like `yubikey-agent`, and then
+    `age-plugin-yubikey` is run (either directly or as a plugin), the agent
+    won't request a PIN entry on its next use.
+  - If a YubiKey's PIN was requested by either a previous invocation of
+    `age-plugin-yubikey` or an agent like `yubikey-agent`, subsequent calls to
+    `age-plugin-yubikey` won't request a PIN entry to decrypt a file with an
+    identity that has a PIN policy of `once`.
+
+### Fixed
+- Identities can now be generated with a PIN policy of "always" (in previous
+  versions of `age-plugin-yubikey` this would cause an error).
+
+## [0.3.3] - 2023-02-11
+### Fixed
+- When `age-plugin-yubikey` assists the user in changing their PIN from the
+  default PIN, it no longer tells the user that PINs shorter than 6 characters
+  are allowed, and instead loops until the user enters a PIN of valid length.
+  It also now prevents the user from setting their PIN to the default PIN, to
+  avoid creating a cycle.
+- More kinds of SmartCard readers are ignored when they have no SmartCard
+  inserted.
+
 ## [0.3.2] - 2023-01-01
 ### Changed
 - The "sharing violation" logic now also sends SIGHUP to any `yubikey-agent`

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "age-plugin-yubikey"
 description = "YubiKey plugin for age clients"
-version = "0.3.2"
+version = "0.5.1"
 authors = ["Jack Grigg <thestr4d@gmail.com>"]
 repository = "https://github.com/str4d/age-plugin-yubikey"
 readme = "README.md"
@@ -9,7 +9,7 @@ keywords = ["age", "cli", "encryption", "yubikey"]
 categories = ["command-line-utilities", "cryptography"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
-rust-version = "1.56" # MSRV
+rust-version = "1.70" # MSRV
 
 [package.metadata.deb]
 extended-description = """\
@@ -22,34 +22,45 @@ assets = [
 ]
 
 [dependencies]
-age-core = "0.8"
-age-plugin = "0.3"
-base64 = "0.13"
-bech32 = "0.8"
+age-core = "0.11"
+age-plugin = "0.6"
+base64 = "0.22"
+bech32 = "0.11"
 console = { version = "0.15", default-features = false }
-dialoguer = { version = "0.9", default-features = false, features = ["password"] }
-env_logger = "0.9"
+dialoguer = { version = "0.11", default-features = false, features = ["password"] }
+env_logger = "0.10"
 gumdrop = "0.8"
 hex = "0.4"
+hkdf = "0.12"
+hpke = { version = "0.12", default-features = false, features = ["alloc", "p256"] }
+yubikey = { version = "=0.8.0-pre.0", features = ["untested"] }
 log = "0.4"
-p256 = { version = "0.9", features = ["ecdh"] }
+p256 = { version = "0.13", features = ["ecdh"] }
 pcsc = "2.4"
 rand = "0.8"
-sha2 = "0.9"
-which = "4.1"
+sha2 = "0.10"
+which = "5"
 x509 = "0.2"
-x509-parser = "0.12"
-yubikey = { version = "0.5", features = ["untested"] }
+x509-parser = "0.14"
+
 
 # Translations
-i18n-embed = { version = "0.13", features = ["desktop-requester", "fluent-system"] }
-i18n-embed-fl = "0.6"
+i18n-embed = { version = "0.15", features = ["desktop-requester", "fluent-system"] }
+i18n-embed-fl = "0.9"
 lazy_static = "1"
-rust-embed = "6"
+rust-embed = "8"
 
 # GnuPG coexistence
-sysinfo = ">=0.26, <0.26.4"
+sysinfo = "0.29"
 
 [dev-dependencies]
 flate2 = "1"
 man = "0.3"
+tempfile = "3"
+test-with = "0.11"
+which = "5"
+
+[patch.crates-io]
+age-core = { git = "https://github.com/str4d/rage.git", rev = "e08c450aa5d7b1cc5706094080c0042ddd60aaf7" }
+age-plugin = { git = "https://github.com/str4d/rage.git", rev = "e08c450aa5d7b1cc5706094080c0042ddd60aaf7" }
+yubikey = { git = "https://git.ts.zusein.com/james/yubikey.rs.git", rev = "8c86cab3724a2c6c60348a13d8a93f3652507920" }

README.md

@@ -6,26 +6,42 @@ which enables files to be encrypted to age identities stored on YubiKeys.
 
 ## Installation
 
+| Environment | CLI command |
+|-------------|-------------|
+| Cargo (Rust 1.70+) | `cargo install age-plugin-yubikey` |
+| Homebrew (macOS or Linux) | `brew install age-plugin-yubikey` |
+| Arch Linux | `pacman -S age-plugin-yubikey` |
+| Debian | [Debian package](https://github.com/str4d/age-plugin-yubikey/releases) |
+| NixOS | Add to config:<br>`environment.systemPackages = [`<br>`  pkgs.age-plugin-yubikey`<br>`];`<br>Or run `nix-env -i age-plugin-yubikey` |
+| Ubuntu 20.04+ | [Debian package](https://github.com/str4d/age-plugin-yubikey/releases) |
+| OpenBSD | `pkg_add age-plugin-yubikey` (security/age-plugin-yubikey) |
+
 On Windows, Linux, and macOS, you can use the
 [pre-built binaries](https://github.com/str4d/age-plugin-yubikey/releases).
 
-If your system has Rust 1.56+ installed (either via `rustup` or a system
-package), you can build directly from source:
-
-```
-cargo install age-plugin-yubikey
-```
-
 Help from new packagers is very welcome.
 
 ### Linux, BSD, etc.
 
 On non-Windows, non-macOS systems, you need to ensure that the `pcscd` service
-is installed and running. On Debian or Ubuntu, you can do this with:
+is installed and running. 
 
-```
-$ sudo apt-get install pcscd
-```
+| Environment | CLI command |
+|-------------|-------------|
+| Debian or Ubuntu | `sudo apt-get install pcscd` |
+| Fedora | `sudo dnf install pcsc-lite` |
+| OpenBSD | As ```root``` do:<br>`pkg_add pcsc-lite ccid`<br>`rcctl enable pcscd`<br>`rcctl start pcscd` |
+| FreeBSD | As ```root``` do:<br>`pkg install pcsc-lite libccid`<br>`service pcscd enable`<br>`service pcscd start` |
+| Arch | `sudo pacman -S pcsclite pcsc-tools yubikey-manager`<br>`sudo systemctl enable pcscd`<br>`sudo systemctl start pcscd`| 
+
+When installing via Cargo, you also need to ensure that the development headers
+for the `pcsc-lite` library are available, so that the `pcsc-sys` crate can be
+compiled.
+
+| Environment | CLI command |
+|-------------|-------------|
+| Debian or Ubuntu | `sudo apt-get install libpcsclite-dev` |
+| Fedora | `sudo dnf install pcsc-lite-devel` |
 
 ### Windows Subsystem for Linux (WSL)
 
@@ -44,7 +60,12 @@ YubiKey:
 
 ## Configuration
 
-There are two ways to configure a YubiKey as an `age` identity. You can run the
+`age-plugin-yubikey` identities have two parts:
+- The secret key material, which is stored inside a YubiKey.
+- An age identity file, which contains information that an age client can use to
+  figure out which YubiKey secret key should be used.
+
+There are two ways to configure a YubiKey as an age identity. You can run the
 plugin binary directly to use a simple text interface, which will create an age
 identity file:
 
@@ -70,6 +91,14 @@ Once an identity has been created, you can regenerate it later:
 $ age-plugin-yubikey --identity [--serial SERIAL] --slot SLOT
 ```
 
+To use the identity with an age client, it needs to be stored in a file. When
+using the above programmatic flags, you can do this by redirecting standard
+output to a file. On a Unix system like macOS or Ubuntu:
+
+```
+$ age-plugin-yubikey --identity --slot SLOT > yubikey-identity.txt
+```
+
 ## Usage
 
 The age recipients contained in all connected YubiKeys can be printed on
@@ -79,28 +108,44 @@ standard output:
 $ age-plugin-yubikey --list
 ```
 
-To encrypt files to these YubiKey recipients, ensure that `age-plugin-yubikey`
-is accessible in your `PATH`, and then use the recipients with an age client as
-normal (e.g. `rage -r age1yubikey1...`).
+To encrypt files to these YubiKey recipients, ensure you have a recent version
+of an age client, and then use the recipients with it as normal (e.g.
+`rage -r age1tag1...`). If this does not work, make `age-plugin-yubikey`
+accessible in your `PATH` with the name `age-plugin-tag` and try again.
 
 The output of the `--list` command can also be used directly to encrypt files to
 all recipients (e.g. `age -R filename.txt`).
 
-To decrypt files encrypted to a YubiKey identity, pass the identity file to the
-age client as normal (e.g. `rage -d -i yubikey-identity.txt`).
+To decrypt files encrypted to a YubiKey identity, ensure that
+`age-plugin-yubikey` is accessible in your `PATH`, and then pass the identity
+file to the age client as normal (e.g. `rage -d -i yubikey-identity.txt`).
 
 ## Advanced topics
 
 ### Agent support
 
 `age-plugin-yubikey` does not provide or interact with an agent for decryption.
-As age plugin binaries have short lifetimes (they only run while the age client
-is running), this means that YubiKey identities configured with a PIN policy of
-`once` will actually prompt for the PIN on every decryption.
+It does however attempt to preserve the PIN cache by not soft-resetting the
+YubiKey after a decryption or read-only operation, which enables YubiKey
+identities configured with a PIN policy of `once` to not prompt for the PIN on
+every decryption. **This does not work for YubiKey 4 series.**
 
-A decryption agent will most likely be implemented as a separate age plugin that
-interacts with [`yubikey-agent`](https://github.com/FiloSottile/yubikey-agent),
-enabling YubiKeys to be used simultaneously with age and SSH.
+The session that corresponds to the `once` policy can be ended in several ways,
+not all of which are necessarily intuitive:
+
+- Unplugging the YubiKey (the obvious way).
+- Using a different applet (e.g. FIDO2). This causes the PIV applet to be closed
+  which clears its state.
+  - This is why the YubiKey 4 series does not support PIN cache preservation:
+    their serial can only be obtained by switching to the OTP applet.
+- Generating a new age identity via `age-plugin-yubikey --generate` or the CLI
+  interface. This is to avoid leaving the YubiKey authenticated with the
+  management key.
+
+If the current PIN UX proves to be insufficient, a decryption agent will most
+likely be implemented as a separate age plugin that interacts with
+[`yubikey-agent`](https://github.com/FiloSottile/yubikey-agent), enabling
+YubiKeys to be used simultaneously with age and SSH.
 
 ### Manual setup and technical details
 

examples/generate-docs.rs

@@ -6,7 +6,7 @@ use std::io::prelude::*;
 const MANPAGES_DIR: &str = "./target/manpages";
 
 fn generate_manpage(page: String, name: &str) {
-    let file = File::create(format!("{}/{}.1.gz", MANPAGES_DIR, name))
+    let file = File::create(format!("{MANPAGES_DIR}/{name}.1.gz"))
         .expect("Should be able to open file in target directory");
     let mut encoder = GzEncoder::new(file, Compression::best());
     encoder

i18n/en-US/age_plugin_yubikey.ftl

@@ -43,6 +43,8 @@ yubikey-metadata =
     #      Created: {$created}
     #   PIN policy: {$pin_policy}
     # Touch policy: {$touch_policy}
+yubikey-legacy-recipient =
+    # Legacy recipient: {$recipient}
 yubikey-identity =
     {$yubikey_metadata}
     #    Recipient: {$recipient}
@@ -76,6 +78,14 @@ cli-setup-name-identity       = 📛 Name this identity
 cli-setup-select-pin-policy   = 🔤 Select a PIN policy
 cli-setup-select-touch-policy = 👆 Select a touch policy
 
+cli-setup-yk4-pin-policy =
+    ⚠️ Your {-yubikey} is a {-yubikey} 4 series. With ephemeral applications like
+    {-age-plugin-yubikey}, a PIN policy of "Once" behaves like a PIN policy of
+    "Always", and your PIN will be requested for every decryption. However, you
+    might still benefit from a PIN policy of "Once" in long-running applications
+    like agents.
+cli-setup-yk4-pin-policy-confirm = Use PIN policy of "Once" with {-yubikey} 4?
+
 cli-setup-generate-new = Generate new identity in slot {$slot_index}?
 cli-setup-use-existing = Use existing identity in slot {$slot_index}?
 
@@ -112,6 +122,7 @@ cli-setup-finished =
 open-yk-with-serial    = ⏳ Please insert the {-yubikey} with serial {$yubikey_serial}.
 open-yk-without-serial = ⏳ Please insert the {-yubikey}.
 warn-yk-not-connected  = Ignoring {$yubikey_name}: not connected
+warn-yk-missing-applet = Ignoring {$yubikey_name}: Missing {$applet_name} applet
 
 print-recipient = Recipient: {$recipient}
 
@@ -127,13 +138,15 @@ mgr-change-default-pin =
     ✨ Your {-yubikey} is using the default PIN. Let's change it!
     ✨ We'll also set the PUK equal to the PIN.
 
-    🔐 The PIN is up to 8 numbers, letters, or symbols. Not just numbers!
+    🔐 The PIN can be numbers, letters, or symbols. Not just numbers!
+    📏 The PIN must be at least 6 and at most 8 characters in length.
     ❌ Your keys will be lost if the PIN and PUK are locked after 3 incorrect tries.
 
 mgr-enter-current-puk = Enter current PUK (default is {$default_puk})
 mgr-choose-new-pin    = Choose a new PIN/PUK
 mgr-repeat-new-pin    = Repeat the PIN/PUK
 mgr-pin-mismatch      = PINs don't match
+mgr-nope-default-pin  = You entered the default PIN again. You need to change it.
 
 mgr-changing-mgmt-key =
     ✨ Your {-yubikey} is using the default management key.
@@ -144,6 +157,12 @@ mgr-changing-mgmt-key-error =
     {"  "}{$management_key}
 mgr-changing-mgmt-key-success = Success!
 
+## YubiKey keygen
+
+builder-gen-key  = 🎲 Generating key...
+builder-gen-cert = 🔏 Generating certificate...
+builder-touch-yk = 👆 Please touch the {-yubikey}
+
 ## Plugin usage
 
 plugin-err-invalid-recipient = Invalid recipient
@@ -170,8 +189,12 @@ plugin-err-pin-required     = A PIN is required for {-yubikey} with serial {$yub
 
 ## Errors
 
+err-mgmt-key-auth = Failed to authenticate with the PIN-protected management key.
+rec-mgmt-key-auth =
+    Check whether your management key is using the TDES algorithm.
+    AES is not supported yet: {$aes_url}
 err-custom-mgmt-key = Custom unprotected non-TDES management keys are not supported.
-rec-custom-mgmt-key =
+rec-change-mgmt-key =
     You can use the {-yubikey} Manager CLI to change to a protected management key:
     {"  "}{$cmd}
 
@@ -180,10 +203,10 @@ rec-custom-mgmt-key =
 
 err-invalid-flag-command = Flag '{$flag}' cannot be used with '{$command}'.
 err-invalid-flag-tui     = Flag '{$flag}' cannot be used with the interactive interface.
-err-invalid-pin-length   = The PIN needs to be 1-8 characters.
 err-invalid-pin-policy   = Invalid PIN policy '{$policy}' (expected [{$expected}]).
 err-invalid-slot         = Invalid slot '{$slot}' (expected number between 1 and 20).
 err-invalid-touch-policy = Invalid touch policy '{$policy}' (expected [{$expected}]).
+err-io-user              = Failed to get input from user: {$err}
 err-io                   = Failed to set up {-yubikey}: {$err}
 err-multiple-commands    = Only one of {-cmd-generate}, {-cmd-identity}, {-cmd-list}, {-cmd-list-all} can be specified.
 err-multiple-yubikeys    = Multiple {-yubikeys} are plugged in. Use {-flag-serial} to select a single {-yubikey}.
@@ -204,16 +227,27 @@ rec-yk-no-service-pcscd =
     If you are on Debian or Ubuntu, you can install it with:
     {"  "}{$apt}
 
+rec-yk-no-service-pcscd-bsd =
+    You can install and run it as root with:
+    {"  "}{$pkg}
+    {"  "}{$service_enable}
+    {"  "}{$service_start}
+
 err-yk-no-service-win = The Smart Cards for Windows service is not running.
 rec-yk-no-service-win =
     See this troubleshooting guide for more help:
     {"  "}{$url}
 
 err-yk-not-found         = Please insert the {-yubikey} you want to set up
-err-yk-wrong-pin         = Invalid PIN ({$tries} tries remaining before it is blocked)
 err-yk-general           = Error while communicating with {-yubikey}: {$err}
 err-yk-general-cause     = Cause: {$inner_err}
 
+err-yk-wrong-pin = Invalid {$pin_kind} ({$tries ->
+    [one] {$tries} try remaining
+   *[other] {$tries} tries remaining
+} before it is blocked)
+err-yk-pin-locked = {$pin_kind} locked
+
 err-ux-A = Did this not do what you expected? Could an error be more useful?
 err-ux-B = Tell us
 # Put (len(A) - len(B) - 46) spaces here.

rust-toolchain

@@ -1 +0,0 @@
-1.56.0

rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.70.0"
+components = ["clippy", "rustfmt"]

src/builder.rs

@@ -1,3 +1,4 @@
+use dialoguer::Password;
 use rand::{rngs::OsRng, RngCore};
 use x509::RelativeDistinguishedName;
 use yubikey::{
@@ -8,10 +9,11 @@ use yubikey::{
 
 use crate::{
     error::Error,
+    fl,
     key::{self, Stub},
-    p256::Recipient,
+    native::p256tag,
     util::{Metadata, POLICY_EXTENSION_OID},
-    BINARY_NAME, USABLE_SLOTS,
+    Recipient, BINARY_NAME, USABLE_SLOTS,
 };
 
 pub(crate) const DEFAULT_PIN_POLICY: PinPolicy = PinPolicy::Once;
@@ -86,17 +88,13 @@ impl IdentityBuilder {
         let pin_policy = self.pin_policy.unwrap_or(DEFAULT_PIN_POLICY);
         let touch_policy = self.touch_policy.unwrap_or(DEFAULT_TOUCH_POLICY);
 
+        eprintln!("{}", fl!("builder-gen-key"));
+
         // No need to ask for users to enter their PIN if the PIN policy requires it,
         // because here we _always_ require them to enter their PIN in order to access the
         // protected management key (which is necessary in order to generate identities).
         key::manage(yubikey)?;
 
-        if let TouchPolicy::Never = touch_policy {
-            // No need to touch YubiKey
-        } else {
-            eprintln!("👆 Please touch the YubiKey");
-        }
-
         // Generate a new key in the selected slot.
         let generated = yubikey_generate(
             yubikey,
@@ -106,9 +104,14 @@ impl IdentityBuilder {
             touch_policy,
         )?;
 
-        let recipient = Recipient::from_spki(&generated).expect("YubiKey generates a valid pubkey");
+        let recipient = Recipient::P256Tag(
+            p256tag::Recipient::from_spki(&generated).expect("YubiKey generates a valid pubkey"),
+        );
         let stub = Stub::new(yubikey.serial(), slot, &recipient);
 
+        eprintln!();
+        eprintln!("{}", fl!("builder-gen-cert"));
+
         // Pick a random serial for the new self-signed certificate.
         let mut serial = [0; 20];
         OsRng.fill_bytes(&mut serial);
@@ -117,6 +120,23 @@ impl IdentityBuilder {
             .name
             .unwrap_or(format!("age identity {}", hex::encode(stub.tag)));
 
+        if let PinPolicy::Always = pin_policy {
+            // We need to enter the PIN again.
+            let pin = Password::new()
+                .with_prompt(fl!(
+                    "plugin-enter-pin",
+                    yubikey_serial = yubikey.serial().to_string(),
+                ))
+                .report(true)
+                .interact()?;
+            yubikey.verify_pin(pin.as_bytes())?;
+        }
+        if let TouchPolicy::Never = touch_policy {
+            // No need to touch YubiKey
+        } else {
+            eprintln!("{}", fl!("builder-touch-yk"));
+        }
+
         let cert = Certificate::generate_self_signed(
             yubikey,
             SlotId::Retired(slot),

src/error.rs

@@ -15,24 +15,33 @@ macro_rules! wlnfl {
 
 pub enum Error {
     CustomManagementKey,
+    Dialog(dialoguer::Error),
     InvalidFlagCommand(String, String),
     InvalidFlagTui(String),
-    InvalidPinLength,
     InvalidPinPolicy(String),
     InvalidSlot(u8),
     InvalidTouchPolicy(String),
     Io(io::Error),
+    ManagementKeyAuth,
     MultipleCommands,
     MultipleYubiKeys,
     NoEmptySlots(Serial),
     NoMatchingSerial(Serial),
+    PukLocked,
     SlotHasNoIdentity(RetiredSlotId),
     SlotIsNotEmpty(RetiredSlotId),
     TimedOut,
     UseListForSingleSlot,
+    WrongPuk(u8),
     YubiKey(yubikey::Error),
 }
 
+impl From<dialoguer::Error> for Error {
+    fn from(e: dialoguer::Error) -> Self {
+        Error::Dialog(e)
+    }
+}
+
 impl From<io::Error> for Error {
     fn from(e: io::Error) -> Self {
         Error::Io(e)
@@ -49,13 +58,21 @@ impl From<yubikey::Error> for Error {
 // manually to provide the error output we want.
 impl fmt::Debug for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        const CHANGE_MGMT_KEY_CMD: &str =
+            "ykman piv access change-management-key -a TDES --protect";
+        const CHANGE_MGMT_KEY_URL: &str = "https://developers.yubico.com/yubikey-manager/";
+
         match self {
             Error::CustomManagementKey => {
                 wlnfl!(f, "err-custom-mgmt-key")?;
-                let cmd = "ykman piv access change-management-key --protect";
-                let url = "https://developers.yubico.com/yubikey-manager/";
-                wlnfl!(f, "rec-custom-mgmt-key", cmd = cmd, url = url)?;
+                wlnfl!(
+                    f,
+                    "rec-change-mgmt-key",
+                    cmd = CHANGE_MGMT_KEY_CMD,
+                    url = CHANGE_MGMT_KEY_URL
+                )?;
             }
+            Error::Dialog(e) => wlnfl!(f, "err-io-user", err = e.to_string())?,
             Error::InvalidFlagCommand(flag, command) => wlnfl!(
                 f,
                 "err-invalid-flag-command",
@@ -63,7 +80,6 @@ impl fmt::Debug for Error {
                 command = command.as_str(),
             )?,
             Error::InvalidFlagTui(flag) => wlnfl!(f, "err-invalid-flag-tui", flag = flag.as_str())?,
-            Error::InvalidPinLength => wlnfl!(f, "err-invalid-pin-length")?,
             Error::InvalidPinPolicy(s) => wlnfl!(
                 f,
                 "err-invalid-pin-policy",
@@ -78,6 +94,17 @@ impl fmt::Debug for Error {
                 expected = "always, cached, never",
             )?,
             Error::Io(e) => wlnfl!(f, "err-io", err = e.to_string())?,
+            Error::ManagementKeyAuth => {
+                let aes_url = "https://github.com/str4d/age-plugin-yubikey/issues/92";
+                wlnfl!(f, "err-mgmt-key-auth")?;
+                wlnfl!(f, "rec-mgmt-key-auth", aes_url = aes_url)?;
+                wlnfl!(
+                    f,
+                    "rec-change-mgmt-key",
+                    cmd = CHANGE_MGMT_KEY_CMD,
+                    url = CHANGE_MGMT_KEY_URL
+                )?;
+            }
             Error::MultipleCommands => wlnfl!(f, "err-multiple-commands")?,
             Error::MultipleYubiKeys => wlnfl!(f, "err-multiple-yubikeys")?,
             Error::NoEmptySlots(serial) => {
@@ -86,6 +113,7 @@ impl fmt::Debug for Error {
             Error::NoMatchingSerial(serial) => {
                 wlnfl!(f, "err-no-matching-serial", serial = serial.to_string())?
             }
+            Error::PukLocked => wlnfl!(f, "err-yk-pin-locked", pin_kind = "PUK")?,
             Error::SlotHasNoIdentity(slot) => {
                 wlnfl!(f, "err-slot-has-no-identity", slot = slot_to_ui(slot))?
             }
@@ -94,6 +122,9 @@ impl fmt::Debug for Error {
             }
             Error::TimedOut => wlnfl!(f, "err-timed-out")?,
             Error::UseListForSingleSlot => wlnfl!(f, "err-use-list-for-single")?,
+            Error::WrongPuk(tries) => {
+                wlnfl!(f, "err-yk-wrong-pin", pin_kind = "PUK", tries = tries)?
+            }
             Error::YubiKey(e) => match e {
                 yubikey::Error::NotFound => wlnfl!(f, "err-yk-not-found")?,
                 yubikey::Error::PcscError {
@@ -107,13 +138,40 @@ impl fmt::Debug for Error {
                         wlnfl!(f, "err-yk-no-service-macos")?;
                         let url = "https://apple.stackexchange.com/a/438198";
                         wlnfl!(f, "rec-yk-no-service-macos", url = url)?;
+                    } else if cfg!(target_os = "openbsd") {
+                        wlnfl!(f, "err-yk-no-service-pcscd")?;
+                        let pkg = "pkg_add pcsc-lite ccid";
+                        let service_enable = "rcctl enable pcscd";
+                        let service_start = "rcctl start pcscd";
+                        wlnfl!(
+                            f,
+                            "rec-yk-no-service-pcscd-bsd",
+                            pkg = pkg,
+                            service_enable = service_enable,
+                            service_start = service_start
+                        )?;
+                    } else if cfg!(target_os = "freebsd") {
+                        wlnfl!(f, "err-yk-no-service-pcscd")?;
+                        let pkg = "pkg install pcsc-lite libccid";
+                        let service_enable = "service pcscd enable";
+                        let service_start = "service pcscd start";
+                        wlnfl!(
+                            f,
+                            "rec-yk-no-service-pcscd-bsd",
+                            pkg = pkg,
+                            service_enable = service_enable,
+                            service_start = service_start
+                        )?;
                     } else {
                         wlnfl!(f, "err-yk-no-service-pcscd")?;
                         let apt = "sudo apt-get install pcscd";
                         wlnfl!(f, "rec-yk-no-service-pcscd", apt = apt)?;
                     }
                 }
-                yubikey::Error::WrongPin { tries } => wlnfl!(f, "err-yk-wrong-pin", tries = tries)?,
+                yubikey::Error::PinLocked => wlnfl!(f, "err-yk-pin-locked", pin_kind = "PIN")?,
+                yubikey::Error::WrongPin { tries } => {
+                    wlnfl!(f, "err-yk-wrong-pin", pin_kind = "PIN", tries = tries)?
+                }
                 e => {
                     wlnfl!(f, "err-yk-general", err = e.to_string())?;
                     use std::error::Error;

src/format.rs

@@ -1,128 +0,0 @@
-use age_core::{
-    format::{FileKey, Stanza},
-    primitives::{aead_encrypt, hkdf},
-    secrecy::ExposeSecret,
-};
-use p256::{ecdh::EphemeralSecret, elliptic_curve::sec1::ToEncodedPoint};
-use rand::rngs::OsRng;
-
-use crate::{p256::Recipient, STANZA_TAG};
-
-pub(crate) const STANZA_KEY_LABEL: &[u8] = b"piv-p256";
-
-const TAG_BYTES: usize = 4;
-const EPK_BYTES: usize = 33;
-const ENCRYPTED_FILE_KEY_BYTES: usize = 32;
-
-/// The ephemeral key bytes in a piv-p256 stanza.
-///
-/// The bytes contain a compressed SEC-1 encoding of a valid point.
-#[derive(Debug)]
-pub(crate) struct EphemeralKeyBytes(p256::EncodedPoint);
-
-impl EphemeralKeyBytes {
-    fn from_bytes(bytes: [u8; EPK_BYTES]) -> Option<Self> {
-        let encoded = p256::EncodedPoint::from_bytes(&bytes).ok()?;
-        if encoded.is_compressed() && encoded.decompress().is_some() {
-            Some(EphemeralKeyBytes(encoded))
-        } else {
-            None
-        }
-    }
-
-    fn from_public_key(epk: &p256::PublicKey) -> Self {
-        EphemeralKeyBytes(epk.to_encoded_point(true))
-    }
-
-    pub(crate) fn as_bytes(&self) -> &[u8] {
-        self.0.as_bytes()
-    }
-
-    pub(crate) fn decompress(&self) -> p256::EncodedPoint {
-        self.0
-            .decompress()
-            .expect("EphemeralKeyBytes is a valid compressed encoding by construction")
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct RecipientLine {
-    pub(crate) tag: [u8; TAG_BYTES],
-    pub(crate) epk_bytes: EphemeralKeyBytes,
-    pub(crate) encrypted_file_key: [u8; ENCRYPTED_FILE_KEY_BYTES],
-}
-
-impl From<RecipientLine> for Stanza {
-    fn from(r: RecipientLine) -> Self {
-        Stanza {
-            tag: STANZA_TAG.to_owned(),
-            args: vec![
-                base64::encode_config(&r.tag, base64::STANDARD_NO_PAD),
-                base64::encode_config(r.epk_bytes.as_bytes(), base64::STANDARD_NO_PAD),
-            ],
-            body: r.encrypted_file_key.to_vec(),
-        }
-    }
-}
-
-impl RecipientLine {
-    pub(super) fn from_stanza(s: &Stanza) -> Option<Result<Self, ()>> {
-        if s.tag != STANZA_TAG {
-            return None;
-        }
-
-        fn base64_arg<A: AsRef<[u8]>, B: AsMut<[u8]>>(arg: &A, mut buf: B) -> Option<B> {
-            if arg.as_ref().len() != ((4 * buf.as_mut().len()) + 2) / 3 {
-                return None;
-            }
-
-            base64::decode_config_slice(arg, base64::STANDARD_NO_PAD, buf.as_mut())
-                .ok()
-                .map(|_| buf)
-        }
-
-        let (tag, epk_bytes) = match &s.args[..] {
-            [tag, epk_bytes] => (
-                base64_arg(tag, [0; TAG_BYTES]),
-                base64_arg(epk_bytes, [0; EPK_BYTES]).and_then(EphemeralKeyBytes::from_bytes),
-            ),
-            _ => (None, None),
-        };
-
-        Some(match (tag, epk_bytes, s.body[..].try_into()) {
-            (Some(tag), Some(epk_bytes), Ok(encrypted_file_key)) => Ok(RecipientLine {
-                tag,
-                epk_bytes,
-                encrypted_file_key,
-            }),
-            // Anything else indicates a structurally-invalid stanza.
-            _ => Err(()),
-        })
-    }
-
-    pub(crate) fn wrap_file_key(file_key: &FileKey, pk: &Recipient) -> Self {
-        let esk = EphemeralSecret::random(OsRng);
-        let epk = esk.public_key();
-        let epk_bytes = EphemeralKeyBytes::from_public_key(&epk);
-
-        let shared_secret = esk.diffie_hellman(pk.public_key());
-
-        let mut salt = vec![];
-        salt.extend_from_slice(epk_bytes.as_bytes());
-        salt.extend_from_slice(pk.to_encoded().as_bytes());
-
-        let enc_key = hkdf(&salt, STANZA_KEY_LABEL, shared_secret.as_bytes());
-
-        let encrypted_file_key = {
-            let mut key = [0; ENCRYPTED_FILE_KEY_BYTES];
-            key.copy_from_slice(&aead_encrypt(&enc_key, file_key.expose_secret()));
-            key
-        };
-
-        RecipientLine {
-            tag: pk.tag(),
-            epk_bytes,
-            encrypted_file_key,
-        }
-    }
-}

src/key.rs

@@ -1,19 +1,20 @@
 //! Structs for handling YubiKeys.
 
-use age_core::{
-    format::{FileKey, FILE_KEY_BYTES},
-    primitives::{aead_decrypt, hkdf},
-    secrecy::ExposeSecret,
-};
+use age_core::primitives::bech32_encode;
+use age_core::secrecy::{ExposeSecret, SecretString};
 use age_plugin::{identity, Callbacks};
-use bech32::{ToBase32, Variant};
 use dialoguer::Password;
 use log::{debug, error, warn};
+use std::convert::Infallible;
+use std::env;
 use std::fmt;
-use std::io;
+use std::io::{self, Read, Write};
 use std::iter;
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
 use std::thread::sleep;
 use std::time::{Duration, Instant, SystemTime};
+use x509_parser::der_parser::oid::Oid;
 use yubikey::{
     certificate::Certificate,
     piv::{decrypt_data, AlgorithmId, RetiredSlotId, SlotId},
@@ -24,15 +25,18 @@ use yubikey::{
 use crate::{
     error::Error,
     fl,
-    format::{RecipientLine, STANZA_KEY_LABEL},
-    p256::{Recipient, TAG_BYTES},
-    util::{otp_serial_prefix, Metadata},
-    IDENTITY_PREFIX,
+    native::p256tag,
+    recipient::TAG_BYTES,
+    util::{otp_serial_prefix, Metadata, POLICY_EXTENSION_OID},
+    Recipient, IDENTITY_PREFIX,
 };
 
 const ONE_SECOND: Duration = Duration::from_secs(1);
 const FIFTEEN_SECONDS: Duration = Duration::from_secs(15);
 
+/// The set of OIDs that we understand and use when parsing YubiKey slot certificates.
+const KNOWN_OIDS: &[&[u64]] = &[POLICY_EXTENSION_OID];
+
 pub(crate) fn is_connected(reader: Reader) -> bool {
     filter_connected(&reader)
 }
@@ -40,7 +44,7 @@ pub(crate) fn is_connected(reader: Reader) -> bool {
 pub(crate) fn filter_connected(reader: &Reader) -> bool {
     match reader.open() {
         Err(yubikey::Error::PcscError {
-            inner: Some(pcsc::Error::RemovedCard),
+            inner: Some(pcsc::Error::NoSmartcard | pcsc::Error::RemovedCard),
         }) => {
             warn!(
                 "{}",
@@ -48,7 +52,24 @@ pub(crate) fn filter_connected(reader: &Reader) -> bool {
             );
             false
         }
-        _ => true,
+        Err(yubikey::Error::AppletNotFound { applet_name }) => {
+            warn!(
+                "{}",
+                fl!(
+                    "warn-yk-missing-applet",
+                    yubikey_name = reader.name(),
+                    applet_name = applet_name,
+                ),
+            );
+            false
+        }
+        Err(_) => true,
+        Ok(yubikey) => {
+            // We only connected as a side-effect of confirming that we can connect, so
+            // avoid resetting the YubiKey.
+            disconnect_without_reset(yubikey);
+            true
+        }
     }
 }
 
@@ -180,6 +201,9 @@ fn open_by_serial(serial: Serial) -> Result<YubiKey, yubikey::Error> {
 
             if serial == yubikey.serial() {
                 return Ok(yubikey);
+            } else {
+                // We didn't want this YubiKey; don't reset it.
+                disconnect_without_reset(yubikey);
             }
         }
 
@@ -236,6 +260,114 @@ pub(crate) fn open(serial: Option<Serial>) -> Result<YubiKey, Error> {
     Ok(yubikey)
 }
 
+/// Sends a request to the SSH agent to trigger reconnection to the YubiKey.
+///
+/// This function sends an `SSH_AGENTC_REQUEST_IDENTITIES` (opcode 11) message to the
+/// SSH agent socket specified by the `SSH_AUTH_SOCK` environment variable. This triggers
+/// agents like `yubikey-agent` to reconnect to the YubiKey on-demand, preserving PIN
+/// cache state.
+///
+/// All errors are silently ignored to avoid affecting the main encryption/decryption
+/// workflow.
+#[cfg(unix)]
+fn poke_ssh_agent() {
+    // Get SSH_AUTH_SOCK; silently return if not set
+    let socket_path = match env::var("SSH_AUTH_SOCK") {
+        Ok(path) if !path.is_empty() => path,
+        _ => return,
+    };
+
+    // Connect to the SSH agent socket
+    let mut stream = match UnixStream::connect(&socket_path) {
+        Ok(s) => s,
+        Err(e) => {
+            debug!("Failed to connect to SSH agent socket: {}", e);
+            return;
+        }
+    };
+
+    // Set a short timeout to avoid blocking
+    let timeout = Some(Duration::from_secs(1));
+    let _ = stream.set_read_timeout(timeout);
+    let _ = stream.set_write_timeout(timeout);
+
+    // SSH_AGENTC_REQUEST_IDENTITIES message:
+    // - 4 bytes: message length (big-endian) = 1
+    // - 1 byte: message type = 11 (SSH_AGENTC_REQUEST_IDENTITIES)
+    const SSH_AGENTC_REQUEST_IDENTITIES: [u8; 5] = [0, 0, 0, 1, 11];
+
+    if let Err(e) = stream.write_all(&SSH_AGENTC_REQUEST_IDENTITIES) {
+        debug!("Failed to send request to SSH agent: {}", e);
+        return;
+    }
+
+    // Read and discard the response (we don't need the identities list)
+    // Response format: 4-byte length + message body
+    let mut length_buf = [0u8; 4];
+    if stream.read_exact(&mut length_buf).is_ok() {
+        let length = u32::from_be_bytes(length_buf) as usize;
+        // Limit read to prevent memory issues with malformed responses
+        if length <= 64 * 1024 {
+            let mut response = vec![0u8; length];
+            let _ = stream.read_exact(&mut response);
+        }
+    }
+
+    debug!("Sent reconnection trigger to SSH agent at {}", socket_path);
+}
+
+#[cfg(not(unix))]
+fn poke_ssh_agent() {
+    // SSH agent socket communication is Unix-specific
+}
+
+/// Disconnect from the YubiKey without resetting it.
+///
+/// This can be used to preserve the YubiKey's PIN and touch caches. There are two cases
+/// where we want to do this:
+///
+/// - We connected to this YubiKey in a read-only context, so we have not made any changes
+///   to the YubiKey's state. However, we might have asked an agent to release the YubiKey
+///   in `key::open_connection`, and we want to allow any state it may have left behind
+///   (such as cached PINs or touches) to persist beyond our execution, for usability.
+/// - We opened this connection in a decryption context, so the only changes to the
+///   YubiKey's state were to potentially cache the PIN and/or touch (depending on the
+///   policies of the slot). We want to allow these to persist beyond our execution, for
+///   usability.
+///
+/// After releasing the YubiKey, this function also sends a request to the SSH agent
+/// (if available) to trigger reconnection, allowing agents like `yubikey-agent` to
+/// reclaim the device and preserve PIN cache state.
+pub(crate) fn disconnect_without_reset(yubikey: YubiKey) {
+    let _ = yubikey.disconnect(pcsc::Disposition::LeaveCard);
+    poke_ssh_agent();
+}
+
+fn request_pin<E, E2>(
+    mut prompt: impl FnMut(Option<String>) -> Result<Result<SecretString, E>, E2>,
+    serial: Serial,
+) -> Result<Result<SecretString, E>, E2> {
+    let mut prev_error = None;
+    loop {
+        prev_error = Some(match prompt(prev_error)? {
+            Ok(pin) => match pin.expose_secret().len() {
+                // A PIN must be between 6 and 8 characters.
+                6..=8 => break Ok(Ok(pin)),
+                // If the string is 44 bytes and starts with the YubiKey's serial
+                // encoded as 12-byte modhex, the user probably touched the YubiKey
+                // early and "typed" an OTP.
+                44 if pin.expose_secret().starts_with(&otp_serial_prefix(serial)) => {
+                    fl!("plugin-err-accidental-touch")
+                }
+                // Otherwise, the PIN is either too short or too long.
+                0..=5 => fl!("plugin-err-pin-too-short"),
+                _ => fl!("plugin-err-pin-too-long"),
+            },
+            Err(e) => break Ok(Err(e)),
+        });
+    }
+}
+
 pub(crate) fn manage(yubikey: &mut YubiKey) -> Result<(), Error> {
     const DEFAULT_PIN: &str = "123456";
     const DEFAULT_PUK: &str = "12345678";
@@ -247,6 +379,7 @@ pub(crate) fn manage(yubikey: &mut YubiKey) -> Result<(), Error> {
             yubikey_serial = yubikey.serial().to_string(),
             default_pin = DEFAULT_PIN,
         ))
+        .report(true)
         .interact()?;
     yubikey.verify_pin(pin.as_bytes())?;
 
@@ -258,46 +391,96 @@ pub(crate) fn manage(yubikey: &mut YubiKey) -> Result<(), Error> {
         let current_puk = Password::new()
             .with_prompt(fl!("mgr-enter-current-puk", default_puk = DEFAULT_PUK))
             .interact()?;
-        let new_pin = Password::new()
-            .with_prompt(fl!("mgr-choose-new-pin"))
-            .with_confirmation(fl!("mgr-repeat-new-pin"), fl!("mgr-pin-mismatch"))
-            .interact()?;
-        if new_pin.len() > 8 {
-            return Err(Error::InvalidPinLength);
-        }
-        yubikey.change_puk(current_puk.as_bytes(), new_pin.as_bytes())?;
+        let new_pin = loop {
+            let pin = request_pin(
+                |prev_error| {
+                    if let Some(err) = prev_error {
+                        eprintln!("{err}");
+                    }
+                    Password::new()
+                        .with_prompt(fl!("mgr-choose-new-pin"))
+                        .with_confirmation(fl!("mgr-repeat-new-pin"), fl!("mgr-pin-mismatch"))
+                        .interact()
+                        .map(|pin| Result::<_, Infallible>::Ok(SecretString::from(pin)))
+                },
+                yubikey.serial(),
+            )?
+            .unwrap();
+            if pin.expose_secret() == DEFAULT_PIN {
+                eprintln!("{}", fl!("mgr-nope-default-pin"));
+            } else {
+                break pin;
+            }
+        };
+        let new_pin = new_pin.expose_secret();
+        yubikey
+            .change_puk(current_puk.as_bytes(), new_pin.as_bytes())
+            .map_err(|e| match e {
+                yubikey::Error::PinLocked => Error::PukLocked,
+                yubikey::Error::WrongPin { tries } => Error::WrongPuk(tries),
+                _ => Error::YubiKey(e),
+            })?;
         yubikey.change_pin(pin.as_bytes(), new_pin.as_bytes())?;
     }
 
-    if let Ok(mgm_key) = MgmKey::get_protected(yubikey) {
-        yubikey.authenticate(mgm_key)?;
-    } else {
-        // Try to authenticate with the default management key.
-        yubikey
-            .authenticate(MgmKey::default())
-            .map_err(|_| Error::CustomManagementKey)?;
+    match MgmKey::get_protected(yubikey) {
+        Ok(mgm_key) => yubikey.authenticate(mgm_key).map_err(|e| match e {
+            yubikey::Error::AuthenticationError => Error::ManagementKeyAuth,
+            _ => e.into(),
+        })?,
+        Err(yubikey::Error::AuthenticationError) => Err(Error::ManagementKeyAuth)?,
+        _ => {
+            // Try to authenticate with the default management key.
+            yubikey
+                .authenticate(MgmKey::default())
+                .map_err(|_| Error::CustomManagementKey)?;
 
-        // Migrate to a PIN-protected management key.
-        let mgm_key = MgmKey::generate();
-        eprintln!();
-        eprintln!("{}", fl!("mgr-changing-mgmt-key"));
-        eprint!("... ");
-        mgm_key.set_protected(yubikey).map_err(|e| {
-            eprintln!(
-                "{}",
-                fl!(
-                    "mgr-changing-mgmt-key-error",
-                    management_key = hex::encode(mgm_key.as_ref()),
-                )
-            );
-            e
-        })?;
-        eprintln!("{}", fl!("mgr-changing-mgmt-key-success"));
+            // Migrate to a PIN-protected management key.
+            let mgm_key = MgmKey::generate();
+            eprintln!();
+            eprintln!("{}", fl!("mgr-changing-mgmt-key"));
+            eprint!("... ");
+            mgm_key.set_protected(yubikey).map_err(|e| {
+                eprintln!(
+                    "{}",
+                    fl!(
+                        "mgr-changing-mgmt-key-error",
+                        management_key = hex::encode(mgm_key.as_ref()),
+                    )
+                );
+                e
+            })?;
+            eprintln!("{}", fl!("mgr-changing-mgmt-key-success"));
+        }
     }
 
     Ok(())
 }
 
+/// Parses the certificate to identify the preferred recipient type it corresponds to.
+pub(crate) fn identify_recipient(cert: &Certificate) -> Option<Recipient> {
+    let known_oids = KNOWN_OIDS
+        .iter()
+        .map(|oid| Oid::from(oid).unwrap())
+        .collect::<Vec<_>>();
+
+    // If the certificate contains any unrecognised critical extensions, reject it: we
+    // don't know how to correctly use the identity. In particular, some identities store
+    // parts of their private key material in certificate extensions to work around
+    // hardware limitations. Not understanding these extensions could lead to encrypting
+    // with the wrong protocol and violating security assumptions.
+    let (_, c) = x509_parser::parse_x509_certificate(cert.as_ref()).ok()?;
+    if c.tbs_certificate
+        .extensions()
+        .iter()
+        .any(|ext| ext.critical && !known_oids.contains(&ext.oid))
+    {
+        return None;
+    }
+
+    p256tag::Recipient::from_certificate(cert).map(Recipient::P256Tag)
+}
+
 /// Returns an iterator of keys that are occupying plugin-compatible slots, along with the
 /// corresponding recipient if the key is compatible with this plugin.
 pub(crate) fn list_slots(
@@ -307,8 +490,7 @@ pub(crate) fn list_slots(
         // We only use the retired slots.
         match key.slot() {
             SlotId::Retired(slot) => {
-                // Only P-256 keys are compatible with us.
-                let recipient = Recipient::from_certificate(key.certificate());
+                let recipient = identify_recipient(key.certificate());
                 Some((key, slot, recipient))
             }
             _ => None,
@@ -336,14 +518,9 @@ pub struct Stub {
 impl fmt::Display for Stub {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(
-            bech32::encode(
-                IDENTITY_PREFIX,
-                self.to_bytes().to_base32(),
-                Variant::Bech32,
-            )
-            .expect("HRP is valid")
-            .to_uppercase()
-            .as_str(),
+            bech32_encode(IDENTITY_PREFIX, &self.to_bytes())
+                .to_uppercase()
+                .as_str(),
         )
     }
 }
@@ -363,7 +540,7 @@ impl Stub {
         Stub {
             serial,
             slot,
-            tag: recipient.tag(),
+            tag: recipient.static_tag(),
             identity_index: 0,
         }
     }
@@ -390,10 +567,6 @@ impl Stub {
         bytes
     }
 
-    pub(crate) fn matches(&self, line: &RecipientLine) -> bool {
-        self.tag == line.tag
-    }
-
     /// Returns:
     /// - `Ok(Ok(Some(connection)))` if we successfully connected to this YubiKey.
     /// - `Ok(Ok(None))` if the user told us to skip this YubiKey.
@@ -515,9 +688,10 @@ impl Stub {
         let (cert, pk) = match Certificate::read(&mut yubikey, SlotId::Retired(self.slot))
             .ok()
             .and_then(|cert| {
-                Recipient::from_certificate(&cert)
-                    .filter(|pk| pk.tag() == self.tag)
-                    .map(|pk| (cert, pk))
+                // Parse as the preferred recipient for each identity type.
+                identify_recipient(&cert)
+                    .filter(|recipient| recipient.static_tag() == self.tag)
+                    .map(|r| (cert, r))
             }) {
             Some(pk) => pk,
             None => {
@@ -533,7 +707,6 @@ impl Stub {
             cert,
             pk,
             slot: self.slot,
-            tag: self.tag,
             identity_index: self.identity_index,
             cached_metadata: None,
             last_touch: None,
@@ -546,17 +719,21 @@ pub(crate) struct Connection {
     cert: Certificate,
     pk: Recipient,
     slot: RetiredSlotId,
-    tag: [u8; 4],
     identity_index: usize,
     cached_metadata: Option<Metadata>,
     last_touch: Option<Instant>,
 }
 
 impl Connection {
+    /// Returns the preferred recipient for encrypting to this identity.
     pub(crate) fn recipient(&self) -> &Recipient {
         &self.pk
     }
 
+    pub(crate) fn stub(&self) -> Stub {
+        Stub::new(self.yubikey.serial(), self.slot, &self.pk)
+    }
+
     pub(crate) fn request_pin_if_necessary<E>(
         &mut self,
         callbacks: &mut dyn Callbacks<E>,
@@ -574,46 +751,37 @@ impl Connection {
                     metadata => metadata,
                 };
         }
-        if let Some(PinPolicy::Never) = self.cached_metadata.as_ref().and_then(|m| m.pin_policy) {
-            return Ok(Ok(()));
+        match self.cached_metadata.as_ref().and_then(|m| m.pin_policy) {
+            Some(PinPolicy::Never) => return Ok(Ok(())),
+            Some(PinPolicy::Once) if self.yubikey.verify_pin(&[]).is_ok() => return Ok(Ok(())),
+            _ => (),
         }
 
         // The policy requires a PIN, so request it.
-        // Note that we can't distinguish between PinPolicy::Once and PinPolicy::Always
-        // because this plugin is ephemeral, so we always request the PIN.
-        let enter_pin_msg = fl!(
-            "plugin-enter-pin",
-            yubikey_serial = self.yubikey.serial().to_string(),
-        );
-        let mut message = enter_pin_msg.clone();
-        let pin = loop {
-            message = match callbacks.request_secret(&message)? {
-                Ok(pin) => match pin.expose_secret().len() {
-                    // A PIN must be between 6 and 8 characters.
-                    6..=8 => break pin,
-                    // If the string is 44 bytes and starts with the YubiKey's serial
-                    // encoded as 12-byte modhex, the user probably touched the YubiKey
-                    // early and "typed" an OTP.
-                    44 if pin
-                        .expose_secret()
-                        .starts_with(&otp_serial_prefix(self.yubikey.serial())) =>
-                    {
-                        format!("{} {}", fl!("plugin-err-accidental-touch"), enter_pin_msg)
-                    }
-                    // Otherwise, the PIN is either too short or too long.
-                    0..=5 => format!("{} {}", fl!("plugin-err-pin-too-short"), enter_pin_msg),
-                    _ => format!("{} {}", fl!("plugin-err-pin-too-long"), enter_pin_msg),
-                },
-                Err(_) => {
-                    return Ok(Err(identity::Error::Identity {
-                        index: self.identity_index,
-                        message: fl!(
-                            "plugin-err-pin-required",
-                            yubikey_serial = self.yubikey.serial().to_string(),
-                        ),
-                    }))
-                }
-            };
+        let pin = match request_pin(
+            |prev_error| {
+                callbacks.request_secret(&format!(
+                    "{}{}{}",
+                    prev_error.as_deref().unwrap_or(""),
+                    prev_error.as_deref().map(|_| " ").unwrap_or(""),
+                    fl!(
+                        "plugin-enter-pin",
+                        yubikey_serial = self.yubikey.serial().to_string(),
+                    )
+                ))
+            },
+            self.yubikey.serial(),
+        )? {
+            Ok(pin) => pin,
+            Err(_) => {
+                return Ok(Err(identity::Error::Identity {
+                    index: self.identity_index,
+                    message: fl!(
+                        "plugin-err-pin-required",
+                        yubikey_serial = self.yubikey.serial().to_string(),
+                    ),
+                }))
+            }
         };
         if let Err(e) = self.yubikey.verify_pin(pin.expose_secret().as_bytes()) {
             return Ok(Err(identity::Error::Identity {
@@ -624,8 +792,10 @@ impl Connection {
         Ok(Ok(()))
     }
 
-    pub(crate) fn unwrap_file_key(&mut self, line: &RecipientLine) -> Result<FileKey, ()> {
-        assert_eq!(self.tag, line.tag);
+    pub(crate) fn p256_ecdh(&mut self, epk_bytes: &[u8]) -> Result<yubikey::Buffer, ()> {
+        // The YubiKey API for performing scalar multiplication takes the point in its
+        // uncompressed SEC-1 encoding.
+        assert_eq!(epk_bytes.len(), 65);
 
         // Check if the touch policy requires a touch.
         let needs_touch = match (
@@ -637,11 +807,9 @@ impl Connection {
             _ => false,
         };
 
-        // The YubiKey API for performing scalar multiplication takes the point in its
-        // uncompressed SEC-1 encoding.
         let shared_secret = match decrypt_data(
             &mut self.yubikey,
-            line.epk_bytes.decompress().as_bytes(),
+            epk_bytes,
             AlgorithmId::EccP256,
             SlotId::Retired(self.slot),
         ) {
@@ -658,20 +826,14 @@ impl Connection {
             }
         }
 
-        let mut salt = vec![];
-        salt.extend_from_slice(line.epk_bytes.as_bytes());
-        salt.extend_from_slice(self.pk.to_encoded().as_bytes());
+        Ok(shared_secret)
+    }
 
-        let enc_key = hkdf(&salt, STANZA_KEY_LABEL, shared_secret.as_ref());
-
-        // A failure to decrypt is fatal, because we assume that we won't
-        // encounter 32-bit collisions on the key tag embedded in the header.
-        match aead_decrypt(&enc_key, FILE_KEY_BYTES, &line.encrypted_file_key) {
-            Ok(pt) => Ok(TryInto::<[u8; FILE_KEY_BYTES]>::try_into(&pt[..])
-                .unwrap()
-                .into()),
-            Err(_) => Err(()),
-        }
+    /// Close this connection without resetting the YubiKey.
+    ///
+    /// This can be used to preserve the YubiKey's PIN and touch caches.
+    pub(crate) fn disconnect_without_reset(self) {
+        disconnect_without_reset(self.yubikey);
     }
 }
 

src/main.rs

@@ -16,19 +16,20 @@ use yubikey::{piv::RetiredSlotId, reader::Context, PinPolicy, Serial, TouchPolic
 
 mod builder;
 mod error;
-mod format;
 mod key;
-mod p256;
+mod native;
+mod piv_p256;
 mod plugin;
 mod util;
 
+mod recipient;
+use recipient::Recipient;
+
 use error::Error;
 
 const PLUGIN_NAME: &str = "yubikey";
 const BINARY_NAME: &str = "age-plugin-yubikey";
-const RECIPIENT_PREFIX: &str = "age1yubikey";
-const IDENTITY_PREFIX: &str = "age-plugin-yubikey-";
-const STANZA_TAG: &str = "piv-p256";
+const IDENTITY_PREFIX: bech32::Hrp = bech32::Hrp::parse_unchecked("AGE-PLUGIN-YUBIKEY-");
 
 const USABLE_SLOTS: [RetiredSlotId; 20] = [
     RetiredSlotId::R1,
@@ -181,13 +182,20 @@ fn generate(flags: PluginFlags) -> Result<(), Error> {
 
     util::print_identity(stub, recipient, metadata);
 
+    // We have written to the YubiKey, which means we've authenticated with the management
+    // key. Out of an abundance of caution, we let the YubiKey be reset on disconnect,
+    // which will clear its PIN and touch caches. This has as small negative UX effect,
+    // but identity generation is a relatively infrequent occurrence, and users are more
+    // likely to see their cached PINs reset due to switching applets (e.g. from PIV to
+    // FIDO2).
+
     Ok(())
 }
 
 fn print_single(
     serial: Option<Serial>,
     slot: RetiredSlotId,
-    printer: impl Fn(key::Stub, p256::Recipient, util::Metadata),
+    printer: impl Fn(key::Stub, Recipient, util::Metadata),
 ) -> Result<(), Error> {
     let mut yubikey = key::open(serial)?;
 
@@ -200,6 +208,8 @@ fn print_single(
 
     printer(stub, recipient, metadata);
 
+    key::disconnect_without_reset(yubikey);
+
     Ok(())
 }
 
@@ -207,7 +217,7 @@ fn print_multiple(
     kind: &str,
     serial: Option<Serial>,
     all: bool,
-    printer: impl Fn(key::Stub, p256::Recipient, util::Metadata),
+    printer: impl Fn(key::Stub, Recipient, util::Metadata),
 ) -> Result<(), Error> {
     let mut readers = Context::open()?;
 
@@ -233,6 +243,8 @@ fn print_multiple(
             println!();
         }
         println!();
+
+        key::disconnect_without_reset(yubikey);
     }
     if printed > 1 {
         eprintln!("{}", fl!("printed-multiple", kind = kind, count = printed));
@@ -245,7 +257,7 @@ fn print_details(
     kind: &str,
     flags: PluginFlags,
     all: bool,
-    printer: impl Fn(key::Stub, p256::Recipient, util::Metadata),
+    printer: impl Fn(key::Stub, Recipient, util::Metadata),
 ) -> Result<(), Error> {
     if let Some(slot) = flags.slot {
         print_single(flags.serial, slot, printer)
@@ -285,8 +297,14 @@ fn list(flags: PluginFlags, all: bool) -> Result<(), Error> {
         flags,
         all,
         |_, recipient, metadata| {
-            println!("{}", metadata);
-            println!("{}", recipient.to_string());
+            println!("{metadata}");
+            if let Some(legacy_recipient) = recipient.legacy_recipient(&metadata) {
+                println!(
+                    "{}",
+                    fl!("yubikey-legacy-recipient", recipient = legacy_recipient)
+                );
+            }
+            println!("{recipient}");
         },
     )
 }
@@ -316,11 +334,7 @@ fn main() -> Result<(), Error> {
     }
 
     if let Some(state_machine) = opts.age_plugin {
-        run_state_machine(
-            &state_machine,
-            plugin::RecipientPlugin::default,
-            plugin::IdentityPlugin::default,
-        )?;
+        run_state_machine(&state_machine, plugin::Handler)?;
         Ok(())
     } else if opts.version {
         println!("age-plugin-yubikey {}", env!("CARGO_PKG_VERSION"));
@@ -360,11 +374,13 @@ fn main() -> Result<(), Error> {
             .iter()
             .map(|reader| {
                 key::open_connection(reader).map(|yk| {
-                    fl!(
+                    let name = fl!(
                         "cli-setup-yk-name",
                         yubikey_name = reader.name(),
                         yubikey_serial = yk.serial().to_string(),
-                    )
+                    );
+                    key::disconnect_without_reset(yk);
+                    name
                 })
             })
             .collect::<Result<Vec<_>, _>>()?;
@@ -372,6 +388,7 @@ fn main() -> Result<(), Error> {
             .with_prompt(fl!("cli-setup-select-yk"))
             .items(&reader_names)
             .default(0)
+            .report(true)
             .interact_opt()?
         {
             Some(yk) => readers_list[yk].open()?,
@@ -392,10 +409,14 @@ fn main() -> Result<(), Error> {
                             let (_, cert) =
                                 x509_parser::parse_x509_certificate(key.certificate().as_ref())
                                     .unwrap();
-                            let (name, _) = util::extract_name(&cert, true).unwrap();
-                            let created = cert.validity().not_before.to_rfc2822();
+                            let (name, _) = util::extract_name_and_version(&cert, true).unwrap();
+                            let created = cert
+                                .validity()
+                                .not_before
+                                .to_rfc2822()
+                                .unwrap_or_else(|e| format!("Invalid date: {e}"));
 
-                            format!("{}, created: {}", name, created)
+                            format!("{name}, created: {created}")
                         })
                     })
             })
@@ -426,6 +447,7 @@ fn main() -> Result<(), Error> {
                     .with_prompt(fl!("cli-setup-select-slot"))
                     .items(&slots)
                     .default(0)
+                    .report(true)
                     .interact_opt()?
                 {
                     Some(slot) => {
@@ -443,6 +465,7 @@ fn main() -> Result<(), Error> {
 
                 if Confirm::new()
                     .with_prompt(fl!("cli-setup-use-existing", slot_index = slot_index))
+                    .report(true)
                     .interact()?
                 {
                     let stub = key::Stub::new(yubikey.serial(), slot, &recipient);
@@ -450,8 +473,10 @@ fn main() -> Result<(), Error> {
                         util::Metadata::extract(&mut yubikey, slot, key.certificate(), true)
                             .unwrap();
 
+                    key::disconnect_without_reset(yubikey);
                     ((stub, recipient, metadata), false)
                 } else {
+                    key::disconnect_without_reset(yubikey);
                     return Ok(());
                 }
             } else {
@@ -462,30 +487,57 @@ fn main() -> Result<(), Error> {
                         flags.name.as_deref().unwrap_or("age identity TAG_HEX")
                     ))
                     .allow_empty(true)
+                    .report(true)
                     .interact_text()?;
 
-                let pin_policy = match Select::new()
-                    .with_prompt(fl!("cli-setup-select-pin-policy"))
-                    .items(&[
-                        fl!("pin-policy-always"),
-                        fl!("pin-policy-once"),
-                        fl!("pin-policy-never"),
-                    ])
-                    .default(
-                        [PinPolicy::Always, PinPolicy::Once, PinPolicy::Never]
-                            .iter()
-                            .position(|p| {
-                                p == &flags.pin_policy.unwrap_or(builder::DEFAULT_PIN_POLICY)
-                            })
-                            .unwrap(),
-                    )
-                    .interact_opt()?
-                {
-                    Some(0) => PinPolicy::Always,
-                    Some(1) => PinPolicy::Once,
-                    Some(2) => PinPolicy::Never,
-                    Some(_) => unreachable!(),
-                    None => return Ok(()),
+                let mut displayed_yk4_warning = false;
+                let pin_policy = loop {
+                    let pin_policy = match Select::new()
+                        .with_prompt(fl!("cli-setup-select-pin-policy"))
+                        .items(&[
+                            fl!("pin-policy-always"),
+                            fl!("pin-policy-once"),
+                            fl!("pin-policy-never"),
+                        ])
+                        .default(
+                            [PinPolicy::Always, PinPolicy::Once, PinPolicy::Never]
+                                .iter()
+                                .position(|p| {
+                                    p == &flags.pin_policy.unwrap_or(builder::DEFAULT_PIN_POLICY)
+                                })
+                                .unwrap(),
+                        )
+                        .report(true)
+                        .interact_opt()?
+                    {
+                        Some(0) => PinPolicy::Always,
+                        Some(1) => PinPolicy::Once,
+                        Some(2) => PinPolicy::Never,
+                        Some(_) => unreachable!(),
+                        None => return Ok(()),
+                    };
+
+                    // We can't preserve the PIN cache for YubiKey 4 series, because to
+                    // retrieve the serial we switch to the OTP applet.
+                    match (pin_policy, yubikey.version().major) {
+                        (PinPolicy::Once, 4) => {
+                            if !displayed_yk4_warning {
+                                eprintln!();
+                                eprintln!("{}", fl!("cli-setup-yk4-pin-policy"));
+                                eprintln!();
+                                displayed_yk4_warning = true;
+                            }
+
+                            if Confirm::new()
+                                .with_prompt(fl!("cli-setup-yk4-pin-policy-confirm"))
+                                .report(true)
+                                .interact()?
+                            {
+                                break pin_policy;
+                            }
+                        }
+                        _ => break pin_policy,
+                    }
                 };
 
                 let touch_policy = match Select::new()
@@ -503,6 +555,7 @@ fn main() -> Result<(), Error> {
                             })
                             .unwrap(),
                     )
+                    .report(true)
                     .interact_opt()?
                 {
                     Some(0) => TouchPolicy::Always,
@@ -514,6 +567,7 @@ fn main() -> Result<(), Error> {
 
                 if Confirm::new()
                     .with_prompt(fl!("cli-setup-generate-new", slot_index = slot_index))
+                    .report(true)
                     .interact()?
                 {
                     eprintln!();
@@ -529,6 +583,7 @@ fn main() -> Result<(), Error> {
                         true,
                     )
                 } else {
+                    key::disconnect_without_reset(yubikey);
                     return Ok(());
                 }
             }
@@ -541,6 +596,7 @@ fn main() -> Result<(), Error> {
                 "age-yubikey-identity-{}.txt",
                 hex::encode(stub.tag)
             ))
+            .report(true)
             .interact_text()?;
 
         let mut file = match OpenOptions::new()
@@ -552,6 +608,7 @@ fn main() -> Result<(), Error> {
             Err(e) if e.kind() == io::ErrorKind::AlreadyExists => {
                 if Confirm::new()
                     .with_prompt(fl!("cli-setup-identity-file-exists"))
+                    .report(true)
                     .interact()?
                 {
                     File::create(&file_name)?
@@ -562,6 +619,15 @@ fn main() -> Result<(), Error> {
             Err(e) => return Err(e.into()),
         };
 
+        let identity = if let Some(legacy_recipient) = recipient.legacy_recipient(&metadata) {
+            format!(
+                "{}\n{stub}",
+                fl!("yubikey-legacy-recipient", recipient = legacy_recipient),
+            )
+        } else {
+            stub.to_string()
+        };
+
         writeln!(
             file,
             "{}",
@@ -569,7 +635,7 @@ fn main() -> Result<(), Error> {
                 "yubikey-identity",
                 yubikey_metadata = metadata.to_string(),
                 recipient = recipient.to_string(),
-                identity = stub.to_string(),
+                identity = identity,
             )
         )?;
         file.sync_data()?;
@@ -577,14 +643,8 @@ fn main() -> Result<(), Error> {
         // If `rage` binary is installed, use it in examples. Otherwise default to `age`.
         let age_binary = which::which("rage").map(|_| "rage").unwrap_or("age");
 
-        let encrypt_usage = format!(
-            "$ cat foo.txt | {} -r {} -o foo.txt.age",
-            age_binary, recipient
-        );
-        let decrypt_usage = format!(
-            "$ cat foo.txt.age | {} -d -i {} > foo.txt",
-            age_binary, file_name
-        );
+        let encrypt_usage = format!("$ cat foo.txt | {age_binary} -r {recipient} -o foo.txt.age");
+        let decrypt_usage = format!("$ cat foo.txt.age | {age_binary} -d -i {file_name} > foo.txt");
         let identity_usage = format!(
             "$ age-plugin-yubikey -i --serial {} --slot {} > {}",
             stub.serial,

src/native.rs

@@ -0,0 +1,59 @@
+use std::marker::PhantomData;
+use std::rc::Rc;
+use std::sync::RwLock;
+
+use hkdf::Hkdf;
+use sha2::Sha256;
+
+use crate::key::Connection;
+
+pub(crate) mod p256tag;
+
+/// Derives a tag for the tagged age recipient formats.
+fn stanza_tag(ikm: &[u8], salt: &str) -> [u8; 4] {
+    let (tag, _) = Hkdf::<Sha256>::extract(Some(salt.as_bytes()), ikm);
+    tag[..4].try_into().expect("correct length")
+}
+
+/// Pretend that a YubiKey connection is a KEM private key.
+struct YubiKeyKemPrivateKey<'a, Kem> {
+    conn: Rc<RwLock<&'a mut Connection>>,
+    _kem: PhantomData<Kem>,
+}
+
+impl<'a, Kem> YubiKeyKemPrivateKey<'a, Kem> {
+    fn new(conn: &'a mut Connection) -> Self {
+        Self {
+            conn: Rc::new(RwLock::new(conn)),
+            _kem: PhantomData::default(),
+        }
+    }
+}
+
+impl<'a, Kem> Clone for YubiKeyKemPrivateKey<'a, Kem> {
+    fn clone(&self) -> Self {
+        Self {
+            conn: self.conn.clone(),
+            _kem: PhantomData::default(),
+        }
+    }
+}
+
+impl<'a, Kem> PartialEq for YubiKeyKemPrivateKey<'a, Kem> {
+    fn eq(&self, other: &Self) -> bool {
+        self.conn.read().unwrap().stub() == other.conn.read().unwrap().stub()
+    }
+}
+impl<'a, Kem> Eq for YubiKeyKemPrivateKey<'a, Kem> {}
+
+impl<'a, Kem: hpke::Kem> hpke::Serializable for YubiKeyKemPrivateKey<'a, Kem> {
+    type OutputSize = <Kem::PrivateKey as hpke::Serializable>::OutputSize;
+    fn write_exact(&self, _: &mut [u8]) {
+        unreachable!("Never called")
+    }
+}
+impl<'a, Kem: hpke::Kem> hpke::Deserializable for YubiKeyKemPrivateKey<'a, Kem> {
+    fn from_bytes(_: &[u8]) -> Result<Self, hpke::HpkeError> {
+        unreachable!("Never called")
+    }
+}

src/native/p256tag.rs

@@ -0,0 +1,292 @@
+use std::fmt;
+use std::marker::PhantomData;
+
+use age_core::{
+    format::{FileKey, Stanza},
+    primitives::{bech32_encode_to_fmt, hpke_open, hpke_seal},
+    secrecy::{zeroize::Zeroize, ExposeSecret},
+};
+use base64::{prelude::BASE64_STANDARD_NO_PAD, Engine};
+use hpke::{Deserializable, Serializable};
+use p256::{
+    elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint},
+    EncodedPoint,
+};
+use rand::rngs::OsRng;
+use yubikey::{certificate::PublicKeyInfo, Certificate};
+
+use super::{stanza_tag, YubiKeyKemPrivateKey};
+use crate::{
+    key::{self, Connection},
+    recipient::static_tag,
+    util::base64_arg,
+};
+
+pub(crate) const PLUGIN_NAME: &str = "tag";
+const RECIPIENT_PREFIX: bech32::Hrp = bech32::Hrp::parse_unchecked("age1tag");
+
+const P256TAG_RECIPIENT_TAG: &str = "p256tag";
+const P256TAG_SALT: &str = "age-encryption.org/p256tag";
+
+const TAG_BYTES: usize = 4;
+/// Per [RFC 9180 section 7.1.1]:
+/// > For P-256, P-384, and P-521, the `SerializePublicKey()` function of the KEM performs
+/// > the uncompressed Elliptic-Curve-Point-to-Octet-String conversion according to [SECG].
+///
+/// [RFC 9180 section 7.1.1]: https://www.rfc-editor.org/rfc/rfc9180.html#section-7.1.1
+/// [SECG]: https://secg.org/sec1-v2.pdf
+const ENC_BYTES: usize = 65;
+
+type Kem = hpke::kem::DhP256HkdfSha256;
+
+/// The non-hybrid tagged age recipient type, designed for hardware keys where decryption
+/// potentially requires user presence.
+///
+/// With knowledge of the recipient, it is possible to check if a stanza was addressed to
+/// a specific recipient before attempting decryption. This offers less privacy than the
+/// untagged recipient types.
+#[derive(Clone, PartialEq, Eq)]
+pub(crate) struct Recipient {
+    /// Compressed encoding of the recipient public key.
+    compressed: EncodedPoint,
+    /// Cached in-memory representation, for HPKE.
+    pk_recip: <Kem as hpke::Kem>::PublicKey,
+}
+
+impl fmt::Display for Recipient {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        bech32_encode_to_fmt(f, RECIPIENT_PREFIX, self.compressed.as_bytes())
+    }
+}
+
+impl fmt::Debug for Recipient {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl Recipient {
+    /// Attempts to parse a valid p256tag recipient from its compressed SEC-1 byte encoding.
+    pub(crate) fn from_bytes(bytes: &[u8]) -> Option<Self> {
+        let encoded = p256::EncodedPoint::from_bytes(bytes).ok()?;
+        if !encoded.is_compressed() {
+            return None;
+        }
+
+        let point = p256::PublicKey::from_encoded_point(&encoded).into_option()?;
+
+        let pk_recip =
+            <Kem as hpke::Kem>::PublicKey::from_bytes(point.to_encoded_point(false).as_bytes())
+                .expect("valid");
+
+        Some(Self {
+            compressed: encoded,
+            pk_recip,
+        })
+    }
+
+    pub(crate) fn from_certificate(cert: &Certificate) -> Option<Self> {
+        Self::from_spki(cert.subject_pki())
+    }
+
+    pub(crate) fn from_spki(spki: &PublicKeyInfo) -> Option<Self> {
+        let encoded = match spki {
+            PublicKeyInfo::EcP256(pubkey) => Some(pubkey),
+            _ => None,
+        }?;
+
+        // Check that the certificate encoding is uncompressed.
+        let pk_recip = <Kem as hpke::Kem>::PublicKey::from_bytes(encoded.as_bytes()).ok()?;
+
+        let point = p256::PublicKey::from_encoded_point(encoded).into_option()?;
+        let compressed = point.to_encoded_point(true);
+
+        Some(Self {
+            compressed,
+            pk_recip,
+        })
+    }
+
+    /// Returns the compressed SEC-1 encoding of this recipient.
+    pub(crate) fn to_compressed(&self) -> p256::EncodedPoint {
+        self.compressed
+    }
+
+    pub(crate) fn static_tag(&self) -> [u8; TAG_BYTES] {
+        static_tag(self.compressed.as_bytes())
+    }
+
+    pub(crate) fn wrap_file_key(&self, file_key: &FileKey) -> RecipientLine {
+        let (enc, ct) = hpke_seal::<Kem, _>(
+            &self.pk_recip,
+            P256TAG_SALT.as_bytes(),
+            file_key.expose_secret(),
+            &mut OsRng,
+        );
+
+        RecipientLine {
+            tag: tag(&enc, self.static_tag()),
+            enc,
+            ct,
+        }
+    }
+}
+
+fn tag(enc: &<Kem as hpke::Kem>::EncappedKey, static_tag: [u8; TAG_BYTES]) -> [u8; TAG_BYTES] {
+    let ikm = enc
+        .to_bytes()
+        .into_iter()
+        .chain(static_tag)
+        .collect::<Vec<u8>>();
+
+    stanza_tag(&ikm, P256TAG_SALT)
+}
+
+pub(crate) struct RecipientLine {
+    tag: [u8; TAG_BYTES],
+    enc: <Kem as hpke::Kem>::EncappedKey,
+    ct: Vec<u8>,
+}
+
+impl From<RecipientLine> for Stanza {
+    fn from(r: RecipientLine) -> Self {
+        Stanza {
+            tag: P256TAG_RECIPIENT_TAG.to_owned(),
+            args: vec![
+                BASE64_STANDARD_NO_PAD.encode(r.tag),
+                BASE64_STANDARD_NO_PAD.encode(r.enc.to_bytes()),
+            ],
+            body: r.ct,
+        }
+    }
+}
+
+impl RecipientLine {
+    pub(crate) fn from_stanza(s: Stanza) -> Option<Result<Self, ()>> {
+        if s.tag != P256TAG_RECIPIENT_TAG {
+            return None;
+        }
+
+        let (tag, enc) = match &s.args[..] {
+            [encoded_tag, encoded_enc] => (
+                base64_arg(encoded_tag, [0; TAG_BYTES]),
+                base64_arg(encoded_enc, [0; ENC_BYTES])
+                    .and_then(|bytes| <Kem as hpke::Kem>::EncappedKey::from_bytes(&bytes[..]).ok()),
+            ),
+            _ => (None, None),
+        };
+
+        Some(match (tag, enc) {
+            (Some(tag), Some(epk_bytes)) => Ok(RecipientLine {
+                tag,
+                enc: epk_bytes,
+                ct: s.body,
+            }),
+            // Anything else indicates a structurally-invalid stanza.
+            _ => Err(()),
+        })
+    }
+
+    pub(crate) fn matches_stub(&self, stub: &key::Stub) -> bool {
+        self.tag == tag(&self.enc, stub.tag)
+    }
+
+    pub(crate) fn unwrap_file_key(&self, conn: &mut Connection) -> Result<FileKey, ()> {
+        // > The identity implementation [...] MUST check that the body length is exactly
+        // > 32 bytes before attempting to decrypt it, to mitigate partitioning oracle
+        // > attacks.
+        if self.ct.len() != 32 {
+            return Err(());
+        }
+
+        let sk_recip = YubiKeyKemPrivateKey::new(conn);
+
+        // A failure to decrypt is fatal, because we assume that we won't
+        // encounter 32-bit collisions on the key tag embedded in the header.
+        hpke_open::<YubiKeyDhP256HkdfSha256>(
+            &self.enc,
+            &sk_recip,
+            P256TAG_SALT.as_bytes(),
+            &self.ct,
+        )
+        .map_err(|_| ())
+        .map(|mut pt| {
+            FileKey::init_with_mut(|file_key| {
+                file_key.copy_from_slice(&pt);
+                pt.zeroize();
+            })
+        })
+    }
+}
+
+/// A decap-only version of [`Kem`] where the private key is stored on a YubiKey.
+struct YubiKeyDhP256HkdfSha256<'a>(PhantomData<&'a ()>);
+
+impl<'a> hpke::Kem for YubiKeyDhP256HkdfSha256<'a> {
+    type PublicKey = <Kem as hpke::Kem>::PublicKey;
+    type PrivateKey = YubiKeyKemPrivateKey<'a, Kem>;
+
+    fn sk_to_pk(_: &Self::PrivateKey) -> Self::PublicKey {
+        unreachable!("Never called")
+    }
+
+    type EncappedKey = <Kem as hpke::Kem>::EncappedKey;
+    type NSecret = <Kem as hpke::Kem>::NSecret;
+    const KEM_ID: u16 = <Kem as hpke::Kem>::KEM_ID;
+
+    fn derive_keypair(_: &[u8]) -> (Self::PrivateKey, Self::PublicKey) {
+        unreachable!("Never called")
+    }
+
+    fn decap(
+        sk_recip: &Self::PrivateKey,
+        pk_sender_id: Option<&Self::PublicKey>,
+        encapped_key: &Self::EncappedKey,
+    ) -> Result<hpke::kem::SharedSecret<Self>, hpke::HpkeError> {
+        let mut sk_recip = sk_recip.conn.write().unwrap();
+
+        // Put together the binding context used for all KDF operations
+        let suite_id = b"KEM\x00\x10";
+
+        // Compute the shared secret from the ephemeral inputs
+        let kex_res_eph = sk_recip
+            .p256_ecdh(&encapped_key.to_bytes())
+            .map_err(|_| hpke::HpkeError::DecapError)?;
+
+        // Compute the sender's pubkey from their privkey
+        let pk_recip = match sk_recip.recipient() {
+            crate::recipient::Recipient::P256Tag(recipient) => &recipient.pk_recip,
+            _ => panic!("should have been filtered out earlier"),
+        };
+
+        assert!(pk_sender_id.is_none());
+
+        // kem_context = encapped_key || pk_recip || pk_sender_id
+        let kem_context = [encapped_key.to_bytes(), pk_recip.to_bytes()]
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+
+        // The "unauthed shared secret" is derived from just the KEX of the ephemeral
+        // input with the recipient pubkey. The HKDF-Expand call only errors if the
+        // output values are 255x the digest size of the hash function. Since these
+        // values are fixed at compile time, we don't worry about it.
+        let mut shared_secret = <hpke::kem::SharedSecret<Self> as Default>::default();
+        hpke::kdf::extract_and_expand::<hpke::kdf::HkdfSha256>(
+            &kex_res_eph,
+            suite_id,
+            &kem_context,
+            &mut shared_secret.0,
+        )
+        .expect("shared secret is way too big");
+        Ok(shared_secret)
+    }
+
+    fn encap<R: rand::CryptoRng + rand::RngCore>(
+        _: &Self::PublicKey,
+        _: Option<(&Self::PrivateKey, &Self::PublicKey)>,
+        _: &mut R,
+    ) -> Result<(hpke::kem::SharedSecret<Self>, Self::EncappedKey), hpke::HpkeError> {
+        unreachable!("Never called")
+    }
+}

src/piv_p256.rs

@@ -0,0 +1,178 @@
+use age_core::{
+    format::{FileKey, Stanza, FILE_KEY_BYTES},
+    primitives::{aead_decrypt, aead_encrypt, hkdf},
+    secrecy::{zeroize::Zeroize, ExposeSecret},
+};
+use base64::{prelude::BASE64_STANDARD_NO_PAD, Engine};
+use p256::{
+    ecdh::EphemeralSecret,
+    elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint},
+};
+use rand::rngs::OsRng;
+use sha2::Sha256;
+
+use crate::{key::Connection, recipient::TAG_BYTES, util::base64_arg};
+
+mod recipient;
+pub(crate) use recipient::Recipient;
+
+const STANZA_TAG: &str = "piv-p256";
+pub(crate) const STANZA_KEY_LABEL: &[u8] = b"piv-p256";
+
+const EPK_BYTES: usize = 33;
+const ENCRYPTED_FILE_KEY_BYTES: usize = 32;
+
+/// The ephemeral key bytes in a piv-p256 stanza.
+///
+/// The bytes contain a compressed SEC-1 encoding of a valid point.
+#[derive(Debug)]
+pub(crate) struct EphemeralKeyBytes(p256::EncodedPoint);
+
+impl EphemeralKeyBytes {
+    fn from_bytes(bytes: [u8; EPK_BYTES]) -> Option<Self> {
+        let encoded = p256::EncodedPoint::from_bytes(bytes).ok()?;
+        if encoded.is_compressed()
+            && p256::PublicKey::from_encoded_point(&encoded)
+                .is_some()
+                .into()
+        {
+            Some(EphemeralKeyBytes(encoded))
+        } else {
+            None
+        }
+    }
+
+    fn from_public_key(epk: &p256::PublicKey) -> Self {
+        EphemeralKeyBytes(epk.to_encoded_point(true))
+    }
+
+    pub(crate) fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+
+    pub(crate) fn decompress(&self) -> p256::EncodedPoint {
+        // EphemeralKeyBytes is a valid compressed encoding by construction.
+        let p = p256::PublicKey::from_encoded_point(&self.0).unwrap();
+        p.to_encoded_point(false)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct RecipientLine {
+    pub(crate) tag: [u8; TAG_BYTES],
+    pub(crate) epk_bytes: EphemeralKeyBytes,
+    pub(crate) encrypted_file_key: [u8; ENCRYPTED_FILE_KEY_BYTES],
+}
+
+impl From<RecipientLine> for Stanza {
+    fn from(r: RecipientLine) -> Self {
+        Stanza {
+            tag: STANZA_TAG.to_owned(),
+            args: vec![
+                BASE64_STANDARD_NO_PAD.encode(r.tag),
+                BASE64_STANDARD_NO_PAD.encode(r.epk_bytes.as_bytes()),
+            ],
+            body: r.encrypted_file_key.to_vec(),
+        }
+    }
+}
+
+impl RecipientLine {
+    pub(super) fn from_stanza(s: &Stanza) -> Option<Result<Self, ()>> {
+        if s.tag != STANZA_TAG {
+            return None;
+        }
+
+        let (tag, epk_bytes) = match &s.args[..] {
+            [tag, epk_bytes] => (
+                base64_arg(tag, [0; TAG_BYTES]),
+                base64_arg(epk_bytes, [0; EPK_BYTES]).and_then(EphemeralKeyBytes::from_bytes),
+            ),
+            _ => (None, None),
+        };
+
+        Some(match (tag, epk_bytes, s.body[..].try_into()) {
+            (Some(tag), Some(epk_bytes), Ok(encrypted_file_key)) => Ok(RecipientLine {
+                tag,
+                epk_bytes,
+                encrypted_file_key,
+            }),
+            // Anything else indicates a structurally-invalid stanza.
+            _ => Err(()),
+        })
+    }
+}
+
+impl Recipient {
+    pub(crate) fn wrap_file_key(&self, file_key: &FileKey) -> RecipientLine {
+        let esk = EphemeralSecret::random(&mut OsRng);
+        let epk = esk.public_key();
+        let epk_bytes = EphemeralKeyBytes::from_public_key(&epk);
+
+        let shared_secret = esk.diffie_hellman(self.public_key());
+
+        let salt = salt(&epk_bytes, self.to_encoded());
+
+        let enc_key = {
+            let mut okm = [0; 32];
+            shared_secret
+                .extract::<Sha256>(Some(&salt))
+                .expand(STANZA_KEY_LABEL, &mut okm)
+                .expect("okm is the correct length");
+            okm
+        };
+
+        let encrypted_file_key = {
+            let mut key = [0; ENCRYPTED_FILE_KEY_BYTES];
+            key.copy_from_slice(&aead_encrypt(&enc_key, file_key.expose_secret()));
+            key
+        };
+
+        RecipientLine {
+            tag: self.tag(),
+            epk_bytes,
+            encrypted_file_key,
+        }
+    }
+}
+
+impl RecipientLine {
+    pub(crate) fn unwrap_file_key(&self, conn: &mut Connection) -> Result<FileKey, ()> {
+        let (static_tag, pk) = match conn.recipient() {
+            crate::recipient::Recipient::PivP256(recipient) => {
+                (recipient.tag(), recipient.to_encoded())
+            }
+            crate::recipient::Recipient::P256Tag(recipient) => {
+                (recipient.static_tag(), recipient.to_compressed())
+            }
+        };
+        assert_eq!(self.tag, static_tag);
+
+        let salt = salt(&self.epk_bytes, pk);
+
+        // The YubiKey API for performing scalar multiplication takes the point in its
+        // uncompressed SEC-1 encoding.
+        let shared_secret = conn.p256_ecdh(self.epk_bytes.decompress().as_bytes())?;
+
+        let enc_key = hkdf(&salt, STANZA_KEY_LABEL, shared_secret.as_ref());
+
+        // A failure to decrypt is fatal, because we assume that we won't
+        // encounter 32-bit collisions on the key tag embedded in the header.
+        aead_decrypt(&enc_key, FILE_KEY_BYTES, &self.encrypted_file_key)
+            .map_err(|_| ())
+            .map(|mut pt| {
+                FileKey::init_with_mut(|file_key| {
+                    file_key.copy_from_slice(&pt);
+                    pt.zeroize();
+                })
+            })
+    }
+}
+
+fn salt(epk_bytes: &EphemeralKeyBytes, pk: p256::EncodedPoint) -> Vec<u8> {
+    assert!(pk.is_compressed());
+    let mut salt = vec![];
+    salt.extend_from_slice(epk_bytes.as_bytes());
+    salt.extend_from_slice(pk.as_bytes());
+    salt
+}

src/piv_p256/recipient.rs

@@ -1,13 +1,11 @@
-use bech32::{ToBase32, Variant};
+use age_core::primitives::bech32_encode_to_fmt;
 use p256::elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint};
-use sha2::{Digest, Sha256};
-use yubikey::{certificate::PublicKeyInfo, Certificate};
 
 use std::fmt;
 
-use crate::RECIPIENT_PREFIX;
+use crate::recipient::{static_tag, TAG_BYTES};
 
-pub(crate) const TAG_BYTES: usize = 4;
+const RECIPIENT_PREFIX: bech32::Hrp = bech32::Hrp::parse_unchecked("age1yubikey");
 
 /// Wrapper around a compressed secp256r1 curve point.
 #[derive(Clone)]
@@ -21,15 +19,7 @@ impl fmt::Debug for Recipient {
 
 impl fmt::Display for Recipient {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(
-            bech32::encode(
-                RECIPIENT_PREFIX,
-                self.to_encoded().as_bytes().to_base32(),
-                Variant::Bech32,
-            )
-            .expect("HRP is valid")
-            .as_str(),
-        )
+        bech32_encode_to_fmt(f, RECIPIENT_PREFIX, self.to_encoded().as_bytes())
     }
 }
 
@@ -44,23 +34,12 @@ impl Recipient {
         }
     }
 
-    pub(crate) fn from_certificate(cert: &Certificate) -> Option<Self> {
-        Self::from_spki(cert.subject_pki())
-    }
-
-    pub(crate) fn from_spki(spki: &PublicKeyInfo) -> Option<Self> {
-        match spki {
-            PublicKeyInfo::EcP256(pubkey) => Self::from_encoded(pubkey),
-            _ => None,
-        }
-    }
-
     /// Attempts to parse a valid YubiKey recipient from its SEC-1 encoding.
     ///
     /// This accepts both compressed (as used by the plugin) and uncompressed (as used in
     /// the YubiKey certificate) encodings.
     fn from_encoded(encoded: &p256::EncodedPoint) -> Option<Self> {
-        p256::PublicKey::from_encoded_point(encoded).map(Recipient)
+        Option::from(p256::PublicKey::from_encoded_point(encoded)).map(Recipient)
     }
 
     /// Returns the compressed SEC-1 encoding of this recipient.
@@ -69,8 +48,7 @@ impl Recipient {
     }
 
     pub(crate) fn tag(&self) -> [u8; TAG_BYTES] {
-        let tag = Sha256::digest(self.to_encoded().as_bytes());
-        (&tag[0..TAG_BYTES]).try_into().expect("length is correct")
+        static_tag(self.to_encoded().as_bytes())
     }
 
     /// Exposes the wrapped public key.

src/plugin.rs

@@ -2,12 +2,27 @@ use age_core::format::{FileKey, Stanza};
 use age_plugin::{
     identity::{self, IdentityPluginV1},
     recipient::{self, RecipientPluginV1},
-    Callbacks,
+    Callbacks, PluginHandler,
 };
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::io;
 
-use crate::{fl, format, key, p256::Recipient, PLUGIN_NAME};
+use crate::{fl, key, native::p256tag, piv_p256, Recipient, PLUGIN_NAME};
+
+pub(crate) struct Handler;
+
+impl PluginHandler for Handler {
+    type RecipientV1 = RecipientPlugin;
+    type IdentityV1 = IdentityPlugin;
+
+    fn recipient_v1(self) -> io::Result<Self::RecipientV1> {
+        Ok(RecipientPlugin::default())
+    }
+
+    fn identity_v1(self) -> io::Result<Self::IdentityV1> {
+        Ok(IdentityPlugin::default())
+    }
+}
 
 #[derive(Debug, Default)]
 pub(crate) struct RecipientPlugin {
@@ -22,11 +37,7 @@ impl RecipientPluginV1 for RecipientPlugin {
         plugin_name: &str,
         bytes: &[u8],
     ) -> Result<(), recipient::Error> {
-        if let Some(pk) = if plugin_name == PLUGIN_NAME {
-            Recipient::from_bytes(bytes)
-        } else {
-            None
-        } {
+        if let Some(pk) = Recipient::from_bytes(plugin_name, bytes) {
             self.recipients.push(pk);
             Ok(())
         } else {
@@ -58,6 +69,10 @@ impl RecipientPluginV1 for RecipientPlugin {
         }
     }
 
+    fn labels(&mut self) -> HashSet<String> {
+        HashSet::new()
+    }
+
     fn wrap_file_keys(
         &mut self,
         file_keys: Vec<FileKey>,
@@ -95,7 +110,7 @@ impl RecipientPluginV1 for RecipientPlugin {
                     self.recipients
                         .iter()
                         .chain(yk_recipients.iter())
-                        .map(|pk| format::RecipientLine::wrap_file_key(&file_key, pk).into())
+                        .map(|pk| pk.wrap_file_key(&file_key))
                         .collect()
                 })
                 .collect())
@@ -140,16 +155,16 @@ impl IdentityPluginV1 for IdentityPlugin {
         let mut file_keys = HashMap::with_capacity(files.len());
 
         // Filter to files / stanzas for which we have matching YubiKeys
-        let mut candidate_stanzas: Vec<(&key::Stub, HashMap<usize, Vec<format::RecipientLine>>)> =
-            self.yubikeys
-                .iter()
-                .map(|stub| (stub, HashMap::new()))
-                .collect();
+        let mut candidate_stanzas: Vec<(&key::Stub, HashMap<usize, Vec<SupportedStanza>>)> = self
+            .yubikeys
+            .iter()
+            .map(|stub| (stub, HashMap::new()))
+            .collect();
 
-        for (file, stanzas) in files.iter().enumerate() {
-            for (stanza_index, stanza) in stanzas.iter().enumerate() {
+        for (file, stanzas) in files.into_iter().enumerate() {
+            for (stanza_index, stanza) in stanzas.into_iter().enumerate() {
                 match (
-                    format::RecipientLine::from_stanza(stanza).map(|res| {
+                    SupportedStanza::parse(stanza).map(|res| {
                         res.map_err(|_| identity::Error::Stanza {
                             file_index: file,
                             stanza_index,
@@ -163,7 +178,7 @@ impl IdentityPluginV1 for IdentityPlugin {
                         // A line will match at most one YubiKey.
                         if let Some(files) =
                             candidate_stanzas.iter_mut().find_map(|(stub, files)| {
-                                if stub.matches(&line) {
+                                if line.matches_stub(stub) {
                                     Some(files)
                                 } else {
                                     None
@@ -233,7 +248,7 @@ impl IdentityPluginV1 for IdentityPlugin {
                 }
 
                 for (stanza_index, line) in stanzas.iter().enumerate() {
-                    match conn.unwrap_file_key(line) {
+                    match line.unwrap_file_key(&mut conn) {
                         Ok(file_key) => {
                             // We've managed to decrypt this file!
                             file_keys.entry(file_index).or_insert(Ok(file_key));
@@ -249,7 +264,38 @@ impl IdentityPluginV1 for IdentityPlugin {
                     }
                 }
             }
+
+            conn.disconnect_without_reset();
         }
         Ok(file_keys)
     }
 }
+
+enum SupportedStanza {
+    PivP256(piv_p256::RecipientLine),
+    P256Tag(p256tag::RecipientLine),
+}
+
+impl SupportedStanza {
+    fn parse(stanza: Stanza) -> Option<Result<Self, ()>> {
+        piv_p256::RecipientLine::from_stanza(&stanza)
+            .map(|res| res.map(Self::PivP256))
+            .or_else(|| {
+                p256tag::RecipientLine::from_stanza(stanza).map(|res| res.map(Self::P256Tag))
+            })
+    }
+
+    pub(crate) fn matches_stub(&self, stub: &key::Stub) -> bool {
+        match self {
+            SupportedStanza::PivP256(line) => stub.tag == line.tag,
+            SupportedStanza::P256Tag(line) => line.matches_stub(stub),
+        }
+    }
+
+    pub(crate) fn unwrap_file_key(&self, conn: &mut key::Connection) -> Result<FileKey, ()> {
+        match self {
+            SupportedStanza::PivP256(line) => line.unwrap_file_key(conn),
+            SupportedStanza::P256Tag(line) => line.unwrap_file_key(conn),
+        }
+    }
+}

src/recipient.rs

@@ -0,0 +1,70 @@
+use std::fmt;
+
+use age_core::format::{FileKey, Stanza};
+use sha2::{Digest, Sha256};
+
+use crate::{native::p256tag, piv_p256, util::Metadata, PLUGIN_NAME};
+
+pub(crate) const TAG_BYTES: usize = 4;
+
+#[derive(Clone, Debug)]
+pub(crate) enum Recipient {
+    PivP256(piv_p256::Recipient),
+    P256Tag(p256tag::Recipient),
+}
+
+impl fmt::Display for Recipient {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Recipient::PivP256(recipient) => recipient.fmt(f),
+            Recipient::P256Tag(recipient) => recipient.fmt(f),
+        }
+    }
+}
+
+impl Recipient {
+    /// Attempts to parse a supported YubiKey recipient.
+    pub(crate) fn from_bytes(plugin_name: &str, bytes: &[u8]) -> Option<Self> {
+        match plugin_name {
+            PLUGIN_NAME => piv_p256::Recipient::from_bytes(bytes).map(Self::PivP256),
+            p256tag::PLUGIN_NAME => p256tag::Recipient::from_bytes(bytes).map(Self::P256Tag),
+            _ => None,
+        }
+    }
+
+    /// Helper for returning the legacy encoding of this recipient, if any.
+    pub(crate) fn legacy_recipient(&self, metadata: &Metadata) -> Option<String> {
+        metadata
+            .is_pre_p256tag()
+            .then(|| match self {
+                Recipient::P256Tag(recipient) => Some(
+                    piv_p256::Recipient::from_bytes(recipient.to_compressed().as_bytes())
+                        .expect("valid")
+                        .to_string(),
+                ),
+                _ => None,
+            })
+            .flatten()
+    }
+
+    /// Returns the static tag for this recipient.
+    pub(crate) fn static_tag(&self) -> [u8; TAG_BYTES] {
+        match self {
+            Recipient::PivP256(recipient) => recipient.tag(),
+            Recipient::P256Tag(recipient) => recipient.static_tag(),
+        }
+    }
+
+    pub(crate) fn wrap_file_key(&self, file_key: &FileKey) -> Stanza {
+        match self {
+            Recipient::PivP256(recipient) => recipient.wrap_file_key(file_key).into(),
+            Recipient::P256Tag(recipient) => recipient.wrap_file_key(file_key).into(),
+        }
+    }
+}
+
+pub(crate) fn static_tag(pk: &[u8]) -> [u8; TAG_BYTES] {
+    Sha256::digest(pk)[0..TAG_BYTES]
+        .try_into()
+        .expect("length is correct")
+}

src/util.rs

@@ -1,6 +1,7 @@
 use std::fmt;
 use std::iter;
 
+use base64::{prelude::BASE64_STANDARD_NO_PAD, Engine};
 use x509_parser::{certificate::X509Certificate, der_parser::oid::Oid};
 use yubikey::{
     piv::{RetiredSlotId, SlotId},
@@ -8,7 +9,7 @@ use yubikey::{
 };
 
 use crate::fl;
-use crate::{error::Error, key::Stub, p256::Recipient, BINARY_NAME, USABLE_SLOTS};
+use crate::{error::Error, key::Stub, Recipient, BINARY_NAME, USABLE_SLOTS};
 
 pub(crate) const POLICY_EXTENSION_OID: &[u64] = &[1, 3, 6, 1, 4, 1, 41482, 3, 8];
 
@@ -70,7 +71,10 @@ pub(crate) fn otp_serial_prefix(serial: Serial) -> String {
         .collect()
 }
 
-pub(crate) fn extract_name(cert: &X509Certificate, all: bool) -> Option<(String, bool)> {
+pub(crate) fn extract_name_and_version(
+    cert: &X509Certificate,
+    all: bool,
+) -> Option<(String, Option<String>)> {
     // Look at Subject Organization to determine if we created this.
     match cert.subject().iter_organization().next() {
         Some(org) if org.as_str() == Ok(BINARY_NAME) => {
@@ -83,7 +87,16 @@ pub(crate) fn extract_name(cert: &X509Certificate, all: bool) -> Option<(String,
                 .map(|s| s.to_owned())
                 .unwrap_or_default(); // TODO: This should always be present.
 
-            Some((name, true))
+            // We store the binary version as an Organizational Unit attribute.
+            let version = cert
+                .subject()
+                .iter_organizational_unit()
+                .next()
+                .and_then(|cn| cn.as_str().ok())
+                .map(|s| s.to_owned())
+                .unwrap_or_default(); // TODO: This should always be present.
+
+            Some((name, Some(version)))
         }
         _ => {
             // Not one of ours, but we've already filtered for compatibility.
@@ -94,7 +107,7 @@ pub(crate) fn extract_name(cert: &X509Certificate, all: bool) -> Option<(String,
             // Display the entire subject.
             let name = cert.subject().to_string();
 
-            Some((name, false))
+            Some((name, None))
         }
     }
 }
@@ -103,6 +116,7 @@ pub(crate) struct Metadata {
     serial: Serial,
     slot: RetiredSlotId,
     name: String,
+    version: Option<String>,
     created: String,
     pub(crate) pin_policy: Option<PinPolicy>,
     pub(crate) touch_policy: Option<TouchPolicy>,
@@ -122,7 +136,10 @@ impl Metadata {
         // https://developers.yubico.com/PIV/Introduction/PIV_attestation.html
         let policies = |c: &X509Certificate| {
             c.tbs_certificate
-                .find_extension(&Oid::from(POLICY_EXTENSION_OID).unwrap())
+                .get_extension_unique(&Oid::from(POLICY_EXTENSION_OID).unwrap())
+                // If the extension is duplicated, we assume it is invalid.
+                .ok()
+                .flatten()
                 // If the encoded extension doesn't have 2 bytes, we assume it is invalid.
                 .filter(|policy| policy.value.len() >= 2)
                 .map(|policy| {
@@ -145,36 +162,51 @@ impl Metadata {
                 .unwrap_or((None, None))
         };
 
-        extract_name(&cert, all)
-            .map(|(name, ours)| {
-                if ours {
-                    let (pin_policy, touch_policy) = policies(&cert);
-                    (name, pin_policy, touch_policy)
+        extract_name_and_version(&cert, all)
+            .map(|(name, version)| {
+                let (pin_policy, touch_policy) = if version.is_some() {
+                    policies(&cert)
                 } else {
                     // We can extract the PIN and touch policies via an attestation. This
                     // is slow, but the user has asked for all compatible keys, so...
-                    let (pin_policy, touch_policy) =
-                        yubikey::piv::attest(yubikey, SlotId::Retired(slot))
-                            .ok()
-                            .and_then(|buf| {
-                                x509_parser::parse_x509_certificate(&buf)
-                                    .map(|(_, c)| policies(&c))
-                                    .ok()
-                            })
-                            .unwrap_or((None, None));
-
-                    (name, pin_policy, touch_policy)
-                }
+                    yubikey::piv::attest(yubikey, SlotId::Retired(slot))
+                        .ok()
+                        .and_then(|buf| {
+                            x509_parser::parse_x509_certificate(&buf)
+                                .map(|(_, c)| policies(&c))
+                                .ok()
+                        })
+                        .unwrap_or((None, None))
+                };
+                (name, version, pin_policy, touch_policy)
             })
-            .map(|(name, pin_policy, touch_policy)| Metadata {
+            .map(|(name, version, pin_policy, touch_policy)| Metadata {
                 serial: yubikey.serial(),
                 slot,
                 name,
-                created: cert.validity().not_before.to_rfc2822(),
+                version,
+                created: cert
+                    .validity()
+                    .not_before
+                    .to_rfc2822()
+                    .unwrap_or_else(|e| format!("Invalid date: {e}")),
                 pin_policy,
                 touch_policy,
             })
     }
+
+    /// Returns `true` if this identity was generated with an `age-plugin-yubikey` version
+    /// before `p256tag` was added (and became the default).
+    pub(crate) fn is_pre_p256tag(&self) -> bool {
+        self.version
+            .as_ref()
+            .and_then(|version| version.split_once('.'))
+            .and_then(|(major, rest)| rest.split_once('.').map(|(minor, _)| (major, minor)))
+            .is_some_and(|(major, minor)| {
+                // `p256tag` added in v0.6.0
+                major == "0" && minor.parse::<u8>().is_ok_and(|minor| minor < 6)
+            })
+    }
 }
 
 impl fmt::Display for Metadata {
@@ -196,19 +228,40 @@ impl fmt::Display for Metadata {
 }
 
 pub(crate) fn print_identity(stub: Stub, recipient: Recipient, metadata: Metadata) {
+    let legacy_recipient = recipient.legacy_recipient(&metadata);
     let recipient = recipient.to_string();
     if !console::user_attended() {
         let recipient = recipient.as_str();
         eprintln!("{}", fl!("print-recipient", recipient = recipient));
     }
 
+    let identity = if let Some(legacy_recipient) = legacy_recipient {
+        format!(
+            "{}\n{stub}",
+            fl!("yubikey-legacy-recipient", recipient = legacy_recipient),
+        )
+    } else {
+        stub.to_string()
+    };
+
     println!(
         "{}",
         fl!(
             "yubikey-identity",
             yubikey_metadata = metadata.to_string(),
             recipient = recipient,
-            identity = stub.to_string(),
+            identity = identity,
         )
     );
 }
+
+pub(crate) fn base64_arg<A: AsRef<[u8]>, B: AsMut<[u8]>>(arg: &A, mut buf: B) -> Option<B> {
+    if arg.as_ref().len() != ((4 * buf.as_mut().len()) + 2) / 3 {
+        return None;
+    }
+
+    BASE64_STANDARD_NO_PAD
+        .decode_slice_unchecked(arg, buf.as_mut())
+        .ok()
+        .and_then(|len| (len == buf.as_mut().len()).then_some(buf))
+}

tests/integration.rs

@@ -0,0 +1,125 @@
+use std::env;
+use std::io::Write;
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+const PLUGIN_BIN: &str = env!("CARGO_BIN_EXE_age-plugin-yubikey");
+
+#[test_with::env(YUBIKEY_SERIAL, YUBIKEY_SLOT)]
+#[cfg_attr(all(unix, not(target_os = "macos")), test_with::executable(pcscd))]
+#[test]
+fn recipient_and_identity_match() {
+    let recipient = Command::new(PLUGIN_BIN)
+        .arg("--list")
+        .arg("--serial")
+        .arg(env::var("YUBIKEY_SERIAL").unwrap())
+        .arg("--slot")
+        .arg(env::var("YUBIKEY_SLOT").unwrap())
+        .output()
+        .unwrap();
+    assert_eq!(recipient.status.code(), Some(0));
+
+    let identity = Command::new(PLUGIN_BIN)
+        .arg("--identity")
+        .arg("--serial")
+        .arg(env::var("YUBIKEY_SERIAL").unwrap())
+        .arg("--slot")
+        .arg(env::var("YUBIKEY_SLOT").unwrap())
+        .output()
+        .unwrap();
+    assert_eq!(identity.status.code(), Some(0));
+
+    let recipient_file = String::from_utf8_lossy(&recipient.stdout);
+    let recipient = recipient_file.lines().last().unwrap();
+    let identity = String::from_utf8_lossy(&identity.stdout);
+    assert!(identity.contains(recipient));
+}
+
+#[test_with::executable(rage)]
+#[test]
+fn plugin_encrypt() {
+    let enc_file = tempfile::NamedTempFile::new_in(env!("CARGO_TARGET_TMPDIR")).unwrap();
+
+    let mut process = Command::new(which::which("rage").unwrap())
+        .arg("-r")
+        .arg("age1yubikey1q2w7u3vpya839jxxuq8g0sedh3d740d4xvn639sqhr95ejj8vu3hyfumptt")
+        .arg("-o")
+        .arg(enc_file.path())
+        .stdin(Stdio::piped())
+        .env("PATH", Path::new(PLUGIN_BIN).parent().unwrap())
+        .spawn()
+        .unwrap();
+
+    // Scope to ensure stdin is closed.
+    {
+        let mut stdin = process.stdin.take().unwrap();
+        stdin.write_all(b"Testing YubiKey encryption").unwrap();
+        stdin.flush().unwrap();
+    }
+
+    let status = process.wait().unwrap();
+    assert_eq!(status.code(), Some(0));
+}
+
+#[test_with::env(YUBIKEY_SERIAL, YUBIKEY_SLOT)]
+#[test_with::executable(rage)]
+#[cfg_attr(all(unix, not(target_os = "macos")), test_with::executable(pcscd))]
+#[test]
+fn plugin_decrypt() {
+    let mut identity_file = tempfile::NamedTempFile::new_in(env!("CARGO_TARGET_TMPDIR")).unwrap();
+    let enc_file = tempfile::NamedTempFile::new_in(env!("CARGO_TARGET_TMPDIR")).unwrap();
+    let plaintext = "Testing YubiKey encryption";
+
+    // Write an identity file corresponding to this YubiKey slot.
+    let identity = Command::new(PLUGIN_BIN)
+        .arg("--identity")
+        .arg("--serial")
+        .arg(env::var("YUBIKEY_SERIAL").unwrap())
+        .arg("--slot")
+        .arg(env::var("YUBIKEY_SLOT").unwrap())
+        .output()
+        .unwrap();
+    assert_eq!(identity.status.code(), Some(0));
+    identity_file.write_all(&identity.stdout).unwrap();
+    identity_file.flush().unwrap();
+
+    // Encrypt to the YubiKey slot.
+    let mut enc_process = Command::new(which::which("rage").unwrap())
+        .arg("-e")
+        .arg("-i")
+        .arg(identity_file.path())
+        .arg("-o")
+        .arg(enc_file.path())
+        .stdin(Stdio::piped())
+        .env("PATH", Path::new(PLUGIN_BIN).parent().unwrap())
+        .spawn()
+        .unwrap();
+
+    // Scope to ensure stdin is closed.
+    {
+        let mut stdin = enc_process.stdin.take().unwrap();
+        stdin.write_all(plaintext.as_bytes()).unwrap();
+        stdin.flush().unwrap();
+    }
+
+    let enc_status = enc_process.wait().unwrap();
+    assert_eq!(enc_status.code(), Some(0));
+
+    // Decrypt with the YubiKey.
+    let dec_process = Command::new(which::which("rage").unwrap())
+        .arg("-d")
+        .arg("-i")
+        .arg(identity_file.path())
+        .arg(enc_file.path())
+        .stdin(Stdio::piped())
+        .env("PATH", Path::new(PLUGIN_BIN).parent().unwrap())
+        .output()
+        .unwrap();
+
+    let stderr = String::from_utf8_lossy(&dec_process.stderr);
+    if !stderr.is_empty() {
+        assert!(stderr.contains("age-plugin-yubikey"));
+        assert!(stderr.ends_with("...\n"));
+    }
+    assert_eq!(String::from_utf8_lossy(&dec_process.stdout), plaintext);
+}