Fix docstring for Certificate::generate_self_signed (#632)

Co-authored-by: roblabla <robin@harfanglab.fr>

.cargo/audit.toml

@@ -0,0 +1,6 @@
+[advisories]
+ignore = [
+    "RUSTSEC-2020-0071", # chrono
+    "RUSTSEC-2021-0145", # atty
+    "RUSTSEC-2023-0071", # rsa: Marvin Attack: potential key recovery
+] # advisory IDs to ignore e.g. ["RUSTSEC-2019-0001", ...]

.github/dependabot.yml

@@ -0,0 +1,19 @@
+version: 2
+updates:
+  - package-ecosystem: cargo
+    versioning-strategy: lockfile-only
+    directory: "/"
+    allow:
+      - dependency-type: "all"
+    groups:
+      all-deps:
+        patterns:
+          - "*"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10

.github/workflows/ci.yml

@@ -0,0 +1,89 @@
+name: CI
+
+on:
+  pull_request: {}
+  push:
+    branches: main
+
+env:
+  CARGO_INCREMENTAL: 0
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - run: sudo apt-get install libpcsclite-dev
+      - run: cargo check
+
+  test:
+    strategy:
+      matrix:
+        include:
+          - platform: ubuntu-latest
+            toolchain: stable
+            deps: sudo apt-get install libpcsclite-dev
+          - platform: windows-latest
+            toolchain: stable
+            deps: true
+          - platform: macos-latest
+            toolchain: stable
+            deps: true
+          - platform: ubuntu-latest
+            toolchain: 1.85.0 # MSRV
+            deps: sudo apt-get install libpcsclite-dev
+          - platform: windows-latest
+            toolchain: 1.85.0 # MSRV
+            deps: true
+          - platform: macos-latest
+            toolchain: 1.85.0 # MSRV
+            deps: true
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.toolchain }}
+          override: true
+      - run: ${{ matrix.deps }}
+      - run: cargo build --all --all-features --release
+      - run: cargo test --all --all-features --release
+
+  rustfmt:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v6
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          components: rustfmt
+
+      - name: Run cargo fmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.85.0 # MSRV
+          components: clippy
+          override: true
+      - run: sudo apt-get install libpcsclite-dev
+      - run: cargo clippy --all --all-features -- -D warnings

.github/workflows/rust.yml

@@ -1,175 +0,0 @@
-# Based on https://github.com/actions-rs/meta/blob/master/recipes/quickstart.md
-
-on:
-  pull_request: {}
-  push:
-    branches: develop
-
-name: Rust
-
-jobs:
-  check:
-    name: Check
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v1
-
-      - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-      - name: Install libpcsclite-dev
-        run: sudo apt-get install libpcsclite-dev
-
-      - name: Run cargo check
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-
-  # Need to install `libpscslite-dev` on Linux
-  linux:
-    name: Test Suite
-    strategy:
-      matrix:
-        toolchain:
-          - 1.39.0
-          - stable
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v1
-
-      - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.toolchain }}
-          override: true
-
-      - name: Install libpcsclite-dev
-        run: sudo apt-get install libpcsclite-dev
-
-      - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        env:
-          RUSTFLAGS: -D warnings
-        with:
-          command: test
-          args: --all --release
-
-      - name: Run cargo build --all-features
-        uses: actions-rs/cargo@v1
-        env:
-          RUSTFLAGS: -D warnings
-        with:
-          command: build
-          args: --all --all-features
-
-  test:
-    name: Test Suite
-    strategy:
-      matrix:
-        platform:
-          - macos-latest
-          - windows-latest
-        toolchain:
-          - 1.39.0
-          - stable
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v1
-
-      - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.toolchain }}
-          override: true
-
-      - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        env:
-          RUSTFLAGS: -D warnings
-        with:
-          command: test
-          args: --all --release
-
-      - name: Run cargo build --all-features
-        uses: actions-rs/cargo@v1
-        env:
-          RUSTFLAGS: -D warnings
-        with:
-          command: build
-          args: --all --all-features
-
-  fmt:
-    name: Rustfmt
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v1
-
-      - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-      - name: Install rustfmt
-        run: rustup component add rustfmt
-
-      - name: Run cargo fmt
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v1
-
-      - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-      - name: Install libpcsclite-dev
-        run: sudo apt-get install libpcsclite-dev
-
-      - name: Install clippy
-        run: rustup component add clippy
-
-      - name: Run cargo clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: --all --all-features -- -D warnings
-
-  # TODO: use actions-rs/audit-check
-  security_audit:
-    name: Security Audit
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v1
-
-      - name: Install stable toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-      - name: Install cargo audit
-        run: cargo install cargo-audit
-
-      - name: Run cargo audit
-        uses: actions-rs/cargo@v1
-        with:
-          command: audit
-          args: --deny-warnings

.github/workflows/security_audit.yml

@@ -0,0 +1,45 @@
+name: Security Audit
+on:
+  pull_request:
+    paths: Cargo.lock
+  push:
+    branches: main
+    paths: Cargo.lock
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  # TODO: use actions-rs/audit-check
+  security_audit:
+    name: Security Audit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v6
+
+      - name: Cache cargo registry
+        uses: actions/cache@v5
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v5
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-index-${{ hashFiles('Cargo.lock') }}
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Install cargo audit
+        run: cargo install cargo-audit
+
+      - name: Run cargo audit
+        uses: actions-rs/cargo@v1
+        with:
+          command: audit
+          args: --deny warnings

CHANGELOG.md

