yubikey-cli v0.6.0 (#404 )

yubikey v0.6.0 (#403 )
Bump der-parser to v8; x509-parser to v0.14 (#402 )
2022-08-10 17:23:41 -07:00 · 2022-08-10 16:41:26 -07:00 · 2022-08-10 15:19:21 -07:00 · 2022-08-10 14:57:39 -07:00 · 2022-08-10 14:34:58 -07:00 · 2022-08-10 14:26:33 -07:00
47 changed files with 8177 additions and 7027 deletions
@@ -0,0 +1,5 @@
+[advisories]
+ignore = [
+    "RUSTSEC-2020-0071", # time
+    "RUSTSEC-2020-0159", # chrono
+] 
@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: weekly
+    time: '13:00'
+  open-pull-requests-limit: 10
@@ -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@v1
+      - 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.57.0 # MSRV
+            deps: sudo apt-get install libpcsclite-dev
+          - platform: windows-latest
+            toolchain: 1.57.0 # MSRV
+            deps: true
+          - platform: macos-latest
+            toolchain: 1.57.0 # MSRV
+            deps: true
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v1
+      - 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@v1
+
+      - 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@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.57.0 # MSRV
+          components: clippy
+          override: true
+      - run: sudo apt-get install libpcsclite-dev
+      - run: cargo clippy --all --all-features -- -D warnings
@@ -1,125 +0,0 @@
-# Based on https://github.com/actions-rs/meta/blob/master/recipes/quickstart.md
-
-on:
-  pull_request: {}
-  push:
-    branches: master
-
-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: Run cargo check
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-
-  test:
-    name: Test Suite
-    strategy:
-      matrix:
-        platform:
-          - ubuntu-latest
-          - macos-latest
-          # TODO: support Windows after eliminating C legacy
-          # - 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: --release
-
-  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 clippy
-        run: rustup component add clippy
-
-      - name: Run cargo clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: -- -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
@@ -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@v1
+
+      - name: Cache cargo registry
+        uses: actions/cache@v1
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v1
+        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 --ignore RUSTSEC-2019-0031 # spin
@@ -1,3 +1,2 @@
 /target
 **/*.rs.bk
-Cargo.lock
@@ -4,5 +4,222 @@ 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.1 (2019-11-18)
- It typechecks, ship it!
+## 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])
+
+### Changed
+- Use `Reader` to connect to `YubiKey` ([#51])
+- Convert `SlotId` and `AlgorithmId` into enums ([#44])
+- Use `secrecy` crate for storing `CachedPin` ([#43])
+- Change `CHUID` struct to hold complete CHUID value ([#42])
+- Eliminate all usages of `unsafe` ([#37], [#39])
+- Make anonymous CHUID struct public ([#36])
+- Have `sign_data` and `decrypt_data` return a `Buffer` ([#34])
+- `Ins` (APDU instruction codes) enum ([#33])
+- Factor `Response` into `apdu` module; improved debugging ([#32])
+
+[#51]: https://github.com/iqlusioninc/yubikey.rs/pull/51
+[#45]: https://github.com/iqlusioninc/yubikey.rs/pull/45
+[#44]: https://github.com/iqlusioninc/yubikey.rs/pull/44
+[#43]: https://github.com/iqlusioninc/yubikey.rs/pull/43
+[#42]: https://github.com/iqlusioninc/yubikey.rs/pull/42
+[#39]: https://github.com/iqlusioninc/yubikey.rs/pull/39
+[#37]: https://github.com/iqlusioninc/yubikey.rs/pull/37
+[#36]: https://github.com/iqlusioninc/yubikey.rs/pull/36
+[#34]: https://github.com/iqlusioninc/yubikey.rs/pull/34
+[#33]: https://github.com/iqlusioninc/yubikey.rs/pull/33
+[#32]: https://github.com/iqlusioninc/yubikey.rs/pull/32
+
+## yubikey-piv 0.0.2 (2019-11-25)
+### Added
+- `untested` Cargo feature to mark untested functionality ([#30])
+- Initial connect test and docs ([#19])
+- Clean up APDU construction with builder API ([#15])
+
+### Changed
+- Rewrite translated code to use the `pcsc` crate ([#17])
+- Rename ErrorKind to Error ([#13])
+- Use `des` crate for 3DES operations ([#10])
+- Replace `PKCS5_PBKDF2_HMAC_SHA1` with `pbkdf2` et al crates ([#9])
+- Replace `RAND_bytes` with `getrandom` crate ([#8])
+- Use `log` crate for logging ([#7])
+- Replace `ErrorKind::Ok` with `Result` ([#6])
+
+[#30]: https://github.com/iqlusioninc/yubikey.rs/pull/30
+[#19]: https://github.com/iqlusioninc/yubikey.rs/pull/19
+[#17]: https://github.com/iqlusioninc/yubikey.rs/pull/17
+[#15]: https://github.com/iqlusioninc/yubikey.rs/pull/15
+[#13]: https://github.com/iqlusioninc/yubikey.rs/pull/13
+[#10]: https://github.com/iqlusioninc/yubikey.rs/pull/10
+[#9]: https://github.com/iqlusioninc/yubikey.rs/pull/9
+[#8]: https://github.com/iqlusioninc/yubikey.rs/pull/8
+[#7]: https://github.com/iqlusioninc/yubikey.rs/pull/7
+[#6]: https://github.com/iqlusioninc/yubikey.rs/pull/6
+
+## yubikey-piv 0.0.1 (2019-11-18)
+- Initial release
@@ -6,8 +6,8 @@ In the interest of fostering an open and welcoming environment, we as
 contributors and maintainers pledge to making participation in our project and
 our community a harassment-free experience for everyone, regardless of age, body
 size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.

 ## Our Standards

@@ -55,8 +55,8 @@ further defined and clarified by project maintainers.
 ## Enforcement

 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at [bascule@gmail.com]. All
-complaints will be reviewed and investigated and will result in a response that
+reported by contacting the project team at [oss@iqlusion.io](mailto:oss@iqlusion.io).
+All complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
 Further details of specific enforcement policies may be posted separately.
@@ -65,12 +65,10 @@ Project maintainers who do not follow or enforce the Code of Conduct in good
 faith may face temporary or permanent repercussions as determined by other
 members of the project's leadership.

-[bascule@gmail.com]: mailto:bascule@gmail.com
-
 ## Attribution

 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org

-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/
@@ -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
@@ -1,21 +1,59 @@
 [package]
-name    = "yubikey-piv"
-version = "0.0.1" # Also update html_root_url in lib.rs when bumping this
+name = "yubikey"
+version = "0.6.0"
 description = """
-Pure Rust host-side driver for the YubiKey Personal Identity Verification (PIV)
-CCID application providing general-purpose public-key signing and encryption
-with hardware-backed private keys for RSA (2048/1024) and ECC (P-256/P-384)
-algorithms (e.g, PKCS#1v1.5, ECDSA)
+Pure Rust cross-platform host-side driver for YubiKey devices from Yubico with
+support for hardware-backed public-key decryption and digital signatures using
+the Personal Identity Verification (PIV) application. Supports RSA (1024/2048)
+or ECC (NIST P-256/P-384) algorithms e.g, PKCS#1v1.5, ECDSA
 """
-
-authors    = ["Tony Arcieri <bascule@gmail.com>", "Yubico AB"]
-edition    = "2018"
+authors = ["Tony Arcieri <tony@iqlusion.io>", "Yubico AB"]
 license = "BSD-2-Clause"
-repository = "https://github.com/tarcieri/yubikey-piv.rs"
+repository = "https://github.com/iqlusioninc/yubikey.rs"
 readme = "README.md"
 categories = ["api-bindings", "cryptography", "hardware-support"]
-keywords   = ["ccid", "ecdsa", "rsa", "piv", "yubikey"]
+keywords = ["ecdsa", "encryption", "rsa", "piv", "signature"]
+edition = "2021"
+rust-version = "1.57"
+
+[workspace]
+members = [".", "cli"]

 [dependencies]
-libc = "0.2"
+chrono = "0.4"
+cookie-factory = "0.3"
+der-parser = "8"
+des = "0.8"
+elliptic-curve = "0.12"
+hmac = "0.12"
+log = "0.4"
+nom = "7"
+num-bigint-dig = { version = "0.8", features = ["rand"] }
+num-traits = "0.2"
+num-integer = "0.1"
+pbkdf2 = { version = "0.11", default-features = false }
+p256 = "0.11"
+p384 = "0.11"
+pcsc = "2"
+rand_core = { version = "0.6", features = ["std"] }
+rsa = "0.6"
+secrecy = "0.8"
+sha1 = "0.10"
+sha2 = "0.10"
+subtle = "2"
+subtle-encoding = "0.5"
+uuid = { version = "1.0", features = ["v4"] }
+x509 = "0.2"
+x509-parser = "0.14"
 zeroize = "1"
+
+[dev-dependencies]
+env_logger = "0.9"
+lazy_static = "1"
+
+[features]
+untested = []
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
@@ -1,17 +1,18 @@
-<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]
+[![2-Clause BSD Licensed][license-image]][license-link]
+![MSRV][msrv-image]
+[![Safety Dance][safety-image]][safety-link]
 [![Build Status][build-image]][build-link]
-[![Gitter Chat][gitter-image]][gitter-link]
+[![dependency status][deps-image]][deps-link]

-Pure Rust host-side YubiKey [Personal Identity Verification (PIV)][1] driver
-with general-purpose public-key encryption and signing support.
+Pure Rust cross-platform host-side driver for [YubiKey] devices from [Yubico]
+with support for public-key encryption and digital signatures using the
+[Personal Identity Verification (PIV)][PIV] application.

 [Documentation][docs-link]

@@ -22,55 +23,107 @@ to store a number of RSA (2048/1024) 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.

-If you've been wanting to use Rust to sign and/or encrypt stuff using a
-private key generated and stored on a Yubikey (with option PIN-based access),
+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 data using a
+private key generated and stored on a YubiKey (with option PIN-based access),
 this is the crate you've been after!

-One small problem, it's not done yet... 😫
-
-But it might be close?
-
-## History
-
-This library is a Rust translation of the [yubico-piv-tool][2] utility by
-Yubico, which was originally written in C. It was mechanically translated
-from C into Rust using [Corrode][3], and then subsequently heavily
-refactored into safer, more idiomatic Rust§.
-
-Note that while this project started as a fork of a [Yubico][4] project,
+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.

-§ *NOTE*: This section is actually full of lies and notes aspirations/goals,
-  not history. That said, there's been a decent amount of work cleaning up the
-  mechanically translated code, and at ~5klocs it's not that much.
+## Minimum Supported Rust Version
+
+Rust **1.57** or newer.
+
+## Supported YubiKeys
+
+- [YubiKey 4] series
+- [YubiKey 5] series
+
+NOTE: Nano and USB-C variants of the above are also supported.
+      Pre-YK4 [YubiKey NEO] series is **NOT** supported (see [#18]).
+
+## Supported Operating Systems
+
+- Linux
+- macOS
+- Windows

 ## Security Warning

-No security audits of this crate have ever been performed, and it has not been
-thoroughly assessed to ensure its operation is constant-time on common CPU
-architectures.
+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!

-## Requirements
+## Testing

- Rust 1.39+
+To run the full test suite, you'll need a connected YubiKey NEO/4/5 device 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:
+
+```
+cargo test -- --ignored
+```
+
+This crate makes extensive use of the `log` facade to provide detailed
+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`):
+
+```
+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:
+
+```
+running 1 test
+[INFO  yubikey::yubikey] trying to connect to reader 'Yubico YubiKey OTP+FIDO+CCID'
+[INFO  yubikey::yubikey] connected to 'Yubico YubiKey OTP+FIDO+CCID' successfully
+[TRACE yubikey::apdu] >>> Apdu { cla: 0, ins: SelectApplication, p1: 4, p2: 0, data: [160, 0, 0, 3, 8] }
+[TRACE yubikey::transaction] >>> [0, 164, 4, 0, 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::apdu] >>> Apdu { cla: 0, ins: GetVersion, p1: 0, p2: 0, data: [] }
+[TRACE yubikey::transaction] >>> [0, 253, 0, 0, 0]
+[TRACE yubikey::apdu] <<< Response { status_words: Success, data: [5, 1, 2] }
+[TRACE yubikey::apdu] >>> Apdu { cla: 0, ins: GetSerial, p1: 0, p2: 0, data: [] }
+[TRACE yubikey::transaction] >>> [0, 248, 0, 0, 0]
+[TRACE yubikey::apdu] <<< Response { status_words: Success, data: [0, 115, 0, 178] }
+test connect ... ok
+```
+
+APDU messages labeled `>>>` are being sent to the YubiKey's internal SmartCard,
+and ones labeled `<<<` are the responses.
+
+## 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.

 ## Code of Conduct

-We abide by the [Contributor Covenant][5] and ask that you do as well.
+We abide by the [Contributor Covenant][cc-md] and ask that you do as well.

-For more information, please see [CODE_OF_CONDUCT.md][6].
+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`][2], a C library/CLI program. The original library
-was licensed under a [2-Clause BSD License][5], which this library inherits
+**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-2022 Yubico AB, Tony Arcieri
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -101,29 +154,49 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 Unless you explicitly state otherwise, any contribution intentionally
 submitted for inclusion in the work by you shall be licensed under the
-[2-Clause BSD License][5] as shown above, without any additional terms
+[2-Clause BSD License][BSDL] as shown above, without any additional terms
 or conditions.

 [//]: # (badges)

-[crate-image]: https://img.shields.io/crates/v/yubikey-piv.svg
-[crate-link]: https://crates.io/crates/yubikey-piv
-[docs-image]: https://docs.rs/yubikey-piv/badge.svg
-[docs-link]: https://docs.rs/yubikey-piv/
+[crate-image]: https://img.shields.io/crates/v/yubikey.svg
+[crate-link]: https://crates.io/crates/yubikey
+[docs-image]: https://docs.rs/yubikey/badge.svg
+[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
-[maintenance-image]: https://img.shields.io/badge/maintenance-experimental-blue.svg
-[build-image]: https://github.com/tarcieri/yubikey-piv.rs/workflows/Rust/badge.svg
-[build-link]: https://github.com/tarcieri/yubikey-piv.rs/actions
-[gitter-image]: https://badges.gitter.im/tarcieri/yubihsm-piv.rs.svg
-[gitter-link]: https://gitter.im/tarcieri/community
+[license-link]: https://github.com/iqlusioninc/yubikey.rs/blob/main/COPYING
+[msrv-image]: https://img.shields.io/badge/rustc-1.57+-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.rs/workflows/CI/badge.svg?branch=main&event=push
+[build-link]: https://github.com/iqlusioninc/yubikey.rs/actions
+[deps-image]: https://deps.rs/repo/github/iqlusioninc/yubikey.rs/status.svg
+[deps-link]: https://deps.rs/repo/github/iqlusioninc/yubikey.rs

 [//]: # (general links)

-[1]: https://piv.idmanagement.gov/
-[2]: https://github.com/Yubico/yubico-piv-tool/
-[3]: https://github.com/jameysharp/corrode
-[4]: https://www.yubico.com/
-[5]: https://contributor-covenant.org/
-[6]: https://github.com/tarcieri/yubikey-piv.rs/blob/develop/CODE_OF_CONDUCT.md
-[7]: https://opensource.org/licenses/BSD-2-Clause
+[YubiKey]: https://www.yubico.com/products/yubikey-hardware/
+[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.rs/blob/main/CODE_OF_CONDUCT.md
+[BSDL]: https://opensource.org/licenses/BSD-2-Clause
+
+[//]: # (github issues)
+
+[#18]: https://github.com/iqlusioninc/yubikey.rs/issues/18
+[#20]: https://github.com/iqlusioninc/yubikey.rs/issues/20
+[#21]: https://github.com/iqlusioninc/yubikey.rs/issues/21
+[#22]: https://github.com/iqlusioninc/yubikey.rs/issues/22
+[#23]: https://github.com/iqlusioninc/yubikey.rs/issues/23
+[#24]: https://github.com/iqlusioninc/yubikey.rs/issues/24
+[#25]: https://github.com/iqlusioninc/yubikey.rs/issues/25
+[#26]: https://github.com/iqlusioninc/yubikey.rs/issues/26
+[#27]: https://github.com/iqlusioninc/yubikey.rs/issues/27
+[#28]: https://github.com/iqlusioninc/yubikey.rs/issues/28
@@ -0,0 +1,62 @@
+# Changelog
+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.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
@@ -0,0 +1,26 @@
+[package]
+name = "yubikey-cli"
+version = "0.6.0"
+description = """
+Command-line interface for performing encryption and signing using RSA/ECC keys
+stored on YubiKey devices.
+"""
+authors = ["Tony Arcieri <tony@iqlusion.io>"]
+license = "BSD-2-Clause"
+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.56"
+
+[dependencies]
+clap = { version = "3", features = ["derive"] }
+env_logger = "0.9"
+lazy_static = "1"
+log = "0.4"
+sha2 = "0.9"
+subtle-encoding = "0.5"
+termcolor = "1"
+x509-parser = "0.12"
+yubikey = { version = "0.6", path = ".." }
@@ -0,0 +1,108 @@
+<img src="https://raw.githubusercontent.com/iqlusioninc/yubikey.rs/main/img/logo.png" width="150" height="110">
+
+# yubikey-cli.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]
+
+Pure Rust host-side YubiKey [Personal Identity Verification (PIV)][PIV] CLI
+utility with general-purpose public-key encryption and signing support.
+
+[Documentation][docs-link]
+
+## Minimum Supported Rust Version
+
+Rust **1.57** or newer.
+
+## Supported YubiKeys
+
+- [YubiKey 4] series
+- [YubiKey 5] series
+
+NOTE: Nano and USB-C variants of the above are also supported.
+      Pre-YK4 [YubiKey NEO] series is **NOT** supported (see [#18]).
+
+## 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
+
+Copyright (c) 2014-2022 Yubico AB, Tony Arcieri
+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.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally
+submitted for inclusion in the work by you shall be licensed under the
+[2-Clause BSD License][BSDL] as shown above, without any additional terms
+or conditions.
+
+[//]: # (badges)
+
+[crate-image]: https://img.shields.io/crates/v/yubikey-cli.svg
+[crate-link]: https://crates.io/crates/yubikey-cli
+[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.57+-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.rs/workflows/CI/badge.svg?branch=main&event=push
+[build-link]: https://github.com/iqlusioninc/yubikey.rs/actions
+[gitter-image]: https://badges.gitter.im/badge.svg
+[gitter-link]: https://gitter.im/iqlusioninc/community
+
+[//]: # (general links)
+
+[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/main/CODE_OF_CONDUCT.md
+[BSDL]: https://opensource.org/licenses/BSD-2-Clause
@@ -0,0 +1,16 @@
+//! `yubikey` command-line utility
+
+#![forbid(unsafe_code)]
+#![warn(
+    missing_docs,
+    rust_2018_idioms,
+    unused_lifetimes,
+    unused_qualifications
+)]
+
+use clap::Parser;
+use yubikey_cli::commands::YubiKeyCli;
+
+fn main() {
+    YubiKeyCli::parse().run()
+}
@@ -0,0 +1,90 @@
+//! Commands of the CLI application
+
+pub mod readers;
+pub mod status;
+
+use self::{readers::ReadersCmd, status::StatusCmd};
+use crate::terminal;
+use clap::Parser;
+use std::{env, process::exit};
+use termcolor::ColorChoice;
+use yubikey::{Serial, YubiKey};
+
+/// The `yubikey` CLI utility
+#[derive(Debug, Parser)]
+pub struct YubiKeyCli {
+    /// Serial number of the YubiKey to connect to
+    #[clap(short = 's', long = "serial")]
+    pub serial: Option<Serial>,
+
+    /// Subcommand to execute.
+    #[clap(subcommand)]
+    pub command: Commands,
+}
+
+impl YubiKeyCli {
+    /// Run the underlying command type or print usage info and exit
+    pub fn run(&self) {
+        // TODO(tarcieri): make this more configurable
+        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();
+        }
+
+        self.command.run(self.yubikey_init())
+    }
+
+    /// 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, Parser)]
+pub enum Commands {
+    /// `version` subcommand
+    #[clap(about = "display version information")]
+    Version(VersionOpts),
+
+    /// `readers` subcommand
+    #[clap(about = "list detected readers")]
+    Readers(ReadersCmd),
+
+    /// `status` subcommand
+    #[clap(about = "show yubikey status")]
+    Status(StatusCmd),
+}
+
+impl Commands {
+    /// Run the given command
+    pub fn run(&self, yubikey: YubiKey) {
+        match self {
+            Commands::Version(version) => version.run(),
+            Commands::Readers(list) => list.run(),
+            Commands::Status(status) => status.run(yubikey),
+        }
+    }
+}
+
+/// Version options
+#[derive(Debug, Parser)]
+pub struct VersionOpts {}
+
+impl VersionOpts {
+    /// Display version information
+    pub fn run(&self) {
+        println!("{} {}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
+    }
+}
@@ -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(())
+    }
+}
@@ -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(())
+    }
+}
@@ -0,0 +1,13 @@
+//! `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(missing_docs, rust_2018_idioms, unused_qualifications)]
+
+#[macro_use]
+pub mod terminal;
+pub mod commands;
@@ -0,0 +1,242 @@
+//! Status messages
+
+use lazy_static::lazy_static;
+use log::debug;
+use sha2::{Digest, Sha256};
+use std::{
+    io::{self, Write},
+    str,
+    sync::Mutex,
+};
+use subtle_encoding::hex;
+use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, StandardStreamLock, WriteColor};
+use x509_parser::parse_x509_certificate;
+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::terminal::Status::new()
+            .justified()
+            .bold()
+            .color(termcolor::Color::Green)
+            .status($status)
+            .print_stdout($msg);
+    };
+    ($status:expr, $fmt:expr, $($arg:tt)+) => {
+        $crate::status_ok!($status, format!($fmt, $($arg)+));
+    };
+}
+
+/// Print a warning status message (in yellow if colors are enabled)
+#[macro_export]
+macro_rules! status_warn {
+    ($msg:expr) => {
+        $crate::terminal::Status::new()
+            .bold()
+            .color(termcolor::Color::Yellow)
+            .status("warning:")
+            .print_stdout($msg);
+    };
+    ($fmt:expr, $($arg:tt)+) => {
+        $crate::status_warn!(format!($fmt, $($arg)+));
+    };
+}
+
+/// Print an error message (in red if colors are enabled)
+#[macro_export]
+macro_rules! status_err {
+    ($msg:expr) => {
+        $crate::terminal::Status::new()
+            .bold()
+            .color(termcolor::Color::Red)
+            .status("error:")
+            .print_stderr($msg);
+    };
+    ($fmt:expr, $($arg:tt)+) => {
+        $crate::status_err!(format!($fmt, $($arg)+));
+    };
+}
+
+lazy_static! {
+    /// Color configuration
+    static ref COLOR_CHOICE: Mutex<Option<ColorChoice>> = Mutex::new(None);
+
+    /// Standard output
+    pub static ref STDOUT: StandardStream = StandardStream::stdout(get_color_choice());
+
+    /// Standard error
+    pub static ref STDERR: StandardStream = StandardStream::stderr(get_color_choice());
+}
+
+/// Obtain the color configuration.
+///
+/// Panics if no configuration has been provided.
+fn get_color_choice() -> ColorChoice {
+    let choice = COLOR_CHOICE.lock().unwrap();
+    *choice
+        .as_ref()
+        .expect("terminal stream accessed before initialized!")
+}
+
+/// Set the color configuration.
+///
+/// Panics if the terminal has already been configured.
+pub(super) fn set_color_choice(color_choice: ColorChoice) {
+    let mut choice = COLOR_CHOICE.lock().unwrap();
+    assert!(choice.is_none(), "terminal colors already configured!");
+    *choice = Some(color_choice);
+}
+
+/// Status message builder
+#[derive(Clone, Debug, Default)]
+pub struct Status {
+    /// Should the status be justified?
+    justified: bool,
+
+    /// Should colors be bold?
+    bold: bool,
+
+    /// Color in which status should be displayed
+    color: Option<Color>,
+
+    /// Prefix of the status message (e.g. `Success`)
+    status: Option<String>,
+}
+
+impl Status {
+    /// Create a new status message with default settings
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Justify status on display
+    pub fn justified(mut self) -> Self {
+        self.justified = true;
+        self
+    }
+
+    /// Make colors bold
+    pub fn bold(mut self) -> Self {
+        self.bold = true;
+        self
+    }
+
+    /// Set the colors used to display this message
+    pub fn color(mut self, c: Color) -> Self {
+        self.color = Some(c);
+        self
+    }
+
+    /// Set a status message to display
+    pub fn status<S>(mut self, msg: S) -> Self
+    where
+        S: ToString,
+    {
+        self.status = Some(msg.to_string());
+        self
+    }
+
+    /// Print the given message to stdout
+    pub fn print_stdout(self, msg: impl AsRef<str>) {
+        self.print(&*STDOUT, msg)
+            .expect("error printing to stdout!")
+    }
+
+    /// Print the given message to stderr
+    pub fn print_stderr(self, msg: impl AsRef<str>) {
+        self.print(&*STDERR, msg)
+            .expect("error printing to stderr!")
+    }
+
+    /// Print the given message
+    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))?;
+
+        if let Some(status) = self.status {
+            if self.justified {
+                write!(s, "{:>12}", status)?;
+            } else {
+                write!(s, "{}", status)?;
+            }
+        }
+
+        s.reset()?;
+        writeln!(s, " {}", msg.as_ref())?;
+        s.flush()?;
+
+        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 buf = cert.into_buffer();
+
+    if !buf.is_empty() {
+        let fingerprint = Sha256::digest(&buf);
+        let slot_id: u8 = slot.into();
+        print_cert_attr(stream, "Slot", format!("{:x}", slot_id))?;
+        match parse_x509_certificate(&buf) {
+            Ok((_rem, cert)) => {
+                print_cert_attr(
+                    stream,
+                    "Algorithm",
+                    cert.tbs_certificate.subject_pki.algorithm.algorithm,
+                )?;
+
+                print_cert_attr(stream, "Subject", cert.tbs_certificate.subject)?;
+                print_cert_attr(stream, "Issuer", cert.tbs_certificate.issuer)?;
+                print_cert_attr(
+                    stream,
+                    "Fingerprint",
+                    str::from_utf8(hex::encode(fingerprint).as_slice()).unwrap(),
+                )?;
+                print_cert_attr(
+                    stream,
+                    "Not Before",
+                    cert.tbs_certificate.validity.not_before.to_rfc2822(),
+                )?;
+                print_cert_attr(
+                    stream,
+                    "Not After",
+                    cert.tbs_certificate.validity.not_after.to_rfc2822(),
+                )?;
+            }
+            _ => {
+                println!("Failed to parse certificate");
+                return Ok(());
+            }
+        };
+    }
+
+    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(())
+}
@@ -1,66 +1,463 @@
 //! Application Protocol Data Unit (APDU)

-use zeroize::Zeroize;
+// 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::{transaction::Transaction, Buffer, Result};
+use log::trace;
+use zeroize::{Zeroize, Zeroizing};
+
+/// Maximum amount of command data that can be included in an APDU
+const APDU_DATA_MAX: usize = 0xFF;

 /// Application Protocol Data Unit (APDU).
 ///
-/// These messages are packets used to communicate with the YubiKey using the
-/// Chip Card Interface Device (CCID) protocol.
-#[derive(Clone)]
-pub struct APDU {
-    /// Instruction class - indicates the type of command, e.g. interindustry or proprietary
-    pub cla: u8,
+/// These messages are packets used to communicate with the YubiKey.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Apdu {
+    /// Instruction class: indicates the type of command (e.g. inter-industry or proprietary)
+    cla: u8,

-    /// Instruction code - indicates the specific command, e.g. "write data"
-    pub ins: u8,
+    /// Instruction code: indicates the specific command (e.g. "write data")
+    ins: Ins,

-    /// Instruction parameter 1 for the command, e.g. offset into file at which to write the data
-    pub p1: u8,
+    /// Instruction parameter 1 for the command (e.g. offset into file at which to write the data)
+    p1: u8,

    /// Instruction parameter 2 for the command
-    pub p2: u8,
+    p2: u8,

-    /// Length of command - encodes the number of bytes of command data to follow
-    pub lc: u8,
-
-    /// Command data
-    pub data: [u8; 255],
+    /// Command data to be sent (`lc` is calculated as `data.len()`)
+    data: Vec<u8>,
 }

-impl APDU {
-    /// Get a const pointer to this APDU
-    // TODO(tarcieri): eliminate pointers and use all safe references
-    pub(crate) fn as_ptr(&self) -> *const APDU {
-        self
-    }
-
-    /// Get a mut pointer to this APDU
-    // TODO(tarcieri): eliminate pointers and use all safe references
-    pub(crate) fn as_mut_ptr(&mut self) -> *mut APDU {
-        self
-    }
-}
-
-impl Default for APDU {
-    fn default() -> Self {
+impl Apdu {
+    /// Create a new APDU with the given instruction code
+    pub fn new(ins: impl Into<Ins>) -> Self {
        Self {
            cla: 0,
-            ins: 0,
+            ins: ins.into(),
            p1: 0,
            p2: 0,
-            lc: 0,
-            data: [0u8; 255],
-        }
+            data: vec![],
        }
    }

-impl Zeroize for APDU {
+    /// Set this APDU's class
+    pub fn cla(&mut self, value: u8) -> &mut Self {
+        self.cla = value;
+        self
+    }
+
+    /// Set this APDU's first parameter only
+    pub fn p1(&mut self, value: u8) -> &mut Self {
+        self.p1 = value;
+        self
+    }
+
+    /// Set both parameters for this APDU
+    pub fn params(&mut self, p1: u8, p2: u8) -> &mut Self {
+        self.p1 = p1;
+        self.p2 = p2;
+        self
+    }
+
+    /// Set the command data for this APDU.
+    ///
+    /// Panics if the byte slice is more than 255 bytes!
+    pub fn data(&mut self, bytes: impl AsRef<[u8]>) -> &mut Self {
+        assert!(self.data.is_empty(), "APDU command already set!");
+
+        let bytes = bytes.as_ref();
+
+        assert!(
+            bytes.len() <= APDU_DATA_MAX,
+            "APDU command data too long: {} (max: {})",
+            bytes.len(),
+            APDU_DATA_MAX
+        );
+
+        self.data.extend_from_slice(bytes);
+        self
+    }
+
+    /// Transmit this APDU using the given card transaction
+    pub fn transmit(&self, txn: &Transaction<'_>, recv_len: usize) -> Result<Response> {
+        trace!(">>> {:?}", self);
+        let response = Response::from(txn.transmit(&self.to_bytes(), recv_len)?);
+        trace!("<<< {:?}", &response);
+        Ok(response)
+    }
+
+    /// Serialize this APDU as a self-zeroizing byte buffer
+    pub fn to_bytes(&self) -> Buffer {
+        let mut bytes = Vec::with_capacity(5 + self.data.len());
+        bytes.push(self.cla);
+        bytes.push(self.ins.code());
+        bytes.push(self.p1);
+        bytes.push(self.p2);
+        bytes.push(self.data.len() as u8);
+        bytes.extend_from_slice(self.data.as_ref());
+        Zeroizing::new(bytes)
+    }
+}
+
+impl Drop for Apdu {
+    fn drop(&mut self) {
+        self.zeroize();
+    }
+}
+
+impl Zeroize for Apdu {
    fn zeroize(&mut self) {
-        self.cla.zeroize();
-        self.ins.zeroize();
-        self.p1.zeroize();
-        self.p2.zeroize();
-        self.lc.zeroize();
+        // Only `data` may contain secrets
        self.data.zeroize();
    }
 }
+
+/// APDU instruction codes
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Ins {
+    /// Verify
+    Verify,
+
+    /// Change reference
+    ChangeReference,
+
+    /// Reset retry
+    ResetRetry,
+
+    /// Generate asymmetric
+    GenerateAsymmetric,
+
+    /// Authenticate
+    Authenticate,
+
+    /// Get data
+    GetData,
+
+    /// Put data
+    PutData,
+
+    /// Select application
+    SelectApplication,
+
+    /// Get response APDU
+    GetResponseApdu,
+
+    // Yubico vendor specific instructions
+    // <https://developers.yubico.com/PIV/Introduction/Yubico_extensions.html>
+    /// Set MGM key
+    SetMgmKey,
+
+    /// Import key
+    ImportKey,
+
+    /// Get version
+    GetVersion,
+
+    /// Reset device
+    Reset,
+
+    /// Set PIN retries
+    SetPinRetries,
+
+    /// Generate attestation certificate for asymmetric key
+    Attest,
+
+    /// Get device serial
+    GetSerial,
+
+    /// Other/unrecognized instruction codes
+    Other(u8),
+}
+
+impl Ins {
+    /// Get the code that corresponds to this instruction
+    pub fn code(self) -> u8 {
+        match self {
+            Ins::Verify => 0x20,
+            Ins::ChangeReference => 0x24,
+            Ins::ResetRetry => 0x2c,
+            Ins::GenerateAsymmetric => 0x47,
+            Ins::Authenticate => 0x87,
+            Ins::GetData => 0xcb,
+            Ins::PutData => 0xdb,
+            Ins::SelectApplication => 0xa4,
+            Ins::GetResponseApdu => 0xc0,
+            Ins::SetMgmKey => 0xff,
+            Ins::ImportKey => 0xfe,
+            Ins::GetVersion => 0xfd,
+            Ins::Reset => 0xfb,
+            Ins::SetPinRetries => 0xfa,
+            Ins::Attest => 0xf9,
+            Ins::GetSerial => 0xf8,
+            Ins::Other(code) => code,
+        }
+    }
+}
+
+impl From<u8> for Ins {
+    fn from(code: u8) -> Self {
+        match code {
+            0x20 => Ins::Verify,
+            0x24 => Ins::ChangeReference,
+            0x2c => Ins::ResetRetry,
+            0x47 => Ins::GenerateAsymmetric,
+            0x87 => Ins::Authenticate,
+            0xcb => Ins::GetData,
+            0xdb => Ins::PutData,
+            0xa4 => Ins::SelectApplication,
+            0xc0 => Ins::GetResponseApdu,
+            0xff => Ins::SetMgmKey,
+            0xfe => Ins::ImportKey,
+            0xfd => Ins::GetVersion,
+            0xfb => Ins::Reset,
+            0xfa => Ins::SetPinRetries,
+            0xf9 => Ins::Attest,
+            0xf8 => Ins::GetSerial,
+            code => Ins::Other(code),
+        }
+    }
+}
+
+impl From<Ins> for u8 {
+    fn from(ins: Ins) -> u8 {
+        ins.code()
+    }
+}
+
+/// APDU responses
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Response {
+    /// Status words
+    status_words: StatusWords,
+
+    /// Buffer
+    data: Vec<u8>,
+}
+
+impl Response {
+    /// Create a new response from the given status words and buffer
+    pub fn new(status_words: StatusWords, data: Vec<u8>) -> Response {
+        Response { status_words, data }
+    }
+
+    /// Get the [`StatusWords`] for this response.
+    pub fn status_words(&self) -> StatusWords {
+        self.status_words
+    }
+
+    /// Get the raw [`StatusWords`] code for this response.
+    pub fn code(&self) -> u16 {
+        self.status_words.code()
+    }
+
+    /// Do the status words for this response indicate success?
+    pub fn is_success(&self) -> bool {
+        self.status_words.is_success()
+    }
+
+    /// Borrow the response data
+    pub fn data(&self) -> &[u8] {
+        self.data.as_ref()
+    }
+}
+
+impl AsRef<[u8]> for Response {
+    fn as_ref(&self) -> &[u8] {
+        self.data()
+    }
+}
+
+impl Drop for Response {
+    fn drop(&mut self) {
+        self.zeroize();
+    }
+}
+
+impl From<Vec<u8>> for Response {
+    fn from(mut bytes: Vec<u8>) -> Self {
+        if bytes.len() < 2 {
+            return Response {
+                status_words: StatusWords::None,
+                data: bytes,
+            };
+        }
+
+        let sw = StatusWords::from(
+            (bytes[bytes.len() - 2] as u16) << 8 | (bytes[bytes.len() - 1] as u16),
+        );
+
+        let len = bytes.len() - 2;
+        bytes.truncate(len);
+
+        Response {
+            status_words: sw,
+            data: bytes,
+        }
+    }
+}
+
+impl Zeroize for Response {
+    fn zeroize(&mut self) {
+        // Only `data` may contain secrets
+        self.data.zeroize();
+    }
+}
+
+/// Status Words (SW) are 2-byte values returned by a card command.
+///
+/// The first byte of a status word is referred to as SW1 and the second byte
+/// of a status word is referred to as SW2.
+///
+/// See NIST special publication 800-73-4, section 5.6:
+/// <https://csrc.nist.gov/publications/detail/sp/800-73/4/final>
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) enum StatusWords {
+    /// No status words present in response
+    None,
+
+    /// Successful execution
+    Success,
+
+    /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L53
+    NoInputDataError,
+
+    /// PIN verification failure
+    VerifyFailError {
+        /// Remaining verification attempts
+        tries: u8,
+    },
+
+    /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L55
+    WrongLengthError,
+
+    /// Security status not satisfied
+    SecurityStatusError,
+
+    /// Authentication method blocked
+    AuthBlockedError,
+
+    /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L58
+    DataInvalidError,
+
+    /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L59
+    ConditionsNotSatisfiedError,
+
+    /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L60
+    CommandNotAllowedError,
+
+    /// Incorrect parameter in command data field
+    IncorrectParamError,
+
+    /// Data object or application not found
+    NotFoundError,
+
+    /// Not enough memory
+    NoSpaceError,
+
+    //
+    // Custom Yubico Status Word extensions
+    //
+    /// Incorrect card slot error
+    IncorrectSlotError,
+
+    /// Not supported error
+    NotSupportedError,
+
+    /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L65
+    CommandAbortedError,
+
+    /// Other/unrecognized status words
+    Other(u16),
+}
+
+impl StatusWords {
+    /// Get the numerical response code for these status words
+    pub fn code(self) -> u16 {
+        match self {
+            StatusWords::None => 0,
+            StatusWords::NoInputDataError => 0x6285,
+            StatusWords::VerifyFailError { tries } => 0x63c0 & tries as u16,
+            StatusWords::WrongLengthError => 0x6700,
+            StatusWords::SecurityStatusError => 0x6982,
+            StatusWords::AuthBlockedError => 0x6983,
+            StatusWords::DataInvalidError => 0x6984,
+            StatusWords::ConditionsNotSatisfiedError => 0x6985,
+            StatusWords::CommandNotAllowedError => 0x6986,
+            StatusWords::IncorrectParamError => 0x6a80,
+            StatusWords::NotFoundError => 0x6a82,
+            StatusWords::NoSpaceError => 0x6a84,
+            StatusWords::IncorrectSlotError => 0x6b00,
+            StatusWords::NotSupportedError => 0x6d00,
+            StatusWords::CommandAbortedError => 0x6f00,
+            StatusWords::Success => 0x9000,
+            StatusWords::Other(n) => n,
+        }
+    }
+
+    /// Do these status words indicate success?
+    pub fn is_success(self) -> bool {
+        self == StatusWords::Success
+    }
+}
+
+impl From<u16> for StatusWords {
+    fn from(sw: u16) -> Self {
+        match sw {
+            0x0000 => StatusWords::None,
+            0x6285 => StatusWords::NoInputDataError,
+            sw if sw & 0xfff0 == 0x63c0 => StatusWords::VerifyFailError {
+                tries: (sw & 0x000f) as u8,
+            },
+            0x6700 => StatusWords::WrongLengthError,
+            0x6982 => StatusWords::SecurityStatusError,
+            0x6983 => StatusWords::AuthBlockedError,
+            0x6984 => StatusWords::DataInvalidError,
+            0x6985 => StatusWords::ConditionsNotSatisfiedError,
+            0x6986 => StatusWords::CommandNotAllowedError,
+            0x6a80 => StatusWords::IncorrectParamError,
+            0x6a82 => StatusWords::NotFoundError,
+            0x6a84 => StatusWords::NoSpaceError,
+            0x6b00 => StatusWords::IncorrectSlotError,
+            0x6d00 => StatusWords::NotSupportedError,
+            0x6f00 => StatusWords::CommandAbortedError,
+            0x9000 => StatusWords::Success,
+            _ => StatusWords::Other(sw),
+        }
+    }
+}
+
+impl From<StatusWords> for u16 {
+    fn from(sw: StatusWords) -> u16 {
+        sw.code()
+    }
+}
@@ -0,0 +1,121 @@
+//! Cardholder Capability Container (CCC) ID Support
+
+// 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::{Error, Result, YubiKey};
+use rand_core::{OsRng, RngCore};
+use std::{
+    fmt::{self, Debug, Display},
+    str,
+};
+use subtle_encoding::hex;
+
+/// CCCID offset
+const CCC_ID_OFFS: usize = 9;
+
+/// CCC Object ID
+const OBJ_CAPABILITY: u32 = 0x005f_c107;
+
+/// Cardholder Capability Container (CCC) Template
+///
+/// f0: Card Identifier
+///
+///  - 0xa000000116 == GSC-IS RID
+///  - 0xff == Manufacturer ID (dummy)
+///  - 0x02 == Card type (javaCard)
+///  - next 14 bytes: card ID
+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,
+    0x01, 0x00, 0xf5, 0x01, 0x10, 0xf6, 0x00, 0xf7, 0x00, 0xfa, 0x00, 0xfb, 0x00, 0xfc, 0x00, 0xfd,
+    0x00, 0xfe, 0x00,
+];
+
+/// 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 {
+        let mut id = [0u8; Self::BYTE_SIZE];
+        OsRng.fill_bytes(&mut id);
+        Self(id)
+    }
+}
+
+/// Cardholder Capability Container (CCC) Identifier.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct CccId(pub [u8; Self::BYTE_SIZE]);
+
+impl CccId {
+    /// CCC size in bytes
+    pub const BYTE_SIZE: usize = 51;
+
+    /// Return CardId component of CCC
+    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> {
+        let txn = yubikey.begin_transaction()?;
+        let response = txn.fetch_object(OBJ_CAPABILITY)?;
+
+        if response.len() != CCC_TMPL.len() {
+            return Err(Error::GenericError);
+        }
+
+        Ok(Self(response[..Self::BYTE_SIZE].try_into().unwrap()))
+    }
+
+    /// Set Cardholder Capability Container (CCC) ID
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn set(&self, yubikey: &mut YubiKey) -> Result<()> {
+        let mut buf = CCC_TMPL.to_vec();
+        buf[0..self.0.len()].copy_from_slice(&self.0);
+
+        let txn = yubikey.begin_transaction()?;
+        txn.save_object(OBJ_CAPABILITY, &buf)
+    }
+}
+
+impl Display for CccId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(str::from_utf8(&hex::encode(&self.0[..])).unwrap())
+    }
+}
@@ -0,0 +1,681 @@
+//! X.509 certificate support.
+
+// 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,
+    error::{Error, Result},
+    piv::{sign_data, AlgorithmId, SlotId},
+    serialization::*,
+    transaction::Transaction,
+    yubikey::YubiKey,
+    Buffer,
+};
+use chrono::{DateTime, Utc};
+use elliptic_curve::sec1::EncodedPoint as EcPublicKey;
+use log::error;
+use num_bigint_dig::BigUint;
+use p256::NistP256;
+use p384::NistP384;
+use rsa::{PublicKeyParts, RsaPublicKey};
+use sha2::{Digest, Sha256};
+use std::{fmt, ops::DerefMut};
+use x509::{der::Oid, RelativeDistinguishedName};
+use x509_parser::{parse_x509_certificate, x509::SubjectPublicKeyInfo};
+use zeroize::Zeroizing;
+
+// TODO: Make these der_parser::oid::Oid constants when it has const fn support.
+const OID_RSA_ENCRYPTION: &str = "1.2.840.113549.1.1.1";
+const OID_EC_PUBLIC_KEY: &str = "1.2.840.10045.2.1";
+const OID_NIST_P256: &str = "1.2.840.10045.3.1.7";
+const OID_NIST_P384: &str = "1.3.132.0.34";
+
+const TAG_CERT: u8 = 0x70;
+const TAG_CERT_COMPRESS: u8 = 0x71;
+const TAG_CERT_LRC: u8 = 0xFE;
+
+/// A serial number for a [`Certificate`].
+#[derive(Clone, Debug)]
+pub struct Serial(BigUint);
+
+impl From<BigUint> for Serial {
+    fn from(num: BigUint) -> Serial {
+        Serial(num)
+    }
+}
+
+impl From<[u8; 20]> for Serial {
+    fn from(bytes: [u8; 20]) -> Serial {
+        Serial(BigUint::from_bytes_be(&bytes))
+    }
+}
+
+impl TryFrom<&[u8]> for Serial {
+    type Error = Error;
+
+    fn try_from(bytes: &[u8]) -> Result<Serial> {
+        if bytes.len() <= 20 {
+            Ok(Serial(BigUint::from_bytes_be(bytes)))
+        } else {
+            Err(Error::ParseError)
+        }
+    }
+}
+
+impl Serial {
+    fn to_bytes(&self) -> Vec<u8> {
+        self.0.to_bytes_be()
+    }
+}
+
+/// Information about how a [`Certificate`] is stored within a YubiKey.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CertInfo {
+    /// The certificate is uncompressed.
+    Uncompressed,
+
+    /// The certificate is gzip-compressed.
+    Gzip,
+}
+
+impl TryFrom<u8> for CertInfo {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            0x00 => Ok(CertInfo::Uncompressed),
+            0x01 => Ok(CertInfo::Gzip),
+            _ => Err(Error::InvalidObject),
+        }
+    }
+}
+
+impl From<CertInfo> for u8 {
+    fn from(certinfo: CertInfo) -> u8 {
+        match certinfo {
+            CertInfo::Uncompressed => 0x00,
+            CertInfo::Gzip => 0x01,
+        }
+    }
+}
+
+impl x509::AlgorithmIdentifier for AlgorithmId {
+    type AlgorithmOid = &'static [u64];
+
+    fn algorithm(&self) -> Self::AlgorithmOid {
+        match self {
+            // RSA encryption
+            AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => &[1, 2, 840, 113_549, 1, 1, 1],
+            // EC Public Key
+            AlgorithmId::EccP256 | AlgorithmId::EccP384 => &[1, 2, 840, 10045, 2, 1],
+        }
+    }
+
+    fn parameters<W: std::io::Write>(
+        &self,
+        w: cookie_factory::WriteContext<W>,
+    ) -> cookie_factory::GenResult<W> {
+        use x509::der::write::der_oid;
+
+        // From [RFC 5480](https://tools.ietf.org/html/rfc5480#section-2.1.1):
+        // ```text
+        // ECParameters ::= CHOICE {
+        //   namedCurve         OBJECT IDENTIFIER
+        //   -- implicitCurve   NULL
+        //   -- specifiedCurve  SpecifiedECDomain
+        // }
+        // ```
+        match self {
+            AlgorithmId::EccP256 => der_oid(&[1, 2, 840, 10045, 3, 1, 7][..])(w),
+            AlgorithmId::EccP384 => der_oid(&[1, 3, 132, 0, 34][..])(w),
+            _ => Ok(w),
+        }
+    }
+}
+
+/// 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(EcPublicKey<NistP256>),
+
+    /// EC P-384 keys
+    EcP384(EcPublicKey<NistP384>),
+}
+
+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> {
+        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;
+                let algorithm_parameters = subject_pki
+                    .algorithm
+                    .parameters
+                    .as_ref()
+                    .ok_or(Error::InvalidObject)?;
+
+                match read_pki::ec_parameters(algorithm_parameters)? {
+                    AlgorithmId::EccP256 => EcPublicKey::<NistP256>::from_bytes(key_bytes)
+                        .map(PublicKeyInfo::EcP256)
+                        .map_err(|_| Error::InvalidObject),
+                    AlgorithmId::EccP384 => EcPublicKey::<NistP384>::from_bytes(key_bytes)
+                        .map(PublicKeyInfo::EcP384)
+                        .map_err(|_| Error::InvalidObject),
+                    _ => Err(Error::AlgorithmError),
+                }
+            }
+            _ => Err(Error::InvalidObject),
+        }
+    }
+
+    /// Returns the algorithm that this public key can be used with.
+    pub fn algorithm(&self) -> AlgorithmId {
+        match self {
+            PublicKeyInfo::Rsa { algorithm, .. } => *algorithm,
+            PublicKeyInfo::EcP256(_) => AlgorithmId::EccP256,
+            PublicKeyInfo::EcP384(_) => AlgorithmId::EccP384,
+        }
+    }
+}
+
+impl x509::SubjectPublicKeyInfo for PublicKeyInfo {
+    type AlgorithmId = AlgorithmId;
+    type SubjectPublicKey = Vec<u8>;
+
+    fn algorithm_id(&self) -> AlgorithmId {
+        self.algorithm()
+    }
+
+    fn public_key(&self) -> Vec<u8> {
+        match self {
+            PublicKeyInfo::Rsa { pubkey, .. } => {
+                cookie_factory::gen_simple(write_pki::rsa_pubkey(pubkey), vec![])
+                    .expect("can write to Vec")
+            }
+            PublicKeyInfo::EcP256(pubkey) => pubkey.as_bytes().to_vec(),
+            PublicKeyInfo::EcP384(pubkey) => pubkey.as_bytes().to_vec(),
+        }
+    }
+}
+
+/// Digest algorithms.
+///
+/// See RFC 4055 and RFC 8017.
+enum DigestId {
+    /// Secure Hash Algorithm 256 (SHA256)
+    Sha256,
+}
+
+impl x509::AlgorithmIdentifier for DigestId {
+    type AlgorithmOid = &'static [u64];
+
+    fn algorithm(&self) -> Self::AlgorithmOid {
+        match self {
+            // See https://tools.ietf.org/html/rfc4055#section-2.1
+            DigestId::Sha256 => &[2, 16, 840, 1, 101, 3, 4, 2, 1],
+        }
+    }
+
+    fn parameters<W: std::io::Write>(
+        &self,
+        w: cookie_factory::WriteContext<W>,
+    ) -> cookie_factory::GenResult<W> {
+        // Parameters are an explicit NULL
+        // See https://tools.ietf.org/html/rfc8017#appendix-A.2.4
+        x509::der::write::der_null()(w)
+    }
+}
+
+enum SignatureId {
+    /// Public-Key Cryptography Standards (PKCS) #1 version 1.5 signature algorithm with
+    /// Secure Hash Algorithm 256 (SHA256) and Rivest, Shamir and Adleman (RSA) encryption
+    ///
+    /// See RFC 4055 and RFC 8017.
+    Sha256WithRsaEncryption,
+
+    /// Elliptic Curve Digital Signature Algorithm (DSA) coupled with the Secure Hash
+    /// Algorithm 256 (SHA256) algorithm
+    ///
+    /// See RFC 5758.
+    EcdsaWithSha256,
+}
+
+impl x509::AlgorithmIdentifier for SignatureId {
+    type AlgorithmOid = &'static [u64];
+
+    fn algorithm(&self) -> Self::AlgorithmOid {
+        match self {
+            SignatureId::Sha256WithRsaEncryption => &[1, 2, 840, 113_549, 1, 1, 11],
+            SignatureId::EcdsaWithSha256 => &[1, 2, 840, 10045, 4, 3, 2],
+        }
+    }
+
+    fn parameters<W: std::io::Write>(
+        &self,
+        w: cookie_factory::WriteContext<W>,
+    ) -> cookie_factory::GenResult<W> {
+        // No parameters for any SignatureId
+        Ok(w)
+    }
+}
+
+/// Certificates
+#[derive(Clone, Debug)]
+pub struct Certificate {
+    serial: Serial,
+    #[allow(dead_code)]
+    issuer: String,
+    subject: String,
+    subject_pki: PublicKeyInfo,
+    data: Buffer,
+}
+
+impl<'a> TryFrom<&'a [u8]> for Certificate {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Self::from_bytes(bytes.to_vec())
+    }
+}
+
+impl Certificate {
+    /// Creates a new self-signed certificate for the given key. Writes the resulting
+    /// certificate to the slot before returning it.
+    ///
+    /// `extensions` is optional; if empty, no extensions will be included. Due to the
+    /// need for an `O: Oid` type parameter, users who do not have any extensions should
+    /// use the workaround `let extensions: &[x509::Extension<'_, &[u64]>] = &[];`.
+    pub fn generate_self_signed<O: Oid>(
+        yubikey: &mut YubiKey,
+        key: SlotId,
+        serial: impl Into<Serial>,
+        not_after: Option<DateTime<Utc>>,
+        subject: &[RelativeDistinguishedName<'_>],
+        subject_pki: PublicKeyInfo,
+        extensions: &[x509::Extension<'_, O>],
+    ) -> Result<Self> {
+        let serial = serial.into();
+
+        let mut tbs_cert = Buffer::new(Vec::with_capacity(CB_OBJ_MAX));
+
+        let signature_algorithm = match subject_pki.algorithm() {
+            AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => SignatureId::Sha256WithRsaEncryption,
+            AlgorithmId::EccP256 | AlgorithmId::EccP384 => SignatureId::EcdsaWithSha256,
+        };
+
+        cookie_factory::gen(
+            x509::write::tbs_certificate(
+                &serial.to_bytes(),
+                &signature_algorithm,
+                // Issuer and subject are the same in self-signed certificates.
+                subject,
+                Utc::now(),
+                not_after,
+                subject,
+                &subject_pki,
+                extensions,
+            ),
+            tbs_cert.deref_mut(),
+        )
+        .expect("can serialize to Vec");
+
+        let signature = match signature_algorithm {
+            SignatureId::Sha256WithRsaEncryption => {
+                use cookie_factory::{combinator::slice, sequence::tuple};
+                use x509::{
+                    der::write::{der_octet_string, der_sequence},
+                    write::algorithm_identifier,
+                };
+
+                let em_len = if let AlgorithmId::Rsa1024 = subject_pki.algorithm() {
+                    128
+                } else {
+                    256
+                };
+
+                let h = Sha256::digest(&tbs_cert);
+
+                let t = cookie_factory::gen_simple(
+                    der_sequence((
+                        algorithm_identifier(&DigestId::Sha256),
+                        der_octet_string(&h),
+                    )),
+                    vec![],
+                )
+                .expect("can serialize into Vec");
+
+                let em = cookie_factory::gen_simple(
+                    tuple((
+                        slice(&[0x00, 0x01]),
+                        slice(&vec![0xff; em_len - t.len() - 3]),
+                        slice(&[0x00]),
+                        slice(t),
+                    )),
+                    vec![],
+                )
+                .expect("can serialize to Vec");
+
+                sign_data(yubikey, &em, subject_pki.algorithm(), key)
+            }
+            SignatureId::EcdsaWithSha256 => sign_data(
+                yubikey,
+                &Sha256::digest(&tbs_cert),
+                subject_pki.algorithm(),
+                key,
+            ),
+        }?;
+
+        let mut data = Buffer::new(Vec::with_capacity(CB_OBJ_MAX));
+
+        cookie_factory::gen(
+            x509::write::certificate(&tbs_cert, &signature_algorithm, &signature),
+            data.deref_mut(),
+        )
+        .expect("can serialize to Vec");
+
+        let (issuer, subject) = parse_x509_certificate(&data)
+            .map(|(_, cert)| {
+                (
+                    cert.tbs_certificate.issuer.to_string(),
+                    cert.tbs_certificate.subject.to_string(),
+                )
+            })
+            .expect("We just serialized this correctly");
+
+        let cert = Certificate {
+            serial,
+            issuer,
+            subject,
+            subject_pki,
+            data,
+        };
+
+        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> {
+        let txn = yubikey.begin_transaction()?;
+        let buf = read_certificate(&txn, slot)?;
+
+        if buf.is_empty() {
+            return Err(Error::InvalidObject);
+        }
+
+        Certificate::from_bytes(buf)
+    }
+
+    /// Write this certificate into the YubiKey in the given slot
+    pub fn write(&self, yubikey: &mut YubiKey, slot: SlotId, certinfo: CertInfo) -> Result<()> {
+        let txn = yubikey.begin_transaction()?;
+        write_certificate(&txn, slot, Some(&self.data), certinfo)
+    }
+
+    /// Delete a certificate located at the given slot of the given YubiKey
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn delete(yubikey: &mut YubiKey, slot: SlotId) -> Result<()> {
+        let txn = yubikey.begin_transaction()?;
+        write_certificate(&txn, slot, None, CertInfo::Uncompressed)
+    }
+
+    /// Initialize a local certificate struct from the given bytebuffer
+    pub fn from_bytes(cert: impl Into<Buffer>) -> Result<Self> {
+        let cert = cert.into();
+
+        if cert.is_empty() {
+            error!("certificate cannot be empty");
+            return Err(Error::SizeError);
+        }
+
+        let parsed_cert = match parse_x509_certificate(&cert) {
+            Ok((_, cert)) => cert,
+            _ => return Err(Error::InvalidObject),
+        };
+
+        let serial = Serial::try_from(parsed_cert.tbs_certificate.serial.to_bytes_be().as_slice())
+            .map_err(|_| Error::InvalidObject)?;
+        let issuer = parsed_cert.tbs_certificate.issuer.to_string();
+        let subject = parsed_cert.tbs_certificate.subject.to_string();
+        let subject_pki = PublicKeyInfo::parse(&parsed_cert.tbs_certificate.subject_pki)?;
+
+        Ok(Certificate {
+            serial,
+            issuer,
+            subject,
+            subject_pki,
+            data: cert,
+        })
+    }
+
+    /// Returns the serial number of the certificate.
+    pub fn serial(&self) -> &Serial {
+        &self.serial
+    }
+
+    /// Returns the Issuer field of the certificate.
+    pub fn issuer(&self) -> &str {
+        &self.subject
+    }
+
+    /// Returns the SubjectName field of the certificate.
+    pub fn subject(&self) -> &str {
+        &self.subject
+    }
+
+    /// Returns the SubjectPublicKeyInfo field of the certificate.
+    pub fn subject_pki(&self) -> &PublicKeyInfo {
+        &self.subject_pki
+    }
+
+    /// Extract the inner buffer
+    pub fn into_buffer(self) -> Buffer {
+        self.data
+    }
+}
+
+impl AsRef<[u8]> for Certificate {
+    fn as_ref(&self) -> &[u8] {
+        self.data.as_ref()
+    }
+}
+
+/// Read certificate
+pub(crate) fn read_certificate(txn: &Transaction<'_>, slot: SlotId) -> Result<Buffer> {
+    let object_id = slot.object_id();
+
+    let buf = match txn.fetch_object(object_id) {
+        Ok(b) => b,
+        Err(_) => {
+            // TODO(tarcieri): is this really ok?
+            return Ok(Zeroizing::new(vec![]));
+        }
+    };
+
+    // TODO(str4d): Check the rest of the buffer (TAG_CERT_COMPRESS and TAG_CERT_LRC)
+    if buf[0] == TAG_CERT {
+        Tlv::parse_single(buf, TAG_CERT).or_else(|_| {
+            // TODO(tarcieri): is this really ok?
+            Ok(Zeroizing::new(vec![]))
+        })
+    } else {
+        Ok(buf)
+    }
+}
+
+/// Write certificate
+pub(crate) fn write_certificate(
+    txn: &Transaction<'_>,
+    slot: SlotId,
+    data: Option<&[u8]>,
+    certinfo: CertInfo,
+) -> Result<()> {
+    let object_id = slot.object_id();
+
+    if data.is_none() {
+        return txn.save_object(object_id, &[]);
+    }
+
+    let data = data.unwrap();
+
+    let mut buf = [0u8; CB_OBJ_MAX];
+    let mut offset = Tlv::write(&mut buf, TAG_CERT, data)?;
+
+    // write compression info and LRC trailer
+    offset += Tlv::write(&mut buf[offset..], TAG_CERT_COMPRESS, &[certinfo.into()])?;
+    offset += Tlv::write(&mut buf[offset..], TAG_CERT_LRC, &[])?;
+
+    txn.save_object(object_id, &buf[..offset])
+}
+
+mod read_pki {
+    use der_parser::{
+        asn1_rs::Any,
+        ber::BerObjectContent,
+        der::{parse_der_integer, parse_der_sequence_defined_g, DerObject},
+        error::BerError,
+    };
+    use nom::{combinator, sequence::pair, IResult};
+    use rsa::{BigUint, RsaPublicKey};
+
+    use super::{OID_NIST_P256, OID_NIST_P384};
+    use crate::{piv::AlgorithmId, Error, Result};
+
+    /// 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> {
+        fn parse_rsa_pubkey(i: &[u8]) -> IResult<&[u8], (DerObject<'_>, DerObject<'_>), BerError> {
+            parse_der_sequence_defined_g(|i, _| pair(parse_der_integer, parse_der_integer)(i))(i)
+        }
+
+        fn rsa_pubkey_parts(i: &[u8]) -> IResult<&[u8], (BigUint, BigUint), BerError> {
+            combinator::map(parse_rsa_pubkey, |(modulus, public_exponent)| {
+                let n = match modulus.content {
+                    BerObjectContent::Integer(s) => BigUint::from_bytes_be(s),
+                    _ => panic!("expected DER integer"),
+                };
+                let e = match public_exponent.content {
+                    BerObjectContent::Integer(s) => BigUint::from_bytes_be(s),
+                    _ => panic!("expected DER integer"),
+                };
+
+                (n, e)
+            })(i)
+        }
+
+        let (n, e) = match rsa_pubkey_parts(encoded) {
+            Ok((_, res)) => res,
+            _ => return Err(Error::InvalidObject),
+        };
+
+        RsaPublicKey::new(n, e).map_err(|_| Error::InvalidObject)
+    }
+
+    /// From [RFC 5480](https://tools.ietf.org/html/rfc5480#section-2.1.1):
+    /// ```text
+    /// ECParameters ::= CHOICE {
+    ///   namedCurve         OBJECT IDENTIFIER
+    ///   -- implicitCurve   NULL
+    ///   -- specifiedCurve  SpecifiedECDomain
+    /// }
+    /// ```
+    pub(super) fn ec_parameters(parameters: &Any<'_>) -> Result<AlgorithmId> {
+        let curve_oid = parameters.as_oid().map_err(|_| Error::InvalidObject)?;
+
+        match curve_oid.to_string().as_str() {
+            OID_NIST_P256 => Ok(AlgorithmId::EccP256),
+            OID_NIST_P384 => Ok(AlgorithmId::EccP384),
+            _ => Err(Error::AlgorithmError),
+        }
+    }
+}
+
+mod write_pki {
+    use cookie_factory::{SerializeFn, WriteContext};
+    use rsa::{BigUint, PublicKeyParts, RsaPublicKey};
+    use std::io::Write;
+    use x509::der::write::{der_integer, der_sequence};
+
+    /// Encodes a usize as an ASN.1 integer using DER.
+    fn der_integer_biguint<'a, W: Write + 'a>(num: &'a BigUint) -> impl SerializeFn<W> + 'a {
+        move |w: WriteContext<W>| der_integer(&num.to_bytes_be())(w)
+    }
+
+    /// 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<'a, W: Write + 'a>(
+        pubkey: &'a RsaPublicKey,
+    ) -> impl SerializeFn<W> + 'a {
+        der_sequence((
+            der_integer_biguint(pubkey.n()),
+            der_integer_biguint(pubkey.e()),
+        ))
+    }
+}
@@ -0,0 +1,137 @@
+//! Cardholder Unique Identifier (CHUID) Support
+
+// 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::{Error, Result, YubiKey};
+use std::{
+    fmt::{self, Debug, Display},
+    str,
+};
+use subtle_encoding::hex;
+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
+///
+/// Format defined in SP-800-73-4, Appendix A, Table 9
+///
+/// FASC-N containing S9999F9999F999999F0F1F0000000000300001E encoded in
+/// 4-bit BCD with 1 bit parity. run through the tools/fasc.pl script to get
+/// bytes. This CHUID has an expiry of 2030-01-01.
+///
+/// Defined fields:
+///
+/// - 0x30: FASC-N (hard-coded)
+/// - 0x34: Card UUID / GUID (settable)
+/// - 0x35: Exp. Date (hard-coded)
+/// - 0x3e: Signature (hard-coded, empty)
+/// - 0xfe: Error Detection Code (hard-coded)
+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,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x08, 0x32,
+    0x30, 0x33, 0x30, 0x30, 0x31, 0x30, 0x31, 0x3e, 0x00, 0xfe, 0x00,
+];
+
+/// Cardholder Unique Identifier (CHUID).
+#[derive(Copy, Clone, Debug)]
+pub struct ChuId(pub [u8; Self::BYTE_SIZE]);
+
+impl ChuId {
+    /// CHUID size in bytes
+    pub const BYTE_SIZE: usize = 59;
+
+    /// FASC-N component size
+    pub const FASCN_SIZE: usize = 25;
+
+    /// Expiration size
+    pub const EXPIRATION_SIZE: usize = 8;
+
+    /// Return FASC-N component of CHUID
+    pub fn fascn(&self) -> [u8; Self::FASCN_SIZE] {
+        self.0[CHUID_FASCN_OFFS..(CHUID_FASCN_OFFS + Self::FASCN_SIZE)]
+            .try_into()
+            .unwrap()
+    }
+
+    /// Return Card UUID/GUID component of CHUID
+    pub fn uuid(&self) -> Uuid {
+        Uuid::from_slice(&self.0[CHUID_GUID_OFFS..(CHUID_GUID_OFFS + 16)]).unwrap()
+    }
+
+    /// Return expiration date component of CHUID
+    // TODO(tarcieri): parse expiration?
+    pub fn expiration(&self) -> [u8; Self::EXPIRATION_SIZE] {
+        self.0[CHUID_EXPIRATION_OFFS..(CHUID_EXPIRATION_OFFS + Self::EXPIRATION_SIZE)]
+            .try_into()
+            .unwrap()
+    }
+
+    /// Get Cardholder Unique Identifier (CHUID)
+    pub fn get(yubikey: &mut YubiKey) -> Result<ChuId> {
+        let txn = yubikey.begin_transaction()?;
+        let response = txn.fetch_object(OBJ_CHUID)?;
+
+        if response.len() != CHUID_TMPL.len() {
+            return Err(Error::GenericError);
+        }
+
+        Ok(ChuId(response[..Self::BYTE_SIZE].try_into().unwrap()))
+    }
+
+    /// Set Cardholder Unique Identifier (CHUID)
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn set(&self, yubikey: &mut YubiKey) -> Result<()> {
+        let mut buf = CHUID_TMPL.to_vec();
+        buf[..Self::BYTE_SIZE].copy_from_slice(&self.0);
+
+        let txn = yubikey.begin_transaction()?;
+        txn.save_object(OBJ_CHUID, &buf)
+    }
+}
+
+impl Display for ChuId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(str::from_utf8(&hex::encode(&self.0[..])).unwrap())
+    }
+}
@@ -0,0 +1,147 @@
+//! YubiKey Configuration Values
+
+// 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::{
+        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::time::{Duration, SystemTime, UNIX_EPOCH};
+
+const CB_ADMIN_TIMESTAMP: usize = 0x04;
+const PROTECTED_FLAGS_1_PUK_NOBLOCK: u8 = 0x01;
+
+/// YubiKey configuration.
+#[derive(Copy, Clone, Debug)]
+pub struct Config {
+    /// Protected data available
+    pub protected_data_available: bool,
+
+    /// PUK blocked
+    pub puk_blocked: bool,
+
+    /// No block on upgrade
+    pub puk_noblock_on_upgrade: bool,
+
+    /// PIN last changed
+    pub pin_last_changed: Option<SystemTime>,
+
+    /// MGM type
+    pub mgm_type: MgmType,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            protected_data_available: false,
+            puk_blocked: false,
+            puk_noblock_on_upgrade: false,
+            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(admin_data) = AdminData::read(&txn) {
+            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 {
+                    if item[0] & ADMIN_FLAGS_1_PUK_BLOCKED != 0 {
+                        config.puk_blocked = true;
+                    }
+
+                    if item[0] & ADMIN_FLAGS_1_PROTECTED_MGM != 0 {
+                        config.mgm_type = MgmType::Protected;
+                    }
+                }
+            }
+
+            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 {
+                    config.mgm_type = MgmType::Derived;
+                }
+            }
+
+            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 endianness is correct
+                    let pin_last_changed = u32::from_le_bytes(item.try_into().unwrap());
+
+                    if pin_last_changed != 0 {
+                        config.pin_last_changed =
+                            Some(UNIX_EPOCH + Duration::from_secs(pin_last_changed as u64));
+                    }
+                }
+            }
+        }
+
+        if let Ok(protected_data) = ProtectedData::read(&txn) {
+            config.protected_data_available = true;
+
+            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 {
+                    config.puk_noblock_on_upgrade = true;
+                }
+            }
+
+            if protected_data.get_item(TAG_PROTECTED_MGM).is_ok() {
+                if config.mgm_type != MgmType::Protected {
+                    error!("conflicting MGM key types: protected MGM exists");
+                }
+
+                // Always favor protected MGM
+                config.mgm_type = MgmType::Protected;
+            }
+        }
+
+        Ok(config)
+    }
+}
@@ -1,218 +1,20 @@
-//! Constant values
-// TODO(tarcieri): refactor these into enums!
+//! Miscellaneous constant values

-// 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.
+/// YubiKey max buffer size
+pub(crate) const CB_BUF_MAX: usize = 3072;

-// TODO(tarcieri): document these!
-#![allow(missing_docs, non_upper_case_globals)]
+/// YubiKey max object size
+pub(crate) const CB_OBJ_MAX: usize = CB_BUF_MAX - 9;

-pub const szLOG_SOURCE: &str = "yubikey-piv.rs";
+pub(crate) const CB_OBJ_TAG_MIN: usize = 2; // 1 byte tag + 1 byte len
+#[cfg(feature = "untested")]
+pub(crate) const CB_OBJ_TAG_MAX: usize = CB_OBJ_TAG_MIN + 2; // 1 byte tag + 3 bytes len

-pub const CB_OBJ_MAX: usize = 3063;
+// Admin tags
+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_OBJ_TAG_MIN: usize = 2; // 1 byte tag + 1 byte len
-pub const CB_OBJ_TAG_MAX: usize = (CB_OBJ_TAG_MIN + 2); // 1 byte tag + 3 bytes len
-
-pub const CB_PIN_MAX: usize = 8;
-pub const CB_ECC_POINTP256: usize = 65;
-pub const CB_ECC_POINTP384: usize = 97;
-
-pub const CHUID_GUID_OFFS: usize = 29;
-
-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 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"
-
-// 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_ALGO_RSA1024: u8 = 0x06;
-pub const YKPIV_ALGO_RSA2048: u8 = 0x07;
-pub const YKPIV_ALGO_ECCP256: u8 = 0x11;
-pub const YKPIV_ALGO_ECCP384: u8 = 0x14;
-
-pub const YKPIV_ATR_NEO_R3: &[u8] = b";\xFC\x13\0\0\x811\xFE\x15YubikeyNEOr3\xE1\0";
-
-pub const YKPIV_CARDID_SIZE: usize = 16;
-
-pub const YKPIV_CCCID_SIZE: usize = 14;
-
-pub const YKPIV_CERTINFO_UNCOMPRESSED: u8 = 0;
-pub const YKPIV_CERTINFO_GZIP: u8 = 1;
-
-pub const YKPIV_INS_VERIFY: u8 = 0x20;
-pub const YKPIV_INS_CHANGE_REFERENCE: u8 = 0x24;
-pub const YKPIV_INS_RESET_RETRY: u8 = 0x2c;
-pub const YKPIV_INS_GENERATE_ASYMMETRIC: u8 = 0x47;
-pub const YKPIV_INS_AUTHENTICATE: u8 = 0x87;
-pub const YKPIV_INS_GET_DATA: u8 = 0xcb;
-pub const YKPIV_INS_PUT_DATA: u8 = 0xdb;
-pub const YKPIV_INS_SELECT_APPLICATION: u8 = 0xa4;
-pub const YKPIV_INS_GET_RESPONSE_APDU: u8 = 0xc0;
-
-// Yubico vendor specific instructions
-pub const YKPIV_INS_SET_MGMKEY: u8 = 0xff;
-pub const YKPIV_INS_IMPORT_KEY: u8 = 0xfe;
-pub const YKPIV_INS_GET_VERSION: u8 = 0xfd;
-pub const YKPIV_INS_RESET: u8 = 0xfb;
-pub const YKPIV_INS_SET_PIN_RETRIES: u8 = 0xfa;
-pub const YKPIV_INS_ATTEST: u8 = 0xf9;
-pub const YKPIV_INS_GET_SERIAL: u8 = 0xf8;
-
-pub const YKPIV_KEY_AUTHENTICATION: u8 = 0x9a;
-pub const YKPIV_KEY_CARDMGM: u8 = 0x9b;
-pub const YKPIV_KEY_SIGNATURE: u8 = 0x9c;
-pub const YKPIV_KEY_KEYMGM: u8 = 0x9d;
-pub const YKPIV_KEY_CARDAUTH: u8 = 0x9e;
-pub const YKPIV_KEY_RETIRED1: u8 = 0x82;
-pub const YKPIV_KEY_RETIRED2: u8 = 0x83;
-pub const YKPIV_KEY_RETIRED3: u8 = 0x84;
-pub const YKPIV_KEY_RETIRED4: u8 = 0x85;
-pub const YKPIV_KEY_RETIRED5: u8 = 0x86;
-pub const YKPIV_KEY_RETIRED6: u8 = 0x87;
-pub const YKPIV_KEY_RETIRED7: u8 = 0x88;
-pub const YKPIV_KEY_RETIRED8: u8 = 0x89;
-pub const YKPIV_KEY_RETIRED9: u8 = 0x8a;
-pub const YKPIV_KEY_RETIRED10: u8 = 0x8b;
-pub const YKPIV_KEY_RETIRED11: u8 = 0x8c;
-pub const YKPIV_KEY_RETIRED12: u8 = 0x8d;
-pub const YKPIV_KEY_RETIRED13: u8 = 0x8e;
-pub const YKPIV_KEY_RETIRED14: u8 = 0x8f;
-pub const YKPIV_KEY_RETIRED15: u8 = 0x90;
-pub const YKPIV_KEY_RETIRED16: u8 = 0x91;
-pub const YKPIV_KEY_RETIRED17: u8 = 0x92;
-pub const YKPIV_KEY_RETIRED18: u8 = 0x93;
-pub const YKPIV_KEY_RETIRED19: u8 = 0x94;
-pub const YKPIV_KEY_RETIRED20: u8 = 0x95;
-pub const YKPIV_KEY_ATTESTATION: u8 = 0xf9;
-
-pub const YKPIV_OBJ_CAPABILITY: u32 = 0x005f_c107;
-pub const YKPIV_OBJ_CHUID: u32 = 0x005f_c102;
-pub const YKPIV_OBJ_AUTHENTICATION: u32 = 0x005f_c105; // cert for 9a key
-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_SIGNATURE: u32 = 0x005f_c10a; // cert for 9c key
-pub const YKPIV_OBJ_KEY_MANAGEMENT: u32 = 0x005f_c10b; // cert for 9d key
-pub const YKPIV_OBJ_CARD_AUTH: u32 = 0x005f_c101; // cert for 9e key
-pub const YKPIV_OBJ_DISCOVERY: u32 = 0x7e;
-pub const YKPIV_OBJ_KEY_HISTORY: u32 = 0x005f_c10c;
-pub const YKPIV_OBJ_IRIS: u32 = 0x005f_c121;
-
-pub const YKPIV_OBJ_RETIRED1: u32 = 0x005f_c10d;
-pub const YKPIV_OBJ_RETIRED2: u32 = 0x005f_c10e;
-pub const YKPIV_OBJ_RETIRED3: u32 = 0x005f_c10f;
-pub const YKPIV_OBJ_RETIRED4: u32 = 0x005f_c110;
-pub const YKPIV_OBJ_RETIRED5: u32 = 0x005f_c111;
-pub const YKPIV_OBJ_RETIRED6: u32 = 0x005f_c112;
-pub const YKPIV_OBJ_RETIRED7: u32 = 0x005f_c113;
-pub const YKPIV_OBJ_RETIRED8: u32 = 0x005f_c114;
-pub const YKPIV_OBJ_RETIRED9: u32 = 0x005f_c115;
-pub const YKPIV_OBJ_RETIRED10: u32 = 0x005f_c116;
-pub const YKPIV_OBJ_RETIRED11: u32 = 0x005f_c117;
-pub const YKPIV_OBJ_RETIRED12: u32 = 0x005f_c118;
-pub const YKPIV_OBJ_RETIRED13: u32 = 0x005f_c119;
-pub const YKPIV_OBJ_RETIRED14: u32 = 0x005f_c11a;
-pub const YKPIV_OBJ_RETIRED15: u32 = 0x005f_c11b;
-pub const YKPIV_OBJ_RETIRED16: u32 = 0x005f_c11c;
-pub const YKPIV_OBJ_RETIRED17: u32 = 0x005f_c11d;
-pub const YKPIV_OBJ_RETIRED18: u32 = 0x005f_c11e;
-pub const YKPIV_OBJ_RETIRED19: u32 = 0x005f_c11f;
-pub const YKPIV_OBJ_RETIRED20: u32 = 0x005f_c120;
-
-// Internal object IDs
-
-pub const YKPIV_OBJ_ADMIN_DATA: u32 = 0x005f_ff00;
-pub const YKPIV_OBJ_ATTESTATION: u32 = 0x005f_ff01;
-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_OBJ_MAX_SIZE: usize = 3072;
-
-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;
+// Protected tags
+pub(crate) const TAG_PROTECTED_FLAGS_1: u8 = 0x81;
+pub(crate) const TAG_PROTECTED_MGM: u8 = 0x89;
@@ -30,131 +30,137 @@
 // (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 std::fmt;
+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)]
-pub enum ErrorKind {
-    /// OK
-    // TODO(tarcieri): replace this with proper result types
-    Ok,
-
-    /// Memory error
-    MemoryError,
-
-    /// PCSC error
-    PcscError,
-
-    /// Size error
-    SizeError,
+#[non_exhaustive]
+pub enum Error {
+    /// Algorithm error
+    AlgorithmError,

    /// Applet error
    AppletError,

+    /// Argument error
+    ArgumentError,
+
    /// Authentication error
    AuthenticationError,

-    /// Randomness error
-    RandomnessError,
-
    /// Generic error
    GenericError,

+    /// Invalid object
+    InvalidObject,
+
    /// Key error
    KeyError,

+    /// Memory error
+    MemoryError,
+
+    /// Not supported
+    NotSupported,
+
+    /// Not found
+    NotFound,
+
    /// Parse error
    ParseError,

-    /// Wrong PIN
-    WrongPin,
-
-    /// Invalid object
-    InvalidObject,
-
-    /// Algorithm error
-    AlgorithmError,
+    /// PCSC error
+    PcscError {
+        /// Original PC/SC error
+        inner: Option<pcsc::Error>,
+    },

    /// PIN locked
    PinLocked,

-    /// Argument error
-    ArgumentError,
-
    /// Range error
    RangeError,

-    /// Not supported
-    NotSupported,
+    /// Size error
+    SizeError,
+
+    /// Wrong PIN
+    WrongPin {
+        /// Number of tries remaining
+        tries: u8,
+    },
 }

-impl ErrorKind {
+impl Error {
    /// Name of the 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 {
-        match self {
-            ErrorKind::Ok => "YKPIV_OK",
-            ErrorKind::MemoryError => "YKPIV_MEMORY_ERROR",
-            ErrorKind::PcscError => "YKPIV_PCSC_ERROR",
-            ErrorKind::SizeError => "YKPIV_SIZE_ERROR",
-            ErrorKind::AppletError => "YKPIV_APPLET_ERROR",
-            ErrorKind::AuthenticationError => "YKPIV_AUTHENTICATION_ERROR",
-            ErrorKind::RandomnessError => "YKPIV_RANDOMNESS_ERROR",
-            ErrorKind::GenericError => "YKPIV_GENERIC_ERROR",
-            ErrorKind::KeyError => "YKPIV_KEY_ERROR",
-            ErrorKind::ParseError => "YKPIV_PARSE_ERROR",
-            ErrorKind::WrongPin => "YKPIV_WRONG_PIN",
-            ErrorKind::InvalidObject => "YKPIV_INVALID_OBJECT",
-            ErrorKind::AlgorithmError => "YKPIV_ALGORITHM_ERROR",
-            ErrorKind::PinLocked => "YKPIV_PIN_LOCKED",
-            ErrorKind::ArgumentError => "YKPIV_ARGUMENT_ERROR",
-            ErrorKind::RangeError => "YKPIV_RANGE_ERROR",
-            ErrorKind::NotSupported => "YKPIV_NOT_SUPPORTED",
-        }
+    pub fn name(self) -> Option<&'static str> {
+        Some(match self {
+            Error::AlgorithmError => "YKPIV_ALGORITHM_ERROR",
+            Error::AppletError => "YKPIV_APPLET_ERROR",
+            Error::ArgumentError => "YKPIV_ARGUMENT_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 {
        match self {
-            ErrorKind::Ok => "OK",
-            ErrorKind::MemoryError => "memory error",
-            ErrorKind::PcscError => "PCSC error",
-            ErrorKind::SizeError => "size error",
-            ErrorKind::AppletError => "applet error",
-            ErrorKind::AuthenticationError => "authentication error",
-            ErrorKind::RandomnessError => "randomness error",
-            ErrorKind::GenericError => "generic error",
-            ErrorKind::KeyError => "key error",
-            ErrorKind::ParseError => "parse error",
-            ErrorKind::WrongPin => "wrong pin",
-            ErrorKind::InvalidObject => "invalid object",
-            ErrorKind::AlgorithmError => "algorithm error",
-            ErrorKind::PinLocked => "PIN locked",
-            ErrorKind::ArgumentError => "argument error",
-            ErrorKind::RangeError => "range error",
-            ErrorKind::NotSupported => "not supported",
+            Error::AlgorithmError => "algorithm error",
+            Error::AppletError => "applet error",
+            Error::ArgumentError => "argument error",
+            Error::AuthenticationError => "authentication error",
+            Error::GenericError => "generic error",
+            Error::InvalidObject => "invalid object",
+            Error::KeyError => "key error",
+            Error::MemoryError => "memory error",
+            Error::NotSupported => "not supported",
+            Error::NotFound => "not found",
+            Error::ParseError => "parse error",
+            Error::PcscError { .. } => "PC/SC error",
+            Error::PinLocked => "PIN locked",
+            Error::RangeError => "range error",
+            Error::SizeError => "size error",
+            Error::WrongPin { .. } => "wrong pin",
        }
    }
 }

-impl fmt::Display for ErrorKind {
+impl Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.msg())
    }
 }

-impl std::error::Error for ErrorKind {}
-
-/// Get a string representation of this error
-// TODO(tarcieri): completely replace this with `Display`
-pub fn ykpiv_strerror(err: ErrorKind) -> &'static str {
-    err.msg()
+impl From<pcsc::Error> for Error {
+    fn from(err: pcsc::Error) -> Error {
+        Error::PcscError { inner: Some(err) }
+    }
 }

-/// Get the name of this error
-// TODO(tarcieri): completely replace this with debug
-pub fn ykpiv_strerror_name(err: ErrorKind) -> &'static str {
-    err.name()
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            #[allow(trivial_casts)]
+            Error::PcscError { inner } => inner.as_ref().map(|err| err as &_),
+            _ => None,
+        }
+    }
 }
@@ -1,427 +0,0 @@
-//! Internal functions (mostly 3DES)
-
-// TODO(tarcieri): replace OpenSSL extern "C" invocations with `des` crate
-// - crate: https://crates.io/crates/des
-// - docs: https://docs.rs/des/0
-
-// 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.
-
-// TODO(tarcieri): investigate and remove dead code
-#![allow(non_upper_case_globals, dead_code)]
-#![allow(clippy::missing_safety_doc)]
-
-use crate::consts::*;
-use libc::{
-    c_char, c_int, fclose, feof, fgets, fopen, free, getenv, malloc, memcpy, memset, sscanf,
-    strcasecmp, strcmp,
-};
-use std::{
-    ffi::{CStr, CString},
-    mem,
-    os::raw::c_void,
-};
-
-extern "C" {
-    fn DES_ecb3_encrypt(
-        input: *mut [u8; 8],
-        output: *mut [u8; 8],
-        ks1: *mut DesSubKey,
-        ks2: *mut DesSubKey,
-        ks3: *mut DesSubKey,
-        enc: i32,
-    );
-    fn DES_is_weak_key(key: *mut [u8; 8]) -> i32;
-    fn DES_set_key_unchecked(key: *mut [u8; 8], schedule: *mut DesSubKey);
-    fn PKCS5_PBKDF2_HMAC_SHA1(
-        pass: *const u8,
-        passlen: i32,
-        salt: *const u8,
-        saltlen: i32,
-        iter: i32,
-        keylen: i32,
-        out: *mut u8,
-    ) -> i32;
-    fn RAND_bytes(buf: *mut u8, num: i32) -> i32;
-}
-
-/// DES-related errors
-#[allow(non_camel_case_types)]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[repr(i32)]
-pub enum DesErrorKind {
-    /// Ok
-    Ok = 0,
-
-    /// Invalid parameter
-    InvalidParameter = -1,
-
-    /// Buffer too small
-    BufferTooSmall = -2,
-
-    /// Memory error
-    MemoryError = -3,
-
-    /// General error
-    GeneralError = -4,
-}
-
-/// 3DES subkeys
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct DesSubKey([u8; 16]);
-
-/// 3DES keys
-#[derive(Copy, Clone)]
-pub struct DesKey {
-    /// subkey 1
-    pub ks1: DesSubKey,
-
-    /// subkey 2
-    pub ks2: DesSubKey,
-
-    /// subkey 3
-    pub ks3: DesSubKey,
-}
-
-/// Import DES key
-pub unsafe fn des_import_key(
-    key_type: i32,
-    keyraw: *const u8,
-    keyrawlen: usize,
-    key: *mut *mut DesKey,
-) -> DesErrorKind {
-    let mut key_tmp = [0u8; 8];
-    let cb_expectedkey: usize;
-    let cb_keysize: usize;
-
-    if key_type != DES_TYPE_3DES as i32 {
-        return DesErrorKind::InvalidParameter;
-    }
-
-    cb_expectedkey = (8i32 * 3i32) as (usize);
-    cb_keysize = 8usize;
-
-    if cb_keysize > 8 {
-        return DesErrorKind::MemoryError;
-    }
-
-    if key.is_null() || keyraw.is_null() || keyrawlen != cb_expectedkey {
-        return DesErrorKind::InvalidParameter;
-    }
-
-    *key = malloc(mem::size_of::<DesKey>()) as (*mut DesKey);
-
-    if (*key).is_null() {
-        return DesErrorKind::MemoryError;
-    }
-
-    memset(*key as (*mut c_void), 0i32, mem::size_of::<DesKey>());
-
-    memcpy(
-        key_tmp.as_mut_ptr() as (*mut c_void),
-        keyraw as (*const c_void),
-        cb_keysize,
-    );
-
-    DES_set_key_unchecked(&mut key_tmp, &mut (**key).ks1);
-
-    memcpy(
-        key_tmp.as_mut_ptr() as (*mut c_void),
-        keyraw.add(cb_keysize) as (*const c_void),
-        cb_keysize,
-    );
-
-    DES_set_key_unchecked(&mut key_tmp, &mut (**key).ks2);
-
-    memcpy(
-        key_tmp.as_mut_ptr() as (*mut c_void),
-        keyraw.add(2usize.wrapping_mul(cb_keysize)) as (*const c_void),
-        cb_keysize,
-    );
-
-    DES_set_key_unchecked(&mut key_tmp, &mut (**key).ks3);
-
-    DesErrorKind::Ok
-}
-
-/// Destroy DES key
-pub unsafe fn des_destroy_key(key: *mut DesKey) -> DesErrorKind {
-    if !key.is_null() {
-        free(key as (*mut c_void));
-    }
-
-    DesErrorKind::Ok
-}
-
-/// Encrypt with DES key
-pub unsafe fn des_encrypt(
-    key: *mut DesKey,
-    input: *const u8,
-    inputlen: usize,
-    out: *mut u8,
-    outlen: *mut usize,
-) -> DesErrorKind {
-    if key.is_null() || outlen.is_null() || *outlen < inputlen || input.is_null() || out.is_null() {
-        return DesErrorKind::InvalidParameter;
-    }
-
-    DES_ecb3_encrypt(
-        input as *mut [u8; 8],
-        out as *mut [u8; 8],
-        &mut (*key).ks1,
-        &mut (*key).ks2,
-        &mut (*key).ks3,
-        1,
-    );
-
-    DesErrorKind::Ok
-}
-
-/// Decrypt with DES key
-pub unsafe fn des_decrypt(
-    key: *mut DesKey,
-    in_: *const u8,
-    inlen: usize,
-    out: *mut u8,
-    outlen: *mut usize,
-) -> DesErrorKind {
-    if key.is_null() || outlen.is_null() || *outlen < inlen || in_.is_null() || out.is_null() {
-        return DesErrorKind::InvalidParameter;
-    }
-
-    DES_ecb3_encrypt(
-        in_ as *mut [u8; 8],
-        out as *mut [u8; 8],
-        &mut (*key).ks1,
-        &mut (*key).ks2,
-        &mut (*key).ks3,
-        0,
-    );
-
-    DesErrorKind::Ok
-}
-
-/// Is the given DES key weak?
-pub unsafe fn yk_des_is_weak_key(key: *const u8, _cb_key: usize) -> bool {
-    DES_is_weak_key(key as (*mut [u8; 8])) != 0
-}
-
-/// PRNG errors/results
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[repr(i32)]
-pub enum PRngErrorKind {
-    /// Ok
-    Ok = 0,
-
-    /// General error
-    GeneralError = -1,
-}
-
-/// Generate bytes with the PRNG
-pub unsafe fn _ykpiv_prng_generate(buffer: *mut u8, cb_req: usize) -> PRngErrorKind {
-    if RAND_bytes(buffer, cb_req as (i32)) != -1 {
-        PRngErrorKind::Ok
-    } else {
-        PRngErrorKind::GeneralError
-    }
-}
-
-/// PKCS#5 error types
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[repr(i32)]
-pub enum Pkcs5ErrorKind {
-    /// OK
-    Ok = 0,
-
-    /// General error
-    GeneralError = -1,
-}
-
-/// Decrypt a PKCS#5 key
-pub unsafe fn pkcs5_pbkdf2_sha1(
-    password: *const u8,
-    cb_password: usize,
-    salt: *const u8,
-    cb_salt: usize,
-    iterations: usize,
-    key: *const u8,
-    cb_key: usize,
-) -> Pkcs5ErrorKind {
-    PKCS5_PBKDF2_HMAC_SHA1(
-        password,
-        cb_password as (i32),
-        salt,
-        cb_salt as (i32),
-        iterations as (i32),
-        cb_key as (i32),
-        key as (*mut u8),
-    );
-
-    Pkcs5ErrorKind::Ok
-}
-
-/// Strip whitespace
-// TODO(tarcieri): implement this
-pub unsafe fn _strip_ws(sz: *mut c_char) -> *mut c_char {
-    sz
-}
-
-/// Source of how a setting was configured
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum SettingSource {
-    /// User-specified setting
-    User,
-
-    /// Admin-specified setting
-    Admin,
-
-    /// Default setting
-    Default,
-}
-
-/// Setting booleans
-#[derive(Copy, Clone, Debug)]
-pub struct SettingBool {
-    /// Boolean value
-    pub value: bool,
-
-    /// Source of the configuration setting (user/admin/default)
-    pub source: SettingSource,
-}
-
-/// Get a boolean config value
-pub unsafe fn _get_bool_config(sz_setting: *const c_char) -> SettingBool {
-    let mut setting: SettingBool = SettingBool {
-        value: false,
-        source: SettingSource::Default,
-    };
-    let mut sz_line = [0u8; 256];
-    let mut psz_name: *mut c_char;
-    let mut psz_value: *mut c_char;
-    let mut sz_name = [0u8; 256];
-    let mut sz_value = [0u8; 256];
-
-    let pf = fopen(
-        b"/etc/yubico/yubikeypiv.conf\0".as_ptr() as *const c_char,
-        b"r\0".as_ptr() as *const c_char,
-    );
-
-    if pf.is_null() {
-        return setting;
-    }
-
-    while feof(pf) == 0 {
-        if fgets(
-            sz_line.as_mut_ptr() as *mut c_char,
-            sz_line.len() as c_int,
-            pf,
-        )
-        .is_null()
-        {
-            continue;
-        }
-
-        if sz_line[0] == b'#' {
-            continue;
-        }
-
-        if sz_line[0] == b'\r' {
-            continue;
-        }
-
-        if sz_line[0] == b'\n' {
-            continue;
-        }
-
-        if sscanf(
-            sz_line.as_ptr() as *const c_char,
-            b"%255[^=]=%255s\0".as_ptr() as *const c_char,
-            sz_name.as_mut_ptr(),
-            sz_value.as_mut_ptr(),
-        ) != 2
-        {
-            continue;
-        }
-
-        psz_name = _strip_ws(sz_name.as_mut_ptr() as *mut c_char);
-
-        if strcasecmp(psz_name, sz_setting) != 0 {
-            continue;
-        }
-
-        psz_value = _strip_ws(sz_value.as_mut_ptr() as *mut c_char);
-        setting.source = SettingSource::Admin;
-        setting.value = strcmp(psz_value, b"1\0".as_ptr() as *const c_char) == 0
-            || strcasecmp(psz_value, b"true\0".as_ptr() as *const c_char) == 0;
-    }
-
-    fclose(pf);
-    setting
-}
-
-/// Get a setting boolean from an environment variable
-pub unsafe fn _get_bool_env(sz_setting: *const c_char) -> SettingBool {
-    let mut setting: SettingBool = SettingBool {
-        value: false,
-        source: SettingSource::Default,
-    };
-
-    let sz_name = CString::new(format!(
-        "YUBIKEY_PIV_{}",
-        CStr::from_ptr(sz_setting).to_string_lossy()
-    ))
-    .unwrap();
-
-    let psz_value = getenv(sz_name.as_ptr());
-
-    if !psz_value.is_null() {
-        setting.source = SettingSource::User;
-        setting.value = strcmp(psz_value, b"1\0".as_ptr() as *const c_char) == 0
-            || strcasecmp(psz_value, b"true\0".as_ptr() as *const c_char) == 0;
-    }
-
-    setting
-}
-
-/// Get a setting boolean
-pub unsafe fn setting_get_bool(sz_setting: *const c_char, def: bool) -> SettingBool {
-    let mut setting = _get_bool_config(sz_setting);
-
-    if setting.source == SettingSource::Default {
-        setting = _get_bool_env(sz_setting);
-    }
-
-    if setting.source == SettingSource::Default {
-        setting.value = def;
-    }
-
-    setting
-}
@@ -1,46 +1,102 @@
-//! [YubiKey][1] PIV: [Personal Identity Verification][2] support for
-//! [Yubico][3] devices using the Chip Card Interface Device ([CCID][4])
-//! protocol.
+//! **yubikey.rs**: pure Rust cross-platform host-side driver for [YubiKey]
+//! devices from [Yubico] using the Personal Computer/Smart Card ([PC/SC])
+//! interface as provided by the [`pcsc` crate].
 //!
-//! **PIV** is a [NIST][5] standard for both *signing* and *encryption*
+//! # Features
+//! ## Personal Identity Verification (PIV)
+//! [PIV] is a [NIST] standard for both *signing* and *encryption*
 //! using SmartCards and SmartCard-based hardware tokens like YubiKeys.
 //!
-//! This library natively implements the CCID protocol used to manage and
+//! 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.
 //!
-//! Supported algorithms:
+//! See [Yubico's guide to PIV-enabled YubiKeys][yk-guide] for more information
+//! on which devices support PIV and the available functionality.
 //!
+//! # Minimum Supported Rust Version
+//! Rust **1.57** or newer.
+//!
+//! # Supported YubiKeys
+//! - [YubiKey 4] series
+//! - [YubiKey 5] series
+//!
+//! NOTE: Nano and USB-C variants of the above are also supported.
+//!       Pre-YK4 [YubiKey NEO] series is **NOT** supported.
+//!
+//! # Supported Operating Systems
+//! - Linux
+//! - macOS
+//! - Windows
+//!
+//! # Supported Algorithms
 //! - **Authentication**: `3DES`
-//! - **Encryption**: `RSA1024`, `RSA2048`, `ECCP256`, `ECCP384`
+//! - **Encryption**:
+//!   - RSA: `RSA1024`, `RSA2048`
+//!   - ECC: `ECCP256`, `ECCP384` (NIST curves: P-256, P-384)
 //! - **Signatures**:
 //!   - RSASSA-PKCS#1v1.5: `RSA1024`, `RSA2048`
-//!   - ECDSA: `ECCP256`, `ECCP384`
+//!   - ECDSA: `ECCP256`, `ECCP384` (NIST curves: P-256, P-384)
 //!
-//! ## Status
+//! NOTE: RSASSA-PSS signatures and RSA-OAEP encryption may be supportable (TBD)
 //!
-//! This library is a work-in-progress translation and is not yet usable.
-//! Check back later for updates.
+//! # Status
+//! Functionality which has been successfully tested is available by default.
 //!
-//! ## History
+//! Any functionality which is gated on the `untested` feature has not been
+//! properly tested and is not known to function correctly.
 //!
-//! This library is a Rust translation of the [yubico-piv-tool][6] utility by
+//! Please see the [`untested` functionality tracking issue] for current status.
+//! We would appreciate any help testing this functionality and removing the
+//! `untested` gating as well as writing more automated tests.
+//!
+//! # 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][7], and then subsequently heavily
+//! 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
+//! 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][8].
+//! [Yubico PIV Tool Command Line Guide][piv-tool-guide].
 //!
-//! [1]: https://www.yubico.com/products/yubikey-hardware/
-//! [2]: https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-73-4.pdf
-//! [3]: https://www.yubico.com/
-//! [4]: https://en.wikipedia.org/wiki/CCID_(protocol)
-//! [5]: https://www.nist.gov/
-//! [6]: https://github.com/Yubico/yubico-piv-tool/
-//! [7]: https://github.com/jameysharp/corrode
-//! [8]: https://www.yubico.com/wp-content/uploads/2016/05/Yubico_PIV_Tool_Command_Line_Guide_en.pdf
+//! # 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.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/
+//! [`untested` functionality tracking issue]: https://github.com/iqlusioninc/yubikey.rs/issues/280
+//! [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/iqlusioninc/yubikey.rs/blob/main/CODE_OF_CONDUCT.md
+//! [BSDL]: https://opensource.org/licenses/BSD-2-Clause

 // Adapted from yubico-piv-tool:
 // <https://github.com/Yubico/yubico-piv-tool/>
@@ -72,24 +128,55 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+#![cfg_attr(docsrs, feature(doc_cfg))]
 #![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.1"
-)]
-#![warn(
-    missing_docs,
-    rust_2018_idioms,
-    trivial_casts,
-    trivial_numeric_casts,
-    unused_lifetimes,
-    unused_qualifications
+    html_logo_url = "https://raw.githubusercontent.com/iqlusioninc/yubikey.rs/main/img/logo.png"
 )]
+#![forbid(unsafe_code)]
+#![warn(missing_docs, rust_2018_idioms, trivial_casts, unused_qualifications)]

 mod apdu;
-pub mod consts;
-pub mod error;
-mod internal;
-pub mod util;
-pub mod yubikey;
+mod cccid;
+pub mod certificate;
+mod chuid;
+mod config;
+mod consts;
+mod error;
+mod metadata;
+mod mgm;
+#[cfg(feature = "untested")]
+mod mscmap;
+#[cfg(feature = "untested")]
+mod msroots;
+pub mod piv;
+mod policy;
+pub mod reader;
+mod serialization;
+mod setting;
+mod transaction;
+mod yubikey;

-pub use self::yubikey::YubiKey;
+pub use crate::{
+    cccid::{CardId, CccId},
+    certificate::Certificate,
+    chuid::ChuId,
+    config::Config,
+    error::{Error, Result},
+    mgm::{MgmKey, MgmType},
+    piv::Key,
+    policy::{PinPolicy, TouchPolicy},
+    reader::Context,
+    setting::{Setting, SettingSource},
+    yubikey::{CachedPin, Serial, Version, YubiKey},
+};
+
+#[cfg(feature = "untested")]
+pub use crate::{mscmap::MsContainer, msroots::MsRoots};
+
+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 type Buffer = zeroize::Zeroizing<Vec<u8>>;
@@ -0,0 +1,253 @@
+//! YubiKey Device Metadata
+
+// 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 std::marker::PhantomData;
+use zeroize::Zeroizing;
+
+use crate::{serialization::*, transaction::Transaction, Buffer, Error, Result};
+
+#[cfg(feature = "untested")]
+use crate::consts::{CB_OBJ_MAX, CB_OBJ_TAG_MAX};
+
+#[cfg(feature = "untested")]
+use std::iter;
+
+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::default(),
+        }
+    }
+}
+
+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::default(),
+        })
+    }
+
+    /// Write metadata
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    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
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub(crate) fn delete(txn: &Transaction<'_>) -> Result<()> {
+        txn.save_object(T::obj_id(), &[])
+    }
+
+    /// Get metadata item
+    pub(crate) fn get_item(&self, tag: u8) -> Result<&[u8]> {
+        let mut data = &self.inner[..];
+
+        while !data.is_empty() {
+            let (remaining, tlv) = Tlv::parse(data)?;
+            data = remaining;
+
+            if tlv.tag == tag {
+                // found tag
+                return Ok(tlv.value);
+            }
+        }
+
+        Err(Error::GenericError)
+    }
+
+    /// Set metadata item
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub(crate) fn set_item(&mut self, tag: u8, item: &[u8]) -> Result<()> {
+        let mut cb_temp: usize = 0;
+        let mut tag_temp: u8 = 0;
+        let mut cb_len: usize = 0;
+
+        let mut offset = 0;
+
+        while offset < self.inner.len() {
+            tag_temp = self.inner[offset];
+            offset += 1;
+
+            cb_len = get_length(&self.inner[offset..], &mut cb_temp);
+            offset += cb_len;
+
+            if tag_temp == tag {
+                break;
+            }
+
+            offset += cb_temp;
+        }
+
+        if tag_temp != tag {
+            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
+            assert_eq!(offset, self.inner.len());
+            self.inner
+                .extend(iter::repeat(0).take(1 + get_length_size(item.len()) + item.len()));
+            Tlv::write(&mut self.inner[offset..], tag, item)?;
+
+            return Ok(());
+        }
+
+        // Found tag
+
+        // Check length, if it matches, overwrite
+        if cb_temp == item.len() {
+            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 = (item.len() as isize - cb_temp as isize)
+            + if item.is_empty() {
+                // 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 (self.inner.len() as isize + cb_moved) as usize > CB_OBJ_MAX {
+            return Err(Error::GenericError);
+        }
+
+        // Move remaining data
+        let orig_len = self.inner.len();
+        if cb_moved > 0 {
+            self.inner.extend(iter::repeat(0).take(cb_moved as usize));
+        }
+        self.inner.copy_within(
+            next_offset..orig_len,
+            (next_offset as isize + cb_moved) as usize,
+        );
+        self.inner
+            .resize((orig_len as isize + cb_moved) as usize, 0);
+
+        // Re-encode item and insert
+        if !item.is_empty() {
+            offset -= cb_len;
+            offset += set_length(&mut self.inner[offset..], item.len())?;
+            self.inner[offset..offset + item.len()].copy_from_slice(item);
+        }
+
+        Ok(())
+    }
+}
+
+/// Get the size of a length tag for the given length
+#[cfg(feature = "untested")]
+fn get_length_size(length: usize) -> usize {
+    if length < 0x80 {
+        1
+    } else if length < 0xff {
+        2
+    } else {
+        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
+        }
+    }
+}
@@ -0,0 +1,424 @@
+//! Management Key (MGM) for authenticating to the YubiKey management applet
+
+// 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::{Error, Result};
+use log::error;
+use rand_core::{OsRng, RngCore};
+use zeroize::{Zeroize, Zeroizing};
+
+#[cfg(feature = "untested")]
+use crate::{
+    consts::{TAG_ADMIN_FLAGS_1, TAG_ADMIN_SALT, TAG_PROTECTED_MGM},
+    metadata::{AdminData, ProtectedData},
+    yubikey::YubiKey,
+};
+use des::{
+    cipher::{generic_array::GenericArray, BlockDecrypt, BlockEncrypt, KeyInit},
+    TdesEde3,
+};
+#[cfg(feature = "untested")]
+use {hmac::Hmac, pbkdf2::pbkdf2, sha1::Sha1};
+
+pub(crate) const ADMIN_FLAGS_1_PROTECTED_MGM: u8 = 0x02;
+
+#[cfg(feature = "untested")]
+const CB_ADMIN_SALT: usize = 16;
+
+/// Size of a DES key
+const DES_LEN_DES: usize = 8;
+
+/// Size of a 3DES key
+pub(crate) const DES_LEN_3DES: usize = DES_LEN_DES * 3;
+
+/// Number of PBKDF2 iterations to use when deriving from a password
+#[cfg(feature = "untested")]
+const ITER_MGM_PBKDF2: u32 = 10000;
+
+/// Management Key (MGM) key types (manual/derived/protected).
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum MgmType {
+    /// Manual
+    Manual = 0,
+
+    /// Derived
+    Derived = 1,
+
+    /// Protected
+    Protected = 2,
+}
+
+/// Management Key (MGM).
+///
+/// This key is used to authenticate to the management applet running on
+/// a YubiKey in order to perform administrative functions.
+///
+/// The only supported algorithm for MGM keys is 3DES.
+#[derive(Clone)]
+pub struct MgmKey([u8; DES_LEN_3DES]);
+
+impl MgmKey {
+    /// Generate a random MGM key
+    pub fn generate() -> Self {
+        let mut key_bytes = [0u8; DES_LEN_3DES];
+        OsRng.fill_bytes(&mut key_bytes);
+        Self(key_bytes)
+    }
+
+    /// Create an MGM key from byte slice.
+    ///
+    /// Returns an error if the slice is the wrong size or the key is weak.
+    pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Result<Self> {
+        bytes.as_ref().try_into()
+    }
+
+    /// Create an MGM key from the given byte array.
+    ///
+    /// Returns an error if the key is weak.
+    pub fn new(key_bytes: [u8; DES_LEN_3DES]) -> Result<Self> {
+        if is_weak_key(&key_bytes) {
+            error!(
+                "blacklisting key '{:?}' since it's weak (with odd parity)",
+                &key_bytes
+            );
+
+            return Err(Error::KeyError);
+        }
+
+        Ok(Self(key_bytes))
+    }
+
+    /// Get derived management key (MGM)
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn get_derived(yubikey: &mut YubiKey, pin: &[u8]) -> Result<Self> {
+        let txn = yubikey.begin_transaction()?;
+
+        // recover management key
+        let admin_data = AdminData::read(&txn)?;
+        let salt = admin_data.get_item(TAG_ADMIN_SALT)?;
+
+        if salt.len() != CB_ADMIN_SALT {
+            error!(
+                "derived MGM salt exists, but is incorrect size: {} (expected {})",
+                salt.len(),
+                CB_ADMIN_SALT
+            );
+
+            return Err(Error::GenericError);
+        }
+
+        let mut mgm = [0u8; DES_LEN_3DES];
+        pbkdf2::<Hmac<Sha1>>(pin, salt, ITER_MGM_PBKDF2, &mut mgm);
+        MgmKey::from_bytes(mgm)
+    }
+
+    /// Get protected management key (MGM)
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn get_protected(yubikey: &mut YubiKey) -> Result<Self> {
+        let txn = yubikey.begin_transaction()?;
+
+        let protected_data = ProtectedData::read(&txn).map_err(|e| {
+            error!("could not read protected data (err: {:?})", e);
+            e
+        })?;
+
+        let item = protected_data.get_item(TAG_PROTECTED_MGM).map_err(|e| {
+            error!("could not read protected MGM from metadata (err: {:?})", e);
+            e
+        })?;
+
+        if item.len() != DES_LEN_3DES {
+            error!(
+                "protected data contains MGM, but is the wrong size: {} (expected {})",
+                item.len(),
+                DES_LEN_3DES
+            );
+
+            return Err(Error::AuthenticationError);
+        }
+
+        MgmKey::from_bytes(item)
+    }
+
+    /// Resets the management key for the given YubiKey to the default value.
+    ///
+    /// This will wipe any metadata related to derived and PIN-protected management keys.
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn set_default(yubikey: &mut YubiKey) -> Result<()> {
+        MgmKey::default().set_manual(yubikey, false)
+    }
+
+    /// Configures the given YubiKey to use this management key.
+    ///
+    /// The management key must be stored by the user, and provided when performing key
+    /// management operations.
+    ///
+    /// This will wipe any metadata related to derived and PIN-protected management keys.
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn set_manual(&self, yubikey: &mut YubiKey, require_touch: bool) -> Result<()> {
+        let txn = yubikey.begin_transaction()?;
+
+        txn.set_mgm_key(self, require_touch).map_err(|e| {
+            // Log a warning, since the device mgm key is corrupt or we're in a state
+            // where we can't set the mgm key.
+            error!("could not set new derived mgm key, err = {}", e);
+            e
+        })?;
+
+        // After this point, we've set the mgm key, so the function should succeed,
+        // regardless of being able to set the metadata.
+
+        if let Ok(mut admin_data) = AdminData::read(&txn) {
+            // Clear the protected mgm key bit.
+            if let Ok(item) = admin_data.get_item(TAG_ADMIN_FLAGS_1) {
+                let mut flags_1 = [0u8; 1];
+                if item.len() == flags_1.len() {
+                    flags_1.copy_from_slice(item);
+                    flags_1[0] &= !ADMIN_FLAGS_1_PROTECTED_MGM;
+
+                    if let Err(e) = admin_data.set_item(TAG_ADMIN_FLAGS_1, &flags_1) {
+                        error!("could not set admin flags item, err = {}", e);
+                    }
+                } else {
+                    error!(
+                        "admin data flags are an incorrect size: {} (expected {})",
+                        item.len(),
+                        flags_1.len()
+                    );
+                }
+            }
+
+            // Remove any existing salt for a derived mgm key.
+            if let Err(e) = admin_data.set_item(TAG_ADMIN_SALT, &[]) {
+                error!("could not unset derived mgm salt (err = {})", e)
+            }
+
+            if let Err(e) = admin_data.write(&txn) {
+                error!("could not write admin data, err = {}", e);
+            }
+        }
+
+        // Clear any prior mgm key from protected data.
+        if let Ok(mut protected_data) = ProtectedData::read(&txn) {
+            if let Err(e) = protected_data.set_item(TAG_PROTECTED_MGM, &[]) {
+                error!("could not clear protected mgm item, err = {:?}", e);
+            } else if let Err(e) = protected_data.write(&txn) {
+                error!("could not write protected data, err = {:?}", e);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Configures the given YubiKey to use this as a PIN-protected management key.
+    ///
+    /// This enables key management operations to be performed with access to the PIN.
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    pub fn set_protected(&self, yubikey: &mut YubiKey) -> Result<()> {
+        let txn = yubikey.begin_transaction()?;
+
+        txn.set_mgm_key(self, false).map_err(|e| {
+            // log a warning, since the device mgm key is corrupt or we're in
+            // a state where we can't set the mgm key
+            error!("could not set new derived mgm key, err = {}", e);
+            e
+        })?;
+
+        // after this point, we've set the mgm key, so the function should
+        // succeed, regardless of being able to set the metadata
+
+        // Fetch the current protected data, or start a blank metadata blob.
+        let mut protected_data = ProtectedData::read(&txn).unwrap_or_default();
+
+        // Set the new mgm key in protected data.
+        if let Err(e) = protected_data.set_item(TAG_PROTECTED_MGM, self.as_ref()) {
+            error!("could not set protected mgm item, err = {:?}", e);
+        } else {
+            protected_data.write(&txn).map_err(|e| {
+                error!("could not write protected data, err = {:?}", e);
+                e
+            })?;
+        }
+
+        // set the protected mgm flag in admin data
+
+        let mut flags_1 = [0u8; 1];
+
+        let mut admin_data = if let Ok(mut admin_data) = AdminData::read(&txn) {
+            if let Ok(item) = admin_data.get_item(TAG_ADMIN_FLAGS_1) {
+                if item.len() == flags_1.len() {
+                    flags_1.copy_from_slice(item);
+                } else {
+                    error!(
+                        "admin data flags are an incorrect size: {} (expected {})",
+                        item.len(),
+                        flags_1.len()
+                    );
+                }
+            } else {
+                // flags are not set
+                error!("admin data exists, but flags are not present");
+            }
+
+            // remove any existing salt
+            if let Err(e) = admin_data.set_item(TAG_ADMIN_SALT, &[]) {
+                error!("could not unset derived mgm salt (err = {})", e)
+            }
+
+            admin_data
+        } else {
+            AdminData::default()
+        };
+
+        flags_1[0] |= ADMIN_FLAGS_1_PROTECTED_MGM;
+
+        if let Err(e) = admin_data.set_item(TAG_ADMIN_FLAGS_1, &flags_1) {
+            error!("could not set admin flags item, err = {}", e);
+        } else if let Err(e) = admin_data.write(&txn) {
+            error!("could not write admin data, err = {}", e);
+        }
+
+        Ok(())
+    }
+
+    /// Encrypt with 3DES key
+    pub(crate) fn encrypt(&self, input: &[u8; DES_LEN_DES]) -> [u8; DES_LEN_DES] {
+        let mut output = input.to_owned();
+        TdesEde3::new(GenericArray::from_slice(&self.0))
+            .encrypt_block(GenericArray::from_mut_slice(&mut output));
+        output
+    }
+
+    /// Decrypt with 3DES key
+    pub(crate) fn decrypt(&self, input: &[u8; DES_LEN_DES]) -> [u8; DES_LEN_DES] {
+        let mut output = input.to_owned();
+        TdesEde3::new(GenericArray::from_slice(&self.0))
+            .decrypt_block(GenericArray::from_mut_slice(&mut output));
+        output
+    }
+}
+
+impl AsRef<[u8; DES_LEN_3DES]> for MgmKey {
+    fn as_ref(&self) -> &[u8; DES_LEN_3DES] {
+        &self.0
+    }
+}
+
+/// Default MGM key configured on all YubiKeys
+impl Default for MgmKey {
+    fn default() -> Self {
+        MgmKey([
+            1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+        ])
+    }
+}
+
+impl Drop for MgmKey {
+    fn drop(&mut self) {
+        self.0.zeroize();
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for MgmKey {
+    type Error = Error;
+
+    fn try_from(key_bytes: &'a [u8]) -> Result<Self> {
+        Self::new(key_bytes.try_into().map_err(|_| Error::SizeError)?)
+    }
+}
+
+/// Weak and semi weak DES keys as taken from:
+/// %A D.W. Davies
+/// %A W.L. Price
+/// %T Security for Computer Networks
+/// %I John Wiley & Sons
+/// %D 1984
+const WEAK_DES_KEYS: &[[u8; DES_LEN_DES]] = &[
+    // weak keys
+    [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01],
+    [0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE],
+    [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E],
+    [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1],
+    // semi-weak keys
+    [0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE],
+    [0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01],
+    [0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1],
+    [0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E],
+    [0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1],
+    [0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01],
+    [0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE],
+    [0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E],
+    [0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E],
+    [0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01],
+    [0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE],
+    [0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1],
+];
+
+/// Is this 3DES key weak?
+///
+/// This check is performed automatically when the key is instantiated to
+/// ensure no such keys are used.
+fn is_weak_key(key: &[u8; DES_LEN_3DES]) -> bool {
+    // set odd parity of key
+    let mut tmp = Zeroizing::new([0u8; DES_LEN_3DES]);
+
+    for i in 0..DES_LEN_3DES {
+        // count number of set bits in byte, excluding the low-order bit - SWAR method
+        let mut c = key[i] & 0xFE;
+
+        c = (c & 0x55) + ((c >> 1) & 0x55);
+        c = (c & 0x33) + ((c >> 2) & 0x33);
+        c = (c & 0x0F) + ((c >> 4) & 0x0F);
+
+        // if count is even, set low key bit to 1, otherwise 0
+        tmp[i] = (key[i] & 0xFE) | (if c & 0x01 == 0x01 { 0x00 } else { 0x01 });
+    }
+
+    // check odd parity key against table by DES key block
+    let mut is_weak = false;
+
+    for weak_key in WEAK_DES_KEYS.iter() {
+        if weak_key == &tmp[0..DES_LEN_DES]
+            || weak_key == &tmp[DES_LEN_DES..2 * DES_LEN_DES]
+            || weak_key == &tmp[2 * DES_LEN_DES..3 * DES_LEN_DES]
+        {
+            is_weak = true;
+            break;
+        }
+    }
+
+    is_weak
+}
@@ -0,0 +1,197 @@
+//! 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)>
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+#[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.try_into().unwrap());
+        }
+
+        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)..(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> {
+        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().unwrap()
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for MsContainer {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Self::new(bytes)
+    }
+}
@@ -0,0 +1,160 @@
+//! PKCS#7 formatted certificate store for enterprise trusted roots.
+
+// 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, CB_OBJ_TAG_MAX},
+    serialization::*,
+    Error, Result, YubiKey,
+};
+use log::error;
+
+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>
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+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> {
+        Ok(MsRoots(msroots.as_ref().into()))
+    }
+
+    /// Read `msroots` file from YubiKey
+    pub fn read(yubikey: &mut YubiKey) -> Result<Option<Self>> {
+        let txn = yubikey.begin_transaction()?;
+
+        // allocate first page
+        let mut data = Vec::with_capacity(CB_OBJ_MAX);
+
+        for object_id in OBJ_MSROOTS1..OBJ_MSROOTS5 {
+            let buf = txn.fetch_object(object_id)?;
+
+            let (_, tlv) = match Tlv::parse(&buf) {
+                Ok(res) => res,
+                Err(_) => return Ok(None),
+            };
+
+            if (TAG_MSROOTS_MID != tlv.tag || OBJ_MSROOTS5 == object_id)
+                && (TAG_MSROOTS_END != tlv.tag)
+            {
+                // the current object doesn't contain a valid part of a msroots file
+
+                // treat condition as object isn't found
+                return Ok(None);
+            }
+
+            data.extend_from_slice(tlv.value);
+
+            if tlv.tag == TAG_MSROOTS_END {
+                break;
+            }
+        }
+
+        MsRoots::new(&data).map(Some).map_err(|e| {
+            error!("error parsing msroots: {:?}", e);
+            e
+        })
+    }
+
+    /// Write `msroots` file to YubiKey
+    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 txn = yubikey.begin_transaction()?;
+
+        if data_len == 0 {
+            return txn.save_object(OBJ_MSROOTS1, &[]);
+        }
+
+        // Calculate number of objects required to store blob
+        let n_objs: usize = (data_len / (CB_OBJ_MAX - CB_OBJ_TAG_MAX)) + 1;
+
+        if n_objs > 5 {
+            return Err(Error::SizeError);
+        }
+
+        for i in 0..n_objs {
+            offset = 0;
+
+            data_chunk = if CB_OBJ_MAX - CB_OBJ_TAG_MAX < data_len - data_offset {
+                CB_OBJ_MAX - CB_OBJ_TAG_MAX
+            } else {
+                data_len - data_offset
+            };
+
+            offset += Tlv::write(
+                &mut buf,
+                if i == n_objs - 1 {
+                    TAG_MSROOTS_END
+                } else {
+                    TAG_MSROOTS_MID
+                },
+                &data[data_offset..(data_offset + data_chunk)],
+            )?;
+
+            txn.save_object(OBJ_MSROOTS1 + i as u32, &buf[..offset])?;
+
+            data_offset += data_chunk;
+        }
+
+        Ok(())
+    }
+}
+
+impl AsRef<[u8]> for MsRoots {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
@@ -0,0 +1,917 @@
+//! Personal Identity Verification (PIV) cryptographic keys stored in a YubiKey.
+//!
+//! Support for public-key cryptography using keys stored within the PIV
+//! slots of a YubiKey.
+//!
+//! Supported algorithms:
+//!
+//! - **Encryption**:
+//!   - RSA: `RSA1024`, `RSA2048`
+//!   - ECC: `ECCP256`, `ECCP384` (NIST curves: P-256, P-384)
+//! - **Signatures**:
+//!   - RSASSA-PKCS#1v1.5: `RSA1024`, `RSA2048`
+//!   - ECDSA: `ECCP256`, `ECCP384` (NIST curves: P-256, P-384)
+
+// 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, PublicKeyInfo},
+    error::{Error, Result},
+    policy::{PinPolicy, TouchPolicy},
+    serialization::*,
+    setting,
+    yubikey::YubiKey,
+    Buffer, ObjectId,
+};
+use elliptic_curve::sec1::EncodedPoint as EcPublicKey;
+use log::{debug, error, warn};
+use p256::NistP256;
+use p384::NistP384;
+use rsa::{BigUint, RsaPublicKey};
+use std::{
+    fmt::{Display, Formatter},
+    str::FromStr,
+};
+
+#[cfg(feature = "untested")]
+use {
+    crate::consts::CB_OBJ_MAX,
+    num_bigint_dig::traits::ModInverse,
+    num_integer::Integer,
+    num_traits::{FromPrimitive, One},
+};
+
+#[cfg(feature = "untested")]
+use zeroize::Zeroizing;
+
+const CB_ECC_POINTP256: usize = 65;
+const CB_ECC_POINTP384: usize = 97;
+
+const TAG_RSA_MODULUS: u8 = 0x81;
+const TAG_RSA_EXP: u8 = 0x82;
+const TAG_ECC_POINT: u8 = 0x86;
+
+#[cfg(feature = "untested")]
+const KEYDATA_LEN: usize = 1024;
+
+#[cfg(feature = "untested")]
+const KEYDATA_RSA_EXP: u64 = 65537;
+
+/// Slot identifiers.
+/// <https://developers.yubico.com/PIV/Introduction/Certificate_slots.html>
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Ord, PartialOrd)]
+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> {
+        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 Display for SlotId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SlotId::Retired(r) => write!(f, "{:?}", r),
+            _ => write!(f, "{:?}", self),
+        }
+    }
+}
+
+impl FromStr for SlotId {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<SlotId> {
+        match s {
+            "9a" => Ok(SlotId::Authentication),
+            "9c" => Ok(SlotId::Signature),
+            "9d" => Ok(SlotId::KeyManagement),
+            "9e" => Ok(SlotId::CardAuthentication),
+            "f9" => Ok(SlotId::Attestation),
+            _ => s.parse().map(SlotId::Retired),
+        }
+    }
+}
+
+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, Eq, Hash, Ord, PartialEq, PartialOrd)]
+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> {
+        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 FromStr for RetiredSlotId {
+    type Err = Error;
+
+    fn from_str(value: &str) -> Result<Self> {
+        match value {
+            "82" => Ok(RetiredSlotId::R1),
+            "83" => Ok(RetiredSlotId::R2),
+            "84" => Ok(RetiredSlotId::R3),
+            "85" => Ok(RetiredSlotId::R4),
+            "86" => Ok(RetiredSlotId::R5),
+            "87" => Ok(RetiredSlotId::R6),
+            "88" => Ok(RetiredSlotId::R7),
+            "89" => Ok(RetiredSlotId::R8),
+            "8a" => Ok(RetiredSlotId::R9),
+            "8b" => Ok(RetiredSlotId::R10),
+            "8c" => Ok(RetiredSlotId::R11),
+            "8d" => Ok(RetiredSlotId::R12),
+            "8e" => Ok(RetiredSlotId::R13),
+            "8f" => Ok(RetiredSlotId::R14),
+            "90" => Ok(RetiredSlotId::R15),
+            "91" => Ok(RetiredSlotId::R16),
+            "92" => Ok(RetiredSlotId::R17),
+            "93" => Ok(RetiredSlotId::R18),
+            "94" => Ok(RetiredSlotId::R19),
+            "95" => 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 Display for RetiredSlotId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+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> {
+        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,
+        }
+    }
+}
+
+impl AlgorithmId {
+    /// Writes the `AlgorithmId` in the format the YubiKey expects during key generation.
+    pub(crate) fn write(self, buf: &mut [u8]) -> Result<usize> {
+        Tlv::write(buf, 0x80, &[self.into()])
+    }
+
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    fn get_elem_len(self) -> usize {
+        match self {
+            AlgorithmId::Rsa1024 => 64,
+            AlgorithmId::Rsa2048 => 128,
+            AlgorithmId::EccP256 => 32,
+            AlgorithmId::EccP384 => 48,
+        }
+    }
+
+    #[cfg(feature = "untested")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+    fn get_param_tag(self) -> u8 {
+        match self {
+            AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => 0x01,
+            AlgorithmId::EccP256 | AlgorithmId::EccP384 => 0x6,
+        }
+    }
+}
+
+/// 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>> {
+        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::from_bytes(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
+    }
+}
+
+/// Generate new key.
+pub fn generate(
+    yubikey: &mut YubiKey,
+    slot: SlotId,
+    algorithm: AlgorithmId,
+    pin_policy: PinPolicy,
+    touch_policy: TouchPolicy,
+) -> Result<PublicKeyInfo> {
+    // 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.";
+
+    let setting_roca: setting::Setting;
+
+    match algorithm {
+        AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => {
+            if yubikey.version.major == 4
+                && (yubikey.version.minor < 3
+                    || yubikey.version.minor == 3 && (yubikey.version.patch < 5))
+            {
+                setting_roca = setting::Setting::get(SZ_SETTING_ROCA, true);
+
+                let psz_msg = match setting_roca.source {
+                    setting::SettingSource::User => {
+                        if setting_roca.value {
+                            SZ_ROCA_ALLOW_USER
+                        } else {
+                            SZ_ROCA_BLOCK_USER
+                        }
+                    }
+                    setting::SettingSource::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()?;
+
+    let templ = [0, Ins::GenerateAsymmetric.code(), 0, slot.into()];
+
+    let mut in_data = [0u8; 11];
+    let mut offset = Tlv::write_as(&mut in_data, 0xac, 3, |buf| {
+        assert_eq!(algorithm.write(buf).expect("large enough"), 3);
+    })?;
+
+    let pin_len = pin_policy.write(&mut in_data[offset..])?;
+    in_data[1] += pin_len as u8;
+    offset += pin_len;
+
+    let touch_len = touch_policy.write(&mut in_data[offset..])?;
+    in_data[1] += touch_len as u8;
+    offset += touch_len;
+
+    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 => {
+                match pin_policy {
+                    PinPolicy::Default => match touch_policy {
+                        TouchPolicy::Default => error!("{} (algorithm not supported?)", err_msg),
+                        _ => error!("{} (touch policy not supported?)", err_msg),
+                    },
+                    _ => error!("{} (pin policy not supported?)", err_msg),
+                }
+
+                return Err(Error::AlgorithmError);
+            }
+            StatusWords::SecurityStatusError => {
+                error!("{} (not authenticated)", err_msg);
+                return Err(Error::AuthenticationError);
+            }
+            other => {
+                error!("{} (error {:?})", err_msg, other);
+                return Err(Error::GenericError);
+            }
+        }
+    }
+
+    // TODO(str4d): Response is wrapped in an ASN.1 TLV:
+    //
+    //    0x7f 0x49 -> Application | Constructed | 0x49
+    match algorithm {
+        AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => {
+            // It appears that the inner application-specific value returned by the
+            // YubiKey is constructed such that RSA pubkeys can be parsed in two ways:
+            //
+            // - Use a full ASN.1 parser on the entire datastructure:
+            //
+            //     RSA 1024:
+            //     [127, 73, 129, 136, 129, 129, 128, [ 128 octets ], 130,  3, 1, 0, 1]
+            //     | tag   | len:136 |0x81| len:128 |    modulus    |0x82|len3|  exp  |
+            //
+            //     RSA 2048:
+            //     [127, 73, 130, 1, 9, 129, 130, 1, 0, [ 256 octets ], 130,  3, 1, 0, 1]
+            //     | tag   | len:265  |0x81| len:256  |    modulus    |0x82|len3|  exp  |
+            //
+            // - Skip the first 5 bytes and use crate::serialize::get_length during TLV
+            //   parsing (which treats 128 as a single-byte definite length instead of an
+            //   indefinite length):
+            //
+            //     RSA 1024:
+            //     [127, 73, 129, 136, 129, 129, 128, [ 128 octets ], 130,  3, 1, 0, 1]
+            //     |                      |0x81|len128|   modulus   |0x82|len3|  exp  |
+            //
+            //     RSA 2048:
+            //     [127, 73, 130, 1, 9, 129, 130, 1, 0, [ 256 octets ], 130,  3, 1, 0, 1]
+            //     |                  |0x81| len:256  |    modulus    |0x82|len3|  exp  |
+            //
+            // Because of the above, treat this for now as a 2-byte ASN.1 tag with a
+            // 3-byte length.
+            let data = &response.data()[5..];
+
+            let (data, modulus_tlv) = Tlv::parse(data)?;
+            if modulus_tlv.tag != TAG_RSA_MODULUS {
+                error!("Failed to parse public key structure (modulus)");
+                return Err(Error::ParseError);
+            }
+            let modulus = modulus_tlv.value.to_vec();
+
+            let (_, exp_tlv) = Tlv::parse(data)?;
+            if exp_tlv.tag != TAG_RSA_EXP {
+                error!("failed to parse public key structure (public exponent)");
+                return Err(Error::ParseError);
+            }
+            let exp = exp_tlv.value.to_vec();
+
+            Ok(PublicKeyInfo::Rsa {
+                algorithm,
+                pubkey: RsaPublicKey::new(
+                    BigUint::from_bytes_be(&modulus),
+                    BigUint::from_bytes_be(&exp),
+                )
+                .map_err(|_| Error::InvalidObject)?,
+            })
+        }
+        AlgorithmId::EccP256 | AlgorithmId::EccP384 => {
+            // 2-byte ASN.1 tag, 1-byte length (because all supported EC pubkey lengths
+            // are shorter than 128 bytes, fitting into a definite short ASN.1 length).
+            let data = &response.data()[3..];
+
+            let len = if let AlgorithmId::EccP256 = algorithm {
+                CB_ECC_POINTP256
+            } else {
+                CB_ECC_POINTP384
+            };
+
+            let (_, tlv) = Tlv::parse(data)?;
+
+            if tlv.tag != TAG_ECC_POINT {
+                error!("failed to parse public key structure");
+                return Err(Error::ParseError);
+            }
+
+            // the curve point should always be determined by the curve
+            if tlv.value.len() != len {
+                error!("unexpected length");
+                return Err(Error::AlgorithmError);
+            }
+
+            let point = tlv.value.to_vec();
+
+            match algorithm {
+                AlgorithmId::EccP256 => {
+                    EcPublicKey::<NistP256>::from_bytes(point).map(PublicKeyInfo::EcP256)
+                }
+                AlgorithmId::EccP384 => {
+                    EcPublicKey::<NistP384>::from_bytes(point).map(PublicKeyInfo::EcP384)
+                }
+                _ => return Err(Error::AlgorithmError),
+            }
+            .map_err(|_| Error::InvalidObject)
+        }
+    }
+}
+
+#[cfg(feature = "untested")]
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+fn write_key(
+    yubikey: &mut YubiKey,
+    slot: SlotId,
+    params: Vec<&[u8]>,
+    pin_policy: PinPolicy,
+    touch_policy: TouchPolicy,
+    algorithm: AlgorithmId,
+) -> Result<()> {
+    let mut key_data = Buffer::new(vec![0u8; KEYDATA_LEN]);
+    let templ = [0, Ins::ImportKey.code(), algorithm.into(), slot.into()];
+    let mut offset = 0;
+
+    let elem_len = algorithm.get_elem_len();
+    let param_tag = algorithm.get_param_tag();
+
+    for (i, param) in params.into_iter().enumerate() {
+        offset += Tlv::write_as(
+            &mut key_data[offset..],
+            param_tag + (i as u8),
+            elem_len,
+            |buf| {
+                let padding = elem_len - param.len();
+                for b in &mut buf[..padding] {
+                    *b = 0;
+                }
+                buf[padding..].copy_from_slice(param);
+            },
+        )?;
+    }
+
+    offset += pin_policy.write(&mut key_data[offset..])?;
+    offset += touch_policy.write(&mut key_data[offset..])?;
+
+    let txn = yubikey.begin_transaction()?;
+
+    let status_words = txn
+        .transfer_data(&templ, &key_data[..offset], 256)?
+        .status_words();
+
+    match status_words {
+        StatusWords::Success => Ok(()),
+        StatusWords::SecurityStatusError => Err(Error::AuthenticationError),
+        _ => Err(Error::GenericError),
+    }
+}
+
+/// The key data that makes up an RSA key.
+#[cfg(feature = "untested")]
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+pub struct RsaKeyData {
+    /// The secret prime `p`.
+    p: Buffer,
+    /// The secret prime, `q`.
+    q: Buffer,
+    /// D mod (P-1)
+    dp: Buffer,
+    /// D mod (Q-1)
+    dq: Buffer,
+    /// Q^-1 mod P
+    qinv: Buffer,
+}
+
+#[cfg(feature = "untested")]
+impl RsaKeyData {
+    /// Generates a new RSA key data set from two randomly generated, secret, primes.
+    ///
+    /// Panics if `secret_p` or `secret_q` are invalid primes.
+    pub fn new(secret_p: &[u8], secret_q: &[u8]) -> Self {
+        let p = BigUint::from_bytes_be(secret_p);
+        let q = BigUint::from_bytes_be(secret_q);
+
+        let totient = {
+            let p_t = &p - BigUint::one();
+            let q_t = &p - BigUint::one();
+
+            p_t.lcm(&q_t)
+        };
+
+        let exp = BigUint::from_u64(KEYDATA_RSA_EXP).unwrap();
+
+        let d = exp.mod_inverse(&totient).unwrap();
+        let d = d.to_biguint().unwrap();
+
+        // We calculate the optimization values ahead of time, instead of making the user
+        // do so.
+
+        let dp = &d % (&p - BigUint::one());
+        let dq = &d % (&q - BigUint::one());
+
+        let qinv = q.clone().mod_inverse(&p).unwrap();
+        let (_, qinv) = qinv.to_bytes_be();
+
+        RsaKeyData {
+            p: Zeroizing::new(p.to_bytes_be()),
+            q: Zeroizing::new(q.to_bytes_be()),
+            dp: Zeroizing::new(dp.to_bytes_be()),
+            dq: Zeroizing::new(dq.to_bytes_be()),
+            qinv: Zeroizing::new(qinv),
+        }
+    }
+
+    fn total_len(&self) -> usize {
+        self.p.len() + self.q.len() + self.dp.len() + self.qinv.len()
+    }
+}
+
+/// Imports a private RSA encryption or signing key into the YubiKey.
+///
+/// Errors if `algorithm` isn't `AlgorithmId::Rsa1024` or `AlgorithmId::Rsa2048`.
+#[cfg(feature = "untested")]
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+pub fn import_rsa_key(
+    yubikey: &mut YubiKey,
+    slot: SlotId,
+    algorithm: AlgorithmId,
+    key_data: RsaKeyData,
+    touch_policy: TouchPolicy,
+    pin_policy: PinPolicy,
+) -> Result<()> {
+    match algorithm {
+        AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => (),
+        _ => return Err(Error::AlgorithmError),
+    }
+
+    if key_data.total_len() > KEYDATA_LEN {
+        return Err(Error::SizeError);
+    }
+
+    let params = vec![
+        key_data.p.as_slice(),
+        key_data.q.as_slice(),
+        key_data.dp.as_slice(),
+        key_data.dq.as_slice(),
+        key_data.qinv.as_slice(),
+    ];
+
+    write_key(yubikey, slot, params, pin_policy, touch_policy, algorithm)?;
+
+    Ok(())
+}
+
+/// Imports a private ECC encryption or signing key into the YubiKey.
+///
+/// Errors if `algorithm` isn't `AlgorithmId::EccP256` or ` AlgorithmId::EccP384`.
+#[cfg(feature = "untested")]
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+pub fn import_ecc_key(
+    yubikey: &mut YubiKey,
+    slot: SlotId,
+    algorithm: AlgorithmId,
+    key_data: &[u8],
+    touch_policy: TouchPolicy,
+    pin_policy: PinPolicy,
+) -> Result<()> {
+    match algorithm {
+        AlgorithmId::EccP256 | AlgorithmId::EccP384 => (),
+        _ => return Err(Error::AlgorithmError),
+    }
+
+    if key_data.len() > KEYDATA_LEN {
+        return Err(Error::SizeError);
+    }
+
+    let params = vec![key_data];
+
+    write_key(yubikey, slot, params, pin_policy, touch_policy, algorithm)?;
+
+    Ok(())
+}
+
+/// Generate an attestation certificate for a stored key.
+///
+/// <https://developers.yubico.com/PIV/Introduction/PIV_attestation.html>
+#[cfg(feature = "untested")]
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+pub fn attest(yubikey: &mut YubiKey, key: SlotId) -> Result<Buffer> {
+    let templ = [0, Ins::Attest.code(), key.into(), 0];
+    let txn = yubikey.begin_transaction()?;
+    let response = txn.transfer_data(&templ, &[], CB_OBJ_MAX)?;
+
+    if !response.is_success() {
+        if response.status_words() == StatusWords::NotSupportedError {
+            return Err(Error::NotSupported);
+        } else {
+            return Err(Error::GenericError);
+        }
+    }
+
+    if response.data()[0] != 0x30 {
+        return Err(Error::GenericError);
+    }
+
+    Ok(Buffer::new(response.data().into()))
+}
+
+/// Sign data using a PIV key.
+pub fn sign_data(
+    yubikey: &mut YubiKey,
+    raw_in: &[u8],
+    algorithm: AlgorithmId,
+    key: SlotId,
+) -> Result<Buffer> {
+    let txn = yubikey.begin_transaction()?;
+
+    // don't attempt to reselect in crypt operations to avoid problems with PIN_ALWAYS
+    txn.authenticated_command(raw_in, algorithm, key, false)
+}
+
+/// Decrypt data using a PIV key.
+#[cfg(feature = "untested")]
+#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
+pub fn decrypt_data(
+    yubikey: &mut YubiKey,
+    input: &[u8],
+    algorithm: AlgorithmId,
+    key: SlotId,
+) -> Result<Buffer> {
+    let txn = yubikey.begin_transaction()?;
+
+    // don't attempt to reselect in crypt operations to avoid problems with PIN_ALWAYS
+    txn.authenticated_command(input, algorithm, key, true)
+}
@@ -0,0 +1,92 @@
+//! Enums representing key policies.
+
+use crate::{serialization::Tlv, 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, 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 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, 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()]),
+        }
+    }
+}
@@ -0,0 +1,89 @@
+//! Support for enumerating available PC/SC card readers.
+
+use crate::{Result, YubiKey};
+use std::{
+    borrow::Cow,
+    ffi::CStr,
+    sync::{Arc, Mutex},
+};
+
+/// Iterator over connected readers
+pub type Iter<'ctx> = std::vec::IntoIter<Reader<'ctx>>;
+
+/// PC/SC reader context: used to enumerate available PC/SC [`Reader`]s.
+pub struct Context {
+    /// PC/SC context
+    ctx: Arc<Mutex<pcsc::Context>>,
+
+    /// Buffer for storing reader names
+    reader_names: Vec<u8>,
+}
+
+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> {
+        let ctx = pcsc::Context::establish(pcsc::Scope::System)?;
+        let reader_names = vec![0u8; ctx.list_readers_len()?];
+        Ok(Self {
+            ctx: Arc::new(Mutex::new(ctx)),
+            reader_names,
+        })
+    }
+
+    /// Iterate over the available readers.
+    pub fn iter(&mut self) -> Result<Iter<'_>> {
+        let Self { ctx, reader_names } = self;
+
+        let reader_cstrs: Vec<_> = {
+            let c = ctx.lock().unwrap();
+
+            // ensure PC/SC context is valid
+            c.is_valid()?;
+
+            c.list_readers(reader_names)?.collect()
+        };
+
+        #[allow(clippy::needless_collect)]
+        let readers: Vec<_> = reader_cstrs
+            .iter()
+            .map(|name| Reader::new(name, Arc::clone(ctx)))
+            .collect();
+
+        Ok(readers.into_iter())
+    }
+}
+
+/// An individual connected PC/SC card reader.
+pub struct Reader<'ctx> {
+    /// Name of this reader
+    name: &'ctx CStr,
+
+    /// PC/SC context
+    ctx: Arc<Mutex<pcsc::Context>>,
+}
+
+impl<'ctx> Reader<'ctx> {
+    /// 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.
+    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.
+    pub fn open(&self) -> Result<YubiKey> {
+        self.try_into()
+    }
+
+    /// Connect to this reader, returning its `pcsc::Card`.
+    pub(crate) fn connect(&self) -> Result<pcsc::Card> {
+        let ctx = self.ctx.lock().unwrap();
+        Ok(ctx.connect(self.name, pcsc::ShareMode::Shared, pcsc::Protocols::T1)?)
+    }
+}
@@ -0,0 +1,203 @@
+//! Serialization functions
+
+// 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_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) -> Result<usize> {
+    if length < 0x80 {
+        if buffer.is_empty() {
+            Err(Error::SizeError)
+        } else {
+            buffer[0] = length as u8;
+            Ok(1)
+        }
+    } else if length < 0x100 {
+        if buffer.len() < 2 {
+            Err(Error::SizeError)
+        } else {
+            buffer[0] = 0x81;
+            buffer[1] = length as u8;
+            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;
+        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
+    } else if (buffer[0] & 0x7f) == 1 {
+        *len = buffer[1] as usize;
+        2
+    } else if (buffer[0] & 0x7f) == 2 {
+        let tmp = buffer[1] as usize;
+        *len = (tmp << 8) + buffer[2] as usize;
+        3
+    } else {
+        0
+    }
+}
+
+/// Is length valid?
+pub(crate) fn has_valid_length(buffer: &[u8], len: usize) -> bool {
+    (buffer[0] < 0x81 && len > 0)
+        || ((buffer[0] & 0x7f) == 1 && len > 1)
+        || ((buffer[0] & 0x7f == 2) && (len > 2))
+}
+
+/// Set an object ID header value in the given buffer, returning a mutable
+/// slice immediately after the header.
+///
+/// Panics if the buffer is too small to contain the header.
+pub(crate) fn set_object(object_id: ObjectId, mut buffer: &mut [u8]) -> &mut [u8] {
+    buffer[0] = 0x5c;
+
+    if object_id == OBJ_DISCOVERY {
+        buffer[1] = 1;
+        buffer[2] = OBJ_DISCOVERY as u8;
+        buffer = &mut buffer[3..];
+    } else if object_id > 0xffff && object_id <= 0x00ff_ffff {
+        buffer[1] = 3;
+        buffer[2] = ((object_id >> 16) & 0xff) as u8;
+        buffer[3] = ((object_id >> 8) & 0xff) as u8;
+        buffer[4] = (object_id & 0xff) as u8;
+        buffer = &mut buffer[5..];
+    }
+
+    buffer
+}
@@ -0,0 +1,132 @@
+//! 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 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,
+}
+
+impl Default for SettingSource {
+    fn default() -> Self {
+        Self::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",
+            })
+    }
+}
@@ -0,0 +1,506 @@
+//! YubiKey PC/SC transactions
+
+use crate::{
+    apdu::Response,
+    apdu::{Apdu, Ins, StatusWords},
+    consts::{CB_BUF_MAX, CB_OBJ_MAX},
+    error::{Error, Result},
+    piv::{AlgorithmId, SlotId},
+    serialization::*,
+    yubikey::*,
+    Buffer, ObjectId,
+};
+use log::{error, trace};
+use zeroize::Zeroizing;
+
+#[cfg(feature = "untested")]
+use crate::mgm::{MgmKey, DES_LEN_3DES};
+
+/// PIV Applet ID
+const PIV_AID: [u8; 5] = [0xa0, 0x00, 0x00, 0x03, 0x08];
+
+/// YubiKey OTP Applet ID. Needed to query serial on YK4.
+const YK_AID: [u8; 8] = [0xa0, 0x00, 0x00, 0x05, 0x27, 0x20, 0x01, 0x01];
+
+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.
+    pub fn new(card: &'tx mut pcsc::Card) -> Result<Self> {
+        Ok(Transaction {
+            inner: card.transaction()?,
+        })
+    }
+
+    /// Transmit a single serialized APDU to the card this transaction is open
+    /// with and receive a response.
+    ///
+    /// This is a wrapper for the raw `SCardTransmit` function and operates on
+    /// 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>> {
+        trace!(">>> {:?}", send_buffer);
+
+        let mut recv_buffer = vec![0u8; recv_len];
+
+        let len = self
+            .inner
+            .transmit(send_buffer, recv_buffer.as_mut())?
+            .len();
+
+        recv_buffer.truncate(len);
+        Ok(recv_buffer)
+    }
+
+    /// Select application.
+    pub fn select_application(&self) -> Result<()> {
+        let response = Apdu::new(Ins::SelectApplication)
+            .p1(0x04)
+            .data(&PIV_AID)
+            .transmit(self, 0xFF)
+            .map_err(|e| {
+                error!("failed communicating with card: '{}'", e);
+                e
+            })?;
+
+        if !response.is_success() {
+            error!(
+                "failed selecting application: {:04x}",
+                response.status_words().code()
+            );
+            return Err(Error::GenericError);
+        }
+
+        Ok(())
+    }
+
+    /// Get the version of the PIV application installed on the YubiKey.
+    pub fn get_version(&self) -> Result<Version> {
+        // get version from device
+        let response = Apdu::new(Ins::GetVersion).transmit(self, 261)?;
+
+        if !response.is_success() {
+            return Err(Error::GenericError);
+        }
+
+        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> {
+        let response = if version.major < 5 {
+            // YK4 requires switching to the yk applet to retrieve the serial
+            let sw = Apdu::new(Ins::SelectApplication)
+                .p1(0x04)
+                .data(&YK_AID)
+                .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()
+                );
+                return Err(Error::GenericError);
+            }
+
+            // reselect the PIV applet
+            let sw = Apdu::new(Ins::SelectApplication)
+                .p1(0x04)
+                .data(&PIV_AID)
+                .transmit(self, 0xFF)?
+                .status_words();
+
+            if !sw.is_success() {
+                error!("failed selecting application: {:04x}", sw.code());
+                return Err(Error::GenericError);
+            }
+
+            resp
+        } else {
+            // YK5 implements getting the serial as a PIV applet command (0xf8)
+            let resp = Apdu::new(Ins::GetSerial).transmit(self, 0xFF)?;
+
+            if !resp.is_success() {
+                error!(
+                    "failed retrieving serial number: {:04x}",
+                    resp.status_words().code()
+                );
+                return Err(Error::GenericError);
+            }
+
+            resp
+        };
+
+        response.data()[..4]
+            .try_into()
+            .map(|serial| Serial::from(u32::from_be_bytes(serial)))
+            .map_err(|_| Error::SizeError)
+    }
+
+    /// Verify device PIN.
+    pub fn verify_pin(&self, pin: &[u8]) -> Result<()> {
+        if pin.len() > CB_PIN_MAX {
+            return Err(Error::SizeError);
+        }
+
+        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
+        // case; if we instead sent [0xff; CB_PIN_MAX] it would count as an attempt and
+        // decrease the retry counter.
+        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());
+        }
+
+        let response = query.transmit(self, 261)?;
+
+        match response.status_words() {
+            StatusWords::Success => Ok(()),
+            StatusWords::AuthBlockedError => Err(Error::WrongPin { tries: 0 }),
+            StatusWords::VerifyFailError { tries } => Err(Error::WrongPin { tries }),
+            _ => Err(Error::GenericError),
+        }
+    }
+
+    /// Change the PIN.
+    #[cfg(feature = "untested")]
+    pub fn change_ref(
+        &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);
+        }
+
+        const PIN: u8 = 0x80;
+        const PUK: u8 = 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);
+        indata[CB_PIN_MAX..CB_PIN_MAX + new_pin.len()].copy_from_slice(new_pin);
+
+        let status_words = self
+            .transfer_data(&templ, indata.as_ref(), 0xFF)?
+            .status_words();
+
+        match status_words {
+            StatusWords::Success => Ok(()),
+            StatusWords::AuthBlockedError => Err(Error::PinLocked),
+            StatusWords::VerifyFailError { tries } => Err(Error::WrongPin { tries }),
+            _ => {
+                error!(
+                    "failed changing pin, token response code: {:x}.",
+                    status_words.code()
+                );
+                Err(Error::GenericError)
+            }
+        }
+    }
+
+    /// Set the management key (MGM).
+    #[cfg(feature = "untested")]
+    pub fn set_mgm_key(&self, new_key: &MgmKey, require_touch: bool) -> Result<()> {
+        let p2 = if require_touch { 0xfe } else { 0xff };
+
+        let mut data = [0u8; DES_LEN_3DES + 3];
+        data[0] = ALGO_3DES;
+        data[1] = KEY_CARDMGM;
+        data[2] = DES_LEN_3DES as u8;
+        data[3..3 + DES_LEN_3DES].copy_from_slice(new_key.as_ref());
+
+        let status_words = Apdu::new(Ins::SetMgmKey)
+            .params(0xff, p2)
+            .data(&data)
+            .transmit(self, 261)?
+            .status_words();
+
+        if !status_words.is_success() {
+            return Err(Error::GenericError);
+        }
+
+        Ok(())
+    }
+
+    /// Perform a YubiKey operation which requires authentication.
+    ///
+    /// This is the common backend for all public key encryption and signing
+    /// operations.
+    // TODO(tarcieri): refactor this to be less gross/coupled.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn authenticated_command(
+        &self,
+        sign_in: &[u8],
+        algorithm: AlgorithmId,
+        key: SlotId,
+        decipher: bool,
+    ) -> Result<Buffer> {
+        let in_len = sign_in.len();
+        let mut indata = [0u8; 1024];
+        let templ = [0, Ins::Authenticate.code(), algorithm.into(), key.into()];
+
+        match algorithm {
+            AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => {
+                let key_len = if let AlgorithmId::Rsa1024 = algorithm {
+                    128
+                } else {
+                    256
+                };
+
+                if in_len != key_len {
+                    return Err(Error::SizeError);
+                }
+            }
+            AlgorithmId::EccP256 | AlgorithmId::EccP384 => {
+                let key_len = if let AlgorithmId::EccP256 = algorithm {
+                    32
+                } else {
+                    48
+                };
+
+                if (!decipher && (in_len > key_len)) || (decipher && (in_len != (key_len * 2) + 1))
+                {
+                    return Err(Error::SizeError);
+                }
+            }
+        }
+
+        let bytes = if in_len < 0x80 {
+            1
+        } else if in_len < 0xff {
+            2
+        } else {
+            3
+        };
+
+        let offset = Tlv::write_as(&mut indata, 0x7c, in_len + bytes + 3, |buf| {
+            assert_eq!(Tlv::write(buf, 0x82, &[]).expect("large enough"), 2);
+            assert_eq!(
+                Tlv::write(
+                    &mut buf[2..],
+                    match (algorithm, decipher) {
+                        (AlgorithmId::EccP256, true) | (AlgorithmId::EccP384, true) => 0x85,
+                        _ => 0x81,
+                    },
+                    sign_in
+                )
+                .expect("large enough"),
+                1 + bytes + in_len
+            );
+        })?;
+
+        let response = self
+            .transfer_data(&templ, &indata[..offset], 1024)
+            .map_err(|e| {
+                error!("sign command failed to communicate: {}", e);
+                e
+            })?;
+
+        if !response.is_success() {
+            error!("failed sign command with code {:x}", response.code());
+
+            if response.status_words() == StatusWords::SecurityStatusError {
+                return Err(Error::AuthenticationError);
+            } else {
+                return Err(Error::GenericError);
+            }
+        }
+
+        let (_, outer_tlv) = Tlv::parse(response.data())?;
+
+        // skip the first 7c tag
+        if outer_tlv.tag != 0x7c {
+            error!("failed parsing signature reply (0x7c byte)");
+            return Err(Error::ParseError);
+        }
+
+        let (_, inner_tlv) = Tlv::parse(outer_tlv.value)?;
+
+        // skip the 82 tag
+        if inner_tlv.tag != 0x82 {
+            error!("failed parsing signature reply (0x82 byte)");
+            return Err(Error::ParseError);
+        }
+
+        Ok(Buffer::new(inner_tlv.value.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`].
+    pub fn transfer_data(&self, templ: &[u8], in_data: &[u8], max_out: usize) -> Result<Response> {
+        let mut in_offset = 0;
+        let mut out_data = vec![];
+        let mut sw;
+
+        loop {
+            let mut this_size = 0xff;
+
+            let cla = if in_offset + 0xff < in_data.len() {
+                0x10
+            } else {
+                this_size = in_data.len() - in_offset;
+                templ[0]
+            };
+
+            trace!("going to send {} bytes in this go", this_size);
+
+            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)?;
+
+            sw = response.status_words().code();
+
+            if !response.is_success() && (sw >> 8 != 0x61) {
+                // TODO(tarcieri): is this really OK?
+                return Ok(Response::new(sw.into(), out_data));
+            }
+
+            if !out_data.is_empty() && (out_data.len() - response.data().len() > max_out) {
+                error!(
+                    "output buffer too small: wanted to write {}, max was {}",
+                    out_data.len() - response.data().len(),
+                    max_out
+                );
+
+                return Err(Error::SizeError);
+            }
+
+            out_data.extend_from_slice(&response.data()[..response.data().len()]);
+
+            in_offset += this_size;
+            if in_offset >= in_data.len() {
+                break;
+            }
+        }
+
+        while sw >> 8 == 0x61 {
+            trace!(
+                "The card indicates there is {} bytes more data for us",
+                sw & 0xff
+            );
+
+            let response = Apdu::new(Ins::GetResponseApdu).transmit(self, 261)?;
+            sw = response.status_words().code();
+
+            if sw != StatusWords::Success.code() && (sw >> 8 != 0x61) {
+                return Ok(Response::new(sw.into(), vec![]));
+            }
+
+            if out_data.len() + response.data().len() > max_out {
+                error!(
+                    "output buffer too small: wanted to write {}, max was {}",
+                    out_data.len() + response.data().len(),
+                    max_out
+                );
+
+                return Err(Error::SizeError);
+            }
+
+            out_data.extend_from_slice(&response.data()[..response.data().len()]);
+        }
+
+        Ok(Response::new(sw.into(), out_data))
+    }
+
+    /// Fetch an object.
+    pub fn fetch_object(&self, object_id: ObjectId) -> Result<Buffer> {
+        let mut indata = [0u8; 5];
+        let templ = [0, Ins::GetData.code(), 0x3f, 0xff];
+
+        let mut inlen = indata.len();
+        let indata_remaining = set_object(object_id, &mut indata);
+        inlen -= indata_remaining.len();
+
+        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 (remaining, tlv) = Tlv::parse(response.data())?;
+
+        if !remaining.is_empty() {
+            error!(
+                "invalid length indicated in object: total len is {} but indicated length is {}",
+                tlv.value.len() + remaining.len(),
+                tlv.value.len()
+            );
+
+            return Err(Error::SizeError);
+        }
+
+        Ok(Zeroizing::new(tlv.value.to_vec()))
+    }
+
+    /// Save an object.
+    pub fn save_object(&self, object_id: ObjectId, indata: &[u8]) -> Result<()> {
+        let templ = [0, Ins::PutData.code(), 0x3f, 0xff];
+
+        // TODO(tarcieri): replace with vector
+        let mut data = [0u8; CB_BUF_MAX];
+
+        if indata.len() > CB_OBJ_MAX {
+            return Err(Error::SizeError);
+        }
+
+        let mut len = data.len();
+        let mut data_remaining = set_object(object_id, &mut data);
+
+        let offset = Tlv::write(data_remaining, 0x53, indata)?;
+        data_remaining = &mut data_remaining[offset..];
+        len -= data_remaining.len();
+
+        let status_words = self
+            .transfer_data(&templ, &data[..len], 255)?
+            .status_words();
+
+        match status_words {
+            StatusWords::Success => Ok(()),
+            StatusWords::SecurityStatusError => Err(Error::AuthenticationError),
+            _ => Err(Error::GenericError),
+        }
+    }
+}
@@ -1,46 +0,0 @@
-# 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.
-
-AM_CFLAGS = $(WARN_CFLAGS) @CHECK_CFLAGS@ $(OPENSSL_CFLAGS)
-AM_CPPFLAGS = -I$(top_srcdir)/lib -I$(top_builddir)/lib $(OPENSSL_CFLAGS) $(PCSC_CFLAGS)
-
-AM_LDFLAGS = @CHECK_LIBS@
-
-if COMPILER_CLANG
-AM_LDFLAGS += -no-fast-install
-else
-AM_LDFLAGS += -no-install
-endif
-
-LDADD = ../libykpiv.la $(OPENSSL_LIBS)
-
-api_LDADD = ../../tool/libpiv_util.la
-api_SOURCES = api.c
-check_PROGRAMS = basic parse_key api
-TESTS = $(check_PROGRAMS)
-
-LOG_COMPILER = $(VALGRIND)
@@ -1,993 +0,0 @@
-/*
- * 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.
- *
- */
-
-#include "ykpiv.h"
-#include "internal.h"
-#include "../../tool/openssl-compat.h"
-
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <check.h>
-
-#ifdef __MINGW32__
-#define dprintf(fd, ...) fprintf(stdout, __VA_ARGS__)
-#endif
-
-int destruction_confirmed(void);
-
-// only defined in libcheck 0.11+ (linux distros still shipping 0.10)
-#ifndef ck_assert_ptr_nonnull
-#define ck_assert_ptr_nonnull(a) ck_assert((a) != NULL)
-#endif
-#ifndef ck_assert_mem_eq
-#define ck_assert_mem_eq(a,b,n) ck_assert(memcmp((a), (b), (n)) == 0)
-#endif
-// only defined in libcheck 0.10+ (RHEL7 is still shipping 0.9)
-#ifndef ck_assert_ptr_eq
-#define ck_assert_ptr_eq(a,b) ck_assert((void *)(a) == (void *)(b))
-#endif
-
-ykpiv_state *g_state;
-const uint8_t g_cert[] = {
-  "0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK"
-  "0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK"
-  "0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK"
-  "0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK"
-  "0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK0123456789ABCDEFGHIK"
-};
-
-void setup(void) {
-  ykpiv_rc res;
-
-  // Require user confirmation to continue, since this test suite will clear
-  // any data stored on connected keys.
-  if (!destruction_confirmed())
-    exit(77); // exit code 77 == skipped tests
-
-  res = ykpiv_init(&g_state, true);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_ptr_nonnull(g_state);
-
-  res = ykpiv_connect(g_state, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-}
-
-void teardown(void) {
-  ykpiv_rc res;
-
-  // This is the expected case, if the allocator test ran, since it de-inits.
-  if (NULL == g_state)
-    return;
-
-  res = ykpiv_disconnect(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_done(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-}
-
-#ifdef HW_TESTS
-START_TEST(test_devicemodel) {
-  ykpiv_rc res;
-  ykpiv_devmodel model;
-  char version[256];
-  char reader_buf[2048];
-  size_t num_readers = sizeof(reader_buf);
-
-  res = ykpiv_get_version(g_state, version, sizeof(version));
-  ck_assert_int_eq(res, YKPIV_OK);
-  fprintf(stderr, "Version: %s\n", version);
-  model = ykpiv_util_devicemodel(g_state);
-  fprintf(stdout, "Model: %u\n", model);
-  ck_assert(model == DEVTYPE_YK4 || model == DEVTYPE_NEOr3);
-
-  res = ykpiv_list_readers(g_state, reader_buf, &num_readers);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_int_gt(num_readers, 0);
-  if (model == DEVTYPE_YK4) {
-    ck_assert_ptr_nonnull(strstr(reader_buf, "Yubikey 4"));
-    ck_assert(version[0] == '4'); // Verify app version 4.x
-    ck_assert(version[1] == '.');
-  }
-  else {
-    ck_assert_ptr_nonnull(strstr(reader_buf, "Yubikey NEO"));
-    ck_assert(version[0] == '1'); // Verify app version 1.x
-    ck_assert(version[1] == '.');
-  }
-}
-END_TEST
-
-START_TEST(test_get_set_cardid) {
-  ykpiv_rc res;
-  ykpiv_cardid set_id;
-  ykpiv_cardid get_id;
-
-  memset(&set_id.data, 'i', sizeof(set_id.data));
-  memset(&get_id.data, 0, sizeof(get_id.data));
-
-  res = ykpiv_util_set_cardid(g_state, &set_id);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_util_get_cardid(g_state, &get_id);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_mem_eq(&set_id.data, &get_id.data, sizeof(set_id.data));
-}
-END_TEST
-
-START_TEST(test_list_readers) {
-  ykpiv_rc res;
-  char reader_buf[2048];
-  size_t num_readers = sizeof(reader_buf);
-  char *reader_ptr;
-  res = ykpiv_list_readers(g_state, reader_buf, &num_readers);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_int_gt(num_readers, 0);
-  for(reader_ptr = reader_buf; *reader_ptr != '\0'; reader_ptr += strlen(reader_ptr) + 1) {
-    fprintf(stdout, "Found device: %s\n", reader_ptr);
-  }
-}
-END_TEST
-
-START_TEST(test_read_write_list_delete_cert) {
-  ykpiv_rc res;
-  uint8_t *read_cert = NULL;
-  size_t read_cert_len = 0;
-
-  {
-    res = ykpiv_util_write_cert(g_state, YKPIV_KEY_AUTHENTICATION, (uint8_t*)g_cert, sizeof(g_cert), YKPIV_CERTINFO_UNCOMPRESSED);
-    ck_assert_int_eq(res, YKPIV_OK);
-
-    res = ykpiv_util_read_cert(g_state, YKPIV_KEY_AUTHENTICATION, &read_cert, &read_cert_len);
-    ck_assert_int_eq(res, YKPIV_OK);
-    ck_assert_ptr_nonnull(read_cert);
-    ck_assert_int_eq(read_cert_len, sizeof(g_cert));
-    ck_assert_mem_eq(g_cert, read_cert, sizeof(g_cert));
-
-    res = ykpiv_util_free(g_state, read_cert);
-    ck_assert_int_eq(res, YKPIV_OK);
-  }
-
-  {
-    ykpiv_key *keys = NULL;
-    size_t data_len;
-    uint8_t key_count;
-    res = ykpiv_util_list_keys(g_state, &key_count, &keys, &data_len);
-    ck_assert_int_eq(res, YKPIV_OK);
-    ck_assert_ptr_nonnull(keys);
-    ck_assert_int_gt(key_count, 0);
-
-    res = ykpiv_util_free(g_state, keys);
-    ck_assert_int_eq(res, YKPIV_OK);
-  }
-
-  {
-    res = ykpiv_util_delete_cert(g_state, YKPIV_KEY_AUTHENTICATION);
-    ck_assert_int_eq(res, YKPIV_OK);
-
-    res = ykpiv_util_read_cert(g_state, YKPIV_KEY_AUTHENTICATION, &read_cert, &read_cert_len);
-    ck_assert_int_eq(res, YKPIV_GENERIC_ERROR);
-
-    res = ykpiv_util_free(g_state, read_cert);
-    ck_assert_int_eq(res, YKPIV_OK);
-  }
-}
-END_TEST
-
-#include <openssl/des.h>
-#include <openssl/pem.h>
-#include <openssl/pkcs12.h>
-#include <openssl/rand.h>
-
-// RSA2048 private key, generated with: `openssl genrsa 2048 -out private.pem`
-static const char *private_key_pem =
-  "-----BEGIN RSA PRIVATE KEY-----\n"
-  "MIIEpAIBAAKCAQEAwVUwmVbc+ffOy2+RivxBpgleTVN6bUa0q7jNYB+AseFQYaYq\n"
-  "EGfa+VGdxSGo+8DV1KT9+fNEd5243gXn/tcjtMItKeB+oAQc64s9lIFlYuR8bpq1\n"
-  "ibr33iW2elnnv9mpecqohdCVwM2McWveoPyb7MwlwVuhqexOzJO29bqJcazLbtkf\n"
-  "ZETK0oBx53/ylA4Y6nE9Pa46jW2qhj+KShf1iBg+gAyt3eI+wI2Wmub1WxLLH8D2\n"
-  "w+kow8QhQOa8dHCkRRw771JxVO5+d+Y/Y+x9B1HgF4q0q9xUlhWLK2TR4ChBFzXe\n"
-  "47sAHsSqi/pl5JbwYrHPOE/VEBLukmjL8NFCSQIDAQABAoIBADmEyOK2DyRnb6Ti\n"
-  "2qBJEJb/boj+7wuX36S/ZIrWlIlXiXyj3RvoaiOG/rNpokbURknvlIhKsfIMgLW9\n"
-  "eBo/k6Xxp1IwMjwVPS1uzbFjFfDoHYUijiQd9iSnf7TDDsnrThqoCp9VQViNTt1n\n"
-  "xGKNBS7cRddTFbPiVEdVIzfUeZPR2oRrc4maBCRCrQgg8WNknawmc8zhkf2NiPj3\n"
-  "tWLQHMy1/MgW2W1LM9sgzllEtS5CZUnyGy2HbbhS2tbZ6j9kPzOp0pPxxTTzJmmV\n"
-  "fi1vkJcVW4+MdXjWmhALcPA4dO7Y2Ljiu6VxIxQORRO1DyiCjAs1AVMQxgPAAY41\n"
-  "YR4Q2EkCgYEA4zE0oytg97aVaBY9CKi7/PqR+NI/uEvfoQCnT+ddaJgp/qsspuXo\n"
-  "tJt94p13ANd8O7suqQTVNvbZq1rX10xQjJZ9nvlqQa6iHkN6Epq31XBK3Z+acjIV\n"
-  "A2rAgKBByjz9/CpKHqnOsrTWU1Y7x416IG4BZt42hHdrxRH98/wiDH8CgYEA2djj\n"
-  "AjwgK+MwDnshwT1NNgCSP/2ZHatBAykZ5BCs9BJ6MNYqqXVGYoqs5Z5kSkow+Db3\n"
-  "pipkEieo5w2Rd5zkolTThaVCvRkSe5wRiBpZhaeY+b0UFwavGCb6zU/MmJIMDPiI\n"
-  "2iRGeCXgQDvIS/icIqzbTtp6dZaoMgG7LdSR7TcCgYBtxGhaLas8A8tL7vKuLFgn\n"
-  "cij0vyBqOr5hW596y54l2t7vXGTGfm5gVIAN7WaB0ZsEgPuaTet2Eu44DDwcmZKR\n"
-  "WmR3Wqor8eQCGzfvpTEMvqRtT5+fbPMaI4m+m68ttyo/m28UQZbMYPLscM2RLJnE\n"
-  "8WFcAiD0/33iST8ZksggoQKBgQDE/7Yhsj+hkHxHzB+1QPtOp2uaBHnvc4uCESwB\n"
-  "qvbMbN0kxrejsJLqz98UcozdBYSNIiAHmvQN2uGJuCJhGXdEORNjGxRkLoUhVPwh\n"
-  "qTplfC8BQHQncnrqi21oNw6ctg3BuQsAwaccRZwqWiWCVhrT3J8iCr6NEaWeOySK\n"
-  "iF1CNwKBgQCRpkkZArlccwS0kMvkK+tQ1rG2xWm7c05G34gP/g6dHFRy0gPNMyvi\n"
-  "SkiLTJmQIEZSAEiq0FFgcVwM6o556ftvQZuwDp5rHUbwqnHCpMJKpD9aJpStvfPi\n"
-  "4p9JbYdaGqnq4eoNKemmGnbUof0dR9Zr0lGmcMTwwzBib+4E1d7soA==\n"
-  "-----END RSA PRIVATE KEY-----\n";
-
-// Certificate signed with key above:
-// `openssl req -x509 -key private.pem -out cert.pem -subj "/CN=bar/OU=test/O=example.com/" -new`
-static const char *certificate_pem =
-  "-----BEGIN CERTIFICATE-----\n"
-  "MIIC5zCCAc+gAwIBAgIJAOq8A/cmpxF5MA0GCSqGSIb3DQEBCwUAMDMxDDAKBgNV\n"
-  "BAMMA2JhcjENMAsGA1UECwwEdGVzdDEUMBIGA1UECgwLZXhhbXBsZS5jb20wHhcN\n"
-  "MTcwODAzMTE1MDI2WhcNMTgwODAzMTE1MDI2WjAzMQwwCgYDVQQDDANiYXIxDTAL\n"
-  "BgNVBAsMBHRlc3QxFDASBgNVBAoMC2V4YW1wbGUuY29tMIIBIjANBgkqhkiG9w0B\n"
-  "AQEFAAOCAQ8AMIIBCgKCAQEAwVUwmVbc+ffOy2+RivxBpgleTVN6bUa0q7jNYB+A\n"
-  "seFQYaYqEGfa+VGdxSGo+8DV1KT9+fNEd5243gXn/tcjtMItKeB+oAQc64s9lIFl\n"
-  "YuR8bpq1ibr33iW2elnnv9mpecqohdCVwM2McWveoPyb7MwlwVuhqexOzJO29bqJ\n"
-  "cazLbtkfZETK0oBx53/ylA4Y6nE9Pa46jW2qhj+KShf1iBg+gAyt3eI+wI2Wmub1\n"
-  "WxLLH8D2w+kow8QhQOa8dHCkRRw771JxVO5+d+Y/Y+x9B1HgF4q0q9xUlhWLK2TR\n"
-  "4ChBFzXe47sAHsSqi/pl5JbwYrHPOE/VEBLukmjL8NFCSQIDAQABMA0GCSqGSIb3\n"
-  "DQEBCwUAA4IBAQCamrwdEhNmY2GCQWq6U90Q3XQT6w0HHW/JmtuGeF+BTpVr12gN\n"
-  "/UvEXTo9geWbGcCTjaMMURTa7mUjVUIttIWEVHZMKqBuvsUM1RcuOEX/vitaJJ8K\n"
-  "Sw4upjCNa3ZxUXmSA1FBixZgDzFqjEeSiaJjMU0yX5W2p1T4iNYtF3YqzMF5AWSI\n"
-  "qCO7gP5ezPyg5kDnrO3V7DBgnDiqawq7Pyn9DynKNULX/hc1yls/R+ebb2u8Z+h5\n"
-  "W4YXbzGZb8qdT27qIZaHD638tL6liLkI6UE4KCXH8X8e3fqdbmqvwrq403nOGmsP\n"
-  "cbJb2PEXibNEQG234riKxm7x7vNDLL79Jwtc\n"
-  "-----END CERTIFICATE-----\n";
-
-static bool set_component(unsigned char *in_ptr, const BIGNUM *bn, int element_len) {
-  int real_len = BN_num_bytes(bn);
-
-  if(real_len > element_len) {
-    return false;
-  }
-  memset(in_ptr, 0, (size_t)(element_len - real_len));
-  in_ptr += element_len - real_len;
-  BN_bn2bin(bn, in_ptr);
-
-  return true;
-}
-
-static bool prepare_rsa_signature(const unsigned char *in, unsigned int in_len, unsigned char *out, unsigned int *out_len, int nid) {
-  X509_SIG *digestInfo;
-  X509_ALGOR *algor;
-  ASN1_OCTET_STRING *digest;
-  unsigned char data[1024];
-
-  memcpy(data, in, in_len);
-
-  digestInfo = X509_SIG_new();
-  X509_SIG_getm(digestInfo, &algor, &digest);
-  algor->algorithm = OBJ_nid2obj(nid);
-  X509_ALGOR_set0(algor, OBJ_nid2obj(nid), V_ASN1_NULL, NULL);
-  ASN1_STRING_set(digest, data, in_len);
-  *out_len = (unsigned int)i2d_X509_SIG(digestInfo, &out);
-  X509_SIG_free(digestInfo);
-  return true;
-}
-
-static void import_key(unsigned char slot, unsigned char pin_policy) {
-  ykpiv_rc res;
-  {
-    unsigned char pp = pin_policy;
-    unsigned char tp = YKPIV_TOUCHPOLICY_DEFAULT;
-    EVP_PKEY *private_key = NULL;
-    BIO *bio = NULL;
-    RSA *rsa_private_key = NULL;
-    unsigned char e[4];
-    unsigned char p[128];
-    unsigned char q[128];
-    unsigned char dmp1[128];
-    unsigned char dmq1[128];
-    unsigned char iqmp[128];
-    int element_len = 128;
-    const BIGNUM *bn_e, *bn_p, *bn_q, *bn_dmp1, *bn_dmq1, *bn_iqmp;
-
-    bio = BIO_new_mem_buf(private_key_pem, strlen(private_key_pem));
-    private_key = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL);
-    ck_assert_ptr_nonnull(private_key);
-    BIO_free(bio);
-    rsa_private_key = EVP_PKEY_get1_RSA(private_key);
-    ck_assert_ptr_nonnull(rsa_private_key);
-    RSA_get0_key(rsa_private_key, NULL, &bn_e, NULL);
-    RSA_get0_factors(rsa_private_key, &bn_p, &bn_q);
-    RSA_get0_crt_params(rsa_private_key, &bn_dmp1, &bn_dmq1, &bn_iqmp);
-    ck_assert(set_component(e, bn_e, 3));
-    ck_assert(set_component(p, bn_p, element_len));
-    ck_assert(set_component(q, bn_q, element_len));
-    ck_assert(set_component(dmp1, bn_dmp1, element_len));
-    ck_assert(set_component(dmq1, bn_dmq1, element_len));
-    ck_assert(set_component(iqmp, bn_iqmp, element_len));
-
-    // Try wrong algorithm, fail.
-    res = ykpiv_import_private_key(g_state,
-                                   slot,
-                                   YKPIV_ALGO_RSA1024,
-                                   p, element_len,
-                                   q, element_len,
-                                   dmp1, element_len,
-                                   dmq1, element_len,
-                                   iqmp, element_len,
-                                   NULL, 0,
-                                   pp, tp);
-    ck_assert_int_eq(res, YKPIV_ALGORITHM_ERROR);
-
-    // Try right algorithm
-    res = ykpiv_import_private_key(g_state,
-                                   slot,
-                                   YKPIV_ALGO_RSA2048,
-                                   p, element_len,
-                                   q, element_len,
-                                   dmp1, element_len,
-                                   dmq1, element_len,
-                                   iqmp, element_len,
-                                   NULL, 0,
-                                   pp, tp);
-    ck_assert_int_eq(res, YKPIV_OK);
-    RSA_free(rsa_private_key);
-    EVP_PKEY_free(private_key);
-  }
-
-  // Use imported key to decrypt a thing.  See that it works.
-  {
-    BIO *bio = NULL;
-    X509 *cert = NULL;
-    EVP_PKEY *pub_key = NULL;
-    unsigned char secret[32];
-    unsigned char secret2[32];
-    unsigned char data[256];
-    int len;
-    size_t len2 = sizeof(data);
-    RSA *rsa = NULL;
-    bio = BIO_new_mem_buf(certificate_pem, strlen(certificate_pem));
-    cert = PEM_read_bio_X509(bio, NULL, NULL, NULL);
-    ck_assert_ptr_nonnull(cert);
-    BIO_free(bio);
-    pub_key = X509_get_pubkey(cert);
-    ck_assert_ptr_nonnull(pub_key);
-    rsa = EVP_PKEY_get1_RSA(pub_key);
-    ck_assert_ptr_nonnull(rsa);
-    EVP_PKEY_free(pub_key);
-
-    ck_assert_int_gt(RAND_bytes(secret, sizeof(secret)), 0);
-    len = RSA_public_encrypt(sizeof(secret), secret, data, rsa, RSA_PKCS1_PADDING);
-    ck_assert_int_ge(len, 0);
-    res = ykpiv_verify(g_state, "123456", NULL);
-    ck_assert_int_eq(res, YKPIV_OK);
-    res = ykpiv_decipher_data(g_state, data, (size_t)len, data, &len2, YKPIV_ALGO_RSA2048, slot);
-    ck_assert_int_eq(res, YKPIV_OK);
-    len = RSA_padding_check_PKCS1_type_2(secret2, sizeof(secret2), data + 1, len2 - 1, RSA_size(rsa));
-    ck_assert_int_eq(len, sizeof(secret));
-    ck_assert_int_eq(memcmp(secret, secret2, sizeof(secret)), 0);
-    RSA_free(rsa);
-    X509_free(cert);
-  }
-}
-
-START_TEST(test_import_key) {
-  ykpiv_rc res;
-
-  import_key(0x9a, YKPIV_PINPOLICY_DEFAULT);
-
-  // Verify certificate
-  {
-    BIO *bio = NULL;
-    X509 *cert = NULL;
-    RSA *rsa = NULL;
-    EVP_PKEY *pub_key = NULL;
-    const EVP_MD *md = EVP_sha256();
-    EVP_MD_CTX *mdctx;
-
-    unsigned char signature[1024];
-    unsigned char encoded[1024];
-    unsigned char data[1024];
-    unsigned char signinput[1024];
-    unsigned char rand[128];
-
-    size_t sig_len = sizeof(signature);
-    size_t padlen = 256;
-    unsigned int enc_len;
-    unsigned int data_len;
-
-    bio = BIO_new_mem_buf(certificate_pem, strlen(certificate_pem));
-    cert = PEM_read_bio_X509(bio, NULL, NULL, NULL);
-    ck_assert_ptr_nonnull(cert);
-    BIO_free(bio);
-    pub_key = X509_get_pubkey(cert);
-    ck_assert_ptr_nonnull(pub_key);
-    rsa = EVP_PKEY_get1_RSA(pub_key);
-    ck_assert_ptr_nonnull(rsa);
-    EVP_PKEY_free(pub_key);
-
-    ck_assert_int_gt(RAND_bytes(rand, 128), 0);
-    mdctx = EVP_MD_CTX_create();
-    EVP_DigestInit_ex(mdctx, md, NULL);
-    EVP_DigestUpdate(mdctx, rand, 128);
-    EVP_DigestFinal_ex(mdctx, data, &data_len);
-
-    prepare_rsa_signature(data, data_len, encoded, &enc_len, EVP_MD_type(md));
-    ck_assert_int_ne(RSA_padding_add_PKCS1_type_1(signinput, padlen, encoded, enc_len), 0);
-    res = ykpiv_sign_data(g_state, signinput, padlen, signature, &sig_len, YKPIV_ALGO_RSA2048, 0x9a);
-    ck_assert_int_eq(res, YKPIV_OK);
-
-    ck_assert_int_eq(RSA_verify(EVP_MD_type(md), data, data_len, signature, sig_len, rsa), 1);
-
-    RSA_free(rsa);
-    X509_free(cert);
-    EVP_MD_CTX_destroy(mdctx);
-  }
-
-  // Verify that imported key can not be attested
-  {
-    unsigned char attest[2048];
-    size_t attest_len = sizeof(attest);
-    ykpiv_devmodel model;
-    model = ykpiv_util_devicemodel(g_state);
-    res = ykpiv_attest(g_state, 0x9a, attest, &attest_len);
-    if (model == DEVTYPE_YK4) {
-      ck_assert_int_eq(res, YKPIV_GENERIC_ERROR);
-    }
-    else {
-      ck_assert_int_eq(res, YKPIV_NOT_SUPPORTED);
-    }
-  }
-}
-END_TEST
-
-START_TEST(test_pin_policy_always) {
-  ykpiv_rc res;
-
-  {
-    ykpiv_devmodel model;
-    model = ykpiv_util_devicemodel(g_state);
-    // Only works with YK4.  NEO should skip.
-    if (model != DEVTYPE_YK4) {
-      fprintf(stderr, "WARNING: Not supported with Yubikey NEO.  Test skipped.\n");
-      return;
-    }
-  }
-
-  import_key(0x9e, YKPIV_PINPOLICY_ALWAYS);
-
-  // Verify certificate
-  {
-    BIO *bio = NULL;
-    X509 *cert = NULL;
-    RSA *rsa = NULL;
-    EVP_PKEY *pub_key = NULL;
-    const EVP_MD *md = EVP_sha256();
-    EVP_MD_CTX *mdctx;
-
-    unsigned char signature[1024];
-    unsigned char encoded[1024];
-    unsigned char data[1024];
-    unsigned char signinput[1024];
-    unsigned char rand[128];
-
-    size_t sig_len = sizeof(signature);
-    size_t padlen = 256;
-    unsigned int enc_len;
-    unsigned int data_len;
-
-    bio = BIO_new_mem_buf(certificate_pem, strlen(certificate_pem));
-    cert = PEM_read_bio_X509(bio, NULL, NULL, NULL);
-    ck_assert_ptr_nonnull(cert);
-    BIO_free(bio);
-    pub_key = X509_get_pubkey(cert);
-    ck_assert_ptr_nonnull(pub_key);
-    rsa = EVP_PKEY_get1_RSA(pub_key);
-    ck_assert_ptr_nonnull(rsa);
-    EVP_PKEY_free(pub_key);
-
-    ck_assert_int_gt(RAND_bytes(rand, 128), 0);
-    mdctx = EVP_MD_CTX_create();
-    EVP_DigestInit_ex(mdctx, md, NULL);
-    EVP_DigestUpdate(mdctx, rand, 128);
-    EVP_DigestFinal_ex(mdctx, data, &data_len);
-
-    prepare_rsa_signature(data, data_len, encoded, &enc_len, EVP_MD_type(md));
-    ck_assert_int_ne(RSA_padding_add_PKCS1_type_1(signinput, padlen, encoded, enc_len), 0);
-
-    // Sign without verify: fail
-    res = ykpiv_sign_data(g_state, signinput, padlen, signature, &sig_len, YKPIV_ALGO_RSA2048, 0x9e);
-    ck_assert_int_eq(res, YKPIV_AUTHENTICATION_ERROR);
-
-    // Sign with verify: pass
-    res = ykpiv_verify(g_state, "123456", NULL);
-    ck_assert_int_eq(res, YKPIV_OK);
-    res = ykpiv_sign_data(g_state, signinput, padlen, signature, &sig_len, YKPIV_ALGO_RSA2048, 0x9e);
-    ck_assert_int_eq(res, YKPIV_OK);
-
-    // Sign again without verify: fail
-    res = ykpiv_sign_data(g_state, signinput, padlen, signature, &sig_len, YKPIV_ALGO_RSA2048, 0x9e);
-    ck_assert_int_eq(res, YKPIV_AUTHENTICATION_ERROR);
-
-    // Sign again with verify: pass
-    res = ykpiv_verify(g_state, "123456", NULL);
-    ck_assert_int_eq(res, YKPIV_OK);
-    res = ykpiv_sign_data(g_state, signinput, padlen, signature, &sig_len, YKPIV_ALGO_RSA2048, 0x9e);
-    ck_assert_int_eq(res, YKPIV_OK);
-
-    ck_assert_int_eq(RSA_verify(EVP_MD_type(md), data, data_len, signature, sig_len, rsa), 1);
-
-    RSA_free(rsa);
-    X509_free(cert);
-    EVP_MD_CTX_destroy(mdctx);
-  }
-}
-END_TEST
-
-START_TEST(test_generate_key) {
-  ykpiv_rc res;
-  uint8_t *mod, *exp;
-  size_t mod_len, exp_len;
-  res = ykpiv_util_write_cert(g_state, YKPIV_KEY_AUTHENTICATION, (uint8_t*)g_cert, sizeof(g_cert), YKPIV_CERTINFO_UNCOMPRESSED);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_util_generate_key(g_state,
-                                YKPIV_KEY_AUTHENTICATION,
-                                YKPIV_ALGO_RSA2048,
-                                YKPIV_PINPOLICY_DEFAULT,
-                                YKPIV_TOUCHPOLICY_DEFAULT,
-                                &mod,
-                                &mod_len,
-                                &exp,
-                                &exp_len,
-                                NULL,
-                                NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_util_free(g_state, mod);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_util_free(g_state, exp);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Verify that imported key can be attested
-  {
-    ykpiv_devmodel model;
-    unsigned char attest[2048];
-    size_t attest_len = sizeof(attest);
-    model = ykpiv_util_devicemodel(g_state);
-    res = ykpiv_attest(g_state, YKPIV_KEY_AUTHENTICATION, attest, &attest_len);
-    // Only works with YK4.  NEO should error.
-    if (model == DEVTYPE_YK4) {
-      ck_assert_int_eq(res, YKPIV_OK);
-      ck_assert_int_gt(attest_len, 0);
-    }
-    else {
-      ck_assert_int_eq(res, YKPIV_NOT_SUPPORTED);
-    }
-  }
-}
-END_TEST
-
-START_TEST(test_authenticate) {
-  ykpiv_rc res;
-  const char *default_mgm_key = "010203040506070801020304050607080102030405060708";
-  const char *mgm_key = "112233445566778811223344556677881122334455667788";
-  const char *weak_mgm_key = "FEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFE";
-  unsigned char key[24];
-  size_t key_len = sizeof(key);
-
-  // Try new key, fail.
-  res = ykpiv_hex_decode(mgm_key, strlen(mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_authenticate(g_state, key);
-  ck_assert_int_eq(res, YKPIV_AUTHENTICATION_ERROR);
-
-  // Try default key, succeed
-  res = ykpiv_hex_decode(default_mgm_key, strlen(default_mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_authenticate(g_state, key);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Verify same key works twice
-  res = ykpiv_hex_decode(default_mgm_key, strlen(default_mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_authenticate(g_state, key);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Change to new key
-  res = ykpiv_hex_decode(mgm_key, strlen(mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_set_mgmkey(g_state, key);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Try new key, succeed.
-  res = ykpiv_hex_decode(mgm_key, strlen(mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_authenticate(g_state, key);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Change back to default key
-  res = ykpiv_hex_decode(default_mgm_key, strlen(default_mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_set_mgmkey(g_state, key);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Try default key, succeed
-  res = ykpiv_hex_decode(default_mgm_key, strlen(default_mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_authenticate(g_state, key);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Try to set a weak key, fail
-  res = ykpiv_hex_decode(weak_mgm_key, strlen(weak_mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_set_mgmkey(g_state, key);
-  ck_assert_int_eq(res, YKPIV_KEY_ERROR);
-
-  // Try default key, succeed
-  res = ykpiv_hex_decode(default_mgm_key, strlen(default_mgm_key), key, &key_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_authenticate(g_state, key);
-  ck_assert_int_eq(res, YKPIV_OK);
-}
-END_TEST
-
-START_TEST(test_change_pin) {
-  ykpiv_rc res;
-
-  res = ykpiv_verify(g_state, "123456", NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_change_pin(g_state, "123456", 6, "ABCDEF", 6, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_verify(g_state, "123456", NULL);
-  ck_assert_int_eq(res, YKPIV_WRONG_PIN);
-
-  res = ykpiv_verify(g_state, "ABCDEF", NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_change_pin(g_state, "ABCDEF", 6, "123456", 6, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_verify(g_state, "ABCDEF", NULL);
-  ck_assert_int_eq(res, YKPIV_WRONG_PIN);
-
-  res = ykpiv_verify(g_state, "123456", NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-}
-END_TEST
-
-START_TEST(test_change_puk) {
-  ykpiv_rc res;
-
-  res = ykpiv_unblock_pin(g_state, "12345678", 8, "123456", 6, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_change_puk(g_state, "12345678", 8, "ABCDEFGH", 8, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_unblock_pin(g_state, "12345678", 8, "123456", 6, NULL);
-  ck_assert_int_eq(res, YKPIV_WRONG_PIN);
-
-  res = ykpiv_unblock_pin(g_state, "ABCDEFGH", 8, "123456", 6, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_change_puk(g_state, "ABCDEFGH", 8, "12345678", 8, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_unblock_pin(g_state, "ABCDEFGH", 8, "123456", 6, NULL);
-  ck_assert_int_eq(res, YKPIV_WRONG_PIN);
-
-  res = ykpiv_unblock_pin(g_state, "12345678", 8, "123456", 6, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-}
-END_TEST
-
-static int block_and_reset() {
-  ykpiv_rc res;
-  int tries = 100;
-  int tries_until_blocked;
-
-  tries_until_blocked = 0;
-  while (tries) {
-    res = ykpiv_verify(g_state, "AAAAAA", &tries);
-    if (res == YKPIV_PIN_LOCKED)
-      break;
-    ck_assert_int_eq(res, YKPIV_WRONG_PIN);
-    tries_until_blocked++;
-  }
-
-  // Verify no PIN retries remaining
-  tries = 100;
-  res = ykpiv_get_pin_retries(g_state, &tries);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_int_eq(tries, 0);
-
-  tries = 100;
-  while (tries) {
-    res = ykpiv_change_puk(g_state, "AAAAAAAA", 8, "AAAAAAAA", 8, &tries);
-    if (res == YKPIV_PIN_LOCKED)
-      break;
-    ck_assert_int_eq(res, YKPIV_WRONG_PIN);
-  }
-  res = ykpiv_util_reset(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-  return tries_until_blocked;
-}
-
-START_TEST(test_reset) {
-  ykpiv_rc res;
-  int tries = 100;
-  int tries_until_blocked;
-
-  // Block and reset, with default PIN retries
-  tries_until_blocked = block_and_reset();
-  ck_assert_int_eq(tries_until_blocked, 3);
-
-  // Authenticate and increase PIN retries
-  test_authenticate(0);
-  res = ykpiv_verify(g_state, "123456", NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_set_pin_retries(g_state, 8, 3);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Block and reset again, verifying increased PIN retries
-  tries_until_blocked = block_and_reset();
-  ck_assert_int_eq(tries_until_blocked, 8);
-  // Note: defaults back to 3 retries after reset
-
-  // Verify default (3) PIN retries remaining
-  tries = 0;
-  res = ykpiv_get_pin_retries(g_state, &tries);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_int_eq(tries, 3);
-
-  // Verify still (3) PIN retries remaining
-  tries = 0;
-  res = ykpiv_get_pin_retries(g_state, &tries);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_int_eq(tries, 3);
-
-  // Try wrong PIN
-  res = ykpiv_verify(g_state, "AAAAAA", &tries);
-  ck_assert_int_eq(res, YKPIV_WRONG_PIN);
-
-  // Verify 2 PIN retries remaining
-  tries = 0;
-  res = ykpiv_get_pin_retries(g_state, &tries);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_int_eq(tries, 2);
-
-  // Verify correct PIN
-  tries = 100;
-  res = ykpiv_verify(g_state, "123456", &tries);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Verify back to 3 PIN retries remaining
-  tries = 0;
-  res = ykpiv_get_pin_retries(g_state, &tries);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_int_eq(tries, 3);
-}
-END_TEST
-
-
-struct t_alloc_data{
-  uint32_t count;
-} g_alloc_data;
-
-static void* _test_alloc(void *data, size_t cb) {
-  ck_assert_ptr_eq(data, &g_alloc_data);
-  ((struct t_alloc_data*)data)->count++;
-  return calloc(cb, 1);
-}
-
-static void * _test_realloc(void *data, void *p, size_t cb) {
-  ck_assert_ptr_eq(data, &g_alloc_data);
-  return realloc(p, cb);
-}
-
-static void _test_free(void *data, void *p) {
-  fflush(stderr);
-  ck_assert_ptr_eq(data, &g_alloc_data);
-  ((struct t_alloc_data*)data)->count--;
-  free(p);
-}
-
-ykpiv_allocator test_allocator_cbs = {
-  .pfn_alloc = _test_alloc,
-  .pfn_realloc = _test_realloc,
-  .pfn_free = _test_free,
-  .alloc_data = &g_alloc_data
-};
-
-uint8_t *alloc_auth_cert() {
-  ykpiv_rc res;
-  uint8_t *read_cert = NULL;
-  size_t read_cert_len = 0;
-
-  res = ykpiv_util_write_cert(g_state, YKPIV_KEY_AUTHENTICATION, (uint8_t*)g_cert, sizeof(g_cert), YKPIV_CERTINFO_UNCOMPRESSED);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  res = ykpiv_util_read_cert(g_state, YKPIV_KEY_AUTHENTICATION, &read_cert, &read_cert_len);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_ptr_nonnull(read_cert);
-  ck_assert_int_eq(read_cert_len, sizeof(g_cert));
-  ck_assert_mem_eq(g_cert, read_cert, sizeof(g_cert));
-  return read_cert;
-}
-
-START_TEST(test_allocator) {
-  ykpiv_rc res;
-  const ykpiv_allocator allocator;
-  uint8_t *cert1, *cert2;
-
-  res = ykpiv_done(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-  g_state = NULL;
-
-  res = ykpiv_init_with_allocator(&g_state, false, &test_allocator_cbs);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_ptr_nonnull(g_state);
-
-  // Verify we can communicate with device and make some allocations
-  res = ykpiv_connect(g_state, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-  test_authenticate(0);
-  cert1 = alloc_auth_cert();
-  cert2 = alloc_auth_cert();
-
-  // Verify allocations went through custom allocator, and still live
-  ck_assert_int_gt(g_alloc_data.count, 1);
-
-  // Free and shutdown everything
-  ykpiv_util_free(g_state, cert2);
-  ykpiv_util_free(g_state, cert1);
-  res = ykpiv_disconnect(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_done(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Verify equal number of frees as allocations
-  ck_assert_int_eq(g_alloc_data.count, 0);
-
-  // Clear g_state so teardown() is skipped
-  g_state = NULL;
-}
-END_TEST
-
-START_TEST(test_pin_cache) {
-  ykpiv_rc res;
-  ykpiv_state *local_state;
-  unsigned char data[256];
-  unsigned char data_in[256] = {0};
-  int len = sizeof(data);
-  size_t len2 = sizeof(data);
-
-  import_key(0x9a, YKPIV_PINPOLICY_DEFAULT);
-
-  // Disconnect and reconnect to device to guarantee it is not authed
-  res = ykpiv_disconnect(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_done(g_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_init(&g_state, true);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_ptr_nonnull(g_state);
-  res = ykpiv_connect(g_state, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Verify decryption does not work without auth
-  res = ykpiv_decipher_data(g_state, data_in, (size_t)len, data, &len2, YKPIV_ALGO_RSA2048, 0x9a);
-  ck_assert_int_eq(res, YKPIV_AUTHENTICATION_ERROR);
-
-  // Verify decryption does work when authed
-  res = ykpiv_verify_select(g_state, "123456", 6, NULL, true);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_decipher_data(g_state, data_in, (size_t)len, data, &len2, YKPIV_ALGO_RSA2048, 0x9a);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Verify PIN policy allows continuing to decrypt without re-verifying
-  res = ykpiv_decipher_data(g_state, data_in, (size_t)len, data, &len2, YKPIV_ALGO_RSA2048, 0x9a);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Create a new ykpiv state, connect, and close it.
-  // This forces a card reset from another context, so the original global
-  // context will require a reconnect for its next transaction.
-  res = ykpiv_init(&local_state, true);
-  ck_assert_int_eq(res, YKPIV_OK);
-  ck_assert_ptr_nonnull(local_state);
-  res = ykpiv_connect(local_state, NULL);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_disconnect(local_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-  res = ykpiv_done(local_state);
-  ck_assert_int_eq(res, YKPIV_OK);
-
-  // Verify we are still authenticated on the global context.  This will
-  // require an automatic  reconnect and re-verify with the cached PIN.
-  //
-  // Note that you can verify that this fails by rebuilding with
-  // DISABLE_PIN_CACHE set to 1.
-  res = ykpiv_decipher_data(g_state, data_in, (size_t)len, data, &len2, YKPIV_ALGO_RSA2048, 0x9a);
-  ck_assert_int_eq(res, YKPIV_OK);
-}
-END_TEST
-#endif
-
-int destruction_confirmed(void) {
-  char *confirmed = getenv("YKPIV_ENV_HWTESTS_CONFIRMED");
-  if (confirmed && confirmed[0] == '1')
-    return 1;
-  // Use dprintf() to write directly to stdout, since automake eats the standard stdout/stderr pointers.
-  dprintf(0, "\n***\n*** Hardware tests skipped.  Run \"make hwcheck\".\n***\n\n");
-  return 0;
-}
-
-Suite *test_suite(void) {
-  Suite *s;
-  TCase *tc;
-
-  s = suite_create("libykpiv api");
-  tc = tcase_create("api");
-#ifdef HW_TESTS
-  tcase_add_unchecked_fixture(tc, setup, teardown);
-
-  // Must be first: Reset device.  Tests run serially, and depend on a clean slate.
-  tcase_add_test(tc, test_reset);
-
-  // Authenticate after reset.
-  tcase_add_test(tc, test_authenticate);
-
-  // Test API functionality
-  tcase_add_test(tc, test_change_pin);
-  tcase_add_test(tc, test_change_puk);
-  tcase_add_test(tc, test_devicemodel);
-  tcase_add_test(tc, test_get_set_cardid);
-  tcase_add_test(tc, test_list_readers);
-  tcase_add_test(tc, test_read_write_list_delete_cert);
-  tcase_add_test(tc, test_import_key);
-  tcase_add_test(tc, test_pin_policy_always);
-  tcase_add_test(tc, test_generate_key);
-  tcase_add_test(tc, test_pin_cache);
-
-  // Must be last: tear down and re-test with custom memory allocator
-  tcase_add_test(tc, test_allocator);
-#endif
-  suite_add_tcase(s, tc);
-
-  return s;
-}
-
-int main(void)
-{
-  int number_failed;
-  Suite *s;
-  SRunner *sr;
-
-  s = test_suite();
-  sr = srunner_create(s);
-  srunner_set_fork_status(sr, CK_NOFORK);
-  srunner_run_all(sr, CK_VERBOSE);
-  number_failed = srunner_ntests_failed(sr);
-  srunner_free(sr);
-
-  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
@@ -1,98 +0,0 @@
-/*
- * 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.
- *
- */
-
-#include "ykpiv.h"
-
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <check.h>
-
-START_TEST(test_version_string) {
-  if (strcmp(YKPIV_VERSION_STRING, ykpiv_check_version(NULL)) != 0) {
-    ck_abort_msg("version mismatch %s != %s\n", YKPIV_VERSION_STRING,
-                 ykpiv_check_version(NULL));
-  }
-
-  if (ykpiv_check_version(YKPIV_VERSION_STRING) == NULL) {
-    ck_abort_msg("version NULL?\n");
-  }
-
-  if (ykpiv_check_version("99.99.99") != NULL) {
-    ck_abort_msg("version not NULL?\n");
-  }
-
-  fprintf(stderr, "ykpiv version: header %s library %s\n",
-          YKPIV_VERSION_STRING, ykpiv_check_version (NULL));
-}
-END_TEST
-
-START_TEST(test_strerror) {
-  const char *s;
-
-  if (ykpiv_strerror(YKPIV_OK) == NULL) {
-    ck_abort_msg("ykpiv_strerror NULL\n");
-  }
-
-  s = ykpiv_strerror_name(YKPIV_OK);
-  if (s == NULL || strcmp(s, "YKPIV_OK") != 0) {
-    ck_abort_msg("ykpiv_strerror_name %s\n", s);
-  }
-}
-END_TEST
-
-Suite *basic_suite(void) {
-  Suite *s;
-  TCase *tc;
-
-  s = suite_create("libykpiv basic");
-  tc = tcase_create("basic");
-  tcase_add_test(tc, test_version_string);
-  tcase_add_test(tc, test_strerror);
-  suite_add_tcase(s, tc);
-
-  return s;
-}
-
-int main(void)
-{
-  int number_failed;
-  Suite *s;
-  SRunner *sr;
-
-  s = basic_suite();
-  sr = srunner_create(s);
-  srunner_run_all(sr, CK_NORMAL);
-  number_failed = srunner_ntests_failed(sr);
-  srunner_free(sr);
-  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
@@ -0,0 +1,276 @@
+//! Integration tests
+
+#![forbid(unsafe_code)]
+#![warn(missing_docs, rust_2018_idioms, trivial_casts, unused_qualifications)]
+
+use lazy_static::lazy_static;
+use log::trace;
+use rand_core::{OsRng, RngCore};
+use rsa::{hash::Hash::SHA2_256, PaddingScheme, PublicKey};
+use sha2::{Digest, Sha256};
+use std::{env, sync::Mutex};
+use x509::RelativeDistinguishedName;
+use yubikey::{
+    certificate::{Certificate, PublicKeyInfo},
+    piv::{self, AlgorithmId, Key, RetiredSlotId, SlotId},
+    Error, MgmKey, PinPolicy, TouchPolicy, YubiKey,
+};
+
+lazy_static! {
+    /// Provide thread-safe access to a YubiKey
+    static ref YUBIKEY: Mutex<YubiKey> = init_yubikey();
+}
+
+/// One-time test initialization and setup
+fn init_yubikey() -> Mutex<YubiKey> {
+    // Only show logs if `RUST_LOG` is set
+    if env::var("RUST_LOG").is_ok() {
+        env_logger::builder().format_timestamp(None).init();
+    }
+
+    let yubikey = 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 = YUBIKEY.lock().unwrap();
+
+    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 = YUBIKEY.lock().unwrap();
+
+    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 = YUBIKEY.lock().unwrap();
+    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 = YUBIKEY.lock().unwrap();
+    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 = YUBIKEY.lock().unwrap();
+    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 yubikey = YUBIKEY.lock().unwrap();
+
+    assert!(yubikey.verify_pin(b"123456").is_ok());
+    assert!(MgmKey::get_protected(&mut yubikey).is_err());
+    assert!(yubikey.authenticate(MgmKey::default()).is_ok());
+
+    // Set a protected management key.
+    assert!(MgmKey::generate().set_protected(&mut yubikey).is_ok());
+    let protected = MgmKey::get_protected(&mut yubikey).unwrap();
+    assert!(yubikey.authenticate(MgmKey::default()).is_err());
+    assert!(yubikey.authenticate(protected.clone()).is_ok());
+
+    // Set a manual management key.
+    let manual = MgmKey::generate();
+    assert!(manual.set_manual(&mut yubikey, false).is_ok());
+    assert!(MgmKey::get_protected(&mut yubikey).is_err());
+    assert!(yubikey.authenticate(MgmKey::default()).is_err());
+    assert!(yubikey.authenticate(protected.clone()).is_err());
+    assert!(yubikey.authenticate(manual.clone()).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(MgmKey::default()).is_ok());
+}
+
+//
+// Certificate support
+//
+
+fn generate_self_signed_cert(algorithm: AlgorithmId) -> Certificate {
+    let mut yubikey = YUBIKEY.lock().unwrap();
+
+    assert!(yubikey.verify_pin(b"123456").is_ok());
+    assert!(yubikey.authenticate(MgmKey::default()).is_ok());
+
+    let slot = SlotId::Retired(RetiredSlotId::R1);
+
+    // Generate a new key in the selected slot.
+    let generated = piv::generate(
+        &mut yubikey,
+        slot,
+        algorithm,
+        PinPolicy::Default,
+        TouchPolicy::Default,
+    )
+    .unwrap();
+
+    let mut serial = [0u8; 20];
+    OsRng.fill_bytes(&mut serial);
+
+    // Generate a self-signed certificate for the new key.
+    let extensions: &[x509::Extension<'_, &[u64]>] = &[];
+    let cert_result = Certificate::generate_self_signed(
+        &mut yubikey,
+        slot,
+        serial,
+        None,
+        &[RelativeDistinguishedName::common_name("testSubject")],
+        generated,
+        extensions,
+    );
+
+    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(AlgorithmId::Rsa1024);
+
+    //
+    // Verify that the certificate is signed correctly
+    //
+
+    let pubkey = match cert.subject_pki() {
+        PublicKeyInfo::Rsa { pubkey, .. } => pubkey,
+        _ => unreachable!(),
+    };
+
+    let data = cert.as_ref();
+    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 = &data[data.len() - 128..];
+
+    let hash = Sha256::digest(msg);
+
+    assert!(pubkey
+        .verify(
+            PaddingScheme::PKCS1v15Sign {
+                hash: Some(SHA2_256)
+            },
+            &hash,
+            sig
+        )
+        .is_ok());
+}
+
+#[test]
+#[ignore]
+fn generate_self_signed_ec_cert() {
+    let cert = generate_self_signed_cert(AlgorithmId::EccP256);
+
+    //
+    // Verify that the certificate is signed correctly
+    //
+
+    let pubkey = match cert.subject_pki() {
+        PublicKeyInfo::EcP256(pubkey) => pubkey,
+        _ => unreachable!(),
+    };
+
+    let data = cert.as_ref();
+    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();
+    let vk = p256::ecdsa::VerifyingKey::from_sec1_bytes(pubkey.as_bytes()).unwrap();
+
+    use p256::ecdsa::signature::Verifier;
+    assert!(vk.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");
+}
@@ -1,101 +0,0 @@
- /*
- * 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.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <check.h>
-
-#include "ykpiv.h"
-
-struct key {
-	const char text[49];
-	const unsigned char formatted[24];
-	int valid;
-} keys[] = {
-	{"010203040506070801020304050607080102030405060708",
-		{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08},
-		1},
-	{"a1a2a3a4a5a6a7a8a1a2a3a4a5a6a7a8a1a2a3a4a5a6a7a8",
-		{0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8},
-		1},
-	{"A1A2A3A4A5A6A7A8A1A2A3A4A5A6A7A8A1A2A3A4A5A6A7A8",
-		{0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8},
-		1},
-	{"This is not something considered valid hex......",
-		{},
-		0},
-};
-
-static int parse_key(const char *text, const unsigned char *expected, int valid) {
-	unsigned char key[24];
-	size_t len = sizeof(key);
-	ykpiv_rc res = ykpiv_hex_decode(text, strlen(text), key, &len);
-  if (valid) {
-    ck_assert(res == YKPIV_OK);
-    ck_assert(memcmp(expected, key, 24) == 0);
-  } else {
-    ck_assert(res != YKPIV_OK);
-  }
-	return EXIT_SUCCESS;
-}
-
-START_TEST(test_parse_key) {
-  int res = parse_key(keys[_i].text, keys[_i].formatted, keys[_i].valid);
-  ck_assert(res == EXIT_SUCCESS);
-}
-END_TEST
-
-Suite *parsekey_suite(void) {
-  Suite *s;
-  TCase *tc;
-
-  s = suite_create("libykpiv parsekey");
-  tc = tcase_create("parsekey");
-  tcase_add_loop_test(tc, test_parse_key, 0, sizeof(keys) / sizeof(struct key));
-  suite_add_tcase(s, tc);
-
-  return s;
-}
-
-int main(void)
-{
-  int number_failed;
-  Suite *s;
-  SRunner *sr;
-
-  s = parsekey_suite();
-  sr = srunner_create(s);
-  srunner_run_all(sr, CK_NORMAL);
-  number_failed = srunner_ntests_failed(sr);
-  srunner_free(sr);
-  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}