@@ -4,7 +4,282 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.0.3] (2019-12-02)
+## Unreleased
+### Added
+- `yubikey::certificate::SelfSigned`
+- `yubikey::Error::CertificateBuilder`
+- `yubikey::MgmAlgorithmId`
+- `yubikey::mgm`:
+  - `MgmKey::generate_for`
+  - `MgmKey::get_default`
+  - `impl AsRef<[u8]> for MgmKey`
+
+### Changed
+- MSRV is now 1.81.
+- Migrated the public API to the following (pre-release) dependencies:
+  - `der 0.8.0-rc.1`
+  - `ecdsa 0.17.0-pre.9`
+  - `p256 0.14.0-pre.2`
+  - `p384 0.14.0-pre.2`
+  - `rsa 0.10.0-pre.3`
+  - `sha2 0.11.0-pre.4`
+  - `x509-cert 0.3.0-pre.0`
+- `yubikey::mgm`:
+  - `MgmKey::generate` now takes a `rand::TryCryptoRng` argument.
+  - `MgmKey::generate` now requires the caller to specify the key algorithm via
+    an `MgmAlgorithmId` parameter.
+    - Use `MgmKey::generate_for` if you want to generate a key using the
+      preferred algorithm for a given Yubikey's firmware version.
+  - `MgmKey::from_bytes` now takes an `Option<MgmAlgorithmId>` argument, to
+    disambiguate algorithms with the same key length.
+- `yubikey::piv`:
+  - `ManagementAlgorithmId` has been renamed to `SlotAlgorithmId`, and its
+    `ThreeDes` variant has been replaced by `SlotAlgorithmId::Management`
+    containing a `yubikey::MgmAlgorithmId`.
+- Metadata command returns `Error:NotFound` instead of `Error::GenericError` when the object doesn't exist ([#558]).
+
+### Removed
+- `yubikey::mgm`:
+  - `MgmKey::new` (use `MgmKey::from_bytes(_, Some(MgmAlgorithmId::ThreeDes))`
+    instead).
+  - `impl AsRef<[u8; DES_LEN_3DES]> for MgmKey` (use
+    `impl AsRef<[u8]> for MgmKey` instead).
+  - `impl Default for MgmKey` (use `MgmKey::get_default` instead).
+  - `impl TryFrom<&[u8]> for MgmKey` (use `MgmKey::from_bytes` instead).
+
+## 0.8.0 (2023-08-15)
+### Added
+- `impl Debug for {Context, YubiKey}` ([#457])
+- `YubiKey::disconnect` ([#462])
+- `Error::AppletNotFound` ([#476])
+
+### Changed
+- `Reader::open` now returns `Error::AppletNotFound` instead of `Error::Generic`
+  if the PIV applet is not present on the device. This is returned by non-PIV
+  virtual smart cards like Windows Hello for Business, as well as some smart
+  card readers when no card is present.
+- `Reader::open` now avoids resetting the card if an error occurs (equivalent to
+  calling `YubiKey::disconnect(pcsc::Disposition::LeaveCard)` if `Reader::open`
+  succeeds).
+- Raise minimum `pcsc` version to 2.3.1 and remove workaround ([#478])
+- Bump asymmetric crypto dependencies; MSRV 1.65 ([#490])
+  - `elliptic-curve` v0.13
+  - `k256` v0.13
+  - `p256` v0.13
+  - `p384` v0.13
+  - `pbkdf2` v0.12
+  - `rsa` v0.9 ([#502])
+  - `signature` v2
+- Use `x509-cert` certificate builder ([#495])
+- Make `RsaKeyData::new` fallible ([#517])
+
+### Fixed
+- `StatusWords::code` now returns the correct code (including embedded `tries`
+  count) for `StatusWords::VerifyFailError`. Previously the returned code lost
+  information and was not round-trip compatible with `StatusWords::from(u16)`.
+- Parsing of serial numbers ([#466])
+- Make `YubiKey::open()` more robust ([#504])
+
+[#457]: https://github.com/iqlusioninc/yubikey.rs/pull/457
+[#462]: https://github.com/iqlusioninc/yubikey.rs/pull/462
+[#466]: https://github.com/iqlusioninc/yubikey.rs/pull/466
+[#476]: https://github.com/iqlusioninc/yubikey.rs/pull/476
+[#478]: https://github.com/iqlusioninc/yubikey.rs/pull/478
+[#490]: https://github.com/iqlusioninc/yubikey.rs/pull/490
+[#495]: https://github.com/iqlusioninc/yubikey.rs/pull/495
+[#502]: https://github.com/iqlusioninc/yubikey.rs/pull/502
+[#504]: https://github.com/iqlusioninc/yubikey.rs/pull/504
+[#517]: https://github.com/iqlusioninc/yubikey.rs/pull/517
+
+## 0.7.0 (2022-11-14)
+### Added
+- Display inner PC/SC errors ([#420])
+- Support for metadata command ([#371])
+- Better `certificate::Serial` inspection ([#437])
+
+### Changed
+- MSRV 1.60.0 ([#423])
+- Bump `rsa` to v0.7.1 ([#440])
+- Switch from `lazy_static` to `once_cell` ([#442])
+- Switch from `subtle-encoding` to `base16ct` ([#443])
+
+### Fixed
+- Use `chrono` v0.4.23 or newer ([#436])
+- `Certificate::issuer` was returning the subject instead ([#437])
+
+[#371]: https://github.com/iqlusioninc/yubikey.rs/pull/371
+[#420]: https://github.com/iqlusioninc/yubikey.rs/pull/420
+[#423]: https://github.com/iqlusioninc/yubikey.rs/pull/423
+[#436]: https://github.com/iqlusioninc/yubikey.rs/pull/436
+[#437]: https://github.com/iqlusioninc/yubikey.rs/pull/437
+[#440]: https://github.com/iqlusioninc/yubikey.rs/pull/440
+[#442]: https://github.com/iqlusioninc/yubikey.rs/pull/442
+[#443]: https://github.com/iqlusioninc/yubikey.rs/pull/443
+
+## 0.6.0 (2022-08-10)
+### Changed
+- 2021 edition upgrade ([#343])
+- RustCrypto crate upgrades; MSRV 1.57 ([#378])
+  - `des` v0.8
+  - `elliptic-curve` v0.12
+  - `hmac` v0.12
+  - `num-bigint-dig` v0.8
+  - `pbkdf2` v0.11
+  - `p256` v0.11
+  - `p384` v0.11
+  - `rsa` v0.6
+  - `sha1` v0.10 (replacing `sha-1`)
+  - `sha2` v0.10
+- Bump `uuid` to v1.0 ([#376])
+- Bump `der-parser` to v8.0 ([#402])
+- Bump `x509-parser` to v0.14 ([#402])
+
+[#343]: https://github.com/iqlusioninc/yubikey.rs/pull/343
+[#376]: https://github.com/iqlusioninc/yubikey.rs/pull/376
+[#378]: https://github.com/iqlusioninc/yubikey.rs/pull/378
+[#402]: https://github.com/iqlusioninc/yubikey.rs/pull/402
+
+## 0.5.0 (2021-11-21)
+### Changed
+- Update `rsa` dependency to 0.5 ([#315])
+- Update `pbkdf2` dependency to 0.9 ([#315])
+- Update `x509-parser` dependency to 0.12 ([#315], [#322])
+- Update `nom` to v7.0 ([#322])
+
+[#315]: https://github.com/iqlusioninc/yubikey.rs/pull/315
+[#322]: https://github.com/iqlusioninc/yubikey.rs/pull/322
+
+## 0.4.2 (2021-07-13)
+### Added
+- Make `yubikey::Buffer` a pub type ([#290])
+
+### Changed
+- Have `YubiKey::block_puk` take `&mut self` as argument ([#289])
+
+[#289]: https://github.com/iqlusioninc/yubikey.rs/pull/289
+[#290]: https://github.com/iqlusioninc/yubikey.rs/pull/290
+
+## 0.4.1 (2021-07-12)
+### Changed
+- Rename `SettingValue` to `Setting` ([#286])
+- Rename `Ccc` to `CccId` ([#287])
+
+[#286]: https://github.com/iqlusioninc/yubikey.rs/pull/286
+[#287]: https://github.com/iqlusioninc/yubikey.rs/pull/287
+
+## 0.4.0 (2021-07-12) [YANKED]
+### Added
+- `Result` alias ([#271])
+
+### Changed
+- Renamed crate from `yubikey-piv` => `yubikey` ([#267])
+- Renamed the following:
+    - `APDU` => `Apdu` ([#269])
+    - `CCC` => `Ccc` ([#269])
+    - `CHUID` => `ChuId` ([#269])
+    - `Ccc::cccid` => `Ccc::card_id` ([#270])
+    - `key` => `piv` ([#277])
+    - `readers` => `reader` ([#278])
+    - `readers::Readers` => `reader::Context` ([#278])
+- Bumped the following dependencies:
+  - `rsa` => v0.4 ([#246])
+  - `des` => v0.7 ([#251])
+  - `elliptic-curve` => v0.10 ([#268])
+  - `hmac` => v0.11 ([#251])
+  - `pbkdf2` => v0.8 ([#251])
+  - `p256` => v0.9 ([#268])
+  - `p384` => v0.8 ([#268])
+- MSRV 1.51+ ([#268])
+- Flatten API ([#274])
+- Replace `getrandom` with `rand_core` ([#276])
+
+### Fixed
+- Potential local DoS in TLV parser ([#279])
+
+[#246]: https://github.com/iqlusioninc/yubikey.rs/pull/246
+[#251]: https://github.com/iqlusioninc/yubikey.rs/pull/251
+[#267]: https://github.com/iqlusioninc/yubikey.rs/pull/267
+[#268]: https://github.com/iqlusioninc/yubikey.rs/pull/268
+[#269]: https://github.com/iqlusioninc/yubikey.rs/pull/269
+[#270]: https://github.com/iqlusioninc/yubikey.rs/pull/270
+[#271]: https://github.com/iqlusioninc/yubikey.rs/pull/271
+[#274]: https://github.com/iqlusioninc/yubikey.rs/pull/274
+[#276]: https://github.com/iqlusioninc/yubikey.rs/pull/276
+[#277]: https://github.com/iqlusioninc/yubikey.rs/pull/277
+[#278]: https://github.com/iqlusioninc/yubikey.rs/pull/278
+[#279]: https://github.com/iqlusioninc/yubikey.rs/pull/279
+
+## yubikey-piv 0.3.0 (2021-03-22)
+### Added
+- Typed structs for PIN-protected and admin metadata ([#223])
+- `MgmKey::set_default`/`MgmKey::set_manual` methods ([#224])
+
+### Changed
+- Have `Transaction::set_mgm_key` take touch requirement as bool ([#224])
+
+### Removed
+- `MgmKey::set` method ([#224])
+
+[#223]: https://github.com/iqlusioninc/yubikey.rs/pull/223
+[#224]: https://github.com/iqlusioninc/yubikey.rs/pull/224
+
+## yubikey-piv 0.2.0 (2021-01-30)
+### Changed
+- Bump `der-parser` to v5.0 ([#194])
+- Improve self-signed certificates ([#207])
+- Bump `x509-parser` to v0.9 ([#208])
+- Bump elliptic-curve to 0.8. Also requires bumping p256 and p384 ([#208])
+- Bump MSRV to 1.46+ ([#208])
+- Bump `pbkdf2` dependency to v0.7 ([#219])
+
+[#194]: https://github.com/iqlusioninc/yubikey.rs/pull/194
+[#207]: https://github.com/iqlusioninc/yubikey.rs/pull/207
+[#208]: https://github.com/iqlusioninc/yubikey.rs/pull/208
+[#219]: https://github.com/iqlusioninc/yubikey.rs/pull/219
+
+## yubikey-piv 0.1.0 (2020-10-19)
+### Added
+- `Certificate::generate_self_signed` ([#80])
+- `YubiKey::open_by_serial` ([#69])
+- CCCID/CHUID tests and cleanups ([#65])
+- Test `Config::get` ([#64])
+- Test `Key::list` ([#61])
+- Test `YubiKey::verify_pin` ([#60])
+
+### Changed
+- Bump `crypto-mac`, `des`, `hmac`, `pbkdf2` ([#177])
+- Bump `p256` to v0.5; `p384` to v0.4; MSRV 1.44+ ([#175])
+- Refactor key import function ([#128])
+- Extract `ChangeRefAction` enum ([#82])
+- TLV extraction ([#73])
+- Rename `container` to `mscmap` ([#68])
+- Finish eliminating `consts` module ([#67])
+- Move `sign`/`decrypt`/`import`/`attest` to the `key` module ([#62])
+
+### Fixed
+- `pcsc::Error::NoReadersAvailable` -> `Error::NotFound` in `YubiKey::open*` ([#88])
+
+### Removed
+- YubiKey NEO support ([#63])
+
+[#177]: https://github.com/iqlusioninc/yubikey.rs/pull/177
+[#175]: https://github.com/iqlusioninc/yubikey.rs/pull/175
+[#128]: https://github.com/iqlusioninc/yubikey.rs/pull/128
+[#82]: https://github.com/iqlusioninc/yubikey.rs/pull/82
+[#73]: https://github.com/iqlusioninc/yubikey.rs/pull/73
+[#88]: https://github.com/iqlusioninc/yubikey.rs/pull/88
+[#80]: https://github.com/iqlusioninc/yubikey.rs/pull/80
+[#69]: https://github.com/iqlusioninc/yubikey.rs/pull/69
+[#68]: https://github.com/iqlusioninc/yubikey.rs/pull/68
+[#67]: https://github.com/iqlusioninc/yubikey.rs/pull/67
+[#65]: https://github.com/iqlusioninc/yubikey.rs/pull/65
+[#64]: https://github.com/iqlusioninc/yubikey.rs/pull/64
+[#63]: https://github.com/iqlusioninc/yubikey.rs/pull/63
+[#62]: https://github.com/iqlusioninc/yubikey.rs/pull/62
+[#61]: https://github.com/iqlusioninc/yubikey.rs/pull/61
+[#60]: https://github.com/iqlusioninc/yubikey.rs/pull/60
+
+## yubikey-piv 0.0.3 (2019-12-02)
 ### Added
 - Initial `Readers` enumerator for detecting YubiKeys ([#51])
 - Certificate parsing ([#45])
@@ -20,20 +295,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Ins` (APDU instruction codes) enum ([#33])
 - Factor `Response` into `apdu` module; improved debugging ([#32])
 
-[0.0.3]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/53
+[#51]: https://github.com/iqlusioninc/yubikey.rs/pull/51
-[#51]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/51
+[#45]: https://github.com/iqlusioninc/yubikey.rs/pull/45
-[#45]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/45
+[#44]: https://github.com/iqlusioninc/yubikey.rs/pull/44
-[#44]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/44
+[#43]: https://github.com/iqlusioninc/yubikey.rs/pull/43
-[#43]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/43
+[#42]: https://github.com/iqlusioninc/yubikey.rs/pull/42
-[#42]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/42
+[#39]: https://github.com/iqlusioninc/yubikey.rs/pull/39
-[#39]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/39
+[#37]: https://github.com/iqlusioninc/yubikey.rs/pull/37
-[#37]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/37
+[#36]: https://github.com/iqlusioninc/yubikey.rs/pull/36
-[#36]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/36
+[#34]: https://github.com/iqlusioninc/yubikey.rs/pull/34
-[#34]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/34
+[#33]: https://github.com/iqlusioninc/yubikey.rs/pull/33
-[#33]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/33
+[#32]: https://github.com/iqlusioninc/yubikey.rs/pull/32
-[#32]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/32
 
-## [0.0.2] (2019-11-25)
+## yubikey-piv 0.0.2 (2019-11-25)
 ### Added
 - `untested` Cargo feature to mark untested functionality ([#30])
 - Initial connect test and docs ([#19])
@@ -48,17 +322,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Use `log` crate for logging ([#7])
 - Replace `ErrorKind::Ok` with `Result` ([#6])
 
-[0.0.2]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/31
+[#30]: https://github.com/iqlusioninc/yubikey.rs/pull/30
-[#30]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/30
+[#19]: https://github.com/iqlusioninc/yubikey.rs/pull/19
-[#19]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/19
+[#17]: https://github.com/iqlusioninc/yubikey.rs/pull/17
-[#17]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/17
+[#15]: https://github.com/iqlusioninc/yubikey.rs/pull/15
-[#15]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/15
+[#13]: https://github.com/iqlusioninc/yubikey.rs/pull/13
-[#13]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/13
+[#10]: https://github.com/iqlusioninc/yubikey.rs/pull/10
-[#10]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/10
+[#9]: https://github.com/iqlusioninc/yubikey.rs/pull/9
-[#9]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/9
+[#8]: https://github.com/iqlusioninc/yubikey.rs/pull/8
-[#8]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/8
+[#7]: https://github.com/iqlusioninc/yubikey.rs/pull/7
-[#7]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/7
+[#6]: https://github.com/iqlusioninc/yubikey.rs/pull/6
-[#6]: https://github.com/iqlusioninc/yubikey-piv.rs/pull/6
 
-## 0.0.1 (2019-11-18)
+## yubikey-piv 0.0.1 (2019-11-18)
-- It typechecks, ship it!
+- Initial release

COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2019 Yubico AB, Tony Arcieri
+Copyright (c) 2014-2021 Yubico AB, Tony Arcieri
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Cargo.toml

@@ -1,48 +1,68 @@
 [package]
-name    = "yubikey-piv"
+name = "yubikey"
-version = "0.0.3" # Also update html_root_url in lib.rs when bumping this
+version = "0.9.0-pre.0"
 description = """
-Pure Rust host-side driver for the YubiKey Personal Identity Verification (PIV)
+Pure Rust cross-platform host-side driver for YubiKey devices from Yubico with
-application providing general-purpose public-key signing and encryption
+support for hardware-backed public-key decryption and digital signatures using
-with hardware-backed private keys for RSA (2048/1024) and ECC (P-256/P-384)
+the Personal Identity Verification (PIV) application. Supports RSA (1024/2048/3072/4096)
-algorithms (e.g, PKCS#1v1.5, ECDSA)
+or ECC (NIST P-256/P-384) algorithms e.g, PKCS#1v1.5, ECDSA
 """
-authors    = ["Tony Arcieri <bascule@gmail.com>", "Yubico AB"]
+authors = ["Tony Arcieri <tony@iqlusion.io>", "Yubico AB"]
-edition    = "2018"
 license = "BSD-2-Clause"
-repository = "https://github.com/iqlusioninc/yubikey-piv.rs"
+repository = "https://github.com/iqlusioninc/yubikey.rs"
 readme = "README.md"
-categories = ["api-bindings", "cryptography", "hardware-support"]
+categories = ["api-bindings", "authentication", "cryptography", "hardware-support"]
-keywords   = ["ecdsa", "rsa", "piv", "pcsc", "yubikey"]
+keywords = ["ecdsa", "encryption", "rsa", "piv", "signature"]
+edition = "2021"
+rust-version = "1.85"
 
 [workspace]
 members = [".", "cli"]
 
-[badges]
+[workspace.dependencies]
-maintenance = { status = "experimental" }
+sha2 = "0.11"
+x509-cert = { version = "0.3.0-rc.4", features = ["builder", "hazmat"] }
 
 [dependencies]
-der-parser = "3"
+aes = { version = "0.9.0-rc.4", features = ["zeroize"] }
-des = "0.3"
+bitflags = "2.5.0"
-ecdsa = "0.1"
+cipher = { version = "0.5", features = ["getrandom", "rand_core"] }
-getrandom = "0.1"
+curve25519-dalek = "5.0.0-pre.6"
-hmac = "0.7"
+der = "0.8"
+des = "0.9.0-rc.3"
+ecdsa = { version = "0.17.0-rc.16", features = ["digest", "pem"] }
+ed25519-dalek = { version = "3.0.0-pre.6", features = ["alloc", "pkcs8"] }
+elliptic-curve = "0.14.0-rc.29"
+hex = { package = "base16ct", version = "0.2", features = ["alloc"] }
 log = "0.4"
-nom = "5"
+nom = "8"
-pbkdf2 = "0.3"
+p256 = "0.14.0-rc.8"
-pcsc = "2"
+p384 = "0.14.0-rc.8"
-rsa = "0.1.4"
+pbkdf2 = { version = "0.13.0-rc.10", default-features = false, features = ["hmac"] }
-secrecy = "0.5"
+pcsc = "2.3.1"
-sha-1 = "0.8"
+rand = "0.10"
+rand_core = "0.10"
+rsa = { version = "0.10.0-rc.17", features = ["sha2"] }
+sha1 = { version = "0.11", features = ["oid"] }
+sha2 = { workspace = true, features = ["oid"] }
+signature = "3.0.0-rc.10"
 subtle = "2"
-x509-parser = "0.6"
+uuid = { version = "1.2", features = ["v4"] }
+x25519-dalek = "3.0.0-pre.6"
+x509-cert.workspace = true
 zeroize = "1"
 
 [dev-dependencies]
-env_logger = "0.7"
+env_logger = "0.11"
+once_cell = "1"
 
 [features]
 untested = []
 
+[[example]]
+name = "change-mode"
+required-features = ["untested"]
+
 [package.metadata.docs.rs]
 all-features = true
+rustdoc-args = ["--cfg", "docsrs"]

README.md

@@ -1,50 +1,89 @@
-<img src="https://raw.githubusercontent.com/tendermint/yubihsm-rs/develop/img/logo.png" width="150" height="110">
+<img src="https://raw.githubusercontent.com/iqlusioninc/yubikey.rs/main/img/logo.png" width="150" height="110">
 
-# yubikey-piv.rs
+# yubikey.rs
 
 [![crate][crate-image]][crate-link]
 [![Docs][docs-image]][docs-link]
-![Apache2/MIT licensed][license-image]
-![Rust Version][rustc-image]
-![Maintenance Status: Experimental][maintenance-image]
-[![Safety Dance][safety-image]][safety-link]
 [![Build Status][build-image]][build-link]
-[![Gitter Chat][gitter-image]][gitter-link]
+[![Safety Dance][safety-image]][safety-link]
+[![Dependency Status][deps-image]][deps-link]
+[![2-Clause BSD Licensed][license-image]][license-link]
+![MSRV][msrv-image]
 
-Pure Rust host-side YubiKey [Personal Identity Verification (PIV)][PIV] driver
+Pure Rust cross-platform host-side driver for [YubiKey] devices from [Yubico]
-with general-purpose public-key encryption and signing support.
+with support for public-key encryption and digital signatures using the
+[Personal Identity Verification (PIV)][PIV] application.
+
+Uses the Personal Computer/Smart Card ([PC/SC]) interface with cross-platform
+access provided by the [`pcsc` crate].
 
 [Documentation][docs-link]
 
 ## About
 
 YubiKeys are versatile devices and through their PIV support, you can use them
-to store a number of RSA (2048/1024) and ECC (NIST P-256/P-384) private keys
+to store a number of RSA (1024/2048/3072/4096) and ECC (NIST P-256/P-384) private keys
 with configurable access control policies. Both the signing (RSASSA/ECDSA) and
 encryption (PKCS#1v1.5/ECIES) use cases are supported for either key type.
 
 See [Yubico's guide to PIV-enabled YubiKeys][yk-guide] for more information
 on which devices support PIV and the available functionality.
 
-If you've been wanting to use Rust to sign and/or encrypt stuff using a
+If you've been wanting to use Rust to sign and/or encrypt data using a
-private key generated and stored on a Yubikey (with option PIN-based access),
+private key generated and stored on a YubiKey (with option PIN-based access),
 this is the crate you've been after!
 
 Note that while this project started as a fork of a [Yubico] project,
 this fork is **NOT** an official Yubico project and is in no way supported or
 endorsed by Yubico.
 
+## Features
+
+### Personal Identity Verification (PIV)
+
+[PIV] is a [NIST] standard for both *signing* and *encryption*
+using SmartCards and SmartCard-based hardware tokens like YubiKeys.
+
+PIV-related functionality can be found in the [`piv`] module.
+
+This library natively implements the protocol used to manage and
+utilize PIV encryption and signing keys which can be generated, imported,
+and stored on YubiKey devices.
+
+See [Yubico's guide to PIV-enabled YubiKeys][yk-guide] for more information
+on which devices support PIV and the available functionality.
+
+### Supported Algorithms
+
+- **Authentication**: `3DES`
+- **Encryption**:
+    - RSA: `RSA1024`, `RSA2048`, `RSA3072`, `RSA4096`
+    - ECC: `ECCP256`, `ECCP384` (NIST curves: P-256, P-384)
+- **Signatures**:
+    - RSASSA-PKCS#1v1.5: `RSA1024`, `RSA2048`, `RSA3072`, `RSA4096`
+    - ECDSA: `ECCP256`, `ECCP384` (NIST curves: P-256, P-384)
+
+NOTE:
+
+- RSASSA-PSS signatures and RSA-OAEP encryption may be supportable (TBD)
+- `RSA3072` and `RSA4096` require a YubiKey with firmware 5.7 or newer.
+
 ## Minimum Supported Rust Version
 
-- Rust **1.39+**
+Rust **1.60** or newer.
 
 ## Supported YubiKeys
 
-- [YubiKey NEO] series (may be dropped in the future, see [#18])
 - [YubiKey 4] series
 - [YubiKey 5] series
 
-NOTE: Nano and USB-C variants of the above are also supported
+NOTE: Nano and USB-C variants of the above are also supported. NEO series is NOT supported.
+
+## Supported Operating Systems
+
+- Linux
+- macOS
+- Windows
 
 ## Security Warning
 
@@ -55,48 +94,25 @@ USE AT YOUR OWN RISK!
 
 ## Status
 
-This project is a largely incomplete work-in-progress. So far the only
+Functionality which has been successfully tested is available by default.
-functionality which has actually been tested is connecting to Yubikeys.
 
-If you're interested helping test functionality, the table below documents
+Any functionality which is gated on the `untested` feature has not been
-the current status of the project and relevant GitHub issues for various
+properly tested and is not known to function correctly.
-functions of the YubiKey:
 
-|    | Module        | Issue | Description |
+Please see the [`untested` functionality tracking issue] for current status.
-|----|---------------|-------|-------------|
+We would appreciate any help testing this functionality and removing the
-| 🚧 | `yubikey`     | [#20] | Core functionality: auth, keys, PIN/PUK, encrypt, sign, attest |
+`untested` gating as well as writing more automated tests.
-| ⚠️ | `cccid`       | [#21] | Cardholder Capability Container (CCC) IDs |
-| ⚠️ | `certificate` | [#22] | Certificates for stored keys |
-| ⚠️ | `chuid`       | [#23] | Cardholder Unique Identifier (CHUID) |
-| ⚠️ | `config`      | [#24] | Support for reading on-key configuration |
-| ⚠️ | `container`   | [#25] | MS Container Map Records |
-| ⚠️ | `key`         | [#26] | Crypto key management: list, generate, import |
-| ⚠️ | `mgm`         | [#26] | Management Key (MGM) support: set, get, derive
-| ⚠️ | `msroots`     | [#28] | `msroots` file: PKCS#7 formatted certificate store for enterprise trusted roots |
-
-Legend:
-
-|    | Description                        |
-|----|------------------------------------|
-| 🚧 | Testing and validation in progress |
-| ⚠️ | Untested support                   |
-
-NOTE: Commands marked ⚠️ are disabled by default as they have have not been properly tested and may contain bugs or
-not work at all. USE AT YOUR OWN RISK!
-
-Enable the `untested` feature in your `Cargo.toml` to enable features marked ⚠️
-above.
 
 ## Testing
 
-To run the full test suite, you'll need a connected YubiKey NEO/4/5 device in
+To run the full test suite, you'll need a supported YubiKey device connected
-the default state (i.e. default PIN/PUK).
+which is in the default state (i.e. default PIN/PUK).
 
 Tests which run live against a YubiKey device are marked as `#[ignore]` by
 default in order to pass when running in a CI environment. To run these
 tests locally, invoke the following command:
 
-```
+```shell
 cargo test -- --ignored
 ```
 
@@ -105,26 +121,26 @@ information about what is happening. If you'd like to print this logging
 information while running the tests, set the `RUST_LOG` environment variable
 to a relevant loglevel (e.g. `error`, `warn`, `info`, `debug`, `trace`):
 
-```
+```shell
 RUST_LOG=info cargo test -- --ignored
 ```
 
 To trace every message sent to/from the card i.e. the raw
 Application Protocol Data Unit (APDU) messages, use the `trace` log level:
 
-```
+```text
 running 1 test
-[INFO  yubikey_piv::yubikey] trying to connect to reader 'Yubico YubiKey OTP+FIDO+CCID'
+[INFO  yubikey::yubikey] trying to connect to reader 'Yubico YubiKey OTP+FIDO+CCID'
-[INFO  yubikey_piv::yubikey] connected to 'Yubico YubiKey OTP+FIDO+CCID' successfully
+[INFO  yubikey::yubikey] connected to 'Yubico YubiKey OTP+FIDO+CCID' successfully
-[TRACE yubikey_piv::apdu] >>> APDU { cla: 0, ins: SelectApplication, p1: 4, p2: 0, data: [160, 0, 0, 3, 8] }
+[TRACE yubikey::apdu] >>> Apdu { cla: 0, ins: SelectApplication, p1: 4, p2: 0, data: [160, 0, 0, 3, 8] }
-[TRACE yubikey_piv::transaction] >>> [0, 164, 4, 0, 5, 160, 0, 0, 3, 8]
+[TRACE yubikey::transaction] >>> [0, 164, 4, 0, 5, 160, 0, 0, 3, 8]
-[TRACE yubikey_piv::apdu] <<< Response { status_words: Success, data: [97, 17, 79, 6, 0, 0, 16, 0, 1, 0, 121, 7, 79, 5, 160, 0, 0, 3, 8] }
+[TRACE yubikey::apdu] <<< Response { status_words: Success, data: [97, 17, 79, 6, 0, 0, 16, 0, 1, 0, 121, 7, 79, 5, 160, 0, 0, 3, 8] }
-[TRACE yubikey_piv::apdu] >>> APDU { cla: 0, ins: GetVersion, p1: 0, p2: 0, data: [] }
+[TRACE yubikey::apdu] >>> Apdu { cla: 0, ins: GetVersion, p1: 0, p2: 0, data: [] }
-[TRACE yubikey_piv::transaction] >>> [0, 253, 0, 0, 0]
+[TRACE yubikey::transaction] >>> [0, 253, 0, 0, 0]
-[TRACE yubikey_piv::apdu] <<< Response { status_words: Success, data: [5, 1, 2] }
+[TRACE yubikey::apdu] <<< Response { status_words: Success, data: [5, 1, 2] }
-[TRACE yubikey_piv::apdu] >>> APDU { cla: 0, ins: GetSerial, p1: 0, p2: 0, data: [] }
+[TRACE yubikey::apdu] >>> Apdu { cla: 0, ins: GetSerial, p1: 0, p2: 0, data: [] }
-[TRACE yubikey_piv::transaction] >>> [0, 248, 0, 0, 0]
+[TRACE yubikey::transaction] >>> [0, 248, 0, 0, 0]
-[TRACE yubikey_piv::apdu] <<< Response { status_words: Success, data: [0, 115, 0, 178] }
+[TRACE yubikey::apdu] <<< Response { status_words: Success, data: [0, 115, 0, 178] }
 test connect ... ok
 ```
 
@@ -138,6 +154,14 @@ Yubico, which was originally written in C. It was mechanically translated
 from C into Rust using [Corrode], and then subsequently heavily
 refactored into safer, more idiomatic Rust.
 
+For more information on [yubico-piv-tool] and background information on how
+the YubiKey implementation of PIV works in general, see the
+[Yubico PIV Tool Command Line Guide][piv-tool-guide].
+
+## ⚠️ Security Warning
+
+No security audits of this crate have ever been performed.
+
 ## Code of Conduct
 
 We abide by the [Contributor Covenant][cc-md] and ask that you do as well.
@@ -146,12 +170,12 @@ For more information, please see [CODE_OF_CONDUCT.md][cc-md].
 
 ## License
 
-**yubikey-piv.rs** is a fork of and originally a mechanical translation from
+**yubikey.rs** is a fork of and originally a mechanical translation from
 Yubico's [yubico-piv-tool], a C library/CLI program. The original library
 was licensed under a [2-Clause BSD License][BSDL], which this library inherits
 as a derived work.
 
-Copyright (c) 2014-2019 Yubico AB, Tony Arcieri
+Copyright (c) 2014-2025 Yubico AB, Tony Arcieri
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -187,43 +211,48 @@ or conditions.
 
 [//]: # (badges)
 
-[crate-image]: https://img.shields.io/crates/v/yubikey-piv.svg
+[crate-image]: https://img.shields.io/crates/v/yubikey?logo=rust
-[crate-link]: https://crates.io/crates/yubikey-piv
+[crate-link]: https://crates.io/crates/yubikey
-[docs-image]: https://docs.rs/yubikey-piv/badge.svg
+[docs-image]: https://docs.rs/yubikey/badge.svg
-[docs-link]: https://docs.rs/yubikey-piv/
+[docs-link]: https://docs.rs/yubikey/
 [license-image]: https://img.shields.io/badge/license-BSD-blue.svg
-[rustc-image]: https://img.shields.io/badge/rustc-1.39+-blue.svg
+[license-link]: https://github.com/iqlusioninc/yubikey.rs/blob/main/COPYING
-[maintenance-image]: https://img.shields.io/badge/maintenance-experimental-blue.svg
+[msrv-image]: https://img.shields.io/badge/rustc-1.85+-blue.svg
 [safety-image]: https://img.shields.io/badge/unsafe-forbidden-success.svg
 [safety-link]: https://github.com/rust-secure-code/safety-dance/
-[build-image]: https://github.com/iqlusioninc/yubikey-piv.rs/workflows/Rust/badge.svg?branch=develop&event=push
+[build-image]: https://github.com/iqlusioninc/yubikey.rs/actions/workflows/ci.yml/badge.svg
-[build-link]: https://github.com/iqlusioninc/yubikey-piv.rs/actions
+[build-link]: https://github.com/iqlusioninc/yubikey.rs/actions
-[gitter-image]: https://badges.gitter.im/badge.svg
+[deps-image]: https://deps.rs/repo/github/iqlusioninc/yubikey.rs/status.svg
-[gitter-link]: https://gitter.im/iqlusioninc/community
+[deps-link]: https://deps.rs/repo/github/iqlusioninc/yubikey.rs
 
 [//]: # (general links)
 
-[PIV]: https://piv.idmanagement.gov/
+[YubiKey]: https://www.yubico.com/products/yubikey-hardware/
-[yk-guide]: https://developers.yubico.com/PIV/Introduction/YubiKey_and_PIV.html
 [Yubico]: https://www.yubico.com/
-[YubiKey NEO]: https://support.yubico.com/support/solutions/articles/15000006494-yubikey-neo
+[PIV]: https://piv.idmanagement.gov/
+[NIST]: https://www.nist.gov/
+[PC/SC]: https://en.wikipedia.org/wiki/PC/SC
+[`pcsc` crate]: https://github.com/bluetech/pcsc-rust
+[yk-guide]: https://developers.yubico.com/PIV/Introduction/YubiKey_and_PIV.html
 [YubiKey 4]: https://support.yubico.com/support/solutions/articles/15000006486-yubikey-4
 [YubiKey 5]: https://www.yubico.com/products/yubikey-5-overview/
 [yubico-piv-tool]: https://github.com/Yubico/yubico-piv-tool/
+[piv-tool-guide]: https://docs.yubico.com/software/yubikey/tools/pivtool/Introduction.html
 [Corrode]: https://github.com/jameysharp/corrode
 [cc-web]: https://contributor-covenant.org/
-[cc-md]: https://github.com/iqlusioninc/yubikey-piv.rs/blob/develop/CODE_OF_CONDUCT.md
+[cc-md]: https://github.com/iqlusioninc/yubikey.rs/blob/main/CODE_OF_CONDUCT.md
 [BSDL]: https://opensource.org/licenses/BSD-2-Clause
+[`untested` functionality tracking issue]: https://github.com/iqlusioninc/yubikey.rs/issues/280
 
 [//]: # (github issues)
 
-[#18]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/18
+[#18]: https://github.com/iqlusioninc/yubikey.rs/issues/18
-[#20]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/20
+[#20]: https://github.com/iqlusioninc/yubikey.rs/issues/20
-[#21]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/21
+[#21]: https://github.com/iqlusioninc/yubikey.rs/issues/21
-[#22]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/22
+[#22]: https://github.com/iqlusioninc/yubikey.rs/issues/22
-[#23]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/23
+[#23]: https://github.com/iqlusioninc/yubikey.rs/issues/23
-[#24]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/24
+[#24]: https://github.com/iqlusioninc/yubikey.rs/issues/24
-[#25]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/25
+[#25]: https://github.com/iqlusioninc/yubikey.rs/issues/25
-[#26]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/26
+[#26]: https://github.com/iqlusioninc/yubikey.rs/issues/26
-[#27]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/27
+[#27]: https://github.com/iqlusioninc/yubikey.rs/issues/27
-[#28]: https://github.com/iqlusioninc/yubikey-piv.rs/issues/28
+[#28]: https://github.com/iqlusioninc/yubikey.rs/issues/28

cli/CHANGELOG.md

@@ -4,5 +4,77 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+### Changed
+- MSRV is now 1.81.
+
+## 0.7.0 (2022-11-14)
+### Changed
+- Bump `clap` to v4.0 ([#438])
+- Bump `x509-parser` to v0.14 ([#441])
+- Switch from `lazy_static` to `once_cell` ([#442])
+- Switch from `subtle-encoding` to `base16ct` ([#443])
+- Bump `yubikey` dependency to v0.7 ([#444])
+
+[#438]: https://github.com/iqlusioninc/yubikey.rs/pull/438
+[#441]: https://github.com/iqlusioninc/yubikey.rs/pull/441
+[#442]: https://github.com/iqlusioninc/yubikey.rs/pull/442
+[#443]: https://github.com/iqlusioninc/yubikey.rs/pull/443
+[#444]: https://github.com/iqlusioninc/yubikey.rs/pull/444
+
+## 0.6.0 (2022-08-10)
+### Changed
+- 2021 edition upgrade; MSRV 1.57 ([#343])
+- Migrate from `gumdrop` to `clap` v3 ([#379])
+- Bump `yubikey` dependency to v0.6 ([#403])
+
+[#343]: https://github.com/iqlusioninc/yubikey.rs/pull/343
+[#379]: https://github.com/iqlusioninc/yubikey.rs/pull/379
+[#403]: https://github.com/iqlusioninc/yubikey.rs/pull/403
+
+## 0.5.0 (2021-11-21)
+### Changed
+- Bump `yubikey` dependency to v0.5 ([#327])
+
+[#327]: https://github.com/iqlusioninc/yubikey.rs/pull/327
+ 
+## 0.4.0 (2021-07-12)
+### Changed
+- Switch to renamed `yubikey` crate ([#283])
+- Bump MSRV to 1.51+ ([#283])
+
+[#283]: https://github.com/iqlusioninc/yubikey.rs/pull/283
+
+## 0.3.0 (2021-03-22)
+### Changed
+- Bump `yubikey-piv` dependency to v0.3 ([#240])
+
+[#240]: https://github.com/iqlusioninc/yubikey.rs/pull/240
+
+## 0.2.0 (2021-01-30)
+### Changed
+- Bump MSRV to 1.46+ ([#208])
+- Bump `yubikey-piv` dependency to v0.2 ([#220])
+
+[#208]: https://github.com/iqlusioninc/yubikey.rs/pull/208
+[#220]: https://github.com/iqlusioninc/yubikey.rs/pull/220
+
+## 0.1.0 (2020-10-19)
+### Added
+- `status` command ([#72], [#74])
+
+### Changed
+- Bump `yubikey-piv` to v0.1 ([#180])
+- Bump `x509-parser` to v0.8 ([#181])
+- Bump `sha2` to v0.9 ([#182])
+- Rename `list` command to `readers`; improve usage ([#71])
+
+[#182]: https://github.com/iqlusioninc/yubikey.rs/pull/182
+[#181]: https://github.com/iqlusioninc/yubikey.rs/pull/181
+[#180]: https://github.com/iqlusioninc/yubikey.rs/pull/180
+[#74]: https://github.com/iqlusioninc/yubikey.rs/pull/74
+[#72]: https://github.com/iqlusioninc/yubikey.rs/pull/72
+[#71]: https://github.com/iqlusioninc/yubikey.rs/pull/71
+
 ## 0.0.1 (2019-12-02)
 - Initial release

cli/Cargo.toml

@@ -1,21 +1,26 @@
 [package]
 name = "yubikey-cli"
-version = "0.0.1"
+version = "0.9.0-pre"
 description = """
-Command-line interface for performing encryption and signing using RSA and/or
+Command-line interface for performing encryption and signing using RSA/ECC keys
-ECC keys stored on YubiKey devices.
+stored on YubiKey devices.
 """
-authors = ["Tony Arcieri <bascule@gmail.com>"]
+authors = ["Tony Arcieri <tony@iqlusion.io>"]
-edition = "2018"
 license = "BSD-2-Clause"
-repository = "https://github.com/iqlusioninc/yubikey-piv.rs"
+repository = "https://github.com/iqlusioninc/yubikey.rs"
 readme = "README.md"
 categories = ["command-line-utilities", "cryptography", "hardware-support"]
 keywords = ["ecdsa", "rsa", "piv", "pcsc", "yubikey"]
+edition = "2021"
+rust-version = "1.85"
 
 [dependencies]
-gumdrop = "0.7"
+clap = { version = "4", features = ["derive"] }
-env_logger = "0.7"
+env_logger = "0.11"
-lazy_static = "1"
+hex = { package = "base16ct", version = "0.2", features = ["alloc"] }
+log = "0.4"
+once_cell = "1"
+sha2.workspace = true
 termcolor = "1"
-yubikey-piv = { version = "0.0.3", path = ".." }
+x509-cert.workspace = true
+yubikey = { version = "=0.9.0-pre.0", path = ".." }

cli/README.md

@@ -1,4 +1,4 @@
-<img src="https://raw.githubusercontent.com/tendermint/yubihsm-rs/develop/img/logo.png" width="150" height="110">
+<img src="https://raw.githubusercontent.com/iqlusioninc/yubikey.rs/main/img/logo.png" width="150" height="110">
 
 # yubikey-cli.rs
 
@@ -18,15 +18,14 @@ utility with general-purpose public-key encryption and signing support.
 
 ## Minimum Supported Rust Version
 
-- Rust **1.39+**
+Rust **1.60** or newer.
 
 ## Supported YubiKeys
 
-- [YubiKey NEO] series (may be dropped in the future, see [#18])
 - [YubiKey 4] series
 - [YubiKey 5] series
 
-NOTE: Nano and USB-C variants of the above are also supported
+NOTE: Nano and USB-C variants of the above are also supported. NEO series is NOT supported.
 
 ## Security Warning
 
@@ -35,10 +34,6 @@ an experimental stage and may still contain high-severity issues.
 
 USE AT YOUR OWN RISK!
 
-## Status
-
-WIP. Check back later.
-
 ## Code of Conduct
 
 We abide by the [Contributor Covenant][cc-md] and ask that you do as well.
@@ -47,7 +42,7 @@ For more information, please see [CODE_OF_CONDUCT.md][cc-md].
 
 ## License
 
-Copyright (c) 2014-2019 Yubico AB, Tony Arcieri
+Copyright (c) 2014-2023 Yubico AB, Tony Arcieri
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -88,12 +83,12 @@ or conditions.
 [docs-image]: https://docs.rs/yubikey-cli/badge.svg
 [docs-link]: https://docs.rs/yubikey-cli/
 [license-image]: https://img.shields.io/badge/license-BSD-blue.svg
-[rustc-image]: https://img.shields.io/badge/rustc-1.39+-blue.svg
+[rustc-image]: https://img.shields.io/badge/rustc-1.85+-blue.svg
 [maintenance-image]: https://img.shields.io/badge/maintenance-experimental-blue.svg
 [safety-image]: https://img.shields.io/badge/unsafe-forbidden-success.svg
 [safety-link]: https://github.com/rust-secure-code/safety-dance/
-[build-image]: https://github.com/iqlusioninc/yubikey-cli.rs/workflows/Rust/badge.svg?branch=develop&event=push
+[build-image]: https://github.com/iqlusioninc/yubikey.rs/workflows/CI/badge.svg?branch=main&event=push
-[build-link]: https://github.com/iqlusioninc/yubikey-cli.rs/actions
+[build-link]: https://github.com/iqlusioninc/yubikey.rs/actions
 [gitter-image]: https://badges.gitter.im/badge.svg
 [gitter-link]: https://gitter.im/iqlusioninc/community
 
@@ -102,11 +97,10 @@ or conditions.
 [PIV]: https://piv.idmanagement.gov/
 [yk-guide]: https://developers.yubico.com/PIV/Introduction/YubiKey_and_PIV.html
 [Yubico]: https://www.yubico.com/
-[YubiKey NEO]: https://support.yubico.com/support/solutions/articles/15000006494-yubikey-neo
 [YubiKey 4]: https://support.yubico.com/support/solutions/articles/15000006486-yubikey-4
 [YubiKey 5]: https://www.yubico.com/products/yubikey-5-overview/
 [yubico-piv-tool]: https://github.com/Yubico/yubico-piv-tool/
 [Corrode]: https://github.com/jameysharp/corrode
 [cc-web]: https://contributor-covenant.org/
-[cc-md]: https://github.com/iqlusioninc/yubikey-cli.rs/blob/develop/CODE_OF_CONDUCT.md
+[cc-md]: https://github.com/iqlusioninc/yubikey-cli.rs/blob/main/CODE_OF_CONDUCT.md
 [BSDL]: https://opensource.org/licenses/BSD-2-Clause

cli/src/bin/yubikey/main.rs

@@ -8,9 +8,9 @@
     unused_qualifications
 )]
 
-use gumdrop::Options;
+use clap::Parser;
-use yubikey_cli::commands::YubikeyCli;
+use yubikey_cli::commands::YubiKeyCli;
 
 fn main() {
-    YubikeyCli::parse_args_default_or_exit().run();
+    YubiKeyCli::parse().run()
 }

cli/src/commands.rs

@@ -1,93 +1,85 @@
 //! Commands of the CLI application
 
-pub mod list;
+pub mod readers;
+pub mod status;
 
-use self::list::ListCmd;
+use self::{readers::ReadersCmd, status::StatusCmd};
-use crate::status;
+use crate::terminal;
-use gumdrop::Options;
+use clap::Parser;
-use std::env;
+use std::{env, process::exit};
-use std::process::exit;
 use termcolor::ColorChoice;
+use yubikey::{Serial, YubiKey};
 
 /// The `yubikey` CLI utility
-#[derive(Debug, Options)]
+#[derive(Debug, Parser)]
-pub struct YubikeyCli {
+pub struct YubiKeyCli {
-    /// Obtain help about the current command
+    /// Serial number of the YubiKey to connect to
-    #[options(short = "h", help = "print help message")]
+    #[clap(short = 's', long = "serial")]
-    pub help: bool,
+    pub serial: Option<Serial>,
 
     /// Subcommand to execute.
-    #[options(command)]
+    #[clap(subcommand)]
-    pub command: Option<Commands>,
+    pub command: Commands,
 }
 
-impl YubikeyCli {
+impl YubiKeyCli {
     /// Run the underlying command type or print usage info and exit
     pub fn run(&self) {
         // TODO(tarcieri): make this more configurable
-        status::set_color_choice(ColorChoice::Auto);
+        terminal::set_color_choice(ColorChoice::Auto);
 
         // Only show logs if `RUST_LOG` is set
         if env::var("RUST_LOG").is_ok() {
             env_logger::builder().format_timestamp(None).init();
         }
 
-        match &self.command {
+        self.command.run(self.yubikey_init())
-            Some(cmd) => cmd.run(),
+    }
-            None => println!("{}", Commands::usage()),
+
+    /// Initialize the YubiKey client driver
+    fn yubikey_init(&self) -> YubiKey {
+        match self.serial {
+            Some(serial) => YubiKey::open_by_serial(serial).unwrap_or_else(|e| {
+                status_err!("couldn't open YubiKey (serial #{}): {}", serial, e);
+                exit(1);
+            }),
+            None => YubiKey::open().unwrap_or_else(|e| {
+                status_err!("couldn't open default YubiKey: {}", e);
+                exit(1);
+            }),
         }
     }
 }
 
 /// Subcommands of this application
-#[derive(Debug, Options)]
+#[derive(Debug, Parser)]
 pub enum Commands {
-    /// `help` subcommand
-    #[options(help = "show help for a command")]
-    Help(HelpOpts),
-
     /// `version` subcommand
-    #[options(help = "display version information")]
+    #[clap(about = "display version information")]
     Version(VersionOpts),
 
-    /// `list` subcommand
+    /// `readers` subcommand
-    #[options(help = "list detected readers")]
+    #[clap(about = "list detected readers")]
-    List(ListCmd),
+    Readers(ReadersCmd),
+
+    /// `status` subcommand
+    #[clap(about = "show yubikey status")]
+    Status(StatusCmd),
 }
 
 impl Commands {
     /// Run the given command
-    pub fn run(&self) {
+    pub fn run(&self, yubikey: YubiKey) {
         match self {
-            Commands::Help(help) => help.run(),
             Commands::Version(version) => version.run(),
-            Commands::List(list) => list.run(),
+            Commands::Readers(list) => list.run(),
+            Commands::Status(status) => status.run(yubikey),
         }
     }
 }
 
-/// Help options
-#[derive(Debug, Options)]
-pub struct HelpOpts {
-    #[options(free, help = "subcommand to get help for")]
-    free: Vec<String>,
-}
-
-impl HelpOpts {
-    fn run(&self) {
-        if let Some(command) = self.free.first() {
-            if let Some(usage) = Commands::command_usage(command) {
-                println!("{}", usage);
-                exit(1);
-            }
-        }
-
-        println!("{}", Commands::usage());
-    }
-}
-
 /// Version options
-#[derive(Debug, Options)]
+#[derive(Debug, Parser)]
 pub struct VersionOpts {}
 
 impl VersionOpts {

cli/src/commands/list.rs

@@ -1,40 +0,0 @@
-//! List detected readers
-
-use gumdrop::Options;
-use std::process::exit;
-use yubikey_piv::readers::Readers;
-
-/// The `list` subcommand
-#[derive(Debug, Options)]
-pub struct ListCmd {}
-
-impl ListCmd {
-    /// Run the `list` subcommand
-    pub fn run(&self) {
-        let mut readers = Readers::open().unwrap_or_else(|e| {
-            status_err!("couldn't open PC/SC context: {}", e);
-            exit(1);
-        });
-
-        let readers_iter = readers.iter().unwrap_or_else(|e| {
-            status_err!("couldn't enumerate PC/SC readers: {}", e);
-            exit(1);
-        });
-
-        if readers_iter.len() == 0 {
-            status_err!("no YubiKeys detected!");
-            exit(1);
-        }
-
-        for (i, reader) in readers_iter.enumerate() {
-            let name = reader.name();
-            let mut yubikey = match reader.open() {
-                Ok(yk) => yk,
-                Err(_) => continue,
-            };
-
-            let serial = yubikey.serial();
-            println!("{}: {} (serial: {})", i + 1, name, serial);
-        }
-    }
-}

cli/src/commands/readers.rs

@@ -0,0 +1,64 @@
+//! List detected readers
+
+use crate::terminal::STDOUT;
+use clap::Parser;
+use std::{
+    io::{self, Write},
+    process::exit,
+};
+use termcolor::{ColorSpec, StandardStreamLock, WriteColor};
+use yubikey::{Context, Serial};
+
+/// The `readers` subcommand
+#[derive(Debug, Parser)]
+pub struct ReadersCmd {}
+
+impl ReadersCmd {
+    /// Run the `readers` subcommand
+    pub fn run(&self) {
+        let mut readers = Context::open().unwrap_or_else(|e| {
+            status_err!("couldn't open PC/SC context: {}", e);
+            exit(1);
+        });
+
+        let readers_iter = readers.iter().unwrap_or_else(|e| {
+            status_err!("couldn't enumerate PC/SC readers: {}", e);
+            exit(1);
+        });
+
+        if readers_iter.len() == 0 {
+            status_err!("no YubiKeys detected!");
+            exit(1);
+        }
+
+        let mut s = STDOUT.lock();
+        s.reset().unwrap();
+
+        for (i, reader) in readers_iter.enumerate() {
+            let name = reader.name();
+            let yubikey = match reader.open() {
+                Ok(yk) => yk,
+                Err(_) => continue,
+            };
+
+            let serial = yubikey.serial();
+            self.print_reader(&mut s, i + 1, &name, serial).unwrap();
+        }
+    }
+
+    /// Print a reader
+    fn print_reader(
+        &self,
+        stream: &mut StandardStreamLock<'_>,
+        index: usize,
+        name: &str,
+        serial: Serial,
+    ) -> io::Result<()> {
+        stream.set_color(ColorSpec::new().set_bold(true))?;
+        write!(stream, "{:>3}:", index)?;
+        stream.reset()?;
+        writeln!(stream, " {} (serial: {})", name, serial)?;
+        stream.flush()?;
+        Ok(())
+    }
+}

cli/src/commands/status.rs

@@ -0,0 +1,60 @@
+//! Print device status
+
+use crate::terminal::{print_cert_info, STDOUT};
+use clap::Parser;
+use std::io::{self, Write};
+use termcolor::{ColorSpec, StandardStreamLock, WriteColor};
+use yubikey::{piv::*, YubiKey};
+
+// String to use for `None`
+const NONE_STR: &str = "<none>";
+
+/// The `status` subcommand
+#[derive(Debug, Parser)]
+pub struct StatusCmd {}
+
+impl StatusCmd {
+    /// Run the `status` subcommand
+    pub fn run(&self, mut yk: YubiKey) {
+        let mut s = STDOUT.lock();
+        s.reset().unwrap();
+
+        self.attr(&mut s, "name", yk.name()).unwrap();
+        self.attr(&mut s, "version", yk.version()).unwrap();
+        self.attr(&mut s, "serial", yk.serial()).unwrap();
+
+        if let Ok(chuid) = yk.chuid() {
+            self.attr(&mut s, "CHUID", chuid).unwrap();
+        } else {
+            self.attr(&mut s, "CHUID", NONE_STR).unwrap();
+        }
+
+        if let Ok(chuid) = yk.cccid() {
+            self.attr(&mut s, "CCC", chuid).unwrap();
+        } else {
+            self.attr(&mut s, "CCC", NONE_STR).unwrap();
+        }
+
+        self.attr(&mut s, "PIN retries", yk.get_pin_retries().unwrap())
+            .unwrap();
+
+        for slot in SLOTS.iter().cloned() {
+            print_cert_info(&mut yk, slot, &mut s).unwrap();
+        }
+    }
+
+    /// Print a status attribute
+    fn attr(
+        &self,
+        stream: &mut StandardStreamLock<'_>,
+        name: &str,
+        value: impl ToString,
+    ) -> io::Result<()> {
+        stream.set_color(ColorSpec::new().set_bold(true))?;
+        write!(stream, "{:>12}:", name)?;
+        stream.reset()?;
+        writeln!(stream, " {}", value.to_string())?;
+        stream.flush()?;
+        Ok(())
+    }
+}

cli/src/lib.rs

@@ -1,14 +1,13 @@
-//! `yubikey` command-line utility
+//! `yubikey` command-line utility.
+//!
+//! The goal of this tool is to provide functionality similar to `yubico-piv-tool`
+//! but implemented in pure Rust.
+//!
+//! It also serves as a demonstration/example of how to use the `yubikey` crate.
 
 #![forbid(unsafe_code)]
-#![warn(
+#![warn(missing_docs, rust_2018_idioms, unused_qualifications)]
-    missing_docs,
-    rust_2018_idioms,
-    unused_lifetimes,
-    unused_qualifications
-)]
 
 #[macro_use]
-pub mod status;
+pub mod terminal;
-
 pub mod commands;

cli/src/terminal.rs

@@ -1,15 +1,22 @@
 //! Status messages
 
-use lazy_static::lazy_static;
+use log::debug;
-use std::io::{self, Write};
+use once_cell::sync::Lazy;
-use std::sync::Mutex;
+use sha2::{Digest, Sha256};
-use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
+use std::{
+    io::{self, Write},
+    str,
+    sync::Mutex,
+};
+use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, StandardStreamLock, WriteColor};
+use x509_cert::der::Encode;
+use yubikey::{certificate::Certificate, piv::*, YubiKey};
 
 /// Print a success status message (in green if colors are enabled)
 #[macro_export]
 macro_rules! status_ok {
     ($status:expr, $msg:expr) => {
-        $crate::status::Status::new()
+        $crate::terminal::Status::new()
             .justified()
             .bold()
             .color(termcolor::Color::Green)
@@ -25,7 +32,7 @@ macro_rules! status_ok {
 #[macro_export]
 macro_rules! status_warn {
     ($msg:expr) => {
-        $crate::status::Status::new()
+        $crate::terminal::Status::new()
             .bold()
             .color(termcolor::Color::Yellow)
             .status("warning:")
@@ -40,7 +47,7 @@ macro_rules! status_warn {
 #[macro_export]
 macro_rules! status_err {
     ($msg:expr) => {
-        $crate::status::Status::new()
+        $crate::terminal::Status::new()
             .bold()
             .color(termcolor::Color::Red)
             .status("error:")
@@ -51,16 +58,14 @@ macro_rules! status_err {
     };
 }
 
-lazy_static! {
 /// Color configuration
-    static ref COLOR_CHOICE: Mutex<Option<ColorChoice>> = Mutex::new(None);
+static COLOR_CHOICE: Lazy<Mutex<Option<ColorChoice>>> = Lazy::new(|| Mutex::new(None));
 
 /// Standard output
-    pub static ref STDOUT: StandardStream = StandardStream::stdout(get_color_choice());
+pub static STDOUT: Lazy<StandardStream> = Lazy::new(|| StandardStream::stdout(get_color_choice()));
 
 /// Standard error
-    pub static ref STDERR: StandardStream = StandardStream::stderr(get_color_choice());
+pub static STDERR: Lazy<StandardStream> = Lazy::new(|| StandardStream::stderr(get_color_choice()));
-}
 
 /// Obtain the color configuration.
 ///
@@ -132,18 +137,16 @@ impl Status {
 
     /// Print the given message to stdout
     pub fn print_stdout(self, msg: impl AsRef<str>) {
-        self.print(&*STDOUT, msg)
+        self.print(&STDOUT, msg).expect("error printing to stdout!")
-            .expect("error printing to stdout!")
     }
 
     /// Print the given message to stderr
     pub fn print_stderr(self, msg: impl AsRef<str>) {
-        self.print(&*STDERR, msg)
+        self.print(&STDERR, msg).expect("error printing to stderr!")
-            .expect("error printing to stderr!")
     }
 
     /// Print the given message
-    fn print(self, stream: &StandardStream, msg: impl AsRef<str>) -> Result<(), io::Error> {
+    fn print(self, stream: &StandardStream, msg: impl AsRef<str>) -> io::Result<()> {
         let mut s = stream.lock();
         s.reset()?;
         s.set_color(ColorSpec::new().set_fg(self.color).set_bold(self.bold))?;
@@ -163,3 +166,65 @@ impl Status {
         Ok(())
     }
 }
+
+/// Write information about certificate found in slot a la yubico-piv-tool output.
+pub fn print_cert_info(
+    yubikey: &mut YubiKey,
+    slot: SlotId,
+    stream: &mut StandardStreamLock<'_>,
+) -> io::Result<()> {
+    let cert = match Certificate::read(yubikey, slot) {
+        Ok(c) => c,
+        Err(e) => {
+            debug!("error reading certificate in slot {:?}: {}", slot, e);
+            return Ok(());
+        }
+    };
+    let cert = &cert.cert;
+
+    let fingerprint = Sha256::digest(cert.to_der().unwrap());
+    let slot_id: u8 = slot.into();
+    print_cert_attr(stream, "Slot", format!("{:x}", slot_id))?;
+    print_cert_attr(
+        stream,
+        "Algorithm",
+        cert.tbs_certificate()
+            .subject_public_key_info()
+            .algorithm
+            .oid,
+    )?;
+
+    print_cert_attr(stream, "Subject", cert.tbs_certificate().subject())?;
+    print_cert_attr(stream, "Issuer", cert.tbs_certificate().issuer())?;
+    print_cert_attr(
+        stream,
+        "Fingerprint",
+        hex::upper::encode_string(&fingerprint),
+    )?;
+    print_cert_attr(
+        stream,
+        "Not Before",
+        cert.tbs_certificate().validity().not_before,
+    )?;
+    print_cert_attr(
+        stream,
+        "Not After",
+        cert.tbs_certificate().validity().not_after,
+    )?;
+
+    Ok(())
+}
+
+/// Print a status attribute
+fn print_cert_attr(
+    stream: &mut StandardStreamLock<'_>,
+    name: &str,
+    value: impl ToString,
+) -> io::Result<()> {
+    stream.set_color(ColorSpec::new().set_bold(true))?;
+    write!(stream, "{:>12}:", name)?;
+    stream.reset()?;
+    writeln!(stream, " {}", value.to_string())?;
+    stream.flush()?;
+    Ok(())
+}

examples/change-mode.rs

@@ -0,0 +1,10 @@
+#![cfg(feature = "untested")]
+
+use yubikey::{mgm, YubiKey};
+
+fn main() {
+    let yubikey = YubiKey::open().unwrap();
+
+    let mut mgmt = mgm::Manager::new(yubikey).unwrap();
+    mgmt.enable_yubihsm().unwrap();
+}

src/apdu.rs

@@ -30,7 +30,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use crate::{error::Error, transaction::Transaction, Buffer};
+use crate::{transaction::Transaction, Buffer, Result};
 use log::trace;
 use zeroize::{Zeroize, Zeroizing};
 
@@ -41,7 +41,7 @@ const APDU_DATA_MAX: usize = 0xFF;
 ///
 /// These messages are packets used to communicate with the YubiKey.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub(crate) struct APDU {
+pub(crate) struct Apdu {
     /// Instruction class: indicates the type of command (e.g. inter-industry or proprietary)
     cla: u8,
 
@@ -58,7 +58,7 @@ pub(crate) struct APDU {
     data: Vec<u8>,
 }
 
-impl APDU {
+impl Apdu {
     /// Create a new APDU with the given instruction code
     pub fn new(ins: impl Into<Ins>) -> Self {
         Self {
@@ -71,7 +71,6 @@ impl APDU {
     }
 
     /// Set this APDU's class
-    #[cfg(feature = "untested")]
     pub fn cla(&mut self, value: u8) -> &mut Self {
         self.cla = value;
         self
@@ -83,8 +82,13 @@ impl APDU {
         self
     }
 
+    /// Set this APDU's second parameter only
+    pub(crate) fn p2(&mut self, value: u8) -> &mut Self {
+        self.p2 = value;
+        self
+    }
+
     /// Set both parameters for this APDU
-    #[cfg(feature = "untested")]
     pub fn params(&mut self, p1: u8, p2: u8) -> &mut Self {
         self.p1 = p1;
         self.p2 = p2;
@@ -110,11 +114,31 @@ impl APDU {
         self
     }
 
-    /// Transmit this APDU using the given card transaction
+    /// Transmit this APDU using the given card transaction.
-    pub fn transmit(&self, txn: &Transaction<'_>, recv_len: usize) -> Result<Response, Error> {
+    ///
+    /// Handles ISO 7816-4 `SW1=61` (bytes remaining) responses by issuing
+    /// [`Ins::GetResponseApdu`] commands until all response data is collected.
+    pub fn transmit(&self, txn: &Transaction<'_>, recv_len: usize) -> Result<Response> {
         trace!(">>> {:?}", self);
-        let response = Response::from(txn.transmit(&self.to_bytes(), recv_len)?);
+        let mut response = Response::from(txn.transmit(&self.to_bytes(), recv_len)?);
         trace!("<<< {:?}", &response);
+
+        if let StatusWords::BytesRemaining { .. } = response.status_words() {
+            let mut data = response.data().to_vec();
+            let mut sw = response.status_words();
+
+            while let StatusWords::BytesRemaining { .. } = sw {
+                let next = Response::from(
+                    txn.transmit(&Apdu::new(Ins::GetResponseApdu).to_bytes(), recv_len)?,
+                );
+                trace!("<<< {:?}", &next);
+                data.extend_from_slice(next.data());
+                sw = next.status_words();
+            }
+
+            response = Response::new(sw, data);
+        }
+
         Ok(response)
     }
 
@@ -131,13 +155,13 @@ impl APDU {
     }
 }
 
-impl Drop for APDU {
+impl Drop for Apdu {
     fn drop(&mut self) {
         self.zeroize();
     }
 }
 
-impl Zeroize for APDU {
+impl Zeroize for Apdu {
     fn zeroize(&mut self) {
         // Only `data` may contain secrets
         self.data.zeroize();
@@ -197,6 +221,18 @@ pub enum Ins {
     /// Get device serial
     GetSerial,
 
+    /// Get slot metadata
+    GetMetadata,
+
+    /// Management // Read Config
+    ReadConfig,
+
+    /// Management // Write Config
+    WriteConfig,
+
+    /// Management // DeviceReset
+    DeviceReset,
+
     /// Other/unrecognized instruction codes
     Other(u8),
 }
@@ -221,6 +257,13 @@ impl Ins {
             Ins::SetPinRetries => 0xfa,
             Ins::Attest => 0xf9,
             Ins::GetSerial => 0xf8,
+            Ins::GetMetadata => 0xf7,
+
+            // Management
+            Ins::ReadConfig => 0x1d,
+            Ins::WriteConfig => 0x1c,
+            Ins::DeviceReset => 0x1f,
+
             Ins::Other(code) => code,
         }
     }
@@ -229,6 +272,11 @@ impl Ins {
 impl From<u8> for Ins {
     fn from(code: u8) -> Self {
         match code {
+            // Management
+            0x1d => Ins::ReadConfig,
+            0x1c => Ins::WriteConfig,
+            0x1f => Ins::DeviceReset,
+
             0x20 => Ins::Verify,
             0x24 => Ins::ChangeReference,
             0x2c => Ins::ResetRetry,
@@ -245,6 +293,7 @@ impl From<u8> for Ins {
             0xfa => Ins::SetPinRetries,
             0xf9 => Ins::Attest,
             0xf8 => Ins::GetSerial,
+            0xf7 => Ins::GetMetadata,
             code => Ins::Other(code),
         }
     }
@@ -268,7 +317,6 @@ pub(crate) struct Response {
 
 impl Response {
     /// Create a new response from the given status words and buffer
-    #[cfg(feature = "untested")]
     pub fn new(status_words: StatusWords, data: Vec<u8>) -> Response {
         Response { status_words, data }
     }
@@ -279,7 +327,6 @@ impl Response {
     }
 
     /// Get the raw [`StatusWords`] code for this response.
-    #[cfg(feature = "untested")]
     pub fn code(&self) -> u16 {
         self.status_words.code()
     }
@@ -317,7 +364,7 @@ impl From<Vec<u8>> for Response {
         }
 
         let sw = StatusWords::from(
-            (bytes[bytes.len() - 2] as u16) << 8 | (bytes[bytes.len() - 1] as u16),
+            ((bytes[bytes.len() - 2] as u16) << 8) | (bytes[bytes.len() - 1] as u16),
         );
 
         let len = bytes.len() - 2;
@@ -352,6 +399,12 @@ pub(crate) enum StatusWords {
     /// Successful execution
     Success,
 
+    /// The requested data was too large for the response, and there is data remaining.
+    BytesRemaining {
+        /// The number of bytes remaining, as indicated in the response.
+        len: u8,
+    },
+
     /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L53
     NoInputDataError,
 
@@ -388,6 +441,9 @@ pub(crate) enum StatusWords {
     /// Not enough memory
     NoSpaceError,
 
+    /// Referenced data or reference data not found
+    ReferenceDataNotFoundError,
+
     //
     // Custom Yubico Status Word extensions
     //
@@ -409,8 +465,9 @@ impl StatusWords {
     pub fn code(self) -> u16 {
         match self {
             StatusWords::None => 0,
+            StatusWords::BytesRemaining { len } => 0x6100 | len as u16,
             StatusWords::NoInputDataError => 0x6285,
-            StatusWords::VerifyFailError { tries } => 0x63c0 & tries as u16,
+            StatusWords::VerifyFailError { tries } => 0x63c0 | tries as u16,
             StatusWords::WrongLengthError => 0x6700,
             StatusWords::SecurityStatusError => 0x6982,
             StatusWords::AuthBlockedError => 0x6983,
@@ -420,6 +477,7 @@ impl StatusWords {
             StatusWords::IncorrectParamError => 0x6a80,
             StatusWords::NotFoundError => 0x6a82,
             StatusWords::NoSpaceError => 0x6a84,
+            StatusWords::ReferenceDataNotFoundError => 0x6a88,
             StatusWords::IncorrectSlotError => 0x6b00,
             StatusWords::NotSupportedError => 0x6d00,
             StatusWords::CommandAbortedError => 0x6f00,
@@ -438,6 +496,9 @@ impl From<u16> for StatusWords {
     fn from(sw: u16) -> Self {
         match sw {
             0x0000 => StatusWords::None,
+            sw if sw & 0xff00 == 0x6100 => Self::BytesRemaining {
+                len: (sw & 0x00ff) as u8,
+            },
             0x6285 => StatusWords::NoInputDataError,
             sw if sw & 0xfff0 == 0x63c0 => StatusWords::VerifyFailError {
                 tries: (sw & 0x000f) as u8,
@@ -451,6 +512,7 @@ impl From<u16> for StatusWords {
             0x6a80 => StatusWords::IncorrectParamError,
             0x6a82 => StatusWords::NotFoundError,
             0x6a84 => StatusWords::NoSpaceError,
+            0x6a88 => StatusWords::ReferenceDataNotFoundError,
             0x6b00 => StatusWords::IncorrectSlotError,
             0x6d00 => StatusWords::NotSupportedError,
             0x6f00 => StatusWords::CommandAbortedError,
@@ -465,3 +527,40 @@ impl From<StatusWords> for u16 {
         sw.code()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::StatusWords;
+
+    #[test]
+    fn status_words_round_trip() {
+        let round_trip = |sw: StatusWords| {
+            assert_eq!(StatusWords::from(sw.code()), sw);
+        };
+
+        round_trip(StatusWords::None);
+        round_trip(StatusWords::BytesRemaining { len: 1 });
+        round_trip(StatusWords::BytesRemaining { len: 10 });
+        round_trip(StatusWords::BytesRemaining { len: 0xFF });
+        round_trip(StatusWords::Success);
+        round_trip(StatusWords::NoInputDataError);
+        round_trip(StatusWords::VerifyFailError { tries: 0x0F });
+        round_trip(StatusWords::VerifyFailError { tries: 3 });
+        round_trip(StatusWords::VerifyFailError { tries: 2 });
+        round_trip(StatusWords::VerifyFailError { tries: 1 });
+        round_trip(StatusWords::VerifyFailError { tries: 0 });
+        round_trip(StatusWords::WrongLengthError);
+        round_trip(StatusWords::SecurityStatusError);
+        round_trip(StatusWords::AuthBlockedError);
+        round_trip(StatusWords::DataInvalidError);
+        round_trip(StatusWords::ConditionsNotSatisfiedError);
+        round_trip(StatusWords::CommandNotAllowedError);
+        round_trip(StatusWords::IncorrectParamError);
+        round_trip(StatusWords::NotFoundError);
+        round_trip(StatusWords::NoSpaceError);
+        round_trip(StatusWords::IncorrectSlotError);
+        round_trip(StatusWords::NotSupportedError);
+        round_trip(StatusWords::CommandAbortedError);
+        round_trip(StatusWords::Other(0x1337));
+    }
+}

src/cccid.rs

@@ -30,8 +30,16 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use crate::{consts::*, error::Error, yubikey::YubiKey};
+use crate::{Result, YubiKey};
-use getrandom::getrandom;
+use cipher::common::Generate;
+use rand_core::CryptoRng;
+use std::fmt::{self, Debug, Display};
+
+/// CCCID offset
+const CCC_ID_OFFS: usize = 9;
+
+/// CCC Object ID
+const OBJ_CAPABILITY: u32 = 0x005f_c107;
 
 /// Cardholder Capability Container (CCC) Template
 ///
@@ -41,6 +49,7 @@ use getrandom::getrandom;
 ///  - 0xff == Manufacturer ID (dummy)
 ///  - 0x02 == Card type (javaCard)
 ///  - next 14 bytes: card ID
+#[allow(dead_code)]
 const CCC_TMPL: &[u8] = &[
     0xf0, 0x15, 0xa0, 0x00, 0x00, 0x01, 0x16, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x01, 0x21, 0xf2, 0x01, 0x21, 0xf3, 0x00, 0xf4,
@@ -48,38 +57,66 @@ const CCC_TMPL: &[u8] = &[
     0x00, 0xfe, 0x00,
 ];
 
-/// Cardholder Capability Container (CCC) Identifier
+/// Cardholder Capability Container (CCC) Identifier Card ID.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
+pub struct CardId(pub [u8; Self::BYTE_SIZE]);
+
+impl CardId {
+    /// CCCID size in bytes
+    pub const BYTE_SIZE: usize = 14;
+
+    /// Generate a random CCC Card ID
+    pub fn generate() -> Self {
+        Self(Generate::generate())
+    }
+
+    /// Generate a random CCC Card ID from an [`Rng`]
+    pub fn generate_from_rng<R: CryptoRng + ?Sized>(rng: &mut R) -> Self {
+        Self(Generate::generate_from_rng(rng))
+    }
+}
+
+/// Cardholder Capability Container (CCC) Identifier.
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct CCCID(pub [u8; YKPIV_CCCID_SIZE]);
+pub struct CccId(pub [u8; Self::BYTE_SIZE]);
 
-impl CCCID {
+impl CccId {
-    /// Generate a random CCCID
+    /// CCC size in bytes
-    pub fn generate() -> Result<Self, Error> {
+    pub const BYTE_SIZE: usize = 51;
-        let mut id = [0u8; YKPIV_CCCID_SIZE];
+
-        getrandom(&mut id).map_err(|_| Error::RandomnessError)?;
+    /// Return CardId component of CCC
-        Ok(CCCID(id))
+    pub fn card_id(&self) -> Result<CardId> {
+        let mut cccid = [0u8; CardId::BYTE_SIZE];
+        cccid.copy_from_slice(&self.0[CCC_ID_OFFS..(CCC_ID_OFFS + CardId::BYTE_SIZE)]);
+        Ok(CardId(cccid))
     }
 
     /// Get Cardholder Capability Container (CCC) ID
-    pub fn get(yubikey: &mut YubiKey) -> Result<Self, Error> {
+    pub fn get(yubikey: &mut YubiKey) -> Result<Self> {
         let txn = yubikey.begin_transaction()?;
-        let response = txn.fetch_object(YKPIV_OBJ_CAPABILITY)?;
+        let response = txn.fetch_object(OBJ_CAPABILITY)?;
-
+        Ok(response[..Self::BYTE_SIZE].try_into().map(Self)?)
-        if response.len() != CCC_TMPL.len() {
-            return Err(Error::GenericError);
     }
 
-        let mut cccid = [0u8; YKPIV_CCCID_SIZE];
+    /// Set Cardholder Capability Container (CCC) ID
-        cccid.copy_from_slice(&response[CCC_ID_OFFS..(CCC_ID_OFFS + YKPIV_CCCID_SIZE)]);
+    #[cfg(feature = "untested")]
-        Ok(CCCID(cccid))
+    pub fn set(&self, yubikey: &mut YubiKey) -> Result<()> {
-    }
-
-    /// Get Cardholder Capability Container (CCC) ID
-    pub fn set(&self, yubikey: &mut YubiKey) -> Result<(), Error> {
         let mut buf = CCC_TMPL.to_vec();
-        buf[CCC_ID_OFFS..(CCC_ID_OFFS + self.0.len())].copy_from_slice(&self.0);
+        buf[0..self.0.len()].copy_from_slice(&self.0);
 
         let txn = yubikey.begin_transaction()?;
-        txn.save_object(YKPIV_OBJ_CAPABILITY, &buf)
+        txn.save_object(OBJ_CAPABILITY, &buf)
+    }
+}
+
+impl AsRef<[u8]> for CccId {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl Display for CccId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&hex::upper::encode_string(self.as_ref()))
     }
 }

src/certificate.rs

@@ -1,4 +1,4 @@
-//! YubiKey Certificates
+//! X.509 certificate support.
 
 // Adapted from yubico-piv-tool:
 // <https://github.com/Yubico/yubico-piv-tool/>
@@ -31,132 +31,56 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 use crate::{
-    consts::*,
+    consts::CB_OBJ_MAX,
-    error::Error,
+    error::{Error, Result},
-    key::{AlgorithmId, SlotId},
+    piv::SlotId,
     serialization::*,
     transaction::Transaction,
     yubikey::YubiKey,
     Buffer,
 };
-use ecdsa::{
-    curve::{CompressedCurvePoint, NistP256, NistP384, UncompressedCurvePoint},
-    generic_array::GenericArray,
-};
 use log::error;
-use rsa::{PublicKey, RSAPublicKey};
+use x509_cert::{
-use std::fmt;
+    builder::{profile::BuilderProfile, Builder, CertificateBuilder},
-use x509_parser::{parse_x509_der, x509::SubjectPublicKeyInfo};
+    der::{referenced::OwnedToRef, Decode, Encode},
+    name::Name,
+    serial_number::SerialNumber,
+    spki::{SubjectPublicKeyInfoOwned, SubjectPublicKeyInfoRef},
+    time::Validity,
+};
 use zeroize::Zeroizing;
 
-// TODO: Make these der_parser::oid::Oid constants when it has const fn support.
+const TAG_CERT: u8 = 0x70;
-const OID_RSA_ENCRYPTION: &str = "1.2.840.113549.1.1.1";
+const TAG_CERT_COMPRESS: u8 = 0x71;
-const OID_EC_PUBLIC_KEY: &str = "1.2.840.10045.2.1";
+const TAG_CERT_LRC: u8 = 0xFE;
-const OID_NIST_P256: &str = "1.2.840.10045.3.1.7";
-const OID_NIST_P384: &str = "1.3.132.0.34";
 
-/// An encoded point on the Nist P-256 curve.
+/// Information about how a [`Certificate`] is stored within a YubiKey.
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum EcP256Point {
+pub enum CertInfo {
-    /// Compressed encoding of a point on the curve.
+    /// The certificate is uncompressed.
-    Compressed(CompressedCurvePoint<NistP256>),
+    Uncompressed,
 
-    /// Uncompressed encoding of a point on the curve.
+    /// The certificate is gzip-compressed.
-    Uncompressed(UncompressedCurvePoint<NistP256>),
+    Gzip,
 }
 
-/// An encoded point on the Nist P-384 curve.
+impl TryFrom<u8> for CertInfo {
-#[derive(Clone, Eq, PartialEq)]
+    type Error = Error;
-pub enum EcP384Point {
-    /// Compressed encoding of a point on the curve.
-    Compressed(CompressedCurvePoint<NistP384>),
 
-    /// Uncompressed encoding of a point on the curve.
+    fn try_from(value: u8) -> Result<Self> {
-    Uncompressed(UncompressedCurvePoint<NistP384>),
+        match value {
-}
+            0x00 => Ok(CertInfo::Uncompressed),
-
+            0x01 => Ok(CertInfo::Gzip),
-/// Information about a public key within a [`Certificate`].
-#[derive(Clone, Eq, PartialEq)]
-pub enum PublicKeyInfo {
-    /// RSA keys
-    Rsa {
-        /// RSA algorithm
-        algorithm: AlgorithmId,
-
-        /// Public key
-        pubkey: RSAPublicKey,
-    },
-
-    /// EC P-256 keys
-    EcP256(EcP256Point),
-
-    /// EC P-384 keys
-    EcP384(EcP384Point),
-}
-
-impl fmt::Debug for PublicKeyInfo {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "PublicKeyInfo({:?})", self.algorithm())
-    }
-}
-
-impl PublicKeyInfo {
-    fn parse(subject_pki: &SubjectPublicKeyInfo<'_>) -> Result<Self, Error> {
-        match subject_pki.algorithm.algorithm.to_string().as_str() {
-            OID_RSA_ENCRYPTION => {
-                let pubkey = read_pki::rsa_pubkey(subject_pki.subject_public_key.data)?;
-
-                Ok(PublicKeyInfo::Rsa {
-                    algorithm: match pubkey.n().bits() {
-                        1024 => AlgorithmId::Rsa1024,
-                        2048 => AlgorithmId::Rsa2048,
-                        _ => return Err(Error::AlgorithmError),
-                    },
-                    pubkey,
-                })
-            }
-            OID_EC_PUBLIC_KEY => {
-                let key_bytes = &subject_pki.subject_public_key.data;
-                match read_pki::ec_parameters(&subject_pki.algorithm.parameters)? {
-                    AlgorithmId::EccP256 => match key_bytes.len() {
-                        33 => CompressedCurvePoint::<NistP256>::from_bytes(
-                            GenericArray::clone_from_slice(key_bytes),
-                        )
-                        .map(EcP256Point::Compressed),
-                        65 => UncompressedCurvePoint::<NistP256>::from_bytes(
-                            GenericArray::clone_from_slice(key_bytes),
-                        )
-                        .map(EcP256Point::Uncompressed),
-                        _ => None,
-                    }
-                    .map(PublicKeyInfo::EcP256)
-                    .ok_or(Error::InvalidObject),
-                    AlgorithmId::EccP384 => match key_bytes.len() {
-                        49 => CompressedCurvePoint::<NistP384>::from_bytes(
-                            GenericArray::clone_from_slice(key_bytes),
-                        )
-                        .map(EcP384Point::Compressed),
-                        97 => UncompressedCurvePoint::<NistP384>::from_bytes(
-                            GenericArray::clone_from_slice(key_bytes),
-                        )
-                        .map(EcP384Point::Uncompressed),
-                        _ => None,
-                    }
-                    .map(PublicKeyInfo::EcP384)
-                    .ok_or(Error::InvalidObject),
-                    _ => Err(Error::AlgorithmError),
-                }
-            }
             _ => Err(Error::InvalidObject),
         }
     }
+}
 
-    /// Returns the algorithm that this public key can be used with.
+impl From<CertInfo> for u8 {
-    pub fn algorithm(&self) -> AlgorithmId {
+    fn from(certinfo: CertInfo) -> u8 {
-        match self {
+        match certinfo {
-            PublicKeyInfo::Rsa { algorithm, .. } => *algorithm,
+            CertInfo::Uncompressed => 0x00,
-            PublicKeyInfo::EcP256(_) => AlgorithmId::EccP256,
+            CertInfo::Gzip => 0x01,
-            PublicKeyInfo::EcP384(_) => AlgorithmId::EccP384,
         }
     }
 }
@@ -164,14 +88,46 @@ impl PublicKeyInfo {
 /// Certificates
 #[derive(Clone, Debug)]
 pub struct Certificate {
-    subject: String,
+    /// Inner certificate
-    subject_pki: PublicKeyInfo,
+    pub cert: x509_cert::Certificate,
-    data: Buffer,
 }
 
 impl Certificate {
+    /// Creates a new self-signed certificate for the given key. Writes the resulting
+    /// certificate to the slot before returning it.
+    ///
+    /// `extensions` is a required argument; users who do not have any extensions
+    /// should set the `extensions` argument to `|_| Ok(())`.
+    pub fn generate_self_signed<F, KT: yubikey_signer::KeyType>(
+        yubikey: &mut YubiKey,
+        key: SlotId,
+        serial: SerialNumber,
+        validity: Validity,
+        subject: Name,
+        subject_pki: SubjectPublicKeyInfoOwned,
+        extensions: F,
+    ) -> Result<Self>
+    where
+        F: FnOnce(&mut CertificateBuilder<SelfSigned>) -> der::Result<()>,
+    {
+        let signer =
+            yubikey_signer::Signer::<'_, KT>::new(yubikey, key, subject_pki.owned_to_ref())?;
+        let mut builder =
+            CertificateBuilder::new(SelfSigned { subject }, serial, validity, subject_pki)
+                .map_err(|_| Error::KeyError)?;
+
+        // Add custom extensions
+        extensions(&mut builder)?;
+
+        let cert = builder.build(&signer).map_err(|_| Error::KeyError)?;
+        let cert = Self { cert };
+        cert.write(yubikey, key, CertInfo::Uncompressed)?;
+
+        Ok(cert)
+    }
+
     /// Read a certificate from the given slot in the YubiKey
-    pub fn read(yubikey: &mut YubiKey, slot: SlotId) -> Result<Self, Error> {
+    pub fn read(yubikey: &mut YubiKey, slot: SlotId) -> Result<Self> {
         let txn = yubikey.begin_transaction()?;
         let buf = read_certificate(&txn, slot)?;
 
@@ -179,25 +135,25 @@ impl Certificate {
             return Err(Error::InvalidObject);
         }
 
-        Certificate::new(buf)
+        Self::from_bytes(buf)
     }
 
     /// Write this certificate into the YubiKey in the given slot
-    pub fn write(&self, yubikey: &mut YubiKey, slot: SlotId, certinfo: u8) -> Result<(), Error> {
+    pub fn write(&self, yubikey: &mut YubiKey, slot: SlotId, certinfo: CertInfo) -> Result<()> {
-        let max_size = yubikey.obj_size_max();
         let txn = yubikey.begin_transaction()?;
-        write_certificate(&txn, slot, Some(&self.data), certinfo, max_size)
+        let data = self.cert.to_der().map_err(|_| Error::InvalidObject)?;
+        write_certificate(&txn, slot, Some(&data), certinfo)
     }
 
     /// Delete a certificate located at the given slot of the given YubiKey
-    pub fn delete(yubikey: &mut YubiKey, slot: SlotId) -> Result<(), Error> {
+    #[cfg(feature = "untested")]
-        let max_size = yubikey.obj_size_max();
+    pub fn delete(yubikey: &mut YubiKey, slot: SlotId) -> Result<()> {
         let txn = yubikey.begin_transaction()?;
-        write_certificate(&txn, slot, None, 0, max_size)
+        write_certificate(&txn, slot, None, CertInfo::Uncompressed)
     }
 
     /// Initialize a local certificate struct from the given bytebuffer
-    pub fn new(cert: impl Into<Buffer>) -> Result<Self, Error> {
+    pub fn from_bytes(cert: impl Into<Buffer>) -> Result<Self> {
         let cert = cert.into();
 
         if cert.is_empty() {
@@ -205,49 +161,67 @@ impl Certificate {
             return Err(Error::SizeError);
         }
 
-        let parsed_cert = match parse_x509_der(&cert) {
+        x509_cert::Certificate::from_der(&cert)
-            Ok((_, cert)) => cert,
+            .map(|cert| Self { cert })
-            _ => return Err(Error::InvalidObject),
+            .map_err(|_| Error::InvalidObject)
-        };
+    }
 
-        let subject = format!("{}", parsed_cert.tbs_certificate.subject);
+    /// Returns the Issuer field of the certificate.
-        let subject_pki = PublicKeyInfo::parse(&parsed_cert.tbs_certificate.subject_pki)?;
+    pub fn issuer(&self) -> String {
-
+        self.cert.tbs_certificate().issuer().to_string()
-        Ok(Certificate {
-            subject,
-            subject_pki,
-            data: cert,
-        })
     }
 
     /// Returns the SubjectName field of the certificate.
-    pub fn subject(&self) -> &str {
+    pub fn subject(&self) -> String {
-        &self.subject
+        self.cert.tbs_certificate().subject().to_string()
     }
 
     /// Returns the SubjectPublicKeyInfo field of the certificate.
-    pub fn subject_pki(&self) -> &PublicKeyInfo {
+    pub fn subject_pki(&self) -> SubjectPublicKeyInfoRef<'_> {
-        &self.subject_pki
+        self.cert
-    }
+            .tbs_certificate()
-
+            .subject_public_key_info()
-    /// Extract the inner buffer
+            .owned_to_ref()
-    pub fn into_buffer(self) -> Buffer {
-        self.data
     }
 }
 
-impl AsRef<[u8]> for Certificate {
+/// A [`BuilderProfile`] for self-signed certificates.
-    fn as_ref(&self) -> &[u8] {
+///
-        self.data.as_ref()
+/// This profile has no default extensions.
+pub struct SelfSigned {
+    subject: Name,
+}
+
+impl BuilderProfile for SelfSigned {
+    fn get_issuer(&self, subject: &Name) -> Name {
+        // RFC 5280 Section 3.2:
+        //
+        // > Self-issued certificates are CA certificates in which the issuer and subject
+        // > are the same entity. [..] Self-signed certificates are self-issued
+        // > certificates where the digital signature may be verified by the public key
+        // > bound into the certificate.
+        subject.clone()
+    }
+
+    fn get_subject(&self) -> Name {
+        self.subject.clone()
+    }
+
+    fn build_extensions(
+        &self,
+        _spk: SubjectPublicKeyInfoRef<'_>,
+        _issuer_spk: SubjectPublicKeyInfoRef<'_>,
+        _tbs: &x509_cert::TbsCertificate,
+    ) -> x509_cert::builder::Result<Vec<x509_cert::ext::Extension>> {
+        Ok(vec![])
     }
 }
 
 /// Read certificate
-pub(crate) fn read_certificate(txn: &Transaction<'_>, slot: SlotId) -> Result<Buffer, Error> {
+pub(crate) fn read_certificate(txn: &Transaction<'_>, slot: SlotId) -> Result<Buffer> {
-    let mut len: usize = 0;
     let object_id = slot.object_id();
 
-    let mut buf = match txn.fetch_object(object_id) {
+    let buf = match txn.fetch_object(object_id) {
         Ok(b) => b,
         Err(_) => {
             // TODO(tarcieri): is this really ok?
@@ -255,148 +229,320 @@ pub(crate) fn read_certificate(txn: &Transaction<'_>, slot: SlotId) -> Result<Bu
         }
     };
 
-    if buf.len() < CB_OBJ_TAG_MIN {
+    // TODO(str4d): Check the rest of the buffer (TAG_CERT_COMPRESS and TAG_CERT_LRC)
-        // TODO(tarcieri): is this really ok?
-        return Ok(Zeroizing::new(vec![]));
-    }
-
     if buf[0] == TAG_CERT {
-        let offset = 1 + get_length(&buf[1..], &mut len);
+        Tlv::parse_single(buf, TAG_CERT).or_else(|_| {
-
-        if len > buf.len() - offset {
             // TODO(tarcieri): is this really ok?
-            return Ok(Zeroizing::new(vec![]));
+            Ok(Zeroizing::new(vec![]))
-        }
+        })
-
+    } else {
-        buf.copy_within(offset..offset + len, 0);
-        buf.truncate(len);
-    }
-
         Ok(buf)
     }
+}
 
 /// Write certificate
 pub(crate) fn write_certificate(
     txn: &Transaction<'_>,
     slot: SlotId,
     data: Option<&[u8]>,
-    certinfo: u8,
+    certinfo: CertInfo,
-    max_size: usize,
+) -> Result<()> {
-) -> Result<(), Error> {
-    let mut buf = [0u8; CB_OBJ_MAX];
-    let mut offset = 0;
-
     let object_id = slot.object_id();
 
-    if data.is_none() {
+    if let Some(data) = data {
-        return txn.save_object(object_id, &[]);
+        let mut buf = [0u8; CB_OBJ_MAX];
-    }
+        let mut offset = Tlv::write(&mut buf, TAG_CERT, data)?;
-
-    let data = data.unwrap();
-
-    let mut req_len = 1 /* cert tag */ + 3 /* compression tag + data*/ + 2 /* lrc */;
-    req_len += set_length(&mut buf, data.len());
-    req_len += data.len();
-
-    if req_len < data.len() || req_len > max_size {
-        return Err(Error::SizeError);
-    }
-
-    buf[offset] = TAG_CERT;
-    offset += 1;
-    offset += set_length(&mut buf[offset..], data.len());
-
-    buf[offset..(offset + data.len())].copy_from_slice(&data);
-
-    offset += data.len();
 
         // write compression info and LRC trailer
-    buf[offset] = TAG_CERT_COMPRESS;
+        offset += Tlv::write(&mut buf[offset..], TAG_CERT_COMPRESS, &[certinfo.into()])?;
-    buf[offset + 1] = 0x01;
+        offset += Tlv::write(&mut buf[offset..], TAG_CERT_LRC, &[])?;
-    buf[offset + 2] = if certinfo == YKPIV_CERTINFO_GZIP {
-        0x01
-    } else {
-        0x00
-    };
-    buf[offset + 3] = TAG_CERT_LRC;
-    buf[offset + 4] = 00;
-
-    offset += 5;
 
         txn.save_object(object_id, &buf[..offset])
+    } else {
+        txn.save_object(object_id, &[])
+    }
 }
 
-mod read_pki {
+pub mod yubikey_signer {
-    use der_parser::{
+    //! Signer implementation for yubikey
-        ber::BerObjectContent,
+
-        der::{parse_der_integer, DerObject},
+    use crate::{
-        error::BerError,
+        error::{Error, Result},
-        *,
+        piv::AlgorithmId,
+        piv::{sign_data, SlotId},
+        YubiKey,
     };
-    use nom::{combinator, IResult};
+    use der::{
-    use rsa::{BigUint, RSAPublicKey};
+        asn1::{Any, OctetString},
-
+        oid::db::rfc5912,
-    use super::{OID_NIST_P256, OID_NIST_P384};
+        Encode, Sequence,
-    use crate::{error::Error, key::AlgorithmId};
-
-    /// From [RFC 8017](https://tools.ietf.org/html/rfc8017#appendix-A.1.1):
-    /// ```text
-    /// RSAPublicKey ::= SEQUENCE {
-    ///     modulus           INTEGER,  -- n
-    ///     publicExponent    INTEGER   -- e
-    /// }
-    /// ```
-    pub(super) fn rsa_pubkey(encoded: &[u8]) -> Result<RSAPublicKey, Error> {
-        fn parse_rsa_pubkey(i: &[u8]) -> IResult<&[u8], DerObject<'_>, BerError> {
-            parse_der_sequence_defined!(i, parse_der_integer >> parse_der_integer)
-        }
-
-        fn rsa_pubkey_parts(i: &[u8]) -> IResult<&[u8], (BigUint, BigUint), BerError> {
-            combinator::map(parse_rsa_pubkey, |object| {
-                let seq = object.as_sequence().expect("is DER sequence");
-                assert_eq!(seq.len(), 2);
-
-                let n = match seq[0].content {
-                    BerObjectContent::Integer(s) => BigUint::from_bytes_be(s),
-                    _ => panic!("expected DER integer"),
     };
-                let e = match seq[1].content {
+    use sha2::{Digest, Sha256, Sha384, Sha512};
-                    BerObjectContent::Integer(s) => BigUint::from_bytes_be(s),
+    use signature::Keypair;
-                    _ => panic!("expected DER integer"),
+    use std::{cell::RefCell, fmt, io::Write, marker::PhantomData};
+    use x509_cert::spki::{
+        self, AlgorithmIdentifierOwned, DynSignatureAlgorithmIdentifier, EncodePublicKey,
+        SignatureBitStringEncoding, SubjectPublicKeyInfoRef,
     };
 
-                (n, e)
+    type SigResult<T> = core::result::Result<T, signature::Error>;
-            })(i)
+
+    /// Key to be used to sign certificates
+    pub trait KeyType {
+        /// Error returned when working with signature
+        type Error: Into<signature::Error> + fmt::Debug;
+        /// The signature type returned by the signer
+        type Signature: SignatureBitStringEncoding
+            + for<'s> TryFrom<&'s [u8], Error = Self::Error>
+            + fmt::Debug;
+        /// The public key used to verify signature
+        type VerifyingKey: EncodePublicKey
+            + DynSignatureAlgorithmIdentifier
+            + Clone
+            + From<Self::PublicKey>;
+        /// Public key type used to load the SPKI formatted key
+        type PublicKey: for<'a> TryFrom<SubjectPublicKeyInfoRef<'a>, Error = spki::Error>;
+
+        /// The algorithm used when talking with the yubikey
+        const ALGORITHM: AlgorithmId;
+
+        /// Prepare buffer before submitting it for signature
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>>;
+
+        /// Prepare a prehashed message before submitting it for signature
+        fn prepare_prehash(hashed: &[u8]) -> SigResult<Vec<u8>>;
+
+        /// Read back the signature from the device
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature>;
     }
 
-        let (n, e) = match rsa_pubkey_parts(encoded) {
+    impl KeyType for ed25519_dalek::SigningKey {
-            Ok((_, res)) => res,
+        const ALGORITHM: AlgorithmId = AlgorithmId::Ed25519;
-            _ => return Err(Error::InvalidObject),
+        type Error = ed25519_dalek::SignatureError;
+        type Signature = ed25519_dalek::Signature;
+        type VerifyingKey = ed25519_dalek::VerifyingKey;
+        type PublicKey = ed25519_dalek::VerifyingKey;
+
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>> {
+            Ok(Sha512::digest(input).to_vec())
+        }
+
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature> {
+            Self::Signature::try_from(input)
+        }
+    }
+
+    impl KeyType for p256::NistP256 {
+        const ALGORITHM: AlgorithmId = AlgorithmId::EccP256;
+        type Error = ecdsa::Error;
+        type Signature = p256::ecdsa::DerSignature;
+        type VerifyingKey = p256::ecdsa::VerifyingKey;
+        type PublicKey = p256::ecdsa::VerifyingKey;
+
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>> {
+            Ok(Sha256::digest(input).to_vec())
+        }
+
+        fn prepare_prehash(hashed: &[u8]) -> SigResult<Vec<u8>> {
+            Ok(hashed.to_vec())
+        }
+
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature> {
+            Self::Signature::from_bytes(input)
+        }
+    }
+
+    impl KeyType for p384::NistP384 {
+        const ALGORITHM: AlgorithmId = AlgorithmId::EccP384;
+        type Error = ecdsa::Error;
+        type Signature = p384::ecdsa::DerSignature;
+        type VerifyingKey = p384::ecdsa::VerifyingKey;
+        type PublicKey = p384::ecdsa::VerifyingKey;
+
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>> {
+            Ok(Sha384::digest(input).to_vec())
+        }
+
+        fn prepare_prehash(hashed: &[u8]) -> SigResult<Vec<u8>> {
+            Ok(hashed.to_vec())
+        }
+
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature> {
+            Self::Signature::from_bytes(input)
+        }
+    }
+
+    /// Trait used to handle subtypes of RSA keys
+    pub trait RsaLength {
+        /// The length of the RSA key in bits
+        const BIT_LENGTH: usize;
+        /// The algorithm to use when talking with the Yubikey.
+        const ALGORITHM: AlgorithmId;
+    }
+
+    /// RSA 1024 bits key
+    pub struct Rsa1024;
+
+    impl RsaLength for Rsa1024 {
+        const BIT_LENGTH: usize = 1024;
+        const ALGORITHM: AlgorithmId = AlgorithmId::Rsa1024;
+    }
+
+    /// RSA 2048 bits key
+    pub struct Rsa2048;
+
+    impl RsaLength for Rsa2048 {
+        const BIT_LENGTH: usize = 2048;
+        const ALGORITHM: AlgorithmId = AlgorithmId::Rsa2048;
+    }
+
+    /// RSA 3072 bits key
+    pub struct Rsa3072;
+
+    impl RsaLength for Rsa3072 {
+        const BIT_LENGTH: usize = 3072;
+        const ALGORITHM: AlgorithmId = AlgorithmId::Rsa3072;
+    }
+
+    /// RSA 4096 bits key
+    pub struct Rsa4096;
+
+    impl RsaLength for Rsa4096 {
+        const BIT_LENGTH: usize = 4096;
+        const ALGORITHM: AlgorithmId = AlgorithmId::Rsa4096;
+    }
+
+    /// RSA keys used to sign certificates
+    pub struct YubiRsa<N: RsaLength> {
+        _len: PhantomData<N>,
+    }
+
+    impl<N: RsaLength> KeyType for YubiRsa<N> {
+        type Error = signature::Error;
+        type Signature = rsa::pkcs1v15::Signature;
+        type VerifyingKey = rsa::pkcs1v15::VerifyingKey<Sha256>;
+        type PublicKey = rsa::RsaPublicKey;
+        const ALGORITHM: AlgorithmId = N::ALGORITHM;
+
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>> {
+            let hashed = Sha256::digest(input).to_vec();
+            Self::prepare_prehash(&hashed)
+        }
+
+        fn prepare_prehash(hashed: &[u8]) -> SigResult<Vec<u8>> {
+            OctetString::new(hashed)
+                .map_err(|e| e.into())
+                .and_then(Self::emsa_pkcs1_1_5)
+                .map_err(signature::Error::from_source)
+        }
+
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature> {
+            Self::Signature::try_from(input)
+        }
+    }
+
+    impl<N: RsaLength> YubiRsa<N> {
+        /// https://www.rfc-editor.org/rfc/rfc8017#section-9.2
+        fn emsa_pkcs1_1_5(digest: OctetString) -> Result<Vec<u8>> {
+            /// https://www.rfc-editor.org/rfc/rfc8017#appendix-A.2.4
+            #[derive(Debug, Sequence)]
+            struct DigestInfo {
+                digest_algorithm: AlgorithmIdentifierOwned,
+                digest: OctetString,
+            }
+
+            let em_len = N::BIT_LENGTH / 8;
+
+            let null = Any::null();
+
+            let t = DigestInfo {
+                digest_algorithm: AlgorithmIdentifierOwned {
+                    oid: rfc5912::ID_SHA_256,
+                    parameters: Some(null),
+                },
+                digest,
             };
+            let t = t.to_der()?;
 
-        RSAPublicKey::new(n, e).map_err(|_| Error::InvalidObject)
+            let ps = vec![0xff; em_len - t.len() - 3];
+            assert!(ps.len() >= 8, "spec violation");
+
+            let mut out = Vec::with_capacity(em_len);
+            out.write(&[0x00, 0x01]).map_err(|_| Error::MemoryError)?;
+            out.write(&ps).map_err(|_| Error::MemoryError)?;
+            out.write(&[0x00]).map_err(|_| Error::MemoryError)?;
+            out.write(&t).map_err(|_| Error::MemoryError)?;
+            Ok(out)
+        }
     }
 
-    /// From [RFC 5480](https://tools.ietf.org/html/rfc5480#section-2.1.1):
+    /// The entrypoint to sign data with the yubikey.
-    /// ```text
+    pub struct Signer<'y, KT: KeyType> {
-    /// ECParameters ::= CHOICE {
+        yubikey: RefCell<&'y mut YubiKey>,
-    ///   namedCurve         OBJECT IDENTIFIER
+        key: SlotId,
-    ///   -- implicitCurve   NULL
+        public_key: KT::VerifyingKey,
-    ///   -- specifiedCurve  SpecifiedECDomain
-    /// }
-    /// ```
-    pub(super) fn ec_parameters(parameters: &DerObject<'_>) -> Result<AlgorithmId, Error> {
-        let curve_oid = match parameters.as_context_specific() {
-            Ok((_, Some(named_curve))) => {
-                named_curve.as_oid_val().map_err(|_| Error::InvalidObject)
     }
-            _ => Err(Error::InvalidObject),
-        }?;
 
-        match curve_oid.to_string().as_str() {
+    impl<'y, KT: KeyType> Signer<'y, KT> {
-            OID_NIST_P256 => Ok(AlgorithmId::EccP256),
+        /// Create new Signer
-            OID_NIST_P384 => Ok(AlgorithmId::EccP384),
+        pub fn new(
-            _ => Err(Error::AlgorithmError),
+            yubikey: &'y mut YubiKey,
+            key: SlotId,
+            subject_pki: SubjectPublicKeyInfoRef<'_>,
+        ) -> Result<Self> {
+            let public_key = KT::PublicKey::try_from(subject_pki).map_err(|_| Error::ParseError)?;
+            let public_key = public_key.into();
+
+            Ok(Self {
+                yubikey: RefCell::new(yubikey),
+                key,
+                public_key,
+            })
+        }
+    }
+
+    impl<KT: KeyType> Keypair for Signer<'_, KT> {
+        type VerifyingKey = KT::VerifyingKey;
+        fn verifying_key(&self) -> <Self as Keypair>::VerifyingKey {
+            self.public_key.clone()
+        }
+    }
+
+    impl<KT: KeyType> DynSignatureAlgorithmIdentifier for Signer<'_, KT> {
+        fn signature_algorithm_identifier(&self) -> spki::Result<AlgorithmIdentifierOwned> {
+            self.verifying_key().signature_algorithm_identifier()
+        }
+    }
+
+    impl<KT: KeyType> signature::Signer<KT::Signature> for Signer<'_, KT> {
+        fn try_sign(&self, msg: &[u8]) -> SigResult<KT::Signature> {
+            let data = KT::prepare(msg)?;
+
+            let out = sign_data(
+                &mut self.yubikey.borrow_mut(),
+                &data,
+                KT::ALGORITHM,
+                self.key,
+            )
+            .map_err(signature::Error::from_source)?;
+            let out = KT::read_signature(&out)?;
+            Ok(out)
+        }
+    }
+
+    impl<KT: KeyType> signature::hazmat::PrehashSigner<KT::Signature> for Signer<'_, KT> {
+        fn sign_prehash(&self, hashed: &[u8]) -> SigResult<KT::Signature> {
+            let data = KT::prepare_prehash(hashed)?;
+
+            let out = sign_data(
+                &mut self.yubikey.borrow_mut(),
+                &data,
+                KT::ALGORITHM,
+                self.key,
+            )
+            .map_err(signature::Error::from_source)?;
+            let out = KT::read_signature(&out)?;
+            Ok(out)
         }
     }
 }

src/chuid.rs

@@ -30,8 +30,21 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use crate::{consts::*, error::Error, yubikey::YubiKey};
+use crate::{Result, YubiKey};
-use getrandom::getrandom;
+use std::fmt::{self, Debug, Display};
+use uuid::Uuid;
+
+/// FASC-N offset
+const CHUID_FASCN_OFFS: usize = 2;
+
+/// GUID offset
+const CHUID_GUID_OFFS: usize = 29;
+
+/// Expiration offset
+const CHUID_EXPIRATION_OFFS: usize = 47;
+
+/// CHUID Object ID
+const OBJ_CHUID: u32 = 0x005f_c102;
 
 /// Cardholder Unique Identifier (CHUID) Template
 ///
@@ -48,6 +61,7 @@ use getrandom::getrandom;
 /// - 0x35: Exp. Date (hard-coded)
 /// - 0x3e: Signature (hard-coded, empty)
 /// - 0xfe: Error Detection Code (hard-coded)
+#[allow(dead_code)]
 const CHUID_TMPL: &[u8] = &[
     0x30, 0x19, 0xd4, 0xe7, 0x39, 0xda, 0x73, 0x9c, 0xed, 0x39, 0xce, 0x73, 0x9d, 0x83, 0x68, 0x58,
     0x21, 0x08, 0x42, 0x10, 0x84, 0x21, 0xc8, 0x42, 0x10, 0xc3, 0xeb, 0x34, 0x10, 0x00, 0x00, 0x00,
@@ -55,66 +69,67 @@ const CHUID_TMPL: &[u8] = &[
     0x30, 0x33, 0x30, 0x30, 0x31, 0x30, 0x31, 0x3e, 0x00, 0xfe, 0x00,
 ];
 
-/// Cardholder Unique Identifier (CHUID) Card UUID/GUID value
+/// Cardholder Unique Identifier (CHUID).
 #[derive(Copy, Clone, Debug)]
-pub struct ChuidUuid(pub [u8; YKPIV_CARDID_SIZE]);
+pub struct ChuId(pub [u8; Self::BYTE_SIZE]);
 
-/// Cardholder Unique Identifier (CHUID)
+impl ChuId {
-#[derive(Copy, Clone)]
+    /// CHUID size in bytes
-pub struct CHUID(pub [u8; YKPIV_CHUID_SIZE]);
+    pub const BYTE_SIZE: usize = 59;
+
+    /// FASC-N component size
+    pub const FASCN_SIZE: usize = 25;
+
+    /// Expiration size
+    pub const EXPIRATION_SIZE: usize = 8;
 
-impl CHUID {
     /// Return FASC-N component of CHUID
-    pub fn fascn(&self) -> Result<[u8; YKPIV_FASCN_SIZE], Error> {
+    pub fn fascn(&self) -> [u8; Self::FASCN_SIZE] {
-        let mut fascn = [0u8; YKPIV_FASCN_SIZE];
+        self.0[CHUID_FASCN_OFFS..(CHUID_FASCN_OFFS + Self::FASCN_SIZE)]
-        fascn.copy_from_slice(&self.0[CHUID_FASCN_OFFS..(CHUID_FASCN_OFFS + YKPIV_FASCN_SIZE)]);
+            .try_into()
-        Ok(fascn)
+            .expect("should be FASCN_SIZE")
     }
 
     /// Return Card UUID/GUID component of CHUID
-    pub fn uuid(&self) -> Result<[u8; YKPIV_CARDID_SIZE], Error> {
+    pub fn uuid(&self) -> Uuid {
-        let mut uuid = [0u8; YKPIV_CARDID_SIZE];
+        Uuid::from_slice(&self.0[CHUID_GUID_OFFS..(CHUID_GUID_OFFS + 16)])
-        uuid.copy_from_slice(&self.0[CHUID_GUID_OFFS..(CHUID_GUID_OFFS + YKPIV_CARDID_SIZE)]);
+            .expect("should be UUID-sized")
-        Ok(uuid)
     }
 
     /// Return expiration date component of CHUID
-    pub fn expiration(&self) -> Result<[u8; YKPIV_EXPIRATION_SIZE], Error> {
+    // TODO(tarcieri): parse expiration?
-        let mut expiration = [0u8; YKPIV_EXPIRATION_SIZE];
+    pub fn expiration(&self) -> [u8; Self::EXPIRATION_SIZE] {
-        expiration.copy_from_slice(
+        self.0[CHUID_EXPIRATION_OFFS..(CHUID_EXPIRATION_OFFS + Self::EXPIRATION_SIZE)]
-            &self.0[CHUID_EXPIRATION_OFFS..(CHUID_EXPIRATION_OFFS + YKPIV_EXPIRATION_SIZE)],
+            .try_into()
-        );
+            .expect("should be EXPIRATION_SIZE")
-        Ok(expiration)
-    }
-
-    /// Generate a random Cardholder Unique Identifier (CHUID)
-    pub fn generate() -> Result<ChuidUuid, Error> {
-        let mut id = [0u8; YKPIV_CARDID_SIZE];
-        getrandom(&mut id).map_err(|_| Error::RandomnessError)?;
-        Ok(ChuidUuid(id))
     }
 
     /// Get Cardholder Unique Identifier (CHUID)
-    pub fn get(yubikey: &mut YubiKey) -> Result<CHUID, Error> {
+    pub fn get(yubikey: &mut YubiKey) -> Result<ChuId> {
         let txn = yubikey.begin_transaction()?;
-        let response = txn.fetch_object(YKPIV_OBJ_CHUID)?;
+        let response = txn.fetch_object(OBJ_CHUID)?;
-
+        Ok(response[..Self::BYTE_SIZE].try_into().map(Self)?)
-        if response.len() != CHUID_TMPL.len() {
-            return Err(Error::GenericError);
-        }
-
-        let mut chuid = [0u8; YKPIV_CHUID_SIZE];
-        chuid.copy_from_slice(&response[0..YKPIV_CHUID_SIZE]);
-        let retval = CHUID { 0: chuid };
-        Ok(retval)
     }
 
     /// Set Cardholder Unique Identifier (CHUID)
-    pub fn set(&self, yubikey: &mut YubiKey) -> Result<(), Error> {
+    #[cfg(feature = "untested")]
+    pub fn set(&self, yubikey: &mut YubiKey) -> Result<()> {
         let mut buf = CHUID_TMPL.to_vec();
-        buf[0..self.0.len()].copy_from_slice(&self.0);
+        buf[..Self::BYTE_SIZE].copy_from_slice(&self.0);
 
         let txn = yubikey.begin_transaction()?;
-        txn.save_object(YKPIV_OBJ_CHUID, &buf)
+        txn.save_object(OBJ_CHUID, &buf)
+    }
+}
+
+impl AsRef<[u8]> for ChuId {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl Display for ChuId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&hex::upper::encode_string(self.as_ref()))
     }
 }

src/config.rs

@@ -30,44 +30,61 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use crate::{consts::*, error::Error, metadata, mgm::MgmType, yubikey::YubiKey};
+use crate::{
+    consts::{
+        TAG_ADMIN_FLAGS_1, TAG_ADMIN_SALT, TAG_ADMIN_TIMESTAMP, TAG_PROTECTED_FLAGS_1,
+        TAG_PROTECTED_MGM,
+    },
+    metadata::{AdminData, ProtectedData},
+    mgm::{MgmType, ADMIN_FLAGS_1_PROTECTED_MGM},
+    yubikey::{YubiKey, ADMIN_FLAGS_1_PUK_BLOCKED},
+    Result,
+};
 use log::error;
-use std::convert::TryInto;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-/// Config
+const CB_ADMIN_TIMESTAMP: usize = 0x04;
-#[derive(Copy, Clone)]
+const PROTECTED_FLAGS_1_PUK_NOBLOCK: u8 = 0x01;
+
+/// YubiKey configuration.
+#[derive(Copy, Clone, Debug)]
 pub struct Config {
     /// Protected data available
-    protected_data_available: bool,
+    pub protected_data_available: bool,
 
     /// PUK blocked
-    puk_blocked: bool,
+    pub puk_blocked: bool,
 
     /// No block on upgrade
-    puk_noblock_on_upgrade: bool,
+    pub puk_noblock_on_upgrade: bool,
 
     /// PIN last changed
-    pin_last_changed: u32,
+    pub pin_last_changed: Option<SystemTime>,
 
     /// MGM type
-    mgm_type: MgmType,
+    pub mgm_type: MgmType,
 }
 
-impl Config {
+impl Default for Config {
-    /// Get YubiKey config
+    fn default() -> Config {
-    pub fn get(yubikey: &mut YubiKey) -> Result<Config, Error> {
+        Config {
-        let mut config = Config {
             protected_data_available: false,
             puk_blocked: false,
             puk_noblock_on_upgrade: false,
-            pin_last_changed: 0,
+            pin_last_changed: None,
             mgm_type: MgmType::Manual,
-        };
+        }
+    }
+}
 
+impl Config {
+    /// Get YubiKey config.
+    pub(crate) fn get(yubikey: &mut YubiKey) -> Result<Config> {
+        let mut config = Self::default();
         let txn = yubikey.begin_transaction()?;
 
-        if let Ok(data) = metadata::read(&txn, TAG_ADMIN) {
+        if let Ok(admin_data) = AdminData::read(&txn) {
-            if let Ok(item) = metadata::get_item(&data, TAG_ADMIN_FLAGS_1) {
+            if let Ok(item) = admin_data.get_item(TAG_ADMIN_FLAGS_1) {
                 if item.is_empty() {
                     error!("empty response for admin flags metadata item! ignoring");
                 } else {
@@ -81,7 +98,7 @@ impl Config {
                 }
             }
 
-            if metadata::get_item(&data, TAG_ADMIN_SALT).is_ok() {
+            if admin_data.get_item(TAG_ADMIN_SALT).is_ok() {
                 if config.mgm_type != MgmType::Manual {
                     error!("conflicting types of MGM key administration configured");
                 } else {
@@ -89,20 +106,25 @@ impl Config {
                 }
             }
 
-            if let Ok(item) = metadata::get_item(&data, TAG_ADMIN_TIMESTAMP) {
+            if let Ok(item) = admin_data.get_item(TAG_ADMIN_TIMESTAMP) {
                 if item.len() != CB_ADMIN_TIMESTAMP {
                     error!("pin timestamp in admin metadata is an invalid size");
                 } else {
-                    // TODO(tarcieri): double check this is little endian
+                    // TODO(tarcieri): double-check endianness is correct
-                    config.pin_last_changed = u32::from_le_bytes(item.try_into().unwrap());
+                    let pin_last_changed = u32::from_le_bytes([item[0], item[1], item[2], item[3]]);
+
+                    if pin_last_changed != 0 {
+                        config.pin_last_changed =
+                            Some(UNIX_EPOCH + Duration::from_secs(pin_last_changed as u64));
+                    }
                 }
             }
         }
 
-        if let Ok(data) = metadata::read(&txn, TAG_PROTECTED) {
+        if let Ok(protected_data) = ProtectedData::read(&txn) {
             config.protected_data_available = true;
 
-            if let Ok(item) = metadata::get_item(&data, TAG_PROTECTED_FLAGS_1) {
+            if let Ok(item) = protected_data.get_item(TAG_PROTECTED_FLAGS_1) {
                 if item.is_empty() {
                     error!("empty response for protected flags metadata item! ignoring");
                 } else if item[0] & PROTECTED_FLAGS_1_PUK_NOBLOCK != 0 {
@@ -110,11 +132,9 @@ impl Config {
                 }
             }
 
-            if metadata::get_item(&data, TAG_PROTECTED_MGM).is_ok() {
+            if protected_data.get_item(TAG_PROTECTED_MGM).is_ok() {
                 if config.mgm_type != MgmType::Protected {
-                    error!(
+                    error!("conflicting MGM key types: protected MGM exists");
-                        "conflicting types of mgm key administration configured: protected MGM exists"
-                    );
                 }
 
                 // Always favor protected MGM

src/consts.rs

@@ -1,172 +1,37 @@
-//! Constant values
+//! Miscellaneous constant values
-// TODO(tarcieri): refactor these into enums!
 
-// Adapted from yubico-piv-tool:
+#![allow(dead_code)]
-// <https://github.com/Yubico/yubico-piv-tool/>
-//
-// Copyright (c) 2014-2016 Yubico AB
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//   * Redistributions of source code must retain the above copyright
-//     notice, this list of conditions and the following disclaimer.
-//
-//   * Redistributions in binary form must reproduce the above
-//     copyright notice, this list of conditions and the following
-//     disclaimer in the documentation and/or other materials provided
-//     with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// TODO(tarcieri): document these!
+/// YubiKey max buffer size
-#![allow(missing_docs, non_upper_case_globals)]
+pub(crate) const CB_BUF_MAX: usize = 3072;
 
-pub const szLOG_SOURCE: &str = "yubikey-piv.rs";
+/// YubiKey max object size
+pub(crate) const CB_OBJ_MAX: usize = CB_BUF_MAX - 9;
 
-pub const ADMIN_FLAGS_1_PUK_BLOCKED: u8 = 0x01;
+pub(crate) const CB_OBJ_TAG_MIN: usize = 2; // 1 byte tag + 1 byte len
-pub const ADMIN_FLAGS_1_PROTECTED_MGM: u8 = 0x02;
+pub(crate) const CB_OBJ_TAG_MAX: usize = CB_OBJ_TAG_MIN + 2; // 1 byte tag + 3 bytes len
 
-pub const CB_ADMIN_TIMESTAMP: usize = 0x04;
+// Admin tags
-pub const CB_ADMIN_SALT: usize = 16;
+pub(crate) const TAG_ADMIN_FLAGS_1: u8 = 0x81;
+pub(crate) const TAG_ADMIN_SALT: u8 = 0x82;
+pub(crate) const TAG_ADMIN_TIMESTAMP: u8 = 0x83;
 
-pub const CB_ATR_MAX: usize = 33;
+// Protected tags
+pub(crate) const TAG_PROTECTED_FLAGS_1: u8 = 0x81;
+pub(crate) const TAG_PROTECTED_MGM: u8 = 0x89;
 
-pub const CB_BUF_MAX_NEO: usize = 2048;
+// Management
-pub const CB_BUF_MAX_YK4: usize = 3072;
+pub(crate) const TAG_USB_SUPPORTED: u8 = 0x01;
-pub const CB_BUF_MAX: usize = CB_BUF_MAX_YK4;
+pub(crate) const TAG_SERIAL: u8 = 0x02;
-
+pub(crate) const TAG_USB_ENABLED: u8 = 0x03;
-pub const CB_ECC_POINTP256: usize = 65;
+pub(crate) const TAG_FORM_FACTOR: u8 = 0x04;
-pub const CB_ECC_POINTP384: usize = 97;
+pub(crate) const TAG_VERSION: u8 = 0x05;
-
+pub(crate) const TAG_AUTO_EJECT_TIMEOUT: u8 = 0x06;
-pub const CB_OBJ_MAX_YK4: usize = CB_BUF_MAX_YK4 - 9;
+pub(crate) const TAG_CHALRESP_TIMEOUT: u8 = 0x07;
-pub const CB_OBJ_MAX: usize = CB_OBJ_MAX_YK4;
+pub(crate) const TAG_DEVICE_FLAGS: u8 = 0x08;
-pub const CB_OBJ_MAX_NEO: usize = CB_BUF_MAX_NEO - 9;
+pub(crate) const TAG_APP_VERSIONS: u8 = 0x09;
-
+pub(crate) const TAG_CONFIG_LOCK: u8 = 0x0A;
-pub const CB_OBJ_TAG_MIN: usize = 2; // 1 byte tag + 1 byte len
+pub(crate) const TAG_UNLOCK: u8 = 0x0B;
-pub const CB_OBJ_TAG_MAX: usize = (CB_OBJ_TAG_MIN + 2); // 1 byte tag + 3 bytes len
+pub(crate) const TAG_REBOOT: u8 = 0x0C;
-
+pub(crate) const TAG_NFC_SUPPORTED: u8 = 0x0D;
-pub const CB_PAGE: usize = 4096;
+pub(crate) const TAG_NFC_ENABLED: u8 = 0x0E;
-pub const CB_PIN_MAX: usize = 8;
-
-pub const CCC_ID_OFFS: usize = 9;
-
-pub const CHUID_FASCN_OFFS: usize = 2;
-pub const CHUID_GUID_OFFS: usize = 29;
-pub const CHUID_EXPIRATION_OFFS: usize = 47;
-
-pub const CHREF_ACT_CHANGE_PIN: i32 = 0;
-pub const CHREF_ACT_UNBLOCK_PIN: i32 = 1;
-pub const CHREF_ACT_CHANGE_PUK: i32 = 2;
-
-pub const CONTAINER_NAME_LEN: usize = 40;
-pub const CONTAINER_REC_LEN: usize = (2 * CONTAINER_NAME_LEN) + 27; // 80 + 1 + 1 + 2 + 1 + 1 + 1 + 20
-
-pub const DES_TYPE_3DES: u8 = 1;
-
-pub const DES_LEN_DES: usize = 8;
-pub const DES_LEN_3DES: usize = DES_LEN_DES * 3;
-
-// device types
-
-pub const DEVTYPE_UNKNOWN: u32 = 0x0000_0000;
-pub const DEVTYPE_NEO: u32 = 0x4E45_0000; //"NE"
-pub const DEVTYPE_YK: u32 = 0x594B_0000; //"YK"
-pub const DEVTYPE_NEOr3: u32 = (DEVTYPE_NEO | 0x0000_7233); //"r3"
-pub const DEVTYPE_YK4: u32 = (DEVTYPE_YK | 0x0000_0034); // "4"
-pub const DEVYTPE_YK5: u32 = (DEVTYPE_YK | 0x0000_0035); // "5"
-
-pub const ITER_MGM_PBKDF2: usize = 10000;
-
-pub const PROTECTED_FLAGS_1_PUK_NOBLOCK: u8 = 0x01;
-
-// sw is status words, see NIST special publication 800-73-4, section 5.6
-
-pub const SW_SUCCESS: i32 = 0x9000;
-pub const SW_ERR_SECURITY_STATUS: i32 = 0x6982;
-pub const SW_ERR_AUTH_BLOCKED: i32 = 0x6983;
-pub const SW_ERR_INCORRECT_PARAM: i32 = 0x6a80;
-
-// this is a custom sw for yubikey
-
-pub const SW_ERR_INCORRECT_SLOT: i32 = 0x6b00;
-pub const SW_ERR_NOT_SUPPORTED: i32 = 0x6d00;
-
-pub const TAG_CERT: u8 = 0x70;
-pub const TAG_CERT_COMPRESS: u8 = 0x71;
-pub const TAG_CERT_LRC: u8 = 0xFE;
-pub const TAG_ADMIN: u8 = 0x80;
-pub const TAG_ADMIN_FLAGS_1: u8 = 0x81;
-pub const TAG_ADMIN_SALT: u8 = 0x82;
-pub const TAG_ADMIN_TIMESTAMP: u8 = 0x83;
-pub const TAG_PROTECTED: u8 = 0x88;
-pub const TAG_PROTECTED_FLAGS_1: u8 = 0x81;
-pub const TAG_PROTECTED_MGM: u8 = 0x89;
-pub const TAG_MSCMAP: u8 = 0x81;
-pub const TAG_MSROOTS_END: u8 = 0x82;
-pub const TAG_MSROOTS_MID: u8 = 0x83;
-
-pub const TAG_RSA_MODULUS: u8 = 0x81;
-pub const TAG_RSA_EXP: u8 = 0x82;
-pub const TAG_ECC_POINT: u8 = 0x86;
-
-pub const YKPIV_ALGO_TAG: u8 = 0x80;
-pub const YKPIV_ALGO_3DES: u8 = 0x03;
-
-pub const YKPIV_ATR_NEO_R3: &[u8] = b";\xFC\x13\0\0\x811\xFE\x15YubikeyNEOr3\xE1\0";
-
-pub const YKPIV_CHUID_SIZE: usize = 59;
-pub const YKPIV_CARDID_SIZE: usize = 16;
-pub const YKPIV_FASCN_SIZE: usize = 25;
-pub const YKPIV_EXPIRATION_SIZE: usize = 8;
-
-pub const YKPIV_CCCID_SIZE: usize = 14;
-
-pub const YKPIV_CERTINFO_UNCOMPRESSED: u8 = 0;
-pub const YKPIV_CERTINFO_GZIP: u8 = 1;
-
-pub const YKPIV_KEY_CARDMGM: u8 = 0x9b;
-
-pub const YKPIV_OBJ_CAPABILITY: u32 = 0x005f_c107;
-pub const YKPIV_OBJ_CHUID: u32 = 0x005f_c102;
-pub const YKPIV_OBJ_FINGERPRINTS: u32 = 0x005f_c103;
-pub const YKPIV_OBJ_SECURITY: u32 = 0x005f_c106;
-pub const YKPIV_OBJ_FACIAL: u32 = 0x005f_c108;
-pub const YKPIV_OBJ_PRINTED: u32 = 0x005f_c109;
-pub const YKPIV_OBJ_DISCOVERY: u32 = 0x7e;
-pub const YKPIV_OBJ_KEY_HISTORY: u32 = 0x005f_c10c;
-pub const YKPIV_OBJ_IRIS: u32 = 0x005f_c121;
-
-// Internal object IDs
-
-pub const YKPIV_OBJ_ADMIN_DATA: u32 = 0x005f_ff00;
-pub const YKPIV_OBJ_MSCMAP: u32 = 0x005f_ff10;
-pub const YKPIV_OBJ_MSROOTS1: u32 = 0x005f_ff11;
-pub const YKPIV_OBJ_MSROOTS2: u32 = 0x005f_ff12;
-pub const YKPIV_OBJ_MSROOTS3: u32 = 0x005f_ff13;
-pub const YKPIV_OBJ_MSROOTS4: u32 = 0x005f_ff14;
-pub const YKPIV_OBJ_MSROOTS5: u32 = 0x005f_ff15;
-
-pub const YKPIV_PINPOLICY_TAG: u8 = 0xaa;
-pub const YKPIV_PINPOLICY_DEFAULT: u8 = 0;
-pub const YKPIV_PINPOLICY_NEVER: u8 = 1;
-pub const YKPIV_PINPOLICY_ONCE: u8 = 2;
-pub const YKPIV_PINPOLICY_ALWAYS: u8 = 3;
-
-pub const YKPIV_TOUCHPOLICY_TAG: u8 = 0xab;
-pub const YKPIV_TOUCHPOLICY_DEFAULT: u8 = 0;
-pub const YKPIV_TOUCHPOLICY_NEVER: u8 = 1;
-pub const YKPIV_TOUCHPOLICY_ALWAYS: u8 = 2;
-pub const YKPIV_TOUCHPOLICY_CACHED: u8 = 3;

src/container.rs

@@ -1,227 +0,0 @@
-//! MS Container Map Records
-//!
-//! These appear(?) to be defined in Microsoft's Smart Card Minidriver Specification:
-//! <https://docs.microsoft.com/en-us/previous-versions/windows/hardware/design/dn631754(v=vs.85)>
-
-// Adapted from yubico-piv-tool:
-// <https://github.com/Yubico/yubico-piv-tool/>
-//
-// Copyright (c) 2014-2016 Yubico AB
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//   * Redistributions of source code must retain the above copyright
-//     notice, this list of conditions and the following disclaimer.
-//
-//   * Redistributions in binary form must reproduce the above
-//     copyright notice, this list of conditions and the following
-//     disclaimer in the documentation and/or other materials provided
-//     with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-use crate::{consts::*, error::Error, key::SlotId, serialization::*, yubikey::YubiKey};
-use log::error;
-use std::{
-    convert::{TryFrom, TryInto},
-    fmt::{self, Debug},
-};
-
-/// MS Container Map(?) Records
-#[derive(Copy, Clone)]
-pub struct Container {
-    /// Container name
-    pub name: [u16; CONTAINER_NAME_LEN],
-
-    /// Card slot
-    pub slot: SlotId,
-
-    /// Key spec
-    pub key_spec: u8,
-
-    /// Key size in bits
-    pub key_size_bits: u16,
-
-    /// Flags
-    pub flags: u8,
-
-    /// PIN ID
-    pub pin_id: u8,
-
-    /// Associated ECHD(?) container (typo of "ecdh" perhaps?)
-    pub associated_echd_container: u8,
-
-    /// Cert fingerprint
-    pub cert_fingerprint: [u8; 20],
-}
-
-impl Container {
-    /// Read MS Container Map records
-    pub fn read_mscmap(yubikey: &mut YubiKey) -> Result<Vec<Self>, Error> {
-        let txn = yubikey.begin_transaction()?;
-        let response = txn.fetch_object(YKPIV_OBJ_MSCMAP)?;
-        let mut containers = vec![];
-
-        if response.len() < CB_OBJ_TAG_MIN {
-            // TODO(tarcieri): is this really OK?
-            return Ok(containers);
-        }
-
-        if response[0] != TAG_MSCMAP {
-            // TODO(tarcieri): yubico-piv-tool returned success here? should we?
-            return Err(Error::InvalidObject);
-        }
-
-        let mut len = 0;
-        let offset = 1 + get_length(&response[1..], &mut len);
-
-        if len > response.len() - offset {
-            // TODO(tarcieri): is this really OK?
-            return Ok(containers);
-        }
-
-        for chunk in response[offset..(offset + len)].chunks_exact(CONTAINER_REC_LEN) {
-            containers.push(Container::new(chunk)?);
-        }
-
-        Ok(containers)
-    }
-
-    /// Write MS Container Map records.
-    pub fn write_mscmap(yubikey: &mut YubiKey, containers: &[Self]) -> Result<(), Error> {
-        let mut buf = [0u8; CB_OBJ_MAX];
-        let mut offset = 0;
-        let n_containers = containers.len();
-        let data_len = n_containers * CONTAINER_REC_LEN;
-
-        let max_size = yubikey.obj_size_max();
-        let txn = yubikey.begin_transaction()?;
-
-        if n_containers == 0 {
-            return txn.save_object(YKPIV_OBJ_MSCMAP, &[]);
-        }
-
-        let req_len = 1 + set_length(&mut buf, data_len) + data_len;
-
-        if req_len > max_size {
-            return Err(Error::SizeError);
-        }
-
-        buf[offset] = TAG_MSCMAP;
-        offset += 1;
-        offset += set_length(&mut buf[offset..], data_len);
-
-        for (i, chunk) in buf[..data_len]
-            .chunks_exact_mut(CONTAINER_REC_LEN)
-            .enumerate()
-        {
-            chunk.copy_from_slice(&containers[i].to_bytes());
-        }
-
-        offset += data_len;
-        txn.save_object(YKPIV_OBJ_MSCMAP, &buf[..offset])
-    }
-
-    /// Parse a container record from a byte slice
-    pub fn new(bytes: &[u8]) -> Result<Self, Error> {
-        if bytes.len() != CONTAINER_REC_LEN {
-            error!(
-                "couldn't parse PIV container: expected {}-bytes, got {}-bytes",
-                CONTAINER_REC_LEN,
-                bytes.len()
-            );
-            return Err(Error::ParseError);
-        }
-
-        let mut name = [0u16; CONTAINER_NAME_LEN];
-        let name_bytes_len = CONTAINER_NAME_LEN * 2;
-
-        for (i, chunk) in bytes[..name_bytes_len].chunks_exact(2).enumerate() {
-            name[i] = u16::from_le_bytes(chunk.try_into().unwrap());
-        }
-
-        let mut cert_fingerprint = [0u8; 20];
-        cert_fingerprint.copy_from_slice(&bytes[(bytes.len() - 20)..]);
-
-        Ok(Container {
-            name,
-            slot: bytes[name_bytes_len].try_into()?,
-            key_spec: bytes[name_bytes_len + 1],
-            key_size_bits: u16::from_le_bytes(
-                bytes[(name_bytes_len + 2)..(name_bytes_len + 4)]
-                    .try_into()
-                    .unwrap(),
-            ),
-            flags: bytes[name_bytes_len + 4],
-            pin_id: bytes[name_bytes_len + 5],
-            associated_echd_container: bytes[name_bytes_len + 6],
-            cert_fingerprint,
-        })
-    }
-
-    /// Parse the container name as a UTF-16 string
-    pub fn parse_name(&self) -> Result<String, Error> {
-        String::from_utf16(&self.name).map_err(|_| Error::ParseError)
-    }
-
-    /// Serialize a container record as a byte size
-    pub fn to_bytes(&self) -> [u8; CONTAINER_REC_LEN] {
-        let mut bytes = Vec::with_capacity(CONTAINER_REC_LEN);
-
-        for i in 0..CONTAINER_NAME_LEN {
-            bytes.extend_from_slice(&self.name[i].to_le_bytes());
-        }
-
-        bytes.push(self.slot.into());
-        bytes.push(self.key_spec);
-        bytes.extend_from_slice(&self.key_size_bits.to_le_bytes());
-        bytes.push(self.flags);
-        bytes.push(self.pin_id);
-        bytes.push(self.associated_echd_container);
-        bytes.extend_from_slice(&self.cert_fingerprint);
-
-        // TODO(tarcieri): use TryInto here when const generics are available
-        let mut result = [0u8; CONTAINER_REC_LEN];
-        result.copy_from_slice(&bytes);
-        result
-    }
-}
-
-impl Debug for Container {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "PivContainer {{ name: {:?}, slot: {:?}, key_spec: {}, key_size_bits: {}, \
-             flags: {}, pin_id: {}, associated_echd_container: {}, cert_fingerprint: {:?} }}",
-            &self.name[..],
-            self.slot,
-            self.key_spec,
-            self.key_size_bits,
-            self.flags,
-            self.pin_id,
-            self.associated_echd_container,
-            &self.cert_fingerprint[..]
-        )
-    }
-}
-
-impl<'a> TryFrom<&'a [u8]> for Container {
-    type Error = Error;
-
-    fn try_from(bytes: &'a [u8]) -> Result<Self, Error> {
-        Self::new(bytes)
-    }
-}

src/error.rs

@@ -32,62 +32,75 @@
 
 use std::fmt::{self, Display};
 
-/// Kinds of errors
+/// Result type with [`Error`].
+pub type Result<T> = core::result::Result<T, Error>;
+
+/// Kinds of errors.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[non_exhaustive]
 pub enum Error {
+    /// Algorithm error
+    AlgorithmError,
+
+    /// Applet error
+    AppletError,
+
+    /// We tried to select an applet that could not be found.
+    AppletNotFound {
+        /// Human-readable name of the applet.
+        applet_name: &'static str,
+    },
+
+    /// Argument error
+    ArgumentError,
+
+    /// Authentication error
+    AuthenticationError,
+
+    /// Error while building a certificate
+    CertificateBuilder,
+
+    /// Generic error
+    GenericError,
+
+    /// Invalid object
+    InvalidObject,
+
+    /// Key error
+    KeyError,
+
     /// Memory error
     MemoryError,
 
+    /// Not supported
+    NotSupported,
+
+    /// Not found
+    NotFound,
+
+    /// Parse error
+    ParseError,
+
     /// PCSC error
     PcscError {
         /// Original PC/SC error
         inner: Option<pcsc::Error>,
     },
 
+    /// PIN locked
+    PinLocked,
+
+    /// Range error
+    RangeError,
+
     /// Size error
     SizeError,
 
-    /// Applet error
-    AppletError,
-
-    /// Authentication error
-    AuthenticationError,
-
-    /// Randomness error
-    RandomnessError,
-
-    /// Generic error
-    GenericError,
-
-    /// Key error
-    KeyError,
-
-    /// Parse error
-    ParseError,
-
     /// Wrong PIN
     WrongPin {
         /// Number of tries remaining
         tries: u8,
     },
-
-    /// Invalid object
-    InvalidObject,
-
-    /// Algorithm error
-    AlgorithmError,
-
-    /// PIN locked
-    PinLocked,
-
-    /// Argument error
-    ArgumentError,
-
-    /// Range error
-    RangeError,
-
-    /// Not supported
-    NotSupported,
 }
 
 impl Error {
@@ -95,53 +108,75 @@ impl Error {
     ///
     /// These names map to the legacy names from the Yubico C library, to
     /// assist in web searches for relevant information for these errors.
-    pub fn name(self) -> &'static str {
+    pub fn name(self) -> Option<&'static str> {
-        match self {
+        Some(match self {
-            Error::MemoryError => "YKPIV_MEMORY_ERROR",
-            Error::PcscError { .. } => "YKPIV_PCSC_ERROR",
-            Error::SizeError => "YKPIV_SIZE_ERROR",
-            Error::AppletError => "YKPIV_APPLET_ERROR",
-            Error::AuthenticationError => "YKPIV_AUTHENTICATION_ERROR",
-            Error::RandomnessError => "YKPIV_RANDOMNESS_ERROR",
-            Error::GenericError => "YKPIV_GENERIC_ERROR",
-            Error::KeyError => "YKPIV_KEY_ERROR",
-            Error::ParseError => "YKPIV_PARSE_ERROR",
-            Error::WrongPin { .. } => "YKPIV_WRONG_PIN",
-            Error::InvalidObject => "YKPIV_INVALID_OBJECT",
             Error::AlgorithmError => "YKPIV_ALGORITHM_ERROR",
-            Error::PinLocked => "YKPIV_PIN_LOCKED",
+            Error::AppletError => "YKPIV_APPLET_ERROR",
             Error::ArgumentError => "YKPIV_ARGUMENT_ERROR",
-            Error::RangeError => "YKPIV_RANGE_ERROR",
+            Error::AuthenticationError => "YKPIV_AUTHENTICATION_ERROR",
+            Error::GenericError => "YKPIV_GENERIC_ERROR",
+            Error::InvalidObject => "YKPIV_INVALID_OBJECT",
+            Error::KeyError => "YKPIV_KEY_ERROR",
+            Error::MemoryError => "YKPIV_MEMORY_ERROR",
             Error::NotSupported => "YKPIV_NOT_SUPPORTED",
-        }
+            Error::ParseError => "YKPIV_PARSE_ERROR",
+            Error::PcscError { .. } => "YKPIV_PCSC_ERROR",
+            Error::PinLocked => "YKPIV_PIN_LOCKED",
+            Error::RangeError => "YKPIV_RANGE_ERROR",
+            Error::SizeError => "YKPIV_SIZE_ERROR",
+            Error::WrongPin { .. } => "YKPIV_WRONG_PIN",
+            _ => return None,
+        })
     }
 
     /// Error message
-    pub fn msg(self) -> &'static str {
+    pub fn msg(self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::MemoryError => "memory error",
+            Error::AlgorithmError => f.write_str("algorithm error"),
-            Error::PcscError { .. } => "PCSC error",
+            Error::AppletError => f.write_str("applet error"),
-            Error::SizeError => "size error",
+            Error::AppletNotFound { applet_name } => {
-            Error::AppletError => "applet error",
+                f.write_str(&format!("{applet_name} applet not found"))
-            Error::AuthenticationError => "authentication error",
+            }
-            Error::RandomnessError => "randomness error",
+            Error::ArgumentError => f.write_str("argument error"),
-            Error::GenericError => "generic error",
+            Error::AuthenticationError => f.write_str("authentication error"),
-            Error::KeyError => "key error",
+            Error::CertificateBuilder => f.write_str("certificate builder error"),
-            Error::ParseError => "parse error",
+            Error::GenericError => f.write_str("generic error"),
-            Error::WrongPin { .. } => "wrong pin",
+            Error::InvalidObject => f.write_str("invalid object"),
-            Error::InvalidObject => "invalid object",
+            Error::KeyError => f.write_str("key error"),
-            Error::AlgorithmError => "algorithm error",
+            Error::MemoryError => f.write_str("memory error"),
-            Error::PinLocked => "PIN locked",
+            Error::NotSupported => f.write_str("not supported"),
-            Error::ArgumentError => "argument error",
+            Error::NotFound => f.write_str("not found"),
-            Error::RangeError => "range error",
+            Error::ParseError => f.write_str("parse error"),
-            Error::NotSupported => "not supported",
+
+            Error::PcscError {
+                inner: Some(pcsc_error),
+            } => f.write_fmt(format_args!("PC/SC error: {pcsc_error}")),
+
+            Error::PcscError { .. } => f.write_str("PC/SC error"),
+
+            Error::PinLocked => f.write_str("PIN locked"),
+            Error::RangeError => f.write_str("range error"),
+            Error::SizeError => f.write_str("size error"),
+            Error::WrongPin { .. } => f.write_str("wrong pin"),
         }
     }
 }
 
 impl Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.msg())
+        self.msg(f)
+    }
+}
+
+impl From<std::array::TryFromSliceError> for Error {
+    fn from(_: std::array::TryFromSliceError) -> Error {
+        Error::SizeError
+    }
+}
+
+impl From<std::time::SystemTimeError> for Error {
+    fn from(_: std::time::SystemTimeError) -> Error {
+        Error::GenericError
     }
 }
 
@@ -154,11 +189,21 @@ impl From<pcsc::Error> for Error {
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
-            #[allow(trivial_casts)] // why doesn't this work without the cast???
+            #[allow(trivial_casts)]
-            Error::PcscError { inner } => inner
+            Error::PcscError { inner } => inner.as_ref().map(|err| err as &_),
-                .as_ref()
-                .map(|err| err as &(dyn std::error::Error + 'static)),
             _ => None,
         }
     }
 }
+
+impl From<der::Error> for Error {
+    fn from(_err: der::Error) -> Error {
+        Error::ParseError
+    }
+}
+
+impl From<x509_cert::builder::Error> for Error {
+    fn from(_err: x509_cert::builder::Error) -> Error {
+        Error::CertificateBuilder
+    }
+}

src/key.rs

@@ -1,581 +0,0 @@
-//! PIV cryptographic keys stored in a YubiKey.
-//!
-//! Supported algorithms:
-//!
-//! - **Encryption**: `RSA1024`, `RSA2048`, `ECCP256`, `ECCP384`
-//! - **Signatures**:
-//!   - RSASSA-PKCS#1v1.5: `RSA1024`, `RSA2048`
-//!   - ECDSA: `ECCP256`, `ECCP384`
-
-// Adapted from yubico-piv-tool:
-// <https://github.com/Yubico/yubico-piv-tool/>
-//
-// Copyright (c) 2014-2016 Yubico AB
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//   * Redistributions of source code must retain the above copyright
-//     notice, this list of conditions and the following disclaimer.
-//
-//   * Redistributions in binary form must reproduce the above
-//     copyright notice, this list of conditions and the following
-//     disclaimer in the documentation and/or other materials provided
-//     with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-use crate::{
-    apdu::{Ins, StatusWords},
-    certificate::{self, Certificate},
-    consts::*,
-    error::Error,
-    serialization::*,
-    settings,
-    yubikey::YubiKey,
-    Buffer, ObjectId,
-};
-use log::{debug, error, warn};
-use std::convert::TryFrom;
-
-/// Slot identifiers.
-/// <https://developers.yubico.com/PIV/Introduction/Certificate_slots.html>
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum SlotId {
-    /// This certificate and its associated private key is used to authenticate the card
-    /// and the cardholder. This slot is used for things like system login. The end user
-    /// PIN is required to perform any private key operations. Once the PIN has been
-    /// provided successfully, multiple private key operations may be performed without
-    /// additional cardholder consent.
-    Authentication,
-
-    /// This certificate and its associated private key is used for digital signatures for
-    /// the purpose of document signing, or signing files and executables. The end user
-    /// PIN is required to perform any private key operations. The PIN must be submitted
-    /// every time immediately before a sign operation, to ensure cardholder participation
-    /// for every digital signature generated.
-    Signature,
-
-    /// This certificate and its associated private key is used for encryption for the
-    /// purpose of confidentiality. This slot is used for things like encrypting e-mails
-    /// or files. The end user PIN is required to perform any private key operations. Once
-    /// the PIN has been provided successfully, multiple private key operations may be
-    /// performed without additional cardholder consent.
-    KeyManagement,
-
-    /// This certificate and its associated private key is used to support additional
-    /// physical access applications, such as providing physical access to buildings via
-    /// PIV-enabled door locks. The end user PIN is NOT required to perform private key
-    /// operations for this slot.
-    CardAuthentication,
-
-    /// These slots are only available on the YubiKey 4 & 5. They are meant for previously
-    /// used Key Management keys to be able to decrypt earlier encrypted documents or
-    /// emails. In the YubiKey 4 & 5 all 20 of them are fully available for use.
-    Retired(RetiredSlotId),
-
-    /// This slot is only available on YubiKey version 4.3 and newer. It is only used for
-    /// attestation of other keys generated on device with instruction `f9`. This slot is
-    /// not cleared on reset, but can be overwritten.
-    Attestation,
-}
-
-impl TryFrom<u8> for SlotId {
-    type Error = Error;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            0x9a => Ok(SlotId::Authentication),
-            0x9c => Ok(SlotId::Signature),
-            0x9d => Ok(SlotId::KeyManagement),
-            0x9e => Ok(SlotId::CardAuthentication),
-            0xf9 => Ok(SlotId::Attestation),
-            _ => RetiredSlotId::try_from(value).map(SlotId::Retired),
-        }
-    }
-}
-
-impl From<SlotId> for u8 {
-    fn from(slot: SlotId) -> u8 {
-        match slot {
-            SlotId::Authentication => 0x9a,
-            SlotId::Signature => 0x9c,
-            SlotId::KeyManagement => 0x9d,
-            SlotId::CardAuthentication => 0x9e,
-            SlotId::Retired(retired) => retired.into(),
-            SlotId::Attestation => 0xf9,
-        }
-    }
-}
-
-impl SlotId {
-    /// Returns the [`ObjectId`] that corresponds to a given [`SlotId`].
-    pub(crate) fn object_id(self) -> ObjectId {
-        match self {
-            SlotId::Authentication => 0x005f_c105,
-            SlotId::Signature => 0x005f_c10a,
-            SlotId::KeyManagement => 0x005f_c10b,
-            SlotId::CardAuthentication => 0x005f_c101,
-            SlotId::Retired(retired) => retired.object_id(),
-            SlotId::Attestation => 0x005f_ff01,
-        }
-    }
-}
-
-/// Retired slot IDs.
-#[allow(missing_docs)]
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum RetiredSlotId {
-    R1,
-    R2,
-    R3,
-    R4,
-    R5,
-    R6,
-    R7,
-    R8,
-    R9,
-    R10,
-    R11,
-    R12,
-    R13,
-    R14,
-    R15,
-    R16,
-    R17,
-    R18,
-    R19,
-    R20,
-}
-
-impl TryFrom<u8> for RetiredSlotId {
-    type Error = Error;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            0x82 => Ok(RetiredSlotId::R1),
-            0x83 => Ok(RetiredSlotId::R2),
-            0x84 => Ok(RetiredSlotId::R3),
-            0x85 => Ok(RetiredSlotId::R4),
-            0x86 => Ok(RetiredSlotId::R5),
-            0x87 => Ok(RetiredSlotId::R6),
-            0x88 => Ok(RetiredSlotId::R7),
-            0x89 => Ok(RetiredSlotId::R8),
-            0x8a => Ok(RetiredSlotId::R9),
-            0x8b => Ok(RetiredSlotId::R10),
-            0x8c => Ok(RetiredSlotId::R11),
-            0x8d => Ok(RetiredSlotId::R12),
-            0x8e => Ok(RetiredSlotId::R13),
-            0x8f => Ok(RetiredSlotId::R14),
-            0x90 => Ok(RetiredSlotId::R15),
-            0x91 => Ok(RetiredSlotId::R16),
-            0x92 => Ok(RetiredSlotId::R17),
-            0x93 => Ok(RetiredSlotId::R18),
-            0x94 => Ok(RetiredSlotId::R19),
-            0x95 => Ok(RetiredSlotId::R20),
-            _ => Err(Error::InvalidObject),
-        }
-    }
-}
-
-impl From<RetiredSlotId> for u8 {
-    fn from(slot: RetiredSlotId) -> u8 {
-        match slot {
-            RetiredSlotId::R1 => 0x82,
-            RetiredSlotId::R2 => 0x83,
-            RetiredSlotId::R3 => 0x84,
-            RetiredSlotId::R4 => 0x85,
-            RetiredSlotId::R5 => 0x86,
-            RetiredSlotId::R6 => 0x87,
-            RetiredSlotId::R7 => 0x88,
-            RetiredSlotId::R8 => 0x89,
-            RetiredSlotId::R9 => 0x8a,
-            RetiredSlotId::R10 => 0x8b,
-            RetiredSlotId::R11 => 0x8c,
-            RetiredSlotId::R12 => 0x8d,
-            RetiredSlotId::R13 => 0x8e,
-            RetiredSlotId::R14 => 0x8f,
-            RetiredSlotId::R15 => 0x90,
-            RetiredSlotId::R16 => 0x91,
-            RetiredSlotId::R17 => 0x92,
-            RetiredSlotId::R18 => 0x93,
-            RetiredSlotId::R19 => 0x94,
-            RetiredSlotId::R20 => 0x95,
-        }
-    }
-}
-
-impl RetiredSlotId {
-    /// Returns the [`ObjectId`] that corresponds to a given [`RetiredSlotId`].
-    pub(crate) fn object_id(self) -> ObjectId {
-        match self {
-            RetiredSlotId::R1 => 0x005f_c10d,
-            RetiredSlotId::R2 => 0x005f_c10e,
-            RetiredSlotId::R3 => 0x005f_c10f,
-            RetiredSlotId::R4 => 0x005f_c110,
-            RetiredSlotId::R5 => 0x005f_c111,
-            RetiredSlotId::R6 => 0x005f_c112,
-            RetiredSlotId::R7 => 0x005f_c113,
-            RetiredSlotId::R8 => 0x005f_c114,
-            RetiredSlotId::R9 => 0x005f_c115,
-            RetiredSlotId::R10 => 0x005f_c116,
-            RetiredSlotId::R11 => 0x005f_c117,
-            RetiredSlotId::R12 => 0x005f_c118,
-            RetiredSlotId::R13 => 0x005f_c119,
-            RetiredSlotId::R14 => 0x005f_c11a,
-            RetiredSlotId::R15 => 0x005f_c11b,
-            RetiredSlotId::R16 => 0x005f_c11c,
-            RetiredSlotId::R17 => 0x005f_c11d,
-            RetiredSlotId::R18 => 0x005f_c11e,
-            RetiredSlotId::R19 => 0x005f_c11f,
-            RetiredSlotId::R20 => 0x005f_c120,
-        }
-    }
-}
-
-/// Personal Identity Verification (PIV) key slots
-pub const SLOTS: [SlotId; 24] = [
-    SlotId::Authentication,
-    SlotId::Signature,
-    SlotId::KeyManagement,
-    SlotId::Retired(RetiredSlotId::R1),
-    SlotId::Retired(RetiredSlotId::R2),
-    SlotId::Retired(RetiredSlotId::R3),
-    SlotId::Retired(RetiredSlotId::R4),
-    SlotId::Retired(RetiredSlotId::R5),
-    SlotId::Retired(RetiredSlotId::R6),
-    SlotId::Retired(RetiredSlotId::R7),
-    SlotId::Retired(RetiredSlotId::R8),
-    SlotId::Retired(RetiredSlotId::R9),
-    SlotId::Retired(RetiredSlotId::R10),
-    SlotId::Retired(RetiredSlotId::R11),
-    SlotId::Retired(RetiredSlotId::R12),
-    SlotId::Retired(RetiredSlotId::R13),
-    SlotId::Retired(RetiredSlotId::R14),
-    SlotId::Retired(RetiredSlotId::R15),
-    SlotId::Retired(RetiredSlotId::R16),
-    SlotId::Retired(RetiredSlotId::R17),
-    SlotId::Retired(RetiredSlotId::R18),
-    SlotId::Retired(RetiredSlotId::R19),
-    SlotId::Retired(RetiredSlotId::R20),
-    SlotId::CardAuthentication,
-];
-
-/// Algorithm identifiers
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum AlgorithmId {
-    /// 1024-bit RSA.
-    Rsa1024,
-    /// 2048-bit RSA.
-    Rsa2048,
-    /// ECDSA with the NIST P256 curve.
-    EccP256,
-    /// ECDSA with the NIST P384 curve.
-    EccP384,
-}
-
-impl TryFrom<u8> for AlgorithmId {
-    type Error = Error;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            0x06 => Ok(AlgorithmId::Rsa1024),
-            0x07 => Ok(AlgorithmId::Rsa2048),
-            0x11 => Ok(AlgorithmId::EccP256),
-            0x14 => Ok(AlgorithmId::EccP384),
-            _ => Err(Error::AlgorithmError),
-        }
-    }
-}
-
-impl From<AlgorithmId> for u8 {
-    fn from(id: AlgorithmId) -> u8 {
-        match id {
-            AlgorithmId::Rsa1024 => 0x06,
-            AlgorithmId::Rsa2048 => 0x07,
-            AlgorithmId::EccP256 => 0x11,
-            AlgorithmId::EccP384 => 0x14,
-        }
-    }
-}
-
-/// PIV cryptographic keys stored in a YubiKey
-#[derive(Clone, Debug)]
-pub struct Key {
-    /// Card slot
-    slot: SlotId,
-
-    /// Cert
-    cert: Certificate,
-}
-
-impl Key {
-    /// List Personal Identity Verification (PIV) keys stored in a YubiKey
-    pub fn list(yubikey: &mut YubiKey) -> Result<Vec<Self>, Error> {
-        let mut keys = vec![];
-        let txn = yubikey.begin_transaction()?;
-
-        for slot in SLOTS.iter().cloned() {
-            let buf = match certificate::read_certificate(&txn, slot) {
-                Ok(b) => b,
-                Err(e) => {
-                    debug!("error reading certificate in slot {:?}: {}", slot, e);
-                    continue;
-                }
-            };
-
-            if !buf.is_empty() {
-                let cert = Certificate::new(buf)?;
-                keys.push(Key { slot, cert });
-            }
-        }
-
-        Ok(keys)
-    }
-
-    /// Get the slot ID for this key
-    pub fn slot(&self) -> SlotId {
-        self.slot
-    }
-
-    /// Get the certificate for this key
-    pub fn certificate(&self) -> &Certificate {
-        &self.cert
-    }
-}
-
-// Keygen messages
-// TODO(tarcieri): extract these into an I18N-handling type?
-const SZ_SETTING_ROCA: &str = "Enable_Unsafe_Keygen_ROCA";
-const SZ_ROCA_ALLOW_USER: &str =
-    "was permitted by an end-user configuration setting, but is not recommended.";
-const SZ_ROCA_ALLOW_ADMIN: &str =
-    "was permitted by an administrator configuration setting, but is not recommended.";
-const SZ_ROCA_BLOCK_USER: &str = "was blocked due to an end-user configuration setting.";
-const SZ_ROCA_BLOCK_ADMIN: &str = "was blocked due to an administrator configuration setting.";
-const SZ_ROCA_DEFAULT: &str = "was permitted by default, but is not recommended.  The default behavior will change in a future Yubico release.";
-
-/// Information about a generated key
-// TODO(tarcieri): this could use some more work
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum GeneratedKey {
-    /// RSA keys
-    Rsa {
-        /// RSA algorithm
-        algorithm: AlgorithmId,
-
-        /// Modulus
-        modulus: Vec<u8>,
-
-        /// Exponent
-        exp: Vec<u8>,
-    },
-    /// ECC keys
-    Ecc {
-        /// ECC algorithm
-        algorithm: AlgorithmId,
-
-        /// Public curve point (i.e. public key)
-        point: Vec<u8>,
-    },
-}
-
-impl GeneratedKey {
-    /// Get the algorithm
-    pub fn algorithm(&self) -> AlgorithmId {
-        *match self {
-            GeneratedKey::Rsa { algorithm, .. } => algorithm,
-            GeneratedKey::Ecc { algorithm, .. } => algorithm,
-        }
-    }
-}
-
-/// Generate key
-#[allow(clippy::cognitive_complexity)]
-pub fn generate(
-    yubikey: &mut YubiKey,
-    slot: SlotId,
-    algorithm: AlgorithmId,
-    pin_policy: u8,
-    touch_policy: u8,
-) -> Result<GeneratedKey, Error> {
-    let mut in_data = [0u8; 11];
-    let mut templ = [0, Ins::GenerateAsymmetric.code(), 0, 0];
-    let setting_roca: settings::BoolValue;
-
-    match algorithm {
-        AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => {
-            if yubikey.device_model() == DEVTYPE_YK4
-                && yubikey.version.major == 4
-                && (yubikey.version.minor < 3
-                    || yubikey.version.minor == 3 && (yubikey.version.patch < 5))
-            {
-                setting_roca = settings::BoolValue::get(SZ_SETTING_ROCA, true);
-
-                let psz_msg = match setting_roca.source {
-                    settings::Source::User => {
-                        if setting_roca.value {
-                            SZ_ROCA_ALLOW_USER
-                        } else {
-                            SZ_ROCA_BLOCK_USER
-                        }
-                    }
-                    settings::Source::Admin => {
-                        if setting_roca.value {
-                            SZ_ROCA_ALLOW_ADMIN
-                        } else {
-                            SZ_ROCA_BLOCK_ADMIN
-                        }
-                    }
-                    _ => SZ_ROCA_DEFAULT,
-                };
-
-                warn!(
-                    "YubiKey serial number {} is affected by vulnerability CVE-2017-15361 \
-                     (ROCA) and should be replaced. On-chip key generation {}  See \
-                     YSA-2017-01 <https://www.yubico.com/support/security-advisories/ysa-2017-01/> \
-                     for additional information on device replacement and mitigation assistance",
-                    yubikey.serial, psz_msg
-                );
-
-                if !setting_roca.value {
-                    return Err(Error::NotSupported);
-                }
-            }
-        }
-        _ => (),
-    }
-
-    let txn = yubikey.begin_transaction()?;
-
-    templ[3] = slot.into();
-
-    let mut offset = 5;
-    in_data[..offset].copy_from_slice(&[
-        0xac,
-        3, // length sans this 2-byte header
-        YKPIV_ALGO_TAG,
-        1,
-        algorithm.into(),
-    ]);
-
-    if in_data[4] == 0 {
-        error!("unexpected algorithm");
-        return Err(Error::AlgorithmError);
-    }
-
-    if pin_policy != YKPIV_PINPOLICY_DEFAULT {
-        in_data[1] += 3;
-        in_data[offset..(offset + 3)].copy_from_slice(&[YKPIV_PINPOLICY_TAG, 1, pin_policy]);
-        offset += 3;
-    }
-
-    if touch_policy != YKPIV_TOUCHPOLICY_DEFAULT {
-        in_data[1] += 3;
-        in_data[offset..(offset + 3)].copy_from_slice(&[YKPIV_TOUCHPOLICY_TAG, 1, touch_policy]);
-    }
-
-    let response = txn.transfer_data(&templ, &in_data[..offset], 1024)?;
-
-    if !response.is_success() {
-        let err_msg = "failed to generate new key";
-
-        match response.status_words() {
-            StatusWords::IncorrectSlotError => {
-                error!("{} (incorrect slot)", err_msg);
-                return Err(Error::KeyError);
-            }
-            StatusWords::IncorrectParamError => {
-                if pin_policy != YKPIV_PINPOLICY_DEFAULT {
-                    error!("{} (pin policy not supported?)", err_msg);
-                } else if touch_policy != YKPIV_TOUCHPOLICY_DEFAULT {
-                    error!("{} (touch policy not supported?)", err_msg);
-                } else {
-                    error!("{} (algorithm not supported?)", err_msg);
-                }
-
-                return Err(Error::AlgorithmError);
-            }
-            StatusWords::SecurityStatusError => {
-                error!("{} (not authenticated)", err_msg);
-                return Err(Error::AuthenticationError);
-            }
-            other => {
-                error!("{} (error {:x})", err_msg, other.code());
-                return Err(Error::GenericError);
-            }
-        }
-    }
-
-    let data = Buffer::new(response.data().into());
-
-    match algorithm {
-        AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => {
-            let mut offset = 5;
-            let mut len = 0;
-
-            if data[offset] != TAG_RSA_MODULUS {
-                error!("Failed to parse public key structure (modulus)");
-                return Err(Error::ParseError);
-            }
-
-            offset += 1;
-            offset += get_length(&data[offset..], &mut len);
-            let modulus = data[offset..(offset + len)].to_vec();
-            offset += len;
-
-            if data[offset] != TAG_RSA_EXP {
-                error!("failed to parse public key structure (public exponent)");
-                return Err(Error::ParseError);
-            }
-
-            offset += 1;
-            offset += get_length(&data[offset..], &mut len);
-            let exp = data[offset..(offset + len)].to_vec();
-            Ok(GeneratedKey::Rsa {
-                algorithm,
-                modulus,
-                exp,
-            })
-        }
-        AlgorithmId::EccP256 | AlgorithmId::EccP384 => {
-            let mut offset = 3;
-
-            let len = if let AlgorithmId::EccP256 = algorithm {
-                CB_ECC_POINTP256
-            } else {
-                CB_ECC_POINTP384
-            };
-
-            if data[offset] != TAG_ECC_POINT {
-                error!("failed to parse public key structure");
-                return Err(Error::ParseError);
-            }
-            offset += 1;
-
-            // the curve point should always be determined by the curve
-            let len_byte = data[offset];
-            offset += 1;
-
-            if len_byte as usize != len {
-                error!("unexpected length");
-                return Err(Error::AlgorithmError);
-            }
-
-            let point = data[offset..(offset + len)].to_vec();
-            Ok(GeneratedKey::Ecc { algorithm, point })
-        }
-    }
-}

src/lib.rs

@@ -1,95 +1,17 @@
-//! [YubiKey] PIV: [Personal Identity Verification][PIV] support for
+#![doc = include_str!("../README.md")]
-//! [Yubico] devices using the Personal Computer/Smart Card ([PC/SC])
+#![doc(
-//! interface as provided by the [`pcsc` crate].
+    html_logo_url = "https://raw.githubusercontent.com/iqlusioninc/yubikey.rs/main/img/logo-sq.png"
-//!
+)]
-//! **PIV** is a [NIST] standard for both *signing* and *encryption*
+#![cfg_attr(docsrs, feature(doc_cfg))]
-//! using SmartCards and SmartCard-based hardware tokens like YubiKeys.
+#![forbid(unsafe_code)]
-//!
+#![warn(
-//! This library natively implements the protocol used to manage and
+    clippy::mod_module_files,
-//! utilize PIV encryption and signing keys which can be generated, imported,
+    clippy::unwrap_used,
-//! and stored on YubiKey devices.
+    missing_docs,
-//!
+    rust_2018_idioms,
-//! See [Yubico's guide to PIV-enabled YubiKeys][yk-guide] for more information
+    unused_lifetimes,
-//! on which devices support PIV and the available functionality.
+    unused_qualifications
-//!
+)]
-//! ## Minimum Supported Rust Version
-//!
-//! Rust 1.39+
-//!
-//! ## Supported YubiKeys
-//!
-//! - [YubiKey NEO] series
-//! - [YubiKey 4] series
-//! - [YubiKey 5] series
-//!
-//! NOTE: Nano and USB-C variants of the above are also supported
-//!
-//! ## Supported Algorithms
-//!
-//! - **Authentication**: `3DES`
-//! - **Encryption**: `RSA1024`, `RSA2048`, `ECCP256`, `ECCP384`
-//! - **Signatures**:
-//!   - RSASSA-PKCS#1v1.5: `RSA1024`, `RSA2048`
-//!   - ECDSA: `ECCP256`, `ECCP384`
-//!
-//! NOTE: RSASSA-PSS signatures and RSA-OAEP encryption may be supportable (TBD)
-//!
-//! ## Status
-//!
-//! This is a work-in-progress effort, and while much of the library-level
-//! code from upstream [yubico-piv-tool] has been translated into Rust
-//! presenting a safe interface, much of it is still untested.
-//!
-//! Please see the [project's README.md for a complete status][status].
-//!
-//! ## History
-//!
-//! This library is a Rust translation of the [yubico-piv-tool] utility by
-//! Yubico, which was originally written in C. It was mechanically translated
-//! from C into Rust using [Corrode], and then subsequently heavily
-//! refactored into safer, more idiomatic Rust.
-//!
-//! For more information on [yubico-piv-tool] and background information on how
-//! the YubiKey implementation of PIV works in general, see the
-//! [Yubico PIV Tool Command Line Guide][piv-tool-guide].
-//!
-//! ## Security Warning
-//!
-//! No security audits of this crate have ever been performed. Presently it is in
-//! an experimental stage and may still contain high-severity issues.
-//!
-//! USE AT YOUR OWN RISK!
-//!
-//! ## Code of Conduct
-//!
-//! We abide by the [Contributor Covenant][cc-md] and ask that you do as well.
-//!
-//! For more information, please see [CODE_OF_CONDUCT.md][cc-md].
-//!
-//! ## License
-//!
-//! **yubikey-piv.rs** is a fork of and originally a mechanical translation from
-//! Yubico's [yubico-piv-tool], a C library/CLI program. The original library
-//! was licensed under a [2-Clause BSD License][BSDL], which this library inherits
-//! as a derived work.
-//!
-//! [YubiKey]: https://www.yubico.com/products/yubikey-hardware/
-//! [PIV]: https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-73-4.pdf
-//! [Yubico]: https://www.yubico.com/
-//! [PC/SC]: https://en.wikipedia.org/wiki/PC/SC
-//! [`pcsc` crate]: https://github.com/bluetech/pcsc-rust
-//! [NIST]: https://www.nist.gov/
-//! [yk-guide]: https://developers.yubico.com/PIV/Introduction/YubiKey_and_PIV.html
-//! [YubiKey NEO]: https://support.yubico.com/support/solutions/articles/15000006494-yubikey-neo
-//! [YubiKey 4]: https://support.yubico.com/support/solutions/articles/15000006486-yubikey-4
-//! [YubiKey 5]: https://www.yubico.com/products/yubikey-5-overview/
-//! [status]: https://github.com/tarcieri/yubikey-piv.rs#status
-//! [yubico-piv-tool]: https://github.com/Yubico/yubico-piv-tool/
-//! [Corrode]: https://github.com/jameysharp/corrode
-//! [piv-tool-guide]: https://www.yubico.com/wp-content/uploads/2016/05/Yubico_PIV_Tool_Command_Line_Guide_en.pdf
-//! [cc-web]: https://contributor-covenant.org/
-//! [cc-md]: https://github.com/tarcieri/yubikey-piv.rs/blob/develop/CODE_OF_CONDUCT.md
-//! [BSDL]: https://opensource.org/licenses/BSD-2-Clause
 
 // Adapted from yubico-piv-tool:
 // <https://github.com/Yubico/yubico-piv-tool/>
@@ -121,56 +43,49 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![doc(
-    html_logo_url = "https://raw.githubusercontent.com/tarcieri/yubikey-piv.rs/develop/img/logo.png",
-    html_root_url = "https://docs.rs/yubikey-piv/0.0.3"
-)]
-#![forbid(unsafe_code)]
-#![warn(
-    missing_docs,
-    rust_2018_idioms,
-    trivial_casts,
-    trivial_numeric_casts,
-    unused_lifetimes,
-    unused_qualifications
-)]
-
 mod apdu;
-#[cfg(feature = "untested")]
+mod cccid;
-pub mod cccid;
-#[cfg(feature = "untested")]
 pub mod certificate;
-#[cfg(feature = "untested")]
+mod chuid;
-pub mod chuid;
+mod config;
-#[cfg(feature = "untested")]
+mod consts;
-pub mod config;
+mod error;
-pub mod consts;
-#[cfg(feature = "untested")]
-pub mod container;
-pub mod error;
-#[cfg(feature = "untested")]
-pub mod key;
-#[cfg(feature = "untested")]
 mod metadata;
-#[cfg(feature = "untested")]
 pub mod mgm;
 #[cfg(feature = "untested")]
-pub mod msroots;
+mod mscmap;
-pub mod readers;
 #[cfg(feature = "untested")]
+mod msroots;
+mod otp;
+pub mod piv;
+mod policy;
+pub mod reader;
 mod serialization;
-#[cfg(feature = "untested")]
+mod setting;
-pub mod settings;
 mod transaction;
-pub mod yubikey;
+mod yubikey;
 
-pub use self::{readers::Readers, yubikey::YubiKey};
+pub use crate::{
+    cccid::{CardId, CccId},
+    certificate::Certificate,
+    chuid::ChuId,
+    config::Config,
+    error::{Error, Result},
+    mgm::{MgmAlgorithmId, MgmKey, MgmType},
+    piv::Key,
+    policy::{PinPolicy, TouchPolicy},
+    reader::Context,
+    setting::{Setting, SettingSource},
+    yubikey::{CachedPin, Serial, Version, YubiKey},
+};
 
 #[cfg(feature = "untested")]
-pub use self::{key::Key, mgm::MgmKey};
+pub use crate::{mscmap::MsContainer, msroots::MsRoots};
 
-/// Object identifiers
+pub use uuid::Uuid;
+
+/// Object identifiers: handles to particular objects stored on a YubiKey.
 pub type ObjectId = u32;
 
 /// Buffer type (self-zeroizing byte vector)
-pub(crate) type Buffer = zeroize::Zeroizing<Vec<u8>>;
+pub type Buffer = zeroize::Zeroizing<Vec<u8>>;

src/metadata.rs

@@ -30,59 +30,112 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use crate::{consts::*, error::Error, serialization::*, transaction::Transaction, Buffer};
+use std::{iter, marker::PhantomData};
 use zeroize::Zeroizing;
 
+use crate::{
+    consts::{CB_OBJ_MAX, CB_OBJ_TAG_MAX},
+    serialization::*,
+    transaction::Transaction,
+    Buffer, Error, Result,
+};
+
+const TAG_ADMIN: u8 = 0x80;
+const TAG_PROTECTED: u8 = 0x88;
+pub const OBJ_ADMIN_DATA: u32 = 0x005f_ff00;
+pub const OBJ_PRINTED: u32 = 0x005f_c109;
+
+pub(crate) trait MetadataType: private::Sealed {}
+
+/// A type variable corresponding to PIN-protected metadata.
+pub(crate) enum Protected {}
+impl MetadataType for Protected {}
+
+/// A type variable corresponding to administrative metadata.
+pub(crate) enum Admin {}
+impl MetadataType for Admin {}
+
+/// Metadata stored in a YubiKey.
+pub(crate) struct Metadata<T: MetadataType> {
+    inner: Buffer,
+    _marker: PhantomData<T>,
+}
+
+/// PIN-protected metadata stored in a YubiKey.
+pub(crate) type ProtectedData = Metadata<Protected>;
+/// Administrative metadata stored in a YubiKey.
+pub(crate) type AdminData = Metadata<Admin>;
+
+impl<T: MetadataType> Default for Metadata<T> {
+    fn default() -> Self {
+        Metadata {
+            inner: Zeroizing::new(vec![]),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T: MetadataType> Metadata<T> {
+    /// Read metadata
+    pub(crate) fn read(txn: &Transaction<'_>) -> Result<Self> {
+        let data = txn.fetch_object(T::obj_id())?;
+        Ok(Metadata {
+            inner: Tlv::parse_single(data, T::tag())?,
+            _marker: PhantomData,
+        })
+    }
+
+    /// Write metadata
+    pub(crate) fn write(&self, txn: &Transaction<'_>) -> Result<()> {
+        if self.inner.len() > CB_OBJ_MAX - CB_OBJ_TAG_MAX {
+            return Err(Error::GenericError);
+        }
+
+        if self.inner.is_empty() {
+            return Self::delete(txn);
+        }
+
+        let mut buf = Zeroizing::new(vec![0u8; CB_OBJ_MAX]);
+        let len = Tlv::write(&mut buf, T::tag(), &self.inner)?;
+
+        txn.save_object(T::obj_id(), &buf[..len])
+    }
+
+    /// Delete metadata
+    pub(crate) fn delete(txn: &Transaction<'_>) -> Result<()> {
+        txn.save_object(T::obj_id(), &[])
+    }
+
     /// Get metadata item
-pub(crate) fn get_item(data: &[u8], tag: u8) -> Result<&[u8], Error> {
+    pub(crate) fn get_item(&self, tag: u8) -> Result<&[u8]> {
-    let mut cb_temp: usize = 0;
+        let mut data = &self.inner[..];
-    let mut offset = 0;
 
-    while offset < data.len() {
+        while !data.is_empty() {
-        let tag_temp = data[offset];
+            let (remaining, tlv) = Tlv::parse(data)?;
-        offset += 1;
+            data = remaining;
 
-        if !has_valid_length(&data[offset..], data.len() - 1) {
+            if tlv.tag == tag {
-            return Err(Error::SizeError);
-        }
-
-        offset += get_length(&data[offset..], &mut cb_temp);
-
-        if tag_temp == tag {
                 // found tag
-            break;
+                return Ok(tlv.value);
+            }
         }
 
-        offset += cb_temp;
-    }
-
-    if offset < data.len() {
-        Ok(&data[offset..offset + cb_temp])
-    } else {
         Err(Error::GenericError)
     }
-}
 
     /// Set metadata item
-pub(crate) fn set_item(
+    pub(crate) fn set_item(&mut self, tag: u8, item: &[u8]) -> Result<()> {
-    data: &mut [u8],
-    pcb_data: &mut usize,
-    cb_data_max: usize,
-    tag: u8,
-    p_item: &[u8],
-) -> Result<(), Error> {
         let mut cb_temp: usize = 0;
         let mut tag_temp: u8 = 0;
         let mut cb_len: usize = 0;
-    let cb_item = p_item.len();
 
         let mut offset = 0;
 
-    while offset < *pcb_data {
+        while offset < self.inner.len() {
-        tag_temp = data[offset];
+            tag_temp = self.inner[offset];
             offset += 1;
 
-        cb_len = get_length(&data[offset..], &mut cb_temp);
+            cb_len = get_length(&self.inner[offset..], &mut cb_temp);
             offset += cb_len;
 
             if tag_temp == tag {
@@ -93,26 +146,18 @@ pub(crate) fn set_item(
         }
 
         if tag_temp != tag {
-        if cb_item == 0 {
+            if item.is_empty() {
                 // We've been asked to delete an existing item that isn't in the blob
                 return Ok(());
             }
 
             // We did not find an existing tag, append
-        offset = *pcb_data;
+            assert_eq!(offset, self.inner.len());
-        cb_len = get_length_size(cb_item);
+            self.inner.extend(iter::repeat_n(
-
+                0,
-        // If length would cause buffer overflow, return error
+                1 + get_length_size(item.len()) + item.len(),
-        if (*pcb_data + cb_len + cb_item) > cb_data_max {
+            ));
-            return Err(Error::GenericError);
+            Tlv::write(&mut self.inner[offset..], tag, item)?;
-        }
-
-        data[offset] = tag;
-        offset += 1;
-        offset += set_length(&mut data[offset..], cb_item);
-        data[offset..offset + cb_item].copy_from_slice(p_item);
-
-        *pcb_data += 1 + cb_len + cb_item;
 
             return Ok(());
         }
@@ -120,106 +165,50 @@ pub(crate) fn set_item(
         // Found tag
 
         // Check length, if it matches, overwrite
-    if cb_temp == cb_item {
+        if cb_temp == item.len() {
-        data[offset..offset + cb_item].copy_from_slice(p_item);
+            self.inner[offset..offset + item.len()].copy_from_slice(item);
             return Ok(());
         }
 
         // Length doesn't match, expand/shrink to fit
         let next_offset = offset + cb_temp;
         // Must be signed to have negative offsets
-    let cb_moved: isize = (cb_item as isize - cb_temp as isize)
+        let cb_moved: isize = (item.len() as isize - cb_temp as isize)
-        + if cb_item != 0 {
+            + if item.is_empty() {
-            get_length_size(cb_item) as isize
-        } else {
                 // For tag, if deleting
                 -1
+            } else {
+                get_length_size(item.len()) as isize
             }
             // Accounts for different length encoding
             - cb_len as isize;
 
         // If length would cause buffer overflow, return error
-    if (*pcb_data as isize + cb_moved) as usize > cb_data_max {
+        if (self.inner.len() as isize + cb_moved) as usize > CB_OBJ_MAX {
             return Err(Error::GenericError);
         }
 
         // Move remaining data
-    data.copy_within(
+        let orig_len = self.inner.len();
-        next_offset..*pcb_data,
+        if cb_moved > 0 {
+            self.inner.extend(iter::repeat_n(0, cb_moved as usize));
+        }
+        self.inner.copy_within(
+            next_offset..orig_len,
             (next_offset as isize + cb_moved) as usize,
         );
-    *pcb_data = (*pcb_data as isize + cb_moved) as usize;
+        self.inner
+            .resize((orig_len as isize + cb_moved) as usize, 0);
 
         // Re-encode item and insert
-    if cb_item != 0 {
+        if !item.is_empty() {
             offset -= cb_len;
-        offset += set_length(&mut data[offset..], cb_item);
+            offset += set_length(&mut self.inner[offset..], item.len())?;
-        data[offset..offset + cb_item].copy_from_slice(p_item);
+            self.inner[offset..offset + item.len()].copy_from_slice(item);
         }
 
         Ok(())
     }
-
-/// Read metadata
-pub(crate) fn read(txn: &Transaction<'_>, tag: u8) -> Result<Buffer, Error> {
-    let obj_id = match tag {
-        TAG_ADMIN => YKPIV_OBJ_ADMIN_DATA,
-        TAG_PROTECTED => YKPIV_OBJ_PRINTED,
-        _ => return Err(Error::InvalidObject),
-    };
-
-    let mut data = txn.fetch_object(obj_id)?;
-
-    if data.len() < CB_OBJ_TAG_MIN {
-        return Err(Error::GenericError);
-    }
-
-    if tag != data[0] {
-        return Err(Error::GenericError);
-    }
-
-    let mut pcb_data = 0;
-    let offset = 1 + get_length(&data[1..], &mut pcb_data);
-
-    if pcb_data > data.len() - offset {
-        return Err(Error::GenericError);
-    }
-
-    data.copy_within(offset..offset + pcb_data, 0);
-    data.truncate(pcb_data);
-    Ok(data)
-}
-
-/// Write metadata
-pub(crate) fn write(
-    txn: &Transaction<'_>,
-    tag: u8,
-    data: &[u8],
-    max_size: usize,
-) -> Result<(), Error> {
-    let mut buf = Zeroizing::new(vec![0u8; CB_OBJ_MAX]);
-
-    if data.len() > max_size - CB_OBJ_TAG_MAX {
-        return Err(Error::GenericError);
-    }
-
-    let obj_id = match tag {
-        TAG_ADMIN => YKPIV_OBJ_ADMIN_DATA,
-        TAG_PROTECTED => YKPIV_OBJ_PRINTED,
-        _ => return Err(Error::InvalidObject),
-    };
-
-    if data.is_empty() {
-        // Deleting metadata
-        return txn.save_object(obj_id, &[]);
-    }
-
-    buf[0] = tag;
-    let mut offset = set_length(&mut buf[1..], data.len());
-    buf[offset..(offset + data.len())].copy_from_slice(data);
-    offset += data.len();
-
-    txn.save_object(obj_id, &buf[..offset])
 }
 
 /// Get the size of a length tag for the given length
@@ -232,3 +221,27 @@ fn get_length_size(length: usize) -> usize {
         3
     }
 }
+
+mod private {
+    use super::*;
+    pub trait Sealed {
+        fn tag() -> u8;
+        fn obj_id() -> u32;
+    }
+    impl Sealed for Protected {
+        fn tag() -> u8 {
+            TAG_PROTECTED
+        }
+        fn obj_id() -> u32 {
+            OBJ_PRINTED
+        }
+    }
+    impl Sealed for Admin {
+        fn tag() -> u8 {
+            TAG_ADMIN
+        }
+        fn obj_id() -> u32 {
+            OBJ_ADMIN_DATA
+        }
+    }
+}

src/mscmap.rs

@@ -0,0 +1,198 @@
+//! MS Container Map Records.
+
+// Adapted from yubico-piv-tool:
+// <https://github.com/Yubico/yubico-piv-tool/>
+//
+// Copyright (c) 2014-2016 Yubico AB
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//   * Redistributions of source code must retain the above copyright
+//     notice, this list of conditions and the following disclaimer.
+//
+//   * Redistributions in binary form must reproduce the above
+//     copyright notice, this list of conditions and the following
+//     disclaimer in the documentation and/or other materials provided
+//     with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+use crate::{consts::CB_OBJ_MAX, piv::SlotId, serialization::*, Error, Result, YubiKey};
+use log::error;
+
+const OBJ_MSCMAP: u32 = 0x005f_ff10;
+
+const TAG_MSCMAP: u8 = 0x81;
+
+/// MS Container Map records.
+///
+/// Defined in Microsoft's Smart Card Minidriver Specification:
+/// <https://docs.microsoft.com/en-us/previous-versions/windows/hardware/design/dn631754(v=vs.85)>
+#[derive(Clone, Debug)]
+pub struct MsContainer {
+    /// Container name.
+    pub name: [u16; Self::NAME_LEN],
+
+    /// Card slot.
+    pub slot: SlotId,
+
+    /// Key spec.
+    pub key_spec: u8,
+
+    /// Key size in bits.
+    pub key_size_bits: u16,
+
+    /// Flags.
+    pub flags: u8,
+
+    /// PIN ID.
+    pub pin_id: u8,
+
+    /// Associated ECHD container.
+    pub associated_echd_container: u8,
+
+    /// Cert fingerprint.
+    pub cert_fingerprint: [u8; Self::CERT_FINGERPRINT_LEN],
+}
+
+impl MsContainer {
+    /// Container name length in UTF-16 chars.
+    const NAME_LEN: usize = 40;
+
+    /// Container record length: 27 = 80 + 1 + 1 + 2 + 1 + 1 + 1 + 20
+    const REC_LEN: usize = (2 * Self::NAME_LEN) + 27;
+
+    /// Length of a certificate fingerprint.
+    const CERT_FINGERPRINT_LEN: usize = 20;
+
+    /// Read MS Container Map records.
+    pub fn read_mscmap(yubikey: &mut YubiKey) -> Result<Vec<Self>> {
+        let txn = yubikey.begin_transaction()?;
+        let response = txn.fetch_object(OBJ_MSCMAP)?;
+        let mut containers = vec![];
+
+        let (_, tlv) = match Tlv::parse(&response) {
+            Ok(res) => res,
+            Err(_) => {
+                // TODO(tarcieri): is this really OK?
+                return Ok(containers);
+            }
+        };
+
+        if tlv.tag != TAG_MSCMAP {
+            // TODO(tarcieri): yubico-piv-tool returned success here? should we?
+            return Err(Error::InvalidObject);
+        }
+
+        for chunk in tlv.value.chunks_exact(Self::REC_LEN) {
+            containers.push(MsContainer::new(chunk)?);
+        }
+
+        Ok(containers)
+    }
+
+    /// Write MS Container Map records.
+    pub fn write_mscmap(yubikey: &mut YubiKey, containers: &[Self]) -> Result<()> {
+        let n_containers = containers.len();
+        let data_len = n_containers * Self::REC_LEN;
+
+        let txn = yubikey.begin_transaction()?;
+
+        if n_containers == 0 {
+            return txn.save_object(OBJ_MSCMAP, &[]);
+        }
+
+        let mut buf = [0u8; CB_OBJ_MAX];
+        let offset = Tlv::write_as(&mut buf, TAG_MSCMAP, data_len, |buf| {
+            for (i, chunk) in buf.chunks_exact_mut(Self::REC_LEN).enumerate() {
+                chunk.copy_from_slice(&containers[i].to_bytes());
+            }
+        })?;
+
+        txn.save_object(OBJ_MSCMAP, &buf[..offset])
+    }
+
+    /// Parse a container record from a byte slice.
+    pub fn new(bytes: &[u8]) -> Result<Self> {
+        if bytes.len() != Self::REC_LEN {
+            error!(
+                "couldn't parse PIV container: expected {}-bytes, got {}-bytes",
+                Self::REC_LEN,
+                bytes.len()
+            );
+            return Err(Error::ParseError);
+        }
+
+        let mut name = [0u16; Self::NAME_LEN];
+        let name_bytes_len = Self::NAME_LEN * 2;
+
+        for (i, chunk) in bytes[..name_bytes_len].chunks_exact(2).enumerate() {
+            name[i] = u16::from_le_bytes([chunk[0], chunk[1]]);
+        }
+
+        let mut cert_fingerprint = [0u8; 20];
+        cert_fingerprint.copy_from_slice(&bytes[(bytes.len() - 20)..]);
+
+        Ok(Self {
+            name,
+            slot: bytes[name_bytes_len].try_into()?,
+            key_spec: bytes[name_bytes_len + 1],
+            key_size_bits: u16::from_le_bytes([
+                bytes[name_bytes_len + 2],
+                bytes[name_bytes_len + 3],
+            ]),
+            flags: bytes[name_bytes_len + 4],
+            pin_id: bytes[name_bytes_len + 5],
+            associated_echd_container: bytes[name_bytes_len + 6],
+            cert_fingerprint,
+        })
+    }
+
+    /// Parse the container name as a UTF-16 string.
+    pub fn parse_name(&self) -> Result<String> {
+        String::from_utf16(&self.name).map_err(|_| Error::ParseError)
+    }
+
+    /// Serialize a container record as a byte size.
+    pub fn to_bytes(&self) -> [u8; Self::REC_LEN] {
+        // TODO(tarcieri): use array instead of `Vec`
+        let mut bytes = Vec::with_capacity(Self::REC_LEN);
+
+        for i in 0..Self::NAME_LEN {
+            bytes.extend_from_slice(&self.name[i].to_le_bytes());
+        }
+
+        bytes.push(self.slot.into());
+        bytes.push(self.key_spec);
+        bytes.extend_from_slice(&self.key_size_bits.to_le_bytes());
+        bytes.push(self.flags);
+        bytes.push(self.pin_id);
+        bytes.push(self.associated_echd_container);
+        bytes.extend_from_slice(&self.cert_fingerprint);
+        bytes
+            .as_slice()
+            .try_into()
+            .expect("should be REC_LEN-sized")
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for MsContainer {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Self::new(bytes)
+    }
+}

src/msroots.rs

@@ -1,11 +1,4 @@
-//! `msroots`: PKCS#7 formatted certificate store for enterprise trusted roots.
+//! PKCS#7 formatted certificate store for enterprise trusted roots.
-//!
-//! This `msroots` file contains a bag of certificates with empty content and
-//! an empty signature, allowing an enterprise root certificate truststore to
-//! be written to and read from a YubiKey.
-//!
-//! For more information, see:
-//! <https://docs.microsoft.com/en-us/windows-hardware/drivers/smartcard/developer-guidelines#-interoperability-with-msroots>
 
 // Adapted from yubico-piv-tool:
 // <https://github.com/Yubico/yubico-piv-tool/>
@@ -37,38 +30,58 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use crate::{consts::*, error::Error, serialization::*, yubikey::YubiKey};
+use crate::{
+    consts::{CB_OBJ_MAX, CB_OBJ_TAG_MAX},
+    serialization::*,
+    Error, Result, YubiKey,
+};
 use log::error;
 
-/// `msroots` file: PKCS#7-formatted certificate store for enterprise trust roots
+const OBJ_MSROOTS1: u32 = 0x005f_ff11;
+#[allow(dead_code)]
+const OBJ_MSROOTS2: u32 = 0x005f_ff12;
+#[allow(dead_code)]
+const OBJ_MSROOTS3: u32 = 0x005f_ff13;
+#[allow(dead_code)]
+const OBJ_MSROOTS4: u32 = 0x005f_ff14;
+const OBJ_MSROOTS5: u32 = 0x005f_ff15;
+
+const TAG_MSROOTS_END: u8 = 0x82;
+const TAG_MSROOTS_MID: u8 = 0x83;
+
+/// PKCS#7-formatted certificate store for enterprise trust roots.
+///
+/// The `msroots` file contains a bag of certificates with empty content and
+/// an empty signature, allowing an enterprise root certificate truststore to
+/// be written to and read from a YubiKey.
+///
+/// For more information, see:
+/// <https://docs.microsoft.com/en-us/windows-hardware/drivers/smartcard/developer-guidelines#-interoperability-with-msroots>
 pub struct MsRoots(Vec<u8>);
 
 impl MsRoots {
     /// Initialize a local certificate struct from the given bytebuffer
-    pub fn new(msroots: impl AsRef<[u8]>) -> Result<Self, Error> {
+    pub fn new(msroots: impl AsRef<[u8]>) -> Result<Self> {
         Ok(MsRoots(msroots.as_ref().into()))
     }
 
     /// Read `msroots` file from YubiKey
-    pub fn read(yubikey: &mut YubiKey) -> Result<Option<Self>, Error> {
+    pub fn read(yubikey: &mut YubiKey) -> Result<Option<Self>> {
-        let cb_data = yubikey.obj_size_max();
         let txn = yubikey.begin_transaction()?;
 
         // allocate first page
-        let mut data = Vec::with_capacity(cb_data);
+        let mut data = Vec::with_capacity(CB_OBJ_MAX);
 
-        for object_id in YKPIV_OBJ_MSROOTS1..YKPIV_OBJ_MSROOTS5 {
+        for object_id in OBJ_MSROOTS1..OBJ_MSROOTS5 {
             let buf = txn.fetch_object(object_id)?;
-            let cb_buf = buf.len();
 
-            if cb_buf < CB_OBJ_TAG_MIN {
+            let (_, tlv) = match Tlv::parse(&buf) {
-                return Ok(None);
+                Ok(res) => res,
-            }
+                Err(_) => return Ok(None),
+            };
 
-            let tag = buf[0];
+            if (TAG_MSROOTS_MID != tlv.tag || OBJ_MSROOTS5 == object_id)
-
+                && (TAG_MSROOTS_END != tlv.tag)
-            if (TAG_MSROOTS_MID != tag || YKPIV_OBJ_MSROOTS5 == object_id)
-                && (TAG_MSROOTS_END != tag)
             {
                 // the current object doesn't contain a valid part of a msroots file
 
@@ -76,45 +89,35 @@ impl MsRoots {
                 return Ok(None);
             }
 
-            let mut len: usize = 0;
+            data.extend_from_slice(tlv.value);
-            let offset = 1 + get_length(&buf[1..], &mut len);
 
-            // check that decoded length represents object contents
+            if tlv.tag == TAG_MSROOTS_END {
-            if len > cb_buf - offset {
-                return Ok(None);
-            }
-
-            data.extend_from_slice(&buf[offset..offset + len]);
-
-            if tag == TAG_MSROOTS_END {
                 break;
             }
         }
 
-        MsRoots::new(&data).map(Some).map_err(|e| {
+        MsRoots::new(&data)
-            error!("error parsing msroots: {:?}", e);
+            .map(Some)
-            e
+            .inspect_err(|e| error!("error parsing msroots: {:?}", e))
-        })
     }
 
     /// Write `msroots` file to YubiKey
-    pub fn write(&self, yubikey: &mut YubiKey) -> Result<(), Error> {
+    pub fn write(&self, yubikey: &mut YubiKey) -> Result<()> {
         let mut buf = [0u8; CB_OBJ_MAX];
         let mut offset: usize;
         let mut data_offset: usize = 0;
         let mut data_chunk: usize;
         let data = &self.0;
         let data_len = data.len();
-        let n_objs: usize;
+
-        let cb_obj_max = yubikey.obj_size_max();
         let txn = yubikey.begin_transaction()?;
 
         if data_len == 0 {
-            return txn.save_object(YKPIV_OBJ_MSROOTS1, &[]);
+            return txn.save_object(OBJ_MSROOTS1, &[]);
         }
 
         // Calculate number of objects required to store blob
-        n_objs = (data_len / (cb_obj_max - CB_OBJ_TAG_MAX)) + 1;
+        let n_objs: usize = (data_len / (CB_OBJ_MAX - CB_OBJ_TAG_MAX)) + 1;
 
         if n_objs > 5 {
             return Err(Error::SizeError);
@@ -123,24 +126,23 @@ impl MsRoots {
         for i in 0..n_objs {
             offset = 0;
 
-            data_chunk = if cb_obj_max - CB_OBJ_TAG_MAX < data_len - data_offset {
+            data_chunk = if CB_OBJ_MAX - CB_OBJ_TAG_MAX < data_len - data_offset {
-                cb_obj_max - CB_OBJ_TAG_MAX
+                CB_OBJ_MAX - CB_OBJ_TAG_MAX
             } else {
                 data_len - data_offset
             };
 
-            buf[offset] = if i == n_objs - 1 {
+            offset += Tlv::write(
+                &mut buf,
+                if i == n_objs - 1 {
                     TAG_MSROOTS_END
                 } else {
                     TAG_MSROOTS_MID
-            };
+                },
+                &data[data_offset..(data_offset + data_chunk)],
+            )?;
 
-            offset += 1;
+            txn.save_object(OBJ_MSROOTS1 + i as u32, &buf[..offset])?;
-            offset += set_length(&mut buf[offset..], data_chunk);
-            buf[offset..].copy_from_slice(&data[data_offset..(data_offset + data_chunk)]);
-            offset += data_chunk;
-
-            txn.save_object(YKPIV_OBJ_MSROOTS1 + i as u32, &buf[..offset])?;
 
             data_offset += data_chunk;
         }

src/otp.rs

@@ -0,0 +1,5 @@
+/// YubiKey OTP Applet Name
+pub(crate) const APPLET_NAME: &str = "YubiKey OTP";
+
+/// YubiKey OTP Applet ID. Needed to query serial on YK4.
+pub(crate) const APPLET_ID: &[u8] = &[0xa0, 0x00, 0x00, 0x05, 0x27, 0x20, 0x01, 0x01];

src/policy.rs

@@ -0,0 +1,120 @@
+//! Enums representing key policies.
+
+use crate::{serialization::Tlv, Error, Result};
+
+/// Specifies how often the PIN needs to be entered for access to the credential in a
+/// given slot.
+///
+/// This policy must be set when keys are generated or imported, and cannot be changed later.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PinPolicy {
+    /// Use the default PIN policy for the slot. See the slot's documentation for details.
+    Default,
+
+    /// The end user PIN is **NOT** required to perform private key operations.
+    Never,
+
+    /// The end user PIN is required to perform any private key operations. Once the
+    /// correct PIN has been provided, multiple private key operations may be performed
+    /// without additional cardholder consent.
+    Once,
+
+    /// The end user PIN is required to perform any private key operations. The PIN must
+    /// be submitted immediately before each operation to ensure cardholder participation.
+    Always,
+}
+
+impl From<PinPolicy> for u8 {
+    fn from(policy: PinPolicy) -> u8 {
+        match policy {
+            PinPolicy::Default => 0,
+            PinPolicy::Never => 1,
+            PinPolicy::Once => 2,
+            PinPolicy::Always => 3,
+        }
+    }
+}
+
+impl TryFrom<u8> for PinPolicy {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            0 => Ok(PinPolicy::Default),
+            1 => Ok(PinPolicy::Never),
+            2 => Ok(PinPolicy::Once),
+            3 => Ok(PinPolicy::Always),
+            _ => Err(Error::GenericError),
+        }
+    }
+}
+
+impl PinPolicy {
+    /// Writes the `PinPolicy` in the format the YubiKey expects during key generation or
+    /// importation.
+    pub(crate) fn write(self, buf: &mut [u8]) -> Result<usize> {
+        match self {
+            PinPolicy::Default => Ok(0),
+            _ => Tlv::write(buf, 0xaa, &[self.into()]),
+        }
+    }
+}
+
+/// Specifies under what conditions a physical touch on the metal contact is required, in
+/// addition to the [`PinPolicy`].
+///
+/// This policy must be set when keys are generated or imported, and cannot be changed later.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum TouchPolicy {
+    /// Use the default touch policy for the slot.
+    Default,
+
+    /// A physical touch is **NOT** required to perform private key operations.
+    Never,
+
+    /// A physical touch is required to perform any private key operations. The metal
+    /// contact must be touched during each operation to ensure cardholder participation.
+    Always,
+
+    /// A physical touch is required to perform any private key operations. Each touch
+    /// is cached for 15 seconds, during which time multiple private key operations may be
+    /// performed without additional cardholder interaction. After 15 seconds the cached
+    /// touch is cleared, and further operations require another physical touch.
+    Cached,
+}
+
+impl From<TouchPolicy> for u8 {
+    fn from(policy: TouchPolicy) -> u8 {
+        match policy {
+            TouchPolicy::Default => 0,
+            TouchPolicy::Never => 1,
+            TouchPolicy::Always => 2,
+            TouchPolicy::Cached => 3,
+        }
+    }
+}
+
+impl TouchPolicy {
+    /// Writes the `TouchPolicy` in the format the YubiKey expects during key generation
+    /// or importation.
+    pub(crate) fn write(self, buf: &mut [u8]) -> Result<usize> {
+        match self {
+            TouchPolicy::Default => Ok(0),
+            _ => Tlv::write(buf, 0xab, &[self.into()]),
+        }
+    }
+}
+
+impl TryFrom<u8> for TouchPolicy {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            0 => Ok(TouchPolicy::Default),
+            1 => Ok(TouchPolicy::Never),
+            2 => Ok(TouchPolicy::Always),
+            3 => Ok(TouchPolicy::Cached),
+            _ => Err(Error::GenericError),
+        }
+    }
+}

src/reader.rs

@@ -1,18 +1,18 @@
-//! Support for enumerating available readers
+//! Support for enumerating available PC/SC card readers.
 
-use crate::{error::Error, yubikey::YubiKey};
+use crate::{Error, Result, YubiKey};
 use std::{
     borrow::Cow,
-    convert::TryInto,
     ffi::CStr,
+    fmt,
     sync::{Arc, Mutex},
 };
 
 /// Iterator over connected readers
 pub type Iter<'ctx> = std::vec::IntoIter<Reader<'ctx>>;
 
-/// Enumeration support for available readers
+/// PC/SC reader context: used to enumerate available PC/SC [`Reader`]s.
-pub struct Readers {
+pub struct Context {
     /// PC/SC context
     ctx: Arc<Mutex<pcsc::Context>>,
 
@@ -20,10 +20,16 @@ pub struct Readers {
     reader_names: Vec<u8>,
 }
 
-impl Readers {
+impl fmt::Debug for Context {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Context").finish_non_exhaustive()
+    }
+}
+
+impl Context {
     /// Open a PC/SC context, which can be used to enumerate available PC/SC
     /// readers (which can be used to connect to YubiKeys).
-    pub fn open() -> Result<Self, Error> {
+    pub fn open() -> Result<Self> {
         let ctx = pcsc::Context::establish(pcsc::Scope::System)?;
         let reader_names = vec![0u8; ctx.list_readers_len()?];
         Ok(Self {
@@ -32,12 +38,13 @@ impl Readers {
         })
     }
 
-    /// Iterate over the available readers
+    /// Iterate over the available readers.
-    pub fn iter(&mut self) -> Result<Iter<'_>, Error> {
+    pub fn iter(&mut self) -> Result<Iter<'_>> {
         let Self { ctx, reader_names } = self;
 
         let reader_cstrs: Vec<_> = {
-            let c = ctx.lock().unwrap();
+            // TODO(tarcieri): better error?
+            let c = ctx.lock().map_err(|_| Error::GenericError)?;
 
             // ensure PC/SC context is valid
             c.is_valid()?;
@@ -45,6 +52,7 @@ impl Readers {
             c.list_readers(reader_names)?.collect()
         };
 
+        #[allow(clippy::needless_collect)]
         let readers: Vec<_> = reader_cstrs
             .iter()
             .map(|name| Reader::new(name, Arc::clone(ctx)))
@@ -54,7 +62,7 @@ impl Readers {
     }
 }
 
-/// An individual connected reader
+/// An individual connected PC/SC card reader.
 pub struct Reader<'ctx> {
     /// Name of this reader
     name: &'ctx CStr,
@@ -64,26 +72,27 @@ pub struct Reader<'ctx> {
 }
 
 impl<'ctx> Reader<'ctx> {
-    /// Create a new reader from its name and context
+    /// Create a new reader from its name and context.
     fn new(name: &'ctx CStr, ctx: Arc<Mutex<pcsc::Context>>) -> Self {
         // TODO(tarcieri): open devices, determine they're YubiKeys, get serial?
         Self { name, ctx }
     }
 
-    /// Get this reader's name
+    /// Get this reader's name.
     pub fn name(&self) -> Cow<'_, str> {
         // TODO(tarcieri): is lossy ok here? try to avoid lossiness?
         self.name.to_string_lossy()
     }
 
-    /// Open a connection to this reader, returning a `YubiKey` if successful
+    /// Open a connection to this reader, returning a `YubiKey` if successful.
-    pub fn open(&self) -> Result<YubiKey, Error> {
+    pub fn open(&self) -> Result<YubiKey> {
         self.try_into()
     }
 
-    /// Connect to this reader, returning its `pcsc::Card`
+    /// Connect to this reader, returning its `pcsc::Card`.
-    pub(crate) fn connect(&self) -> Result<pcsc::Card, Error> {
+    pub(crate) fn connect(&self) -> Result<pcsc::Card> {
-        let ctx = self.ctx.lock().unwrap();
+        // TODO(tarcieri): better error?
+        let ctx = self.ctx.lock().map_err(|_| Error::GenericError)?;
         Ok(ctx.connect(self.name, pcsc::ShareMode::Shared, pcsc::Protocols::T1)?)
     }
 }

src/serialization.rs

@@ -30,30 +30,134 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use crate::{consts::*, ObjectId};
+use crate::{consts::CB_OBJ_TAG_MIN, Buffer, Error, ObjectId, Result};
+
+pub const OBJ_DISCOVERY: u32 = 0x7e;
 
 // TODO(tarcieri): refactor these into better serializers/message builders
 
+/// A Type-Length-Value object that has been parsed from a buffer.
+pub(crate) struct Tlv<'a> {
+    pub(crate) tag: u8,
+    pub(crate) value: &'a [u8],
+}
+
+impl<'a> Tlv<'a> {
+    /// Parses a `Tlv` from a buffer, returning the remainder of the buffer.
+    pub(crate) fn parse(buffer: &'a [u8]) -> Result<(&'a [u8], Self)> {
+        if buffer.len() < CB_OBJ_TAG_MIN || !has_valid_length(&buffer[1..], buffer.len() - 1) {
+            return Err(Error::SizeError);
+        }
+
+        let tag = buffer[0];
+        let mut len = 0;
+        let offset = 1 + get_length(&buffer[1..], &mut len);
+        let buffer = buffer.get(offset..).ok_or(Error::SizeError)?;
+
+        if buffer.len() >= len {
+            let (value, buffer) = buffer.split_at(len);
+            Ok((buffer, Tlv { tag, value }))
+        } else {
+            Err(Error::SizeError)
+        }
+    }
+
+    /// Takes a [`Buffer`] containing a single `Tlv` with the given tag, and returns a
+    /// `Buffer` containing only the value part of the `Tlv`.
+    pub(crate) fn parse_single(mut buffer: Buffer, tag: u8) -> Result<Buffer> {
+        if buffer.len() < CB_OBJ_TAG_MIN || !has_valid_length(&buffer[1..], buffer.len() - 1) {
+            return Err(Error::SizeError);
+        }
+
+        if tag != buffer[0] {
+            return Err(Error::GenericError);
+        };
+
+        let mut len = 0;
+        let offset = 1 + get_length(&buffer[1..], &mut len);
+
+        buffer.copy_within(offset..offset + len, 0);
+        buffer.truncate(len);
+        Ok(buffer)
+    }
+
+    /// Writes a TLV to the given buffer.
+    pub(crate) fn write(buffer: &mut [u8], tag: u8, value: &[u8]) -> Result<usize> {
+        if buffer.len() < CB_OBJ_TAG_MIN {
+            return Err(Error::SizeError);
+        }
+        buffer[0] = tag;
+
+        let offset = 1 + set_length(&mut buffer[1..], value.len())?;
+
+        if buffer.len() < offset + value.len() {
+            return Err(Error::SizeError);
+        }
+        buffer[offset..offset + value.len()].copy_from_slice(value);
+
+        Ok(offset + value.len())
+    }
+
+    /// Writes a TLV to the given buffer.
+    ///
+    /// `value` is guaranteed to be called with a mutable slice of length `length`.
+    pub(crate) fn write_as<Gen>(
+        buffer: &mut [u8],
+        tag: u8,
+        length: usize,
+        value: Gen,
+    ) -> Result<usize>
+    where
+        Gen: FnOnce(&mut [u8]),
+    {
+        if buffer.len() < CB_OBJ_TAG_MIN {
+            return Err(Error::SizeError);
+        }
+        buffer[0] = tag;
+
+        let offset = 1 + set_length(&mut buffer[1..], length)?;
+
+        if buffer.len() < offset + length {
+            return Err(Error::SizeError);
+        }
+        value(&mut buffer[offset..offset + length]);
+
+        Ok(offset + length)
+    }
+}
+
 /// Set length
-pub(crate) fn set_length(buffer: &mut [u8], length: usize) -> usize {
+pub(crate) fn set_length(buffer: &mut [u8], length: usize) -> Result<usize> {
     if length < 0x80 {
+        if buffer.is_empty() {
+            Err(Error::SizeError)
+        } else {
             buffer[0] = length as u8;
-        1
+            Ok(1)
+        }
     } else if length < 0x100 {
+        if buffer.len() < 2 {
+            Err(Error::SizeError)
+        } else {
             buffer[0] = 0x81;
             buffer[1] = length as u8;
-        2
+            Ok(2)
+        }
+    } else if buffer.len() < 3 {
+        Err(Error::SizeError)
     } else {
         buffer[0] = 0x82;
         buffer[1] = ((length >> 8) & 0xff) as u8;
         buffer[2] = (length & 0xff) as u8;
-        3
+        Ok(3)
     }
 }
 
 /// Parse length tag, returning the size of the length tag itself as the
 /// returned value, and setting the len parameter to the parsed length.
 pub(crate) fn get_length(buffer: &[u8], len: &mut usize) -> usize {
+    // This is not valid ASN.1 (0x80 is the indefinite length marker).
+    // See comment in key::generate for more context.
     if buffer[0] < 0x81 {
         *len = buffer[0] as usize;
         1
@@ -83,9 +187,9 @@ pub(crate) fn has_valid_length(buffer: &[u8], len: usize) -> bool {
 pub(crate) fn set_object(object_id: ObjectId, mut buffer: &mut [u8]) -> &mut [u8] {
     buffer[0] = 0x5c;
 
-    if object_id == YKPIV_OBJ_DISCOVERY {
+    if object_id == OBJ_DISCOVERY {
         buffer[1] = 1;
-        buffer[2] = YKPIV_OBJ_DISCOVERY as u8;
+        buffer[2] = OBJ_DISCOVERY as u8;
         buffer = &mut buffer[3..];
     } else if object_id > 0xffff && object_id <= 0x00ff_ffff {
         buffer[1] = 3;

src/setting.rs

@@ -0,0 +1,127 @@
+//! Configuration setting values parsed from the environment and config file:
+//! `/etc/yubico/yubikeypiv.conf`
+
+// Adapted from yubico-piv-tool:
+// <https://github.com/Yubico/yubico-piv-tool/>
+//
+// Copyright (c) 2014-2016 Yubico AB
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//   * Redistributions of source code must retain the above copyright
+//     notice, this list of conditions and the following disclaimer.
+//
+//   * Redistributions in binary form must reproduce the above
+//     copyright notice, this list of conditions and the following
+//     disclaimer in the documentation and/or other materials provided
+//     with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/// Default location of the YubiKey PIV configuration file
+pub const DEFAULT_CONFIG_FILE: &str = "/etc/yubico/yubikeypiv.conf";
+
+use std::{
+    env,
+    fs::File,
+    io::{BufRead, BufReader},
+};
+
+/// Source of how a setting was configured.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub enum SettingSource {
+    /// User-specified setting: sourced via `YUBIKEY_PIV_*` environment vars.
+    User,
+
+    /// Admin-specified setting: sourced via the `/etc/yubico/yubikeypiv.conf`
+    /// configuration file.
+    Admin,
+
+    /// Default setting.
+    #[default]
+    Default,
+}
+
+/// Setting booleans: configuration values sourced from a file or the environment.
+///
+/// These can be configured globally in `/etc/yubico/yubikeypiv.conf` by a
+/// system administrator, or by the local user via `YUBIKEY_PIV_*` environment
+/// variables.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Setting {
+    /// Boolean value
+    pub value: bool,
+
+    /// Source of the configuration setting (user, admin, or default)
+    pub source: SettingSource,
+}
+
+impl Setting {
+    /// Get a setting by name.
+    pub fn get(key: &str, default: bool) -> Self {
+        Self::from_file(key)
+            .or_else(|| Self::from_env(key))
+            .unwrap_or(Self {
+                value: default,
+                source: SettingSource::Default,
+            })
+    }
+
+    /// Get a boolean config value from the provided config file
+    fn from_file(key: &str) -> Option<Self> {
+        if let Ok(file) = File::open(DEFAULT_CONFIG_FILE) {
+            for line in BufReader::new(file).lines() {
+                let line = match line {
+                    Ok(line) => line,
+                    _ => continue,
+                };
+
+                if line.starts_with('#') || line.starts_with('\r') || line.starts_with('\n') {
+                    continue;
+                }
+
+                let (name, value) = {
+                    let mut parts = line.splitn(2, '=');
+                    let name = parts.next();
+                    let value = parts.next();
+                    match (name, value, parts.next()) {
+                        (Some(name), Some(value), None) => (name.trim(), value.trim()),
+                        _ => continue,
+                    }
+                };
+
+                if name == key {
+                    return Some(Setting {
+                        source: SettingSource::Admin,
+                        value: value == "1" || value == "true",
+                    });
+                }
+            }
+        }
+
+        None
+    }
+
+    /// Get a setting boolean from an environment variable
+    fn from_env(key: &str) -> Option<Self> {
+        env::var(format!("YUBIKEY_PIV_{key}"))
+            .ok()
+            .map(|value| Setting {
+                source: SettingSource::User,
+                value: value == "1" || value == "true",
+            })
+    }
+}

src/settings.rs

@@ -1,138 +0,0 @@
-//! Configuration setting values parsed from the environment and config file:
-//! `/etc/yubico/yubikeypiv.conf`
-
-// Adapted from yubico-piv-tool:
-// <https://github.com/Yubico/yubico-piv-tool/>
-//
-// Copyright (c) 2014-2016 Yubico AB
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//   * Redistributions of source code must retain the above copyright
-//     notice, this list of conditions and the following disclaimer.
-//
-//   * Redistributions in binary form must reproduce the above
-//     copyright notice, this list of conditions and the following
-//     disclaimer in the documentation and/or other materials provided
-//     with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-/// Default location of the YubiKey PIV configuration file
-pub const DEFAULT_CONFIG_FILE: &str = "/etc/yubico/yubikeypiv.conf";
-
-use std::{
-    env,
-    fs::File,
-    io::{BufRead, BufReader},
-};
-
-/// Source of how a setting was configured
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Source {
-    /// User-specified setting
-    User,
-
-    /// Admin-specified setting
-    Admin,
-
-    /// Default setting
-    Default,
-}
-
-/// Setting booleans
-#[derive(Copy, Clone, Debug)]
-pub struct BoolValue {
-    /// Boolean value
-    pub value: bool,
-
-    /// Source of the configuration setting (user/admin/default)
-    pub source: Source,
-}
-
-impl BoolValue {
-    /// Get a [`BoolValue`] value
-    pub fn get(key: &str, def: bool) -> Self {
-        let mut setting = get_setting_from_file(key);
-
-        if setting.source == Source::Default {
-            setting = get_setting_from_env(key);
-        }
-
-        if setting.source == Source::Default {
-            setting.value = def;
-        }
-
-        setting
-    }
-}
-
-/// Get a boolean config value
-fn get_setting_from_file(key: &str) -> BoolValue {
-    let mut setting: BoolValue = BoolValue {
-        value: false,
-        source: Source::Default,
-    };
-
-    let file = match File::open(DEFAULT_CONFIG_FILE) {
-        Ok(f) => f,
-        Err(_) => return setting,
-    };
-
-    for line in BufReader::new(file).lines() {
-        let line = match line {
-            Ok(line) => line,
-            _ => continue,
-        };
-
-        if line.starts_with('#') || line.starts_with('\r') || line.starts_with('\n') {
-            continue;
-        }
-
-        let (name, value) = {
-            let mut parts = line.splitn(1, '=');
-            let name = parts.next();
-            let value = parts.next();
-            match (name, value, parts.next()) {
-                (Some(name), Some(value), None) => (name.trim(), value.trim()),
-                _ => continue,
-            }
-        };
-
-        if name == key {
-            setting.source = Source::Admin;
-            setting.value = value == "1" || value == "true";
-            break;
-        }
-    }
-
-    setting
-}
-
-/// Get a setting boolean from an environment variable
-fn get_setting_from_env(key: &str) -> BoolValue {
-    let mut setting: BoolValue = BoolValue {
-        value: false,
-        source: Source::Default,
-    };
-
-    if let Ok(value) = env::var(format!("YUBIKEY_PIV_{}", key)) {
-        setting.source = Source::User;
-        setting.value = value == "1" || value == "true";
-    }
-
-    setting
-}

src/transaction.rs

@@ -1,46 +1,45 @@
 //! YubiKey PC/SC transactions
 
 use crate::{
-    apdu::{Ins, APDU},
+    apdu::Response,
-    error::Error,
+    apdu::{Apdu, Ins, StatusWords},
-    yubikey::*,
+    consts::{CB_BUF_MAX, CB_OBJ_MAX},
-};
+    error::{Error, Result},
-#[cfg(feature = "untested")]
-use crate::{
-    apdu::{Response, StatusWords},
-    consts::*,
-    key::{AlgorithmId, SlotId},
     mgm::MgmKey,
+    otp,
+    piv::{self, AlgorithmId, SlotId},
     serialization::*,
+    yubikey::*,
     Buffer, ObjectId,
 };
 use log::{error, trace};
-use std::convert::TryInto;
-#[cfg(feature = "untested")]
 use zeroize::Zeroizing;
 
+#[cfg(feature = "untested")]
+use crate::mgm::{DeviceConfig, DeviceInfo, Lock};
+
+const CB_PIN_MAX: usize = 8;
+
+#[cfg(feature = "untested")]
+pub(crate) enum ChangeRefAction {
+    ChangePin,
+    ChangePuk,
+    UnblockPin,
+}
+
 /// Exclusive transaction with the YubiKey's PC/SC card.
 pub(crate) struct Transaction<'tx> {
     inner: pcsc::Transaction<'tx>,
 }
 
 impl<'tx> Transaction<'tx> {
-    /// Create a new transaction with the given card
+    /// Create a new transaction with the given card.
-    pub fn new(card: &'tx mut pcsc::Card) -> Result<Self, Error> {
+    pub fn new(card: &'tx mut pcsc::Card) -> Result<Self> {
         Ok(Transaction {
             inner: card.transaction()?,
         })
     }
 
-    /// Get an attribute of the card or card reader.
-    pub fn get_attribute<'buf>(
-        &self,
-        attribute: pcsc::Attribute,
-        buffer: &'buf mut [u8],
-    ) -> Result<&'buf [u8], Error> {
-        Ok(self.inner.get_attribute(attribute, buffer)?)
-    }
-
     /// Transmit a single serialized APDU to the card this transaction is open
     /// with and receive a response.
     ///
@@ -48,7 +47,7 @@ impl<'tx> Transaction<'tx> {
     /// single APDU messages at a time. For larger messages that need to be
     /// split into multiple APDUs, use the [`Transaction::transfer_data`]
     /// method instead.
-    pub fn transmit(&self, send_buffer: &[u8], recv_len: usize) -> Result<Vec<u8>, Error> {
+    pub fn transmit(&self, send_buffer: &[u8], recv_len: usize) -> Result<Vec<u8>> {
         trace!(">>> {:?}", send_buffer);
 
         let mut recv_buffer = vec![0u8; recv_len];
@@ -62,113 +61,128 @@ impl<'tx> Transaction<'tx> {
         Ok(recv_buffer)
     }
 
+    /// Select PIV application.
+    pub fn select_piv_application(&self) -> Result<()> {
+        self.select_application(
+            piv::APPLET_ID,
+            piv::APPLET_NAME,
+            "failed selecting application",
+        )
+    }
+
     /// Select application.
-    pub fn select_application(&self) -> Result<(), Error> {
+    pub fn select_application(
-        let response = APDU::new(Ins::SelectApplication)
+        &self,
+        applet: &[u8],
+        applet_name: &'static str,
+        error: &'static str,
+    ) -> Result<()> {
+        let response = Apdu::new(Ins::SelectApplication)
             .p1(0x04)
-            .data(&AID)
+            .data(applet)
             .transmit(self, 0xFF)
-            .map_err(|e| {
+            .inspect_err(|e| error!("failed communicating with card: '{}'", e))?;
-                error!("failed communicating with card: '{}'", e);
-                e
-            })?;
 
         if !response.is_success() {
-            error!(
+            error!("{}: {:04x}", error, response.status_words().code());
-                "failed selecting application: {:04x}",
+            return Err(match response.status_words() {
-                response.status_words().code()
+                StatusWords::NotFoundError => Error::AppletNotFound { applet_name },
-            );
+                _ => Error::GenericError,
-            return Err(Error::GenericError);
+            });
         }
 
         Ok(())
     }
 
-    /// Get the version of the PIV application installed on the YubiKey
+    /// Get the version of the PIV application installed on the YubiKey.
-    pub fn get_version(&self) -> Result<Version, Error> {
+    pub fn get_version(&self) -> Result<Version> {
         // get version from device
-        let response = APDU::new(Ins::GetVersion).transmit(self, 261)?;
+        let response = Apdu::new(Ins::GetVersion).transmit(self, 261)?;
+
+        if !response.is_success() || response.data().is_empty() {
+            return Err(Error::GenericError);
+        }
+
+        Ok(response.data()[..3].try_into().map(Version::new)?)
+    }
+
+    /// Get YubiKey device serial number.
+    pub fn get_serial(&self, version: Version) -> Result<Serial> {
+        match version.major {
+            // YK4 requires switching to the YK applet to retrieve the serial
+            4 => {
+                self.select_application(
+                    otp::APPLET_ID,
+                    otp::APPLET_NAME,
+                    "failed selecting yk application",
+                )?;
+
+                let response = Apdu::new(0x01).p1(0x10).transmit(self, 0xFF)?;
 
                 if !response.is_success() {
-            return Err(Error::GenericError);
+                    // TODO(tarcieri): still reselect the PIV applet in this case?
-        }
-
-        if response.data().len() < 3 {
-            return Err(Error::SizeError);
-        }
-
-        Ok(Version::new(response.data()[..3].try_into().unwrap()))
-    }
-
-    /// Get YubiKey device serial number
-    pub fn get_serial(&self, version: Version) -> Result<Serial, Error> {
-        let yk_applet = [0xa0, 0x00, 0x00, 0x05, 0x27, 0x20, 0x01, 0x01];
-
-        let response = if version.major < 5 {
-            // get serial from neo/yk4 devices using the otp applet
-            let sw = APDU::new(Ins::SelectApplication)
-                .p1(0x04)
-                .data(&yk_applet)
-                .transmit(self, 0xFF)?
-                .status_words();
-
-            if !sw.is_success() {
-                error!("failed selecting yk application: {:04x}", sw.code());
-                return Err(Error::GenericError);
-            }
-
-            let resp = APDU::new(0x01).p1(0x10).transmit(self, 0xFF)?;
-
-            if !resp.is_success() {
                     error!(
                         "failed retrieving serial number: {:04x}",
-                    resp.status_words().code()
+                        response.status_words().code()
                     );
                     return Err(Error::GenericError);
                 }
 
                 // reselect the PIV applet
-            let sw = APDU::new(Ins::SelectApplication)
+                self.select_application(
-                .p1(0x04)
+                    piv::APPLET_ID,
-                .data(&AID)
+                    piv::APPLET_NAME,
-                .transmit(self, 0xFF)?
+                    "failed selecting application",
-                .status_words();
+                )?;
 
-            if !sw.is_success() {
+                response.data().try_into()
-                error!("failed selecting application: {:04x}", sw.code());
-                return Err(Error::GenericError);
             }
 
-            resp
+            // YK5 implements getting the serial as a PIV applet command (0xf8)
-        } else {
+            5 => {
-            // get serial from yk5 and later devices using the f8 command
+                let response = Apdu::new(Ins::GetSerial).transmit(self, 0xFF)?;
-            let resp = APDU::new(Ins::GetSerial).transmit(self, 0xFF)?;
 
-            if !resp.is_success() {
+                if !response.is_success() {
                     error!(
                         "failed retrieving serial number: {:04x}",
-                    resp.status_words().code()
+                        response.status_words().code()
                     );
                     return Err(Error::GenericError);
                 }
 
-            resp
+                response.data().try_into()
-        };
+            }
 
-        response.data()[..4]
+            // Other versions unsupported
-            .try_into()
+            _ => Err(Error::NotSupported),
-            .map(|serial| Serial::from(u32::from_be_bytes(serial)))
+        }
-            .map_err(|_| Error::SizeError)
+    }
+
+    /// Read metadata
+    pub(crate) fn get_metadata(&self, slot: SlotId) -> Result<piv::SlotMetadata> {
+        let response = Apdu::new(Ins::GetMetadata)
+            .p2(slot.into())
+            .transmit(self, CB_OBJ_MAX)?;
+
+        match response.status_words() {
+            StatusWords::Success => {
+                let buf = Buffer::new(response.data().into());
+                piv::SlotMetadata::try_from(buf)
+            }
+            StatusWords::ReferenceDataNotFoundError => Err(Error::NotFound),
+            // Requires firmware 5.2.3
+            StatusWords::NotSupportedError => Err(Error::NotSupported),
+            _ => Err(Error::GenericError),
+        }
     }
 
     /// Verify device PIN.
-    #[cfg(feature = "untested")]
+    pub fn verify_pin(&self, pin: &[u8]) -> Result<()> {
-    pub fn verify_pin(&self, pin: &[u8]) -> Result<(), Error> {
         if pin.len() > CB_PIN_MAX {
             return Err(Error::SizeError);
         }
 
-        let mut query = APDU::new(Ins::Verify);
+        let mut query = Apdu::new(Ins::Verify);
         query.params(0x00, 0x80);
 
         // Empty pin means we are querying the number of retries. We set no data in this
@@ -177,7 +191,7 @@ impl<'tx> Transaction<'tx> {
         if !pin.is_empty() {
             let mut data = Zeroizing::new([0xff; CB_PIN_MAX]);
             data[0..pin.len()].copy_from_slice(pin);
-            query.data(data.as_ref());
+            query.data(data.as_slice());
         }
 
         let response = query.transmit(self, 261)?;
@@ -190,20 +204,26 @@ impl<'tx> Transaction<'tx> {
         }
     }
 
-    /// Change the PIN
+    /// Change the PIN.
     #[cfg(feature = "untested")]
-    pub fn change_pin(&self, action: i32, current_pin: &[u8], new_pin: &[u8]) -> Result<(), Error> {
+    pub fn change_ref(
-        let mut templ = [0, Ins::ChangeReference.code(), 0, 0x80];
+        &self,
-
+        action: ChangeRefAction,
+        current_pin: &[u8],
+        new_pin: &[u8],
+    ) -> Result<()> {
         if current_pin.len() > CB_PIN_MAX || new_pin.len() > CB_PIN_MAX {
             return Err(Error::SizeError);
         }
 
-        if action == CHREF_ACT_UNBLOCK_PIN {
+        const PIN: u8 = 0x80;
-            templ[1] = Ins::ResetRetry.code();
+        const PUK: u8 = 0x81;
-        } else if action == CHREF_ACT_CHANGE_PUK {
+
-            templ[3] = 0x81;
+        let templ = match action {
-        }
+            ChangeRefAction::ChangePin => [0, Ins::ChangeReference.code(), 0, PIN],
+            ChangeRefAction::ChangePuk => [0, Ins::ChangeReference.code(), 0, PUK],
+            ChangeRefAction::UnblockPin => [0, Ins::ResetRetry.code(), 0, PIN],
+        };
 
         let mut indata = Zeroizing::new([0xff; CB_PIN_MAX * 2]);
         indata[0..current_pin.len()].copy_from_slice(current_pin);
@@ -228,25 +248,18 @@ impl<'tx> Transaction<'tx> {
     }
 
     /// Set the management key (MGM).
-    #[cfg(feature = "untested")]
+    pub fn set_mgm_key(&self, new_key: &MgmKey, require_touch: bool) -> Result<()> {
-    pub fn set_mgm_key(&self, new_key: &MgmKey, touch: Option<u8>) -> Result<(), Error> {
+        let p2 = if require_touch { 0xfe } else { 0xff };
-        let p2 = match touch.unwrap_or_default() {
-            0 => 0xff,
-            1 => 0xfe,
-            _ => {
-                return Err(Error::GenericError);
-            }
-        };
 
-        let mut data = [0u8; DES_LEN_3DES + 3];
+        let mut data = Vec::with_capacity(usize::from(new_key.key_size()) + 3);
-        data[0] = YKPIV_ALGO_3DES;
+        data.push(new_key.algorithm_id().into());
-        data[1] = YKPIV_KEY_CARDMGM;
+        data.push(KEY_CARDMGM);
-        data[2] = DES_LEN_3DES as u8;
+        data.push(new_key.key_size());
-        data[3..3 + DES_LEN_3DES].copy_from_slice(new_key.as_ref());
+        data.extend_from_slice(new_key.as_ref());
 
-        let status_words = APDU::new(Ins::SetMgmKey)
+        let status_words = Apdu::new(Ins::SetMgmKey)
             .params(0xff, p2)
-            .data(&data)
+            .data(data)
             .transmit(self, 261)?
             .status_words();
 
@@ -262,7 +275,6 @@ impl<'tx> Transaction<'tx> {
     /// This is the common backend for all public key encryption and signing
     /// operations.
     // TODO(tarcieri): refactor this to be less gross/coupled.
-    #[cfg(feature = "untested")]
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn authenticated_command(
         &self,
@@ -270,21 +282,29 @@ impl<'tx> Transaction<'tx> {
         algorithm: AlgorithmId,
         key: SlotId,
         decipher: bool,
-    ) -> Result<Buffer, Error> {
+    ) -> Result<Buffer> {
         let in_len = sign_in.len();
         let mut indata = [0u8; 1024];
         let templ = [0, Ins::Authenticate.code(), algorithm.into(), key.into()];
-        let mut len: usize = 0;
 
         match algorithm {
-            AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => {
+            AlgorithmId::Rsa1024 => {
-                let key_len = if let AlgorithmId::Rsa1024 = algorithm {
+                if in_len != 128 {
-                    128
+                    return Err(Error::SizeError);
-                } else {
+                }
-                    256
+            }
-                };
+            AlgorithmId::Rsa2048 => {
-
+                if in_len != 256 {
-                if in_len != key_len {
+                    return Err(Error::SizeError);
+                }
+            }
+            AlgorithmId::Rsa3072 => {
+                if in_len != 384 {
+                    return Err(Error::SizeError);
+                }
+            }
+            AlgorithmId::Rsa4096 => {
+                if in_len != 512 {
                     return Err(Error::SizeError);
                 }
             }
@@ -300,6 +320,19 @@ impl<'tx> Transaction<'tx> {
                     return Err(Error::SizeError);
                 }
             }
+            AlgorithmId::X25519 => {
+                if !decipher {
+                    return Err(Error::NotSupported);
+                }
+                if in_len != 32 {
+                    return Err(Error::SizeError);
+                }
+            }
+            AlgorithmId::Ed25519 => {
+                if decipher {
+                    return Err(Error::NotSupported);
+                }
+            }
         }
 
         let bytes = if in_len < 0x80 {
@@ -310,26 +343,27 @@ impl<'tx> Transaction<'tx> {
             3
         };
 
-        indata[0] = 0x7c;
+        let offset = Tlv::write_as(&mut indata, 0x7c, in_len + bytes + 3, |buf| {
-        let mut offset = 1 + set_length(&mut indata[1..], in_len + bytes + 3);
+            assert_eq!(Tlv::write(buf, 0x82, &[]).expect("large enough"), 2);
-        indata[offset] = 0x82;
+            assert_eq!(
-        indata[offset + 1] = 0x00;
+                Tlv::write(
-        indata[offset + 2] = match (algorithm, decipher) {
+                    &mut buf[2..],
-            (AlgorithmId::EccP256, true) | (AlgorithmId::EccP384, true) => 0x85,
+                    match (algorithm, decipher) {
+                        (AlgorithmId::EccP256, true)
+                        | (AlgorithmId::EccP384, true)
+                        | (AlgorithmId::X25519, true) => 0x85,
                         _ => 0x81,
-        };
+                    },
-
+                    sign_in
-        offset += 3;
+                )
-        offset += set_length(&mut indata[offset..], in_len);
+                .expect("large enough"),
-        indata[offset..(offset + in_len)].copy_from_slice(sign_in);
+                1 + bytes + in_len
-        offset += in_len;
+            );
+        })?;
 
         let response = self
             .transfer_data(&templ, &indata[..offset], 1024)
-            .map_err(|e| {
+            .inspect_err(|e| error!("sign command failed to communicate: {}", e))?;
-                error!("sign command failed to communicate: {}", e);
-                e
-            })?;
 
         if !response.is_success() {
             error!("failed sign command with code {:x}", response.code());
@@ -341,41 +375,33 @@ impl<'tx> Transaction<'tx> {
             }
         }
 
-        let data = response.data();
+        let (_, outer_tlv) = Tlv::parse(response.data())?;
 
         // skip the first 7c tag
-        if data[0] != 0x7c {
+        if outer_tlv.tag != 0x7c {
             error!("failed parsing signature reply (0x7c byte)");
             return Err(Error::ParseError);
         }
 
-        let mut offset = 1 + get_length(&data[1..], &mut len);
+        let (_, inner_tlv) = Tlv::parse(outer_tlv.value)?;
 
         // skip the 82 tag
-        if data[offset] != 0x82 {
+        if inner_tlv.tag != 0x82 {
             error!("failed parsing signature reply (0x82 byte)");
             return Err(Error::ParseError);
         }
 
-        offset += 1;
+        Ok(Buffer::new(inner_tlv.value.into()))
-        offset += get_length(&data[offset..], &mut len);
-        Ok(Buffer::new(data[offset..(offset + len)].into()))
     }
 
     /// Send/receive large amounts of data to/from the YubiKey, splitting long
     /// messages into smaller APDU-sized messages (using the provided APDU
     /// template to construct them), and then sending those via
     /// [`Transaction::transmit`].
-    #[cfg(feature = "untested")]
+    pub fn transfer_data(&self, templ: &[u8], in_data: &[u8], max_out: usize) -> Result<Response> {
-    pub fn transfer_data(
-        &self,
-        templ: &[u8],
-        in_data: &[u8],
-        max_out: usize,
-    ) -> Result<Response, Error> {
         let mut in_offset = 0;
         let mut out_data = vec![];
-        let mut sw = 0;
+        let mut sw;
 
         loop {
             let mut this_size = 0xff;
@@ -389,18 +415,19 @@ impl<'tx> Transaction<'tx> {
 
             trace!("going to send {} bytes in this go", this_size);
 
-            let response = APDU::new(templ[1])
+            let response = Apdu::new(templ[1])
                 .cla(cla)
                 .params(templ[2], templ[3])
                 .data(&in_data[in_offset..(in_offset + this_size)])
                 .transmit(self, 261)?;
 
-            if !response.is_success() && (response.status_words().code() >> 8 != 0x61) {
+            sw = response.status_words();
-                // TODO(tarcieri): is this really OK?
-                return Ok(Response::new(sw.into(), out_data));
-            }
 
-            sw = response.status_words().code();
+            match sw {
+                StatusWords::Success | StatusWords::BytesRemaining { .. } => (),
+                // TODO(tarcieri): is this really OK?
+                _ => return Ok(Response::new(sw, out_data)),
+            }
 
             if !out_data.is_empty() && (out_data.len() - response.data().len() > max_out) {
                 error!(
@@ -420,17 +447,15 @@ impl<'tx> Transaction<'tx> {
             }
         }
 
-        while sw >> 8 == 0x61 {
+        while let StatusWords::BytesRemaining { len } = sw {
-            trace!(
+            trace!("The card indicates there is {} bytes more data for us", len);
-                "The card indicates there is {} bytes more data for us",
-                sw & 0xff
-            );
 
-            let response = APDU::new(Ins::GetResponseApdu).transmit(self, 261)?;
+            let response = Apdu::new(Ins::GetResponseApdu).transmit(self, 261)?;
-            sw = response.status_words().code();
+            sw = response.status_words();
 
-            if sw != StatusWords::Success.code() && (sw >> 8 != 0x61) {
+            match sw {
-                return Ok(Response::new(sw.into(), vec![]));
+                StatusWords::Success | StatusWords::BytesRemaining { .. } => (),
+                _ => return Ok(Response::new(sw, vec![])),
             }
 
             if out_data.len() + response.data().len() > max_out {
@@ -446,12 +471,11 @@ impl<'tx> Transaction<'tx> {
             out_data.extend_from_slice(&response.data()[..response.data().len()]);
         }
 
-        Ok(Response::new(sw.into(), out_data))
+        Ok(Response::new(sw, out_data))
     }
 
-    /// Fetch an object
+    /// Fetch an object.
-    #[cfg(feature = "untested")]
+    pub fn fetch_object(&self, object_id: ObjectId) -> Result<Buffer> {
-    pub fn fetch_object(&self, object_id: ObjectId) -> Result<Buffer, Error> {
         let mut indata = [0u8; 5];
         let templ = [0, Ins::GetData.code(), 0x3f, 0xff];
 
@@ -462,40 +486,30 @@ impl<'tx> Transaction<'tx> {
         let response = self.transfer_data(&templ, &indata[..inlen], CB_BUF_MAX)?;
 
         if !response.is_success() {
+            if response.status_words() == StatusWords::NotFoundError {
+                return Err(Error::NotFound);
+            } else {
                 return Err(Error::GenericError);
             }
-
-        let data = Buffer::new(response.data().into());
-        let mut outlen = 0;
-
-        if data.len() < 2 || !has_valid_length(&data[1..], data.len() - 1) {
-            return Err(Error::SizeError);
         }
 
-        let offs = get_length(&data[1..], &mut outlen);
+        let (remaining, tlv) = Tlv::parse(response.data())?;
 
-        if offs == 0 {
+        if !remaining.is_empty() {
-            return Err(Error::SizeError);
-        }
-
-        if outlen + offs + 1 != data.len() {
             error!(
                 "invalid length indicated in object: total len is {} but indicated length is {}",
-                data.len(),
+                tlv.value.len() + remaining.len(),
-                outlen
+                tlv.value.len()
             );
 
             return Err(Error::SizeError);
         }
 
-        Ok(Zeroizing::new(
+        Ok(Zeroizing::new(tlv.value.to_vec()))
-            data[(1 + offs)..(1 + offs + outlen)].to_vec(),
-        ))
     }
 
-    /// Save an object
+    /// Save an object.
-    #[cfg(feature = "untested")]
+    pub fn save_object(&self, object_id: ObjectId, indata: &[u8]) -> Result<()> {
-    pub fn save_object(&self, object_id: ObjectId, indata: &[u8]) -> Result<(), Error> {
         let templ = [0, Ins::PutData.code(), 0x3f, 0xff];
 
         // TODO(tarcieri): replace with vector
@@ -508,14 +522,8 @@ impl<'tx> Transaction<'tx> {
         let mut len = data.len();
         let mut data_remaining = set_object(object_id, &mut data);
 
-        data_remaining[0] = 0x53;
+        let offset = Tlv::write(data_remaining, 0x53, indata)?;
-        data_remaining = &mut data_remaining[1..];
-
-        let offset = set_length(data_remaining, indata.len());
         data_remaining = &mut data_remaining[offset..];
-        data_remaining[..indata.len()].copy_from_slice(indata);
-
-        data_remaining = &mut data_remaining[indata.len()..];
         len -= data_remaining.len();
 
         let status_words = self
@@ -528,4 +536,66 @@ impl<'tx> Transaction<'tx> {
             _ => Err(Error::GenericError),
         }
     }
+
+    /// Write configuration to the YubiKey
+    #[cfg(feature = "untested")]
+    pub fn write_config(
+        &mut self,
+        version: Version,
+        config: DeviceConfig,
+        current_lock: Option<Lock>,
+        new_lock: Option<Lock>,
+    ) -> Result<()> {
+        if version
+            < (Version {
+                major: 5,
+                minor: 0,
+                patch: 0,
+            })
+        {
+            return Err(Error::NotSupported);
+        }
+
+        let data = config.as_tlv(true, current_lock, new_lock)?;
+
+        let response = Apdu::new(Ins::WriteConfig)
+            .params(0x00, 0x00)
+            .data(&data)
+            .transmit(self, 2)?;
+
+        if !response.is_success() {
+            error!(
+                "Unable to write_config: {:04x}",
+                response.status_words().code()
+            );
+            return Err(Error::GenericError);
+        }
+
+        Ok(())
+    }
+
+    /// Write configuration to the YubiKey
+    #[cfg(feature = "untested")]
+    pub fn read_config(&mut self) -> Result<DeviceInfo> {
+        let mut data = [0u8; CB_BUF_MAX];
+        let mut len = data.len();
+        let data_remaining = &mut data[..];
+
+        len -= data_remaining.len();
+        let response = Apdu::new(Ins::ReadConfig)
+            .params(0x00, 0x00)
+            .data(&data[..len])
+            .transmit(self, CB_BUF_MAX + 2)?;
+
+        if !response.is_success() {
+            error!(
+                "Unable to read configuration: {:04x}",
+                response.status_words().code()
+            );
+            return Err(Error::GenericError);
+        }
+
+        let data = response.data();
+        DeviceInfo::parse(data)
+    }
 }

tests/assets/Bob.crt

@@ -0,0 +1,85 @@
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            d4:29:8f:df:8a:af:7b:c0:d7:bf:19:9d:90:d5:ef:ca
+    Signature Algorithm: sha256WithRSAEncryption
+        Issuer: CN=Ferdinand Linnenberg CA
+        Validity
+            Not Before: Feb 10 12:25:37 2022 GMT
+            Not After : May 15 12:25:37 2024 GMT
+        Subject: CN=Bob
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+                Public-Key: (2048 bit)
+                Modulus:
+                    00:d5:27:9b:99:1b:3a:36:64:36:c8:e5:78:64:b6:
+                    9d:70:9d:29:6c:0e:85:91:4b:78:3b:dc:16:c3:09:
+                    8c:d3:74:20:8c:6f:ed:c3:90:c9:1b:4d:80:d5:46:
+                    da:52:7f:d2:2f:bc:b2:f7:40:8d:ad:dd:24:b9:5c:
+                    dc:a2:21:2f:48:ec:06:93:8b:89:f0:cd:63:ff:a1:
+                    fd:ce:36:d5:07:7a:1e:0e:cf:68:a8:c1:b3:7f:62:
+                    84:b7:e1:cf:25:7b:3f:a8:3c:ac:07:1a:fd:c2:e1:
+                    e0:9e:26:24:c1:0d:6d:9d:c6:57:6a:b4:39:28:3d:
+                    88:3e:c9:6a:89:90:72:4a:7b:75:c5:5e:1b:5e:5c:
+                    32:54:a3:ff:eb:01:68:7f:89:b4:4c:01:3f:08:8e:
+                    6c:61:49:60:26:0b:26:58:81:d7:1a:57:ee:52:5c:
+                    05:47:de:da:eb:b5:92:9d:5b:ce:26:18:44:59:3e:
+                    27:d0:61:86:e2:f4:c6:d9:c7:2b:1f:cb:ea:78:f0:
+                    a1:a9:57:d7:98:4c:c1:2f:ae:6a:38:b4:34:53:2e:
+                    5a:9e:f8:58:c7:51:e7:fd:b8:27:cd:87:72:26:c1:
+                    7d:14:c7:cd:fb:f2:04:8a:c4:8f:61:cf:a8:78:bd:
+                    21:be:28:cb:e8:a8:65:29:28:82:46:2f:18:e6:ff:
+                    6f:53
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Basic Constraints: 
+                CA:FALSE
+            X509v3 Subject Key Identifier: 
+                B5:A5:F0:37:25:97:AD:BE:F1:43:52:45:4D:8B:A0:5E:E9:78:21:B8
+            X509v3 Authority Key Identifier: 
+                keyid:26:4E:EB:B0:A5:1B:08:A8:90:2A:85:04:73:84:B5:A5:2C:61:D6:91
+                DirName:/CN=Ferdinand Linnenberg CA
+                serial:8C:E0:40:D9:D8:60:E5:77
+
+            X509v3 Extended Key Usage: 
+                TLS Web Client Authentication
+            X509v3 Key Usage: 
+                Digital Signature
+    Signature Algorithm: sha256WithRSAEncryption
+         19:f3:eb:c1:95:e6:d5:a9:33:d7:2e:02:d8:3a:91:84:81:14:
+         93:fc:03:4d:b1:4b:9d:0b:9b:94:93:9f:1a:0d:87:31:a1:fa:
+         a6:c7:3a:6b:18:24:12:ab:28:fb:c8:e3:09:a2:5d:50:49:00:
+         d9:18:e6:4a:09:18:e0:1c:da:d3:19:96:3d:74:72:fe:e0:8f:
+         ee:59:54:66:2e:57:72:b8:91:55:06:13:e5:9e:89:a2:3a:13:
+         3b:45:30:d3:cd:15:0e:81:eb:4f:b0:6a:a4:6d:00:7d:5b:c0:
+         4a:7f:97:d0:27:27:31:ae:3e:72:f1:74:fe:86:8e:29:a9:42:
+         23:26:22:db:08:8b:df:e9:d3:83:8d:81:10:36:d7:33:68:5e:
+         cb:93:cb:1e:12:c8:cb:be:5e:5c:8e:58:b0:1d:06:5e:c9:98:
+         b7:f1:49:fe:c4:03:de:b4:2b:da:9d:2c:7d:98:37:1c:6c:a8:
+         95:21:6f:23:e3:2e:09:bc:6c:e5:ed:e2:50:d8:f7:da:45:39:
+         d8:34:8a:57:0c:4f:d0:0d:80:06:d6:34:63:72:27:d1:50:d1:
+         d2:21:2c:97:57:17:98:02:95:3a:96:ed:75:9f:cc:f3:b8:f1:
+         3a:85:f9:58:08:9b:a0:75:fd:9b:fd:31:dd:08:dc:14:3d:f4:
+         68:aa:d4:30
+-----BEGIN CERTIFICATE-----
+MIIDXzCCAkegAwIBAgIRANQpj9+Kr3vA178ZnZDV78owDQYJKoZIhvcNAQELBQAw
+IjEgMB4GA1UEAwwXRmVyZGluYW5kIExpbm5lbmJlcmcgQ0EwHhcNMjIwMjEwMTIy
+NTM3WhcNMjQwNTE1MTIyNTM3WjAOMQwwCgYDVQQDDANCb2IwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDVJ5uZGzo2ZDbI5Xhktp1wnSlsDoWRS3g73BbD
+CYzTdCCMb+3DkMkbTYDVRtpSf9IvvLL3QI2t3SS5XNyiIS9I7AaTi4nwzWP/of3O
+NtUHeh4Oz2iowbN/YoS34c8lez+oPKwHGv3C4eCeJiTBDW2dxldqtDkoPYg+yWqJ
+kHJKe3XFXhteXDJUo//rAWh/ibRMAT8IjmxhSWAmCyZYgdcaV+5SXAVH3trrtZKd
+W84mGERZPifQYYbi9MbZxysfy+p48KGpV9eYTMEvrmo4tDRTLlqe+FjHUef9uCfN
+h3ImwX0Ux8378gSKxI9hz6h4vSG+KMvoqGUpKIJGLxjm/29TAgMBAAGjgaMwgaAw
+CQYDVR0TBAIwADAdBgNVHQ4EFgQUtaXwNyWXrb7xQ1JFTYugXul4IbgwUgYDVR0j
+BEswSYAUJk7rsKUbCKiQKoUEc4S1pSxh1pGhJqQkMCIxIDAeBgNVBAMMF0ZlcmRp
+bmFuZCBMaW5uZW5iZXJnIENBggkAjOBA2dhg5XcwEwYDVR0lBAwwCgYIKwYBBQUH
+AwIwCwYDVR0PBAQDAgeAMA0GCSqGSIb3DQEBCwUAA4IBAQAZ8+vBlebVqTPXLgLY
+OpGEgRST/ANNsUudC5uUk58aDYcxofqmxzprGCQSqyj7yOMJol1QSQDZGOZKCRjg
+HNrTGZY9dHL+4I/uWVRmLldyuJFVBhPlnomiOhM7RTDTzRUOgetPsGqkbQB9W8BK
+f5fQJycxrj5y8XT+ho4pqUIjJiLbCIvf6dODjYEQNtczaF7Lk8seEsjLvl5cjliw
+HQZeyZi38Un+xAPetCvanSx9mDccbKiVIW8j4y4JvGzl7eJQ2PfaRTnYNIpXDE/Q
+DYAG1jRjcifRUNHSISyXVxeYApU6lu11n8zzuPE6hflYCJugdf2b/THdCNwUPfRo
+qtQw
+-----END CERTIFICATE-----

tests/assets/Bob.key

@@ -0,0 +1,30 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIIFHDBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQIi6DixMpf5PQCAggA
+MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECLgvCsIAjjXRBIIEyDAss0V4NrI5
+W7KXPRgRJ1tqvQrWZQTIFu4Crzs9Inb4TtSv5mATI9ZU2RMFF6MYXlhIxJng861P
+5IWcU6VeOjRFej8wcB3uTvD2z7NB2cyA5BZSojrZfX5OIEKL9sBzn0vinqmm5N1z
+oXhLMgf0FZssA3+zjIf04vtvmk5pxTCE6dq6vlsEIJyQ0xGc39bStIwk2a4E9wvi
+XayKNJnRFSrTahuI3DvQJPd9TdmM6sBKnrcJrDa6LvH51SrGzW8bBEjDAmC7yJdi
+mBckFTjZ6rGrSxOI6HdnF9RP+y9OiLE4ou5OJ9MbBtngq9OrTImAMZ5ftWowaqX/
+Do1UTqixi4ecWrr5fr1+A2Vch0I1drds2e/mmLR+5GEQXQXZPZKjtPMwxM/AYnTZ
+w/M3T9KtwSj0s5G6Saz4WpzaUL7wATb/UNqMr8Ifl8mHEVoFZhvoRpMWA7Yj1oPb
+cHz8lsfoSrTnK+zLR8ZK3HRu4MtpdCNVwQIJ67T6Feb8YLwYSccTNHBSqUmWRD95
+wOOqY33xcfplaQ2Y+/8+mHScGSEPNmC4f7EggDeUnG3ow0f4n95DENO+aYqGLjSF
++XdCjhD+NTNdlV0z50B6P2XWUoBZOOnPfgFf4nAgn7xQbkZZOk5bQDKo2Zu9jW9/
+uJyTHqI58tcopI3cjd5iQXOJUrM4OWpPIu3p+VWaIAA8JzJIfDN6fyQ3qsMr305L
+30JcjrH6if/6J+2g+DpMAK928JY2hfE8VNWH7096ZnArp42/hLYsNuYnSrL1eS+g
+F/4mvyZyLLTFyB0Frnic4I1QTuNkNmwSrm/B5wIWLqkS7XAyyDDXAcaTHdZCN6nM
+O2OuF7DfBsFcNMM4VagG5adPS9CYkvz0EEh6ho5XiP2yL3tZfsHyuB4njAsV3aFi
+D0Yq7QiCf5iA2d4KsYO6yr1wPfVhlsmPi3++mrHulBwwCQWHTlPgRZnjj1xgmPcQ
+00KsUVh+CMWlf20O5sKhzjvkzbwUj1K+ZfMDuuq1RbzFRSx+Gx8vIaThFg9kVyoP
+zuvzsT6qc3BGNHmaGZ3d5Re25AuGRTF4cTpDfjW0UL7Wnvnis7iMrUasDhyF7CFn
+/KG7eKzxqS08o6D4AM5S/fzZEtszoEgAga6DS2R75FVskDweWuEIsar9UGg3UlmW
+q3+rRPRf1CzrLtyYenkkLg/ajr8JOnFGqZVaLmMnegZQH6rF3aEzlQLNgbNepcuA
+ObSmAO6MR3MlQgdsH/lNzOPdj1gKcE25hOjGfmwgbOXSJv9Cz0bcBLFEyLZSNpRk
+HhNejj6BEz/Cmqg1wm7SOBHsXJGcOTnLO1Y3FBt0I7heWvWmj9rOLG9tvvx9dtrP
+pQyDbIcWonuXLrXYSPyOjmeWoQSzdH3NsCswBV4G+iOiLCJDkElR+mrwKbhtS88T
+3YeZnsCTsmH+jZpxGgPTObjIG91U4UE4Pnkwc2df355VuOKrf0rB/NK0A9hZGqsV
+nxtodjn92P6UFzmfEdt95pMcmurK9wkm1kRkP7cIyAs2lCOIdbgGsszz6Mk16Xqy
+49RdhLxJrJ4gkYZIAbY+KNGVc7uPhm/T9xGrIstbEsoUM7jy7nHMOCCDgdbwX/4X
+caMeSMZcZ+RvraDDBEbSbg==
+-----END ENCRYPTED PRIVATE KEY-----

tests/integration.rs

@@ -3,18 +3,458 @@
 #![forbid(unsafe_code)]
 #![warn(missing_docs, rust_2018_idioms, trivial_casts, unused_qualifications)]
 
-use std::env;
+use cipher::common::{getrandom::SysRng, Generate};
-use yubikey_piv::YubiKey;
+use log::trace;
+use once_cell::sync::Lazy;
+use rsa::{pkcs1v15, RsaPublicKey};
+use sha2::{Digest, Sha256};
+use signature::hazmat::PrehashVerifier;
+use std::{env, str::FromStr, sync::Mutex, time::Duration};
+use x509_cert::{der::Encode, name::Name, serial_number::SerialNumber, time::Validity};
+use yubikey::{
+    certificate::{yubikey_signer, Certificate},
+    piv::{self, AlgorithmId, Key, ManagementSlotId, RetiredSlotId, SlotId},
+    Error, MgmKey, PinPolicy, Serial, TouchPolicy, YubiKey,
+};
 
-#[test]
+static YUBIKEY: Lazy<Mutex<YubiKey>> = Lazy::new(|| {
-#[ignore]
-fn connect() {
     // Only show logs if `RUST_LOG` is set
     if env::var("RUST_LOG").is_ok() {
         env_logger::builder().format_timestamp(None).init();
     }
 
-    let mut yubikey = YubiKey::open().unwrap();
+    let yubikey = if let Ok(serial) = env::var("YUBIKEY_SERIAL") {
-    dbg!(&yubikey.version());
+        let serial = Serial::from_str(&serial).unwrap();
-    dbg!(&yubikey.serial());
+        YubiKey::open_by_serial(serial).unwrap()
+    } else {
+        YubiKey::open().unwrap()
+    };
+
+    trace!("serial: {}", yubikey.serial());
+    trace!("version: {}", yubikey.version());
+
+    Mutex::new(yubikey)
+});
+
+//
+// CCCID support
+//
+
+#[test]
+#[ignore]
+fn test_get_cccid() {
+    let mut yubikey = match YUBIKEY.lock() {
+        Ok(yubikey) => yubikey,
+        Err(poison) => poison.into_inner(),
+    };
+
+    match yubikey.cccid() {
+        Ok(cccid) => trace!("CCCID: {:?}", cccid),
+        Err(Error::NotFound) => trace!("CCCID not found"),
+        Err(err) => panic!("error getting CCCID: {err:?}"),
+    }
+}
+
+//
+// CHUID support
+//
+
+#[test]
+#[ignore]
+fn test_get_chuid() {
+    let mut yubikey = match YUBIKEY.lock() {
+        Ok(yubikey) => yubikey,
+        Err(poison) => poison.into_inner(),
+    };
+
+    match yubikey.chuid() {
+        Ok(chuid) => trace!("CHUID: {:?}", chuid),
+        Err(Error::NotFound) => trace!("CHUID not found"),
+        Err(err) => panic!("error getting CHUID: {err:?}"),
+    }
+}
+
+//
+// Device config support
+//
+
+#[test]
+#[ignore]
+fn test_get_config() {
+    let mut yubikey = match YUBIKEY.lock() {
+        Ok(yubikey) => yubikey,
+        Err(poison) => poison.into_inner(),
+    };
+    let config_result = yubikey.config();
+    assert!(config_result.is_ok());
+    trace!("config: {:?}", config_result.unwrap());
+}
+
+//
+// Cryptographic key support
+//
+
+#[test]
+#[ignore]
+fn test_list_keys() {
+    let mut yubikey = match YUBIKEY.lock() {
+        Ok(yubikey) => yubikey,
+        Err(poison) => poison.into_inner(),
+    };
+    let keys_result = Key::list(&mut yubikey);
+    assert!(keys_result.is_ok());
+    trace!("keys: {:?}", keys_result.unwrap());
+}
+
+//
+// PIN support
+//
+
+#[test]
+#[ignore]
+fn test_verify_pin() {
+    let mut yubikey = match YUBIKEY.lock() {
+        Ok(yubikey) => yubikey,
+        Err(poison) => poison.into_inner(),
+    };
+    assert!(yubikey.verify_pin(b"000000").is_err());
+    assert!(yubikey.verify_pin(b"123456").is_ok());
+}
+
+//
+// Management key support
+//
+
+#[cfg(feature = "untested")]
+#[test]
+#[ignore]
+fn test_set_mgmkey() {
+    let mut rng = SysRng;
+    let mut yubikey = match YUBIKEY.lock() {
+        Ok(yubikey) => yubikey,
+        Err(poison) => poison.into_inner(),
+    };
+    let default_key = MgmKey::get_default(&yubikey).unwrap();
+
+    assert!(yubikey.verify_pin(b"123456").is_ok());
+    assert!(MgmKey::get_protected(&mut yubikey).is_err());
+    assert!(yubikey.authenticate(&default_key).is_ok());
+
+    // Set a protected management key.
+    assert!(MgmKey::generate_for(&yubikey, &mut rng)
+        .unwrap()
+        .set_protected(&mut yubikey)
+        .is_ok());
+    let protected = MgmKey::get_protected(&mut yubikey).unwrap();
+    assert!(yubikey.authenticate(&default_key).is_err());
+    assert!(yubikey.authenticate(&protected).is_ok());
+
+    // Set a manual management key.
+    let manual = MgmKey::generate_for(&yubikey, &mut rng).unwrap();
+    assert!(manual.set_manual(&mut yubikey, false).is_ok());
+    assert!(MgmKey::get_protected(&mut yubikey).is_err());
+    assert!(yubikey.authenticate(&default_key).is_err());
+    assert!(yubikey.authenticate(&protected).is_err());
+    assert!(yubikey.authenticate(&manual).is_ok());
+
+    // Set back to the default management key.
+    assert!(MgmKey::set_default(&mut yubikey).is_ok());
+    assert!(MgmKey::get_protected(&mut yubikey).is_err());
+    assert!(yubikey.authenticate(&protected).is_err());
+    assert!(yubikey.authenticate(&manual).is_err());
+    assert!(yubikey.authenticate(&default_key).is_ok());
+}
+
+//
+// Certificate support
+//
+
+fn generate_self_signed_cert<KT: yubikey_signer::KeyType>() -> Certificate {
+    let mut yubikey = YUBIKEY.lock().unwrap();
+    let default_key = MgmKey::get_default(&yubikey).unwrap();
+
+    assert!(yubikey.verify_pin(b"123456").is_ok());
+    assert!(yubikey.authenticate(&default_key).is_ok());
+
+    let slot = SlotId::Retired(RetiredSlotId::R1);
+
+    // Generate a new key in the selected slot.
+    let generated = piv::generate(
+        &mut yubikey,
+        slot,
+        KT::ALGORITHM,
+        PinPolicy::Default,
+        TouchPolicy::Default,
+    )
+    .unwrap();
+
+    // 0x80 0x00 ... (20bytes) is invalid because of high MSB (serial will keep the sign)
+    // we'll limit ourselves to 19 bytes serial.
+    let serial = <[u8; 19]>::generate();
+    let serial = SerialNumber::new(&serial[..]).expect("serial can't be more than 20 bytes long");
+    let validity = Validity::from_now(Duration::new(500000, 0)).unwrap();
+
+    // Generate a self-signed certificate for the new key.
+    let cert_result = Certificate::generate_self_signed::<_, KT>(
+        &mut yubikey,
+        slot,
+        serial,
+        validity,
+        Name::from_str("CN=testSubject").expect("parse name"),
+        generated,
+        |_builder| Ok(()),
+    );
+
+    assert!(cert_result.is_ok());
+    let cert = cert_result.unwrap();
+    trace!("cert: {:?}", cert);
+    cert
+}
+
+#[test]
+#[ignore]
+fn generate_self_signed_rsa_cert() {
+    let cert = generate_self_signed_cert::<yubikey_signer::YubiRsa<yubikey_signer::Rsa1024>>();
+
+    //
+    // Verify that the certificate is signed correctly
+    //
+
+    let pubkey = RsaPublicKey::try_from(cert.subject_pki()).expect("valid rsa key");
+    let pubkey = pkcs1v15::VerifyingKey::<Sha256>::new(pubkey);
+
+    let data = cert.cert.to_der().expect("serialize certificate");
+    let tbs_cert_len = u16::from_be_bytes(data[6..8].try_into().unwrap()) as usize;
+    let msg = &data[4..8 + tbs_cert_len];
+    let sig = pkcs1v15::Signature::try_from(&data[data.len() - 128..]).unwrap();
+    let hash = Sha256::digest(msg);
+
+    assert!(pubkey.verify_prehash(&hash, &sig).is_ok());
+}
+
+#[test]
+#[ignore]
+fn generate_rsa3072() {
+    let mut yubikey = YUBIKEY.lock().unwrap();
+    let version = yubikey.version();
+    let default_key = MgmKey::get_default(&yubikey).unwrap();
+
+    assert!(yubikey.authenticate(&default_key).is_ok());
+
+    let slot = SlotId::Retired(RetiredSlotId::R1);
+
+    // Generate a new key in the selected slot.
+    let generated = piv::generate(
+        &mut yubikey,
+        slot,
+        AlgorithmId::Rsa3072,
+        PinPolicy::Default,
+        TouchPolicy::Default,
+    );
+
+    match generated {
+        Ok(key) => {
+            let pubkey = key.subject_public_key;
+            assert!(pubkey.bit_len() > 3072)
+        }
+        Err(e) => assert!((version.major, version.minor) < (5, 7) && e == Error::AlgorithmError),
+    }
+}
+
+#[test]
+#[ignore]
+fn generate_self_signed_ec_cert() {
+    let cert = generate_self_signed_cert::<p256::NistP256>();
+
+    //
+    // Verify that the certificate is signed correctly
+    //
+
+    let vk = p256::ecdsa::VerifyingKey::try_from(cert.subject_pki()).expect("ecdsa key expected");
+
+    let data = cert.cert.to_der().expect("serialize certificate");
+    let tbs_cert_len = data[6] as usize;
+    let sig_algo_len = data[7 + tbs_cert_len + 1] as usize;
+    let sig_start = 7 + tbs_cert_len + 2 + sig_algo_len + 3;
+    let msg = &data[4..7 + tbs_cert_len];
+    let sig = p256::ecdsa::Signature::from_der(&data[sig_start..]).unwrap();
+
+    use p256::ecdsa::signature::Verifier;
+    assert!(vk.verify(msg, &sig).is_ok());
+}
+
+#[test]
+#[ignore]
+fn generate_self_signed_cv_cert() {
+    let cert = generate_self_signed_cert::<ed25519_dalek::SigningKey>();
+
+    //
+    // Verify that the certificate is signed correctly
+    //
+
+    let pubkey =
+        ed25519_dalek::VerifyingKey::try_from(cert.subject_pki()).expect("ed25519 key expected");
+
+    let data = cert.cert.to_der().expect("serialize certificate");
+    let cert_len = data[2] as usize;
+    let tbs_cert_len = data[5] as usize;
+    let sig_algo_len: usize = 64;
+    let sig_start = cert_len - sig_algo_len + 3;
+    let msg = &data[3..6 + tbs_cert_len];
+    let sig =
+        ed25519_dalek::Signature::from_slice(&data[sig_start..sig_start + sig_algo_len]).unwrap();
+
+    use ed25519_dalek::Verifier;
+    assert!(pubkey.verify(msg, &sig).is_ok());
+}
+
+#[test]
+#[ignore]
+fn test_slot_id_display() {
+    assert_eq!(format!("{}", SlotId::Authentication), "Authentication");
+    assert_eq!(format!("{}", SlotId::Signature), "Signature");
+    assert_eq!(format!("{}", SlotId::KeyManagement), "KeyManagement");
+    assert_eq!(
+        format!("{}", SlotId::CardAuthentication),
+        "CardAuthentication"
+    );
+    assert_eq!(format!("{}", SlotId::Attestation), "Attestation");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R1)), "R1");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R2)), "R2");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R3)), "R3");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R4)), "R4");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R5)), "R5");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R6)), "R6");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R7)), "R7");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R8)), "R8");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R9)), "R9");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R10)), "R10");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R11)), "R11");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R12)), "R12");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R13)), "R13");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R14)), "R14");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R15)), "R15");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R16)), "R16");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R17)), "R17");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R18)), "R18");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R19)), "R19");
+    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R20)), "R20");
+
+    assert_eq!(
+        format!("{}", SlotId::Management(ManagementSlotId::Pin)),
+        "Pin"
+    );
+    assert_eq!(
+        format!("{}", SlotId::Management(ManagementSlotId::Puk)),
+        "Puk"
+    );
+    assert_eq!(
+        format!("{}", SlotId::Management(ManagementSlotId::Management)),
+        "Management"
+    );
+}
+
+//
+// Metadata
+//
+
+#[test]
+#[ignore]
+fn test_read_metadata() {
+    let mut yubikey = match YUBIKEY.lock() {
+        Ok(yubikey) => yubikey,
+        Err(poison) => poison.into_inner(),
+    };
+    let default_key = MgmKey::get_default(&yubikey).unwrap();
+
+    assert!(yubikey.verify_pin(b"123456").is_ok());
+    assert!(yubikey.authenticate(&default_key).is_ok());
+
+    let slot = SlotId::Retired(RetiredSlotId::R1);
+
+    // Generate a new key in the selected slot.
+    let generated = piv::generate(
+        &mut yubikey,
+        slot,
+        AlgorithmId::EccP256,
+        PinPolicy::Default,
+        TouchPolicy::Default,
+    )
+    .unwrap();
+
+    match piv::metadata(&mut yubikey, slot) {
+        Ok(metadata) => assert_eq!(metadata.public, Some(generated)),
+        Err(Error::NotSupported) => {
+            // Some YubiKeys don't support metadata
+            eprintln!("metadata not supported by this YubiKey");
+        }
+        Err(err) => panic!("{}", err),
+    }
+}
+
+#[test]
+#[ignore]
+fn test_read_metadata_missing_key() {
+    let mut yubikey = YUBIKEY.lock().unwrap();
+    let default_key = MgmKey::get_default(&yubikey).unwrap();
+
+    assert!(yubikey.verify_pin(b"123456").is_ok());
+    assert!(yubikey.authenticate(&default_key).is_ok());
+
+    // we assume that at least one of these slots is empty
+    let slots_to_check = [
+        RetiredSlotId::R10,
+        RetiredSlotId::R11,
+        RetiredSlotId::R12,
+        RetiredSlotId::R13,
+        RetiredSlotId::R14,
+        RetiredSlotId::R15,
+        RetiredSlotId::R16,
+        RetiredSlotId::R17,
+        RetiredSlotId::R18,
+        RetiredSlotId::R19,
+        RetiredSlotId::R20,
+    ];
+
+    for slot in slots_to_check {
+        let slot = SlotId::Retired(slot);
+
+        match piv::metadata(&mut yubikey, slot) {
+            Ok(_) => {
+                eprintln!("Key {} exists", slot);
+            }
+            Err(Error::NotSupported) => {
+                // Some YubiKeys don't support metadata
+                eprintln!("metadata not supported by this YubiKey");
+                return;
+            }
+            Err(Error::NotFound) => {
+                eprintln!("Key {} doesn't exist, ok.", slot);
+                return;
+            }
+            Err(err) => panic!("{}", err),
+        }
+    }
+
+    panic!("No empty slots to check");
+}
+
+#[test]
+#[ignore]
+fn test_parse_cert_from_der() {
+    let bob_der = std::fs::read("tests/assets/Bob.der").expect(".der file not found");
+    let cert = Certificate::from_bytes(bob_der).expect("Failed to parse valid certificate");
+    assert_eq!(
+        cert.subject(),
+        "CN=Bob",
+        "Subject is {} should be CN=Bob",
+        cert.subject()
+    );
+    assert_eq!(
+        cert.issuer(),
+        "CN=Ferdinand Linnenberg CA",
+        "Issuer is {} should be {}",
+        cert.issuer(),
+        "CN=Ferdinand Linnenberg CA"
+    );
 }