yubikey v0.8.0 (#518 )

Make RsaKeyData::new fallible (#517 )
Replaces unwraps with `Error::AlgorithmError`
2023-08-15 19:29:22 -06:00 · 2023-08-15 18:33:30 -06:00 · 2023-08-15 18:21:45 -06:00 · 2023-08-15 18:02:25 -06:00 · 2023-08-15 16:39:29 -06:00 · 2023-08-15 16:31:13 -06:00
33 changed files with 1994 additions and 1776 deletions
@@ -1,5 +1,5 @@
 [advisories]
 ignore = [
-    "RUSTSEC-2020-0071", # time
-    "RUSTSEC-2020-0159", # chrono
-] 
+    "RUSTSEC-2020-0071", # chrono
+    "RUSTSEC-2021-0145", # atty
+] # advisory IDs to ignore e.g. ["RUSTSEC-2019-0001", ...]
@@ -36,13 +36,13 @@ jobs:
            toolchain: stable
            deps: true
          - platform: ubuntu-latest
-            toolchain: 1.57.0 # MSRV
+            toolchain: 1.65.0 # MSRV
            deps: sudo apt-get install libpcsclite-dev
          - platform: windows-latest
-            toolchain: 1.57.0 # MSRV
+            toolchain: 1.65.0 # MSRV
            deps: true
          - platform: macos-latest
-            toolchain: 1.57.0 # MSRV
+            toolchain: 1.65.0 # MSRV
            deps: true
    runs-on: ${{ matrix.platform }}
    steps:
@@ -82,7 +82,7 @@ jobs:
      - uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: 1.57.0 # MSRV
+          toolchain: 1.71.0
          components: clippy
          override: true
      - run: sudo apt-get install libpcsclite-dev
@@ -42,4 +42,4 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: audit
-          args: --deny warnings --ignore RUSTSEC-2019-0031 # spin
+          args: --deny warnings
@@ -4,6 +4,75 @@ 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.8.0 (2023-08-15)
+### Added
+- `impl Debug for {Context, YubiKey}` ([#457])
+- `YubiKey::disconnect` ([#462])
+- `Error::AppletNotFound` ([#476])
+
+### Changed
+- `Reader::open` now returns `Error::AppletNotFound` instead of `Error::Generic`
+  if the PIV applet is not present on the device. This is returned by non-PIV
+  virtual smart cards like Windows Hello for Business, as well as some smart
+  card readers when no card is present.
+- `Reader::open` now avoids resetting the card if an error occurs (equivalent to
+  calling `YubiKey::disconnect(pcsc::Disposition::LeaveCard)` if `Reader::open`
+  succeeds).
+- Raise minimum `pcsc` version to 2.3.1 and remove workaround ([#478])
+- Bump asymmetric crypto dependencies; MSRV 1.65 ([#490])
+  - `elliptic-curve` v0.13
+  - `k256` v0.13
+  - `p256` v0.13
+  - `p384` v0.13
+  - `pbkdf2` v0.12
+  - `rsa` v0.9 ([#502])
+  - `signature` v2
+- Use `x509-cert` certificate builder ([#495])
+- Make `RsaKeyData::new` fallible ([#517])
+
+### Fixed
+- `StatusWords::code` now returns the correct code (including embedded `tries`
+  count) for `StatusWords::VerifyFailError`. Previously the returned code lost
+  information and was not round-trip compatible with `StatusWords::from(u16)`.
+- Parsing of serial numbers ([#466])
+- Make `YubiKey::open()` more robust ([#504])
+
+[#457]: https://github.com/iqlusioninc/yubikey.rs/pull/457
+[#462]: https://github.com/iqlusioninc/yubikey.rs/pull/462
+[#466]: https://github.com/iqlusioninc/yubikey.rs/pull/466
+[#476]: https://github.com/iqlusioninc/yubikey.rs/pull/476
+[#478]: https://github.com/iqlusioninc/yubikey.rs/pull/478
+[#490]: https://github.com/iqlusioninc/yubikey.rs/pull/490
+[#495]: https://github.com/iqlusioninc/yubikey.rs/pull/495
+[#502]: https://github.com/iqlusioninc/yubikey.rs/pull/502
+[#504]: https://github.com/iqlusioninc/yubikey.rs/pull/504
+[#517]: https://github.com/iqlusioninc/yubikey.rs/pull/517
+
+## 0.7.0 (2022-11-14)
+### Added
+- Display inner PC/SC errors ([#420])
+- Support for metadata command ([#371])
+- Better `certificate::Serial` inspection ([#437])
+
+### Changed
+- MSRV 1.60.0 ([#423])
+- Bump `rsa` to v0.7.1 ([#440])
+- Switch from `lazy_static` to `once_cell` ([#442])
+- Switch from `subtle-encoding` to `base16ct` ([#443])
+
+### Fixed
+- Use `chrono` v0.4.23 or newer ([#436])
+- `Certificate::issuer` was returning the subject instead ([#437])
+
+[#371]: https://github.com/iqlusioninc/yubikey.rs/pull/371
+[#420]: https://github.com/iqlusioninc/yubikey.rs/pull/420
+[#423]: https://github.com/iqlusioninc/yubikey.rs/pull/423
+[#436]: https://github.com/iqlusioninc/yubikey.rs/pull/436
+[#437]: https://github.com/iqlusioninc/yubikey.rs/pull/437
+[#440]: https://github.com/iqlusioninc/yubikey.rs/pull/440
+[#442]: https://github.com/iqlusioninc/yubikey.rs/pull/442
+[#443]: https://github.com/iqlusioninc/yubikey.rs/pull/443
+
 ## 0.6.0 (2022-08-10)
 ### Changed
 - 2021 edition upgrade ([#343])
@@ -1,6 +1,6 @@
 [package]
 name = "yubikey"
-version = "0.6.0"
+version = "0.8.0"
 description = """
 Pure Rust cross-platform host-side driver for YubiKey devices from Yubico with
 support for hardware-backed public-key decryption and digital signatures using
@@ -11,45 +11,48 @@ authors = ["Tony Arcieri <tony@iqlusion.io>", "Yubico AB"]
 license = "BSD-2-Clause"
 repository = "https://github.com/iqlusioninc/yubikey.rs"
 readme = "README.md"
-categories = ["api-bindings", "cryptography", "hardware-support"]
+categories = ["api-bindings", "authentication", "cryptography", "hardware-support"]
 keywords = ["ecdsa", "encryption", "rsa", "piv", "signature"]
 edition = "2021"
-rust-version = "1.57"
+rust-version = "1.65"

 [workspace]
 members = [".", "cli"]

+[workspace.dependencies]
+x509-cert = { version = "0.2.3", features = [ "builder", "hazmat" ] }
+
 [dependencies]
-chrono = "0.4"
-cookie-factory = "0.3"
-der-parser = "8"
+der = "0.7.1"
 des = "0.8"
-elliptic-curve = "0.12"
+elliptic-curve = "0.13"
+hex = { package = "base16ct", version = "0.2", features = ["alloc"] }
 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"
+ecdsa = { version = "0.16.7", features = ["digest", "pem"] }
+p256 = "0.13"
+p384 = "0.13"
+pbkdf2 = { version = "0.12", default-features = false, features = ["hmac"] }
+pcsc = "2.3.1"
 rand_core = { version = "0.6", features = ["std"] }
-rsa = "0.6"
+rsa = { version = "0.9.2", features = ["sha2"] }
 secrecy = "0.8"
-sha1 = "0.10"
-sha2 = "0.10"
+sha1 = { version = "0.10", features = ["oid"] }
+sha2 = { version = "0.10", features = ["oid"] }
+signature = "2"
 subtle = "2"
-subtle-encoding = "0.5"
-uuid = { version = "1.0", features = ["v4"] }
-x509 = "0.2"
-x509-parser = "0.14"
+uuid = { version = "1.2", features = ["v4"] }
+x509-cert.workspace = true
 zeroize = "1"

 [dev-dependencies]
-env_logger = "0.9"
-lazy_static = "1"
+env_logger = "0.10"
+once_cell = "1"
+signature = "2"

 [features]
 untested = []
@@ -4,16 +4,19 @@

 [![crate][crate-image]][crate-link]
 [![Docs][docs-image]][docs-link]
+[![Build Status][build-image]][build-link]
+[![Safety Dance][safety-image]][safety-link]
+[![Dependency Status][deps-image]][deps-link]
 [![2-Clause BSD Licensed][license-image]][license-link]
 ![MSRV][msrv-image]
-[![Safety Dance][safety-image]][safety-link]
-[![Build Status][build-image]][build-link]
-[![dependency status][deps-image]][deps-link]

 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.

+Uses the Personal Computer/Smart Card ([PC/SC]) interface with cross-platform
+access provided by the [`pcsc` crate].
+
 [Documentation][docs-link]

 ## About
@@ -34,9 +37,36 @@ Note that while this project started as a fork of a [Yubico] project,
 this fork is **NOT** an official Yubico project and is in no way supported or
 endorsed by Yubico.

+## Features
+
+### Personal Identity Verification (PIV)
+
+[PIV] is a [NIST] standard for both *signing* and *encryption*
+using SmartCards and SmartCard-based hardware tokens like YubiKeys.
+
+PIV-related functionality can be found in the [`piv`] module.
+
+This library natively implements the protocol used to manage and
+utilize PIV encryption and signing keys which can be generated, imported,
+and stored on YubiKey devices.
+
+See [Yubico's guide to PIV-enabled YubiKeys][yk-guide] for more information
+on which devices support PIV and the available functionality.
+
+### Supported Algorithms
+- **Authentication**: `3DES`
+- **Encryption**:
+  - RSA: `RSA1024`, `RSA2048`
+  - 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)
+
+NOTE: RSASSA-PSS signatures and RSA-OAEP encryption may be supportable (TBD)
+
 ## Minimum Supported Rust Version

-Rust **1.57** or newer.
+Rust **1.60** or newer.

 ## Supported YubiKeys

@@ -59,6 +89,17 @@ an experimental stage and may still contain high-severity issues.

 USE AT YOUR OWN RISK!

+## Status
+
+Functionality which has been successfully tested is available by default.
+
+Any functionality which is gated on the `untested` feature has not been
+properly tested and is not known to function correctly.
+
+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.
+
 ## Testing

 To run the full test suite, you'll need a connected YubiKey NEO/4/5 device in
@@ -68,7 +109,7 @@ Tests which run live against a YubiKey device are marked as `#[ignore]` by
 default in order to pass when running in a CI environment. To run these
 tests locally, invoke the following command:

-```
+```shell
 cargo test -- --ignored
 ```

@@ -77,14 +118,14 @@ information about what is happening. If you'd like to print this logging
 information while running the tests, set the `RUST_LOG` environment variable
 to a relevant loglevel (e.g. `error`, `warn`, `info`, `debug`, `trace`):

-```
+```shell
 RUST_LOG=info cargo test -- --ignored
 ```

 To trace every message sent to/from the card i.e. the raw
 Application Protocol Data Unit (APDU) messages, use the `trace` log level:

-```
+```text
 running 1 test
 [INFO  yubikey::yubikey] trying to connect to reader 'Yubico YubiKey OTP+FIDO+CCID'
 [INFO  yubikey::yubikey] connected to 'Yubico YubiKey OTP+FIDO+CCID' successfully
@@ -110,6 +151,14 @@ Yubico, which was originally written in C. It was mechanically translated
 from C into Rust using [Corrode], and then subsequently heavily
 refactored into safer, more idiomatic Rust.

+For more information on [yubico-piv-tool] and background information on how
+the YubiKey implementation of PIV works in general, see the
+[Yubico PIV Tool Command Line Guide][piv-tool-guide].
+
+## ⚠️ Security Warning
+
+No security audits of this crate have ever been performed.
+
 ## Code of Conduct

 We abide by the [Contributor Covenant][cc-md] and ask that you do as well.
@@ -123,7 +172,7 @@ 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-2022 Yubico AB, Tony Arcieri
+Copyright (c) 2014-2023 Yubico AB, Tony Arcieri
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -159,13 +208,13 @@ or conditions.

 [//]: # (badges)

-[crate-image]: https://img.shields.io/crates/v/yubikey.svg
+[crate-image]:  https://buildstats.info/crate/yubikey
 [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
 [license-link]: https://github.com/iqlusioninc/yubikey.rs/blob/main/COPYING
-[msrv-image]: https://img.shields.io/badge/rustc-1.57+-blue.svg
+[msrv-image]: https://img.shields.io/badge/rustc-1.65+-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
@@ -176,9 +225,12 @@ or conditions.
 [//]: # (general links)

 [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/
+[PIV]: https://piv.idmanagement.gov/
+[NIST]: https://www.nist.gov/
+[PC/SC]: https://en.wikipedia.org/wiki/PC/SC
+[`pcsc` crate]: https://github.com/bluetech/pcsc-rust
+[yk-guide]: https://developers.yubico.com/PIV/Introduction/YubiKey_and_PIV.html
 [YubiKey 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/
@@ -187,6 +239,7 @@ or conditions.
 [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
+[`untested` functionality tracking issue]: https://github.com/iqlusioninc/yubikey.rs/issues/280

 [//]: # (github issues)

@@ -4,6 +4,20 @@ 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.7.0 (2022-11-14)
+### Changed
+- Bump `clap` to v4.0 ([#438])
+- Bump `x509-parser` to v0.14 ([#441])
+- Switch from `lazy_static` to `once_cell` ([#442])
+- Switch from `subtle-encoding` to `base16ct` ([#443])
+- Bump `yubikey` dependency to v0.7 ([#444])
+
+[#438]: https://github.com/iqlusioninc/yubikey.rs/pull/438
+[#441]: https://github.com/iqlusioninc/yubikey.rs/pull/441
+[#442]: https://github.com/iqlusioninc/yubikey.rs/pull/442
+[#443]: https://github.com/iqlusioninc/yubikey.rs/pull/443
+[#444]: https://github.com/iqlusioninc/yubikey.rs/pull/444
+
 ## 0.6.0 (2022-08-10)
 ### Changed
 - 2021 edition upgrade; MSRV 1.57 ([#343])
@@ -1,6 +1,6 @@
 [package]
 name = "yubikey-cli"
-version = "0.6.0"
+version = "0.8.0-pre"
 description = """
 Command-line interface for performing encryption and signing using RSA/ECC keys
 stored on YubiKey devices.
@@ -15,12 +15,12 @@ edition = "2021"
 rust-version = "1.56"

 [dependencies]
-clap = { version = "3", features = ["derive"] }
-env_logger = "0.9"
-lazy_static = "1"
+clap = { version = "4", features = ["derive"] }
+env_logger = "0.10"
+hex = { package = "base16ct", version = "0.2", features = ["alloc"] }
 log = "0.4"
-sha2 = "0.9"
-subtle-encoding = "0.5"
+once_cell = "1"
+sha2 = "0.10"
 termcolor = "1"
-x509-parser = "0.12"
-yubikey = { version = "0.6", path = ".." }
+x509-cert.workspace = true
+yubikey = { version = "0.8", path = ".." }
@@ -18,7 +18,7 @@ utility with general-purpose public-key encryption and signing support.

 ## Minimum Supported Rust Version

-Rust **1.57** or newer.
+Rust **1.60** or newer.

 ## Supported YubiKeys

@@ -43,7 +43,7 @@ For more information, please see [CODE_OF_CONDUCT.md][cc-md].

 ## License

-Copyright (c) 2014-2022 Yubico AB, Tony Arcieri
+Copyright (c) 2014-2023 Yubico AB, Tony Arcieri
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -84,7 +84,7 @@ or conditions.
 [docs-image]: https://docs.rs/yubikey-cli/badge.svg
 [docs-link]: https://docs.rs/yubikey-cli/
 [license-image]: https://img.shields.io/badge/license-BSD-blue.svg
-[rustc-image]: https://img.shields.io/badge/rustc-1.57+-blue.svg
+[rustc-image]: https://img.shields.io/badge/rustc-1.60+-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/
@@ -1,16 +1,15 @@
 //! Status messages

-use lazy_static::lazy_static;
 use log::debug;
+use once_cell::sync::Lazy;
 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 x509_cert::der::Encode;
 use yubikey::{certificate::Certificate, piv::*, YubiKey};

 /// Print a success status message (in green if colors are enabled)
@@ -59,16 +58,14 @@ macro_rules! status_err {
    };
 }

-lazy_static! {
 /// Color configuration
-    static ref COLOR_CHOICE: Mutex<Option<ColorChoice>> = Mutex::new(None);
+static COLOR_CHOICE: Lazy<Mutex<Option<ColorChoice>>> = Lazy::new(|| Mutex::new(None));

 /// Standard output
-    pub static ref STDOUT: StandardStream = StandardStream::stdout(get_color_choice());
+pub static STDOUT: Lazy<StandardStream> = Lazy::new(|| StandardStream::stdout(get_color_choice()));

 /// Standard error
-    pub static ref STDERR: StandardStream = StandardStream::stderr(get_color_choice());
-}
+pub static STDERR: Lazy<StandardStream> = Lazy::new(|| StandardStream::stderr(get_color_choice()));

 /// Obtain the color configuration.
 ///
@@ -140,14 +137,12 @@ impl Status {

    /// Print the given message to stdout
    pub fn print_stdout(self, msg: impl AsRef<str>) {
-        self.print(&*STDOUT, msg)
-            .expect("error printing to stdout!")
+        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!")
+        self.print(&STDERR, msg).expect("error printing to stderr!")
    }

    /// Print the given message
@@ -185,44 +180,30 @@ pub fn print_cert_info(
            return Ok(());
        }
    };
-    let buf = cert.into_buffer();
+    let cert = &cert.cert;

-    if !buf.is_empty() {
-        let fingerprint = Sha256::digest(&buf);
+    let fingerprint = Sha256::digest(cert.to_der().unwrap());
    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,
+        cert.tbs_certificate.subject_public_key_info.algorithm.oid,
    )?;

-                print_cert_attr(stream, "Subject", cert.tbs_certificate.subject)?;
-                print_cert_attr(stream, "Issuer", cert.tbs_certificate.issuer)?;
+    print_cert_attr(stream, "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(),
+        &hex::upper::encode_string(&fingerprint),
    )?;
    print_cert_attr(
        stream,
        "Not Before",
-                    cert.tbs_certificate.validity.not_before.to_rfc2822(),
+        cert.tbs_certificate.validity.not_before,
    )?;
-                print_cert_attr(
-                    stream,
-                    "Not After",
-                    cert.tbs_certificate.validity.not_after.to_rfc2822(),
-                )?;
-            }
-            _ => {
-                println!("Failed to parse certificate");
-                return Ok(());
-            }
-        };
-    }
+    print_cert_attr(stream, "Not After", cert.tbs_certificate.validity.not_after)?;

    Ok(())
 }
@@ -195,6 +195,9 @@ pub enum Ins {
    /// Get device serial
    GetSerial,

+    /// Get slot metadata
+    GetMetadata,
+
    /// Other/unrecognized instruction codes
    Other(u8),
 }
@@ -219,6 +222,7 @@ impl Ins {
            Ins::SetPinRetries => 0xfa,
            Ins::Attest => 0xf9,
            Ins::GetSerial => 0xf8,
+            Ins::GetMetadata => 0xf7,
            Ins::Other(code) => code,
        }
    }
@@ -243,6 +247,7 @@ impl From<u8> for Ins {
            0xfa => Ins::SetPinRetries,
            0xf9 => Ins::Attest,
            0xf8 => Ins::GetSerial,
+            0xf7 => Ins::GetMetadata,
            code => Ins::Other(code),
        }
    }
@@ -348,6 +353,12 @@ pub(crate) enum StatusWords {
    /// Successful execution
    Success,

+    /// The requested data was too large for the response, and there is data remaining.
+    BytesRemaining {
+        /// The number of bytes remaining, as indicated in the response.
+        len: u8,
+    },
+
    /// https://github.com/Yubico/yubikey-manager/blob/1f22620b623c6b345dd9f9193ec765a542dddc80/ykman/driver_ccid.py#L53
    NoInputDataError,

@@ -405,8 +416,9 @@ impl StatusWords {
    pub fn code(self) -> u16 {
        match self {
            StatusWords::None => 0,
+            StatusWords::BytesRemaining { len } => 0x6100 | len as u16,
            StatusWords::NoInputDataError => 0x6285,
-            StatusWords::VerifyFailError { tries } => 0x63c0 & tries as u16,
+            StatusWords::VerifyFailError { tries } => 0x63c0 | tries as u16,
            StatusWords::WrongLengthError => 0x6700,
            StatusWords::SecurityStatusError => 0x6982,
            StatusWords::AuthBlockedError => 0x6983,
@@ -434,6 +446,9 @@ impl From<u16> for StatusWords {
    fn from(sw: u16) -> Self {
        match sw {
            0x0000 => StatusWords::None,
+            sw if sw & 0xff00 == 0x6100 => Self::BytesRemaining {
+                len: (sw & 0x00ff) as u8,
+            },
            0x6285 => StatusWords::NoInputDataError,
            sw if sw & 0xfff0 == 0x63c0 => StatusWords::VerifyFailError {
                tries: (sw & 0x000f) as u8,
@@ -461,3 +476,40 @@ impl From<StatusWords> for u16 {
        sw.code()
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::StatusWords;
+
+    #[test]
+    fn status_words_round_trip() {
+        let round_trip = |sw: StatusWords| {
+            assert_eq!(StatusWords::from(sw.code()), sw);
+        };
+
+        round_trip(StatusWords::None);
+        round_trip(StatusWords::BytesRemaining { len: 1 });
+        round_trip(StatusWords::BytesRemaining { len: 10 });
+        round_trip(StatusWords::BytesRemaining { len: 0xFF });
+        round_trip(StatusWords::Success);
+        round_trip(StatusWords::NoInputDataError);
+        round_trip(StatusWords::VerifyFailError { tries: 0x0F });
+        round_trip(StatusWords::VerifyFailError { tries: 3 });
+        round_trip(StatusWords::VerifyFailError { tries: 2 });
+        round_trip(StatusWords::VerifyFailError { tries: 1 });
+        round_trip(StatusWords::VerifyFailError { tries: 0 });
+        round_trip(StatusWords::WrongLengthError);
+        round_trip(StatusWords::SecurityStatusError);
+        round_trip(StatusWords::AuthBlockedError);
+        round_trip(StatusWords::DataInvalidError);
+        round_trip(StatusWords::ConditionsNotSatisfiedError);
+        round_trip(StatusWords::CommandNotAllowedError);
+        round_trip(StatusWords::IncorrectParamError);
+        round_trip(StatusWords::NotFoundError);
+        round_trip(StatusWords::NoSpaceError);
+        round_trip(StatusWords::IncorrectSlotError);
+        round_trip(StatusWords::NotSupportedError);
+        round_trip(StatusWords::CommandAbortedError);
+        round_trip(StatusWords::Other(0x1337));
+    }
+}
@@ -30,13 +30,9 @@
 // (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 crate::{Result, YubiKey};
 use rand_core::{OsRng, RngCore};
-use std::{
-    fmt::{self, Debug, Display},
-    str,
-};
-use subtle_encoding::hex;
+use std::fmt::{self, Debug, Display};

 /// CCCID offset
 const CCC_ID_OFFS: usize = 9;
@@ -52,6 +48,7 @@ const OBJ_CAPABILITY: u32 = 0x005f_c107;
 ///  - 0xff == Manufacturer ID (dummy)
 ///  - 0x02 == Card type (javaCard)
 ///  - next 14 bytes: card ID
+#[allow(dead_code)]
 const CCC_TMPL: &[u8] = &[
    0xf0, 0x15, 0xa0, 0x00, 0x00, 0x01, 0x16, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x01, 0x21, 0xf2, 0x01, 0x21, 0xf3, 0x00, 0xf4,
@@ -94,17 +91,11 @@ impl CccId {
    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()))
+        Ok(response[..Self::BYTE_SIZE].try_into().map(Self)?)
    }

    /// 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);
@@ -114,8 +105,14 @@ impl CccId {
    }
 }

+impl AsRef<[u8]> for CccId {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
 impl Display for CccId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(str::from_utf8(&hex::encode(&self.0[..])).unwrap())
+        f.write_str(&hex::upper::encode_string(self.as_ref()))
    }
 }
@@ -33,71 +33,29 @@
 use crate::{
    consts::CB_OBJ_MAX,
    error::{Error, Result},
-    piv::{sign_data, AlgorithmId, SlotId},
+    piv::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 x509_cert::{
+    builder::{Builder, CertificateBuilder, Profile},
+    der::{self, referenced::OwnedToRef, Decode, Encode},
+    name::Name,
+    serial_number::SerialNumber,
+    spki::{SubjectPublicKeyInfoOwned, SubjectPublicKeyInfoRef},
+    time::Validity,
+};
 use zeroize::Zeroizing;

-// TODO: Make these der_parser::oid::Oid constants when it has const fn support.
-const 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)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum CertInfo {
    /// The certificate is uncompressed.
    Uncompressed,
@@ -127,210 +85,11 @@ impl From<CertInfo> for u8 {
    }
 }

-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())
-    }
+    /// Inner certificate
+    pub cert: x509_cert::Certificate,
 }

 impl Certificate {
@@ -339,112 +98,35 @@ impl Certificate {
    ///
    /// `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>(
+    /// use the workaround `let extensions: &[x509_cert::Extension<'_, &[u64]>] = &[];`.
+    pub fn generate_self_signed<F, KT: yubikey_signer::KeyType>(
        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: SerialNumber,
+        validity: Validity,
+        subject: Name,
+        subject_pki: SubjectPublicKeyInfoOwned,
+        extensions: F,
+    ) -> Result<Self>
+    where
+        F: FnOnce(&mut CertificateBuilder<'_, yubikey_signer::Signer<'_, KT>>) -> der::Result<()>,
+    {
+        let signer = yubikey_signer::Signer::new(yubikey, key, subject_pki.owned_to_ref())?;
+        let mut builder = CertificateBuilder::new(
+            Profile::Manual { issuer: None },
            serial,
-            issuer,
+            validity,
            subject,
            subject_pki,
-            data,
-        };
+            &signer,
+        )
+        .map_err(|_| Error::KeyError)?;

+        // Add custom extensions
+        extensions(&mut builder)?;
+
+        let cert = builder.build().map_err(|_| Error::KeyError)?;
+        let cert = Self { cert };
        cert.write(yubikey, key, CertInfo::Uncompressed)?;

        Ok(cert)
@@ -459,18 +141,18 @@ impl Certificate {
            return Err(Error::InvalidObject);
        }

-        Certificate::from_bytes(buf)
+        Self::from_bytes(buf)
    }

    /// Write this certificate into the YubiKey in the given slot
    pub fn write(&self, yubikey: &mut YubiKey, slot: SlotId, certinfo: CertInfo) -> Result<()> {
        let txn = yubikey.begin_transaction()?;
-        write_certificate(&txn, slot, Some(&self.data), certinfo)
+        let data = self.cert.to_der().map_err(|_| Error::InvalidObject)?;
+        write_certificate(&txn, slot, Some(&data), certinfo)
    }

    /// Delete a certificate located at the given slot of the given YubiKey
    #[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)
@@ -485,55 +167,27 @@ impl Certificate {
            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
+        x509_cert::Certificate::from_der(&cert)
+            .map(|cert| Self { cert })
+            .map_err(|_| Error::InvalidObject)
    }

    /// Returns the Issuer field of the certificate.
-    pub fn issuer(&self) -> &str {
-        &self.subject
+    pub fn issuer(&self) -> String {
+        self.cert.tbs_certificate.issuer.to_string()
    }

    /// Returns the SubjectName field of the certificate.
-    pub fn subject(&self) -> &str {
-        &self.subject
+    pub fn subject(&self) -> String {
+        self.cert.tbs_certificate.subject.to_string()
    }

    /// 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()
+    pub fn subject_pki(&self) -> SubjectPublicKeyInfoRef<'_> {
+        self.cert
+            .tbs_certificate
+            .subject_public_key_info
+            .owned_to_ref()
    }
 }

@@ -569,12 +223,7 @@ pub(crate) fn write_certificate(
 ) -> Result<()> {
    let object_id = slot.object_id();

-    if data.is_none() {
-        return txn.save_object(object_id, &[]);
-    }
-
-    let data = data.unwrap();
-
+    if let Some(data) = data {
        let mut buf = [0u8; CB_OBJ_MAX];
        let mut offset = Tlv::write(&mut buf, TAG_CERT, data)?;

@@ -583,99 +232,228 @@ pub(crate) fn write_certificate(
        offset += Tlv::write(&mut buf[offset..], TAG_CERT_LRC, &[])?;

        txn.save_object(object_id, &buf[..offset])
+    } else {
+        txn.save_object(object_id, &[])
+    }
 }

-mod read_pki {
-    use der_parser::{
-        asn1_rs::Any,
-        ber::BerObjectContent,
-        der::{parse_der_integer, parse_der_sequence_defined_g, DerObject},
-        error::BerError,
+pub mod yubikey_signer {
+    //! Signer implementation for yubikey
+
+    use crate::{
+        error::{Error, Result},
+        piv::AlgorithmId,
+        piv::{sign_data, SlotId},
+        YubiKey,
    };
-    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"),
+    use der::{
+        asn1::{Any, OctetString},
+        oid::db::rfc5912,
+        Encode, Sequence,
    };
-                let e = match public_exponent.content {
-                    BerObjectContent::Integer(s) => BigUint::from_bytes_be(s),
-                    _ => panic!("expected DER integer"),
+    use sha2::{Digest, Sha256, Sha384};
+    use signature::Keypair;
+    use std::{cell::RefCell, fmt, io::Write, marker::PhantomData};
+    use x509_cert::spki::{
+        self, AlgorithmIdentifierOwned, DynSignatureAlgorithmIdentifier, EncodePublicKey,
+        SignatureBitStringEncoding, SubjectPublicKeyInfoRef,
    };

-                (n, e)
-            })(i)
+    type SigResult<T> = core::result::Result<T, signature::Error>;
+
+    /// Key to be used to sign certificates
+    pub trait KeyType {
+        /// Error returned when working with signature
+        type Error: Into<signature::Error> + fmt::Debug;
+        /// The signature type returned by the signer
+        type Signature: SignatureBitStringEncoding
+            + for<'s> TryFrom<&'s [u8], Error = Self::Error>
+            + fmt::Debug;
+        /// The public key used to verify signature
+        type VerifyingKey: EncodePublicKey
+            + DynSignatureAlgorithmIdentifier
+            + Clone
+            + From<Self::PublicKey>;
+        /// Public key type used to load the SPKI formatted key
+        type PublicKey: for<'a> TryFrom<SubjectPublicKeyInfoRef<'a>, Error = spki::Error>;
+
+        /// The algorithm used when talking with the yubikey
+        const ALGORITHM: AlgorithmId;
+
+        /// Prepare buffer before submitting it for signature
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>>;
+        /// Read back the signature from the device
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature>;
    }

-        let (n, e) = match rsa_pubkey_parts(encoded) {
-            Ok((_, res)) => res,
-            _ => return Err(Error::InvalidObject),
+    impl KeyType for p256::NistP256 {
+        const ALGORITHM: AlgorithmId = AlgorithmId::EccP256;
+        type Error = ecdsa::Error;
+        type Signature = p256::ecdsa::DerSignature;
+        type VerifyingKey = p256::ecdsa::VerifyingKey;
+        type PublicKey = p256::ecdsa::VerifyingKey;
+
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>> {
+            Ok(Sha256::digest(input).to_vec())
+        }
+
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature> {
+            Self::Signature::from_bytes(input)
+        }
+    }
+
+    impl KeyType for p384::NistP384 {
+        const ALGORITHM: AlgorithmId = AlgorithmId::EccP384;
+        type Error = ecdsa::Error;
+        type Signature = p384::ecdsa::DerSignature;
+        type VerifyingKey = p384::ecdsa::VerifyingKey;
+        type PublicKey = p384::ecdsa::VerifyingKey;
+
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>> {
+            Ok(Sha384::digest(input).to_vec())
+        }
+
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature> {
+            Self::Signature::from_bytes(input)
+        }
+    }
+
+    /// Trait used to handle subtypes of RSA keys
+    pub trait RsaLength {
+        /// The length of the RSA key in bits
+        const BIT_LENGTH: usize;
+        /// The algorithm to use when talking with the Yubikey.
+        const ALGORITHM: AlgorithmId;
+    }
+
+    /// RSA 1024 bits key
+    pub struct Rsa1024;
+
+    impl RsaLength for Rsa1024 {
+        const BIT_LENGTH: usize = 1024;
+        const ALGORITHM: AlgorithmId = AlgorithmId::Rsa1024;
+    }
+
+    /// RSA 2048 bits key
+    pub struct Rsa2048;
+
+    impl RsaLength for Rsa2048 {
+        const BIT_LENGTH: usize = 2048;
+        const ALGORITHM: AlgorithmId = AlgorithmId::Rsa2048;
+    }
+
+    /// RSA keys used to sign certificates
+    pub struct YubiRsa<N: RsaLength> {
+        _len: PhantomData<N>,
+    }
+
+    impl<N: RsaLength> KeyType for YubiRsa<N> {
+        type Error = signature::Error;
+        type Signature = rsa::pkcs1v15::Signature;
+        type VerifyingKey = rsa::pkcs1v15::VerifyingKey<Sha256>;
+        type PublicKey = rsa::RsaPublicKey;
+        const ALGORITHM: AlgorithmId = N::ALGORITHM;
+
+        fn prepare(input: &[u8]) -> SigResult<Vec<u8>> {
+            let hashed = Sha256::digest(input).to_vec();
+
+            OctetString::new(hashed)
+                .map_err(|e| e.into())
+                .and_then(Self::emsa_pkcs1_1_5)
+                .map_err(signature::Error::from_source)
+        }
+
+        fn read_signature(input: &[u8]) -> SigResult<Self::Signature> {
+            Self::Signature::try_from(input)
+        }
+    }
+
+    impl<N: RsaLength> YubiRsa<N> {
+        /// https://www.rfc-editor.org/rfc/rfc8017#section-9.2
+        fn emsa_pkcs1_1_5(digest: OctetString) -> Result<Vec<u8>> {
+            /// https://www.rfc-editor.org/rfc/rfc8017#appendix-A.2.4
+            #[derive(Debug, Sequence)]
+            struct DigestInfo {
+                digest_algorithm: AlgorithmIdentifierOwned,
+                digest: OctetString,
+            }
+
+            let em_len = N::BIT_LENGTH / 8;
+
+            let null = Any::null();
+
+            let t = DigestInfo {
+                digest_algorithm: AlgorithmIdentifierOwned {
+                    oid: rfc5912::ID_SHA_256,
+                    parameters: Some(null),
+                },
+                digest,
            };
+            let t = t.to_der()?;

-        RsaPublicKey::new(n, e).map_err(|_| Error::InvalidObject)
-    }
+            let ps = vec![0xff; em_len - t.len() - 3];
+            assert!(ps.len() >= 8, "spec violation");

-    /// 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),
-        }
+            let mut out = Vec::with_capacity(em_len);
+            out.write(&[0x00, 0x01]).map_err(|_| Error::MemoryError)?;
+            out.write(&ps).map_err(|_| Error::MemoryError)?;
+            out.write(&[0x00]).map_err(|_| Error::MemoryError)?;
+            out.write(&t).map_err(|_| Error::MemoryError)?;
+            Ok(out)
        }
    }

-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)
+    /// The entrypoint to sign data with the yubikey.
+    pub struct Signer<'y, KT: KeyType> {
+        yubikey: RefCell<&'y mut YubiKey>,
+        key: SlotId,
+        public_key: KT::VerifyingKey,
    }

-    /// 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()),
-        ))
+    impl<'y, KT: KeyType> Signer<'y, KT> {
+        /// Create new Signer
+        pub fn new(
+            yubikey: &'y mut YubiKey,
+            key: SlotId,
+            subject_pki: SubjectPublicKeyInfoRef<'_>,
+        ) -> Result<Self> {
+            let public_key = KT::PublicKey::try_from(subject_pki).map_err(|_| Error::ParseError)?;
+            let public_key = public_key.into();
+
+            Ok(Self {
+                yubikey: RefCell::new(yubikey),
+                key,
+                public_key,
+            })
+        }
+    }
+
+    impl<'y, KT: KeyType> Keypair for Signer<'y, KT> {
+        type VerifyingKey = KT::VerifyingKey;
+        fn verifying_key(&self) -> <Self as Keypair>::VerifyingKey {
+            self.public_key.clone()
+        }
+    }
+
+    impl<'y, KT: KeyType> DynSignatureAlgorithmIdentifier for Signer<'y, KT> {
+        fn signature_algorithm_identifier(&self) -> spki::Result<AlgorithmIdentifierOwned> {
+            self.verifying_key().signature_algorithm_identifier()
+        }
+    }
+
+    impl<'y, KT: KeyType> signature::Signer<KT::Signature> for Signer<'y, KT> {
+        fn try_sign(&self, msg: &[u8]) -> SigResult<KT::Signature> {
+            let data = KT::prepare(msg)?;
+
+            let out = sign_data(
+                &mut self.yubikey.borrow_mut(),
+                &data,
+                KT::ALGORITHM,
+                self.key,
+            )
+            .map_err(signature::Error::from_source)?;
+            let out = KT::read_signature(&out)?;
+            Ok(out)
+        }
    }
 }
@@ -30,12 +30,8 @@
 // (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 crate::{Result, YubiKey};
+use std::fmt::{self, Debug, Display};
 use uuid::Uuid;

 /// FASC-N offset
@@ -65,6 +61,7 @@ const OBJ_CHUID: u32 = 0x005f_c102;
 /// - 0x35: Exp. Date (hard-coded)
 /// - 0x3e: Signature (hard-coded, empty)
 /// - 0xfe: Error Detection Code (hard-coded)
+#[allow(dead_code)]
 const CHUID_TMPL: &[u8] = &[
    0x30, 0x19, 0xd4, 0xe7, 0x39, 0xda, 0x73, 0x9c, 0xed, 0x39, 0xce, 0x73, 0x9d, 0x83, 0x68, 0x58,
    0x21, 0x08, 0x42, 0x10, 0x84, 0x21, 0xc8, 0x42, 0x10, 0xc3, 0xeb, 0x34, 0x10, 0x00, 0x00, 0x00,
@@ -90,12 +87,13 @@ impl ChuId {
    pub fn fascn(&self) -> [u8; Self::FASCN_SIZE] {
        self.0[CHUID_FASCN_OFFS..(CHUID_FASCN_OFFS + Self::FASCN_SIZE)]
            .try_into()
-            .unwrap()
+            .expect("should be FASCN_SIZE")
    }

    /// 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()
+        Uuid::from_slice(&self.0[CHUID_GUID_OFFS..(CHUID_GUID_OFFS + 16)])
+            .expect("should be UUID-sized")
    }

    /// Return expiration date component of CHUID
@@ -103,24 +101,18 @@ impl ChuId {
    pub fn expiration(&self) -> [u8; Self::EXPIRATION_SIZE] {
        self.0[CHUID_EXPIRATION_OFFS..(CHUID_EXPIRATION_OFFS + Self::EXPIRATION_SIZE)]
            .try_into()
-            .unwrap()
+            .expect("should be EXPIRATION_SIZE")
    }

    /// 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()))
+        Ok(response[..Self::BYTE_SIZE].try_into().map(Self)?)
    }

    /// 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);
@@ -130,8 +122,14 @@ impl ChuId {
    }
 }

+impl AsRef<[u8]> for ChuId {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
 impl Display for ChuId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(str::from_utf8(&hex::encode(&self.0[..])).unwrap())
+        f.write_str(&hex::upper::encode_string(self.as_ref()))
    }
 }
@@ -111,7 +111,7 @@ impl Config {
                    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());
+                    let pin_last_changed = u32::from_le_bytes([item[0], item[1], item[2], item[3]]);

                    if pin_last_changed != 0 {
                        config.pin_last_changed =
@@ -45,6 +45,12 @@ pub enum Error {
    /// Applet error
    AppletError,

+    /// We tried to select an applet that could not be found.
+    AppletNotFound {
+        /// Human-readable name of the applet.
+        applet_name: &'static str,
+    },
+
    /// Argument error
    ArgumentError,

@@ -121,31 +127,52 @@ impl Error {
    }

    /// Error message
-    pub fn msg(self) -> &'static str {
+    pub fn msg(self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            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",
+            Error::AlgorithmError => f.write_str("algorithm error"),
+            Error::AppletError => f.write_str("applet error"),
+            Error::AppletNotFound { applet_name } => {
+                f.write_str(&format!("{} applet not found", applet_name))
+            }
+            Error::ArgumentError => f.write_str("argument error"),
+            Error::AuthenticationError => f.write_str("authentication error"),
+            Error::GenericError => f.write_str("generic error"),
+            Error::InvalidObject => f.write_str("invalid object"),
+            Error::KeyError => f.write_str("key error"),
+            Error::MemoryError => f.write_str("memory error"),
+            Error::NotSupported => f.write_str("not supported"),
+            Error::NotFound => f.write_str("not found"),
+            Error::ParseError => f.write_str("parse error"),
+
+            Error::PcscError {
+                inner: Some(pcsc_error),
+            } => f.write_fmt(format_args!("PC/SC error: {}", pcsc_error)),
+
+            Error::PcscError { .. } => f.write_str("PC/SC error"),
+
+            Error::PinLocked => f.write_str("PIN locked"),
+            Error::RangeError => f.write_str("range error"),
+            Error::SizeError => f.write_str("size error"),
+            Error::WrongPin { .. } => f.write_str("wrong pin"),
        }
    }
 }

 impl Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.msg())
+        self.msg(f)
+    }
+}
+
+impl From<std::array::TryFromSliceError> for Error {
+    fn from(_: std::array::TryFromSliceError) -> Error {
+        Error::SizeError
+    }
+}
+
+impl From<std::time::SystemTimeError> for Error {
+    fn from(_: std::time::SystemTimeError) -> Error {
+        Error::GenericError
    }
 }

@@ -164,3 +191,9 @@ impl std::error::Error for Error {
        }
    }
 }
+
+impl From<x509_cert::der::Error> for Error {
+    fn from(_err: x509_cert::der::Error) -> Error {
+        Error::ParseError
+    }
+}
@@ -1,102 +1,17 @@
-//! **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].
-//!
-//! # Features
-//! ## Personal Identity Verification (PIV)
-//! [PIV] is a [NIST] standard for both *signing* and *encryption*
-//! using SmartCards and SmartCard-based hardware tokens like YubiKeys.
-//!
-//! PIV-related functionality can be found in the [`piv`] module.
-//!
-//! This library natively implements the protocol used to manage and
-//! utilize PIV encryption and signing keys which can be generated, imported,
-//! and stored on YubiKey devices.
-//!
-//! See [Yubico's guide to PIV-enabled YubiKeys][yk-guide] for more information
-//! on which devices support PIV and the available functionality.
-//!
-//! # 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**:
-//!   - 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)
-//!
-//! NOTE: RSASSA-PSS signatures and RSA-OAEP encryption may be supportable (TBD)
-//!
-//! # Status
-//! Functionality which has been successfully tested is available by default.
-//!
-//! Any functionality which is gated on the `untested` feature has not been
-//! properly tested and is not known to function correctly.
-//!
-//! 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], and then subsequently heavily
-//! refactored into safer, more idiomatic Rust.
-//!
-//! For more information on [yubico-piv-tool] and background information on how
-//! the YubiKey implementation of PIV works in general, see the
-//! [Yubico PIV Tool Command Line Guide][piv-tool-guide].
-//!
-//! # Security Warning
-//! No security audits of this crate have ever been performed. Presently it is in
-//! an experimental stage and may still contain high-severity issues.
-//!
-//! USE AT YOUR OWN RISK!
-//!
-//! # Code of Conduct
-//! We abide by the [Contributor Covenant][cc-md] and ask that you do as well.
-//!
-//! For more information, please see [CODE_OF_CONDUCT.md][cc-md].
-//!
-//! # License
-//! **yubikey.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
+#![doc = include_str!("../README.md")]
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/iqlusioninc/yubikey.rs/main/img/logo-sq.png"
+)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![forbid(unsafe_code)]
+#![warn(
+    clippy::mod_module_files,
+    clippy::unwrap_used,
+    missing_docs,
+    rust_2018_idioms,
+    unused_lifetimes,
+    unused_qualifications
+)]

 // Adapted from yubico-piv-tool:
 // <https://github.com/Yubico/yubico-piv-tool/>
@@ -128,13 +43,6 @@
 // (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/iqlusioninc/yubikey.rs/main/img/logo.png"
-)]
-#![forbid(unsafe_code)]
-#![warn(missing_docs, rust_2018_idioms, trivial_casts, unused_qualifications)]
-
 mod apdu;
 mod cccid;
 pub mod certificate;
@@ -148,6 +56,7 @@ mod mgm;
 mod mscmap;
 #[cfg(feature = "untested")]
 mod msroots;
+mod otp;
 pub mod piv;
 mod policy;
 pub mod reader;
@@ -71,7 +71,7 @@ impl<T: MetadataType> Default for Metadata<T> {
    fn default() -> Self {
        Metadata {
            inner: Zeroizing::new(vec![]),
-            _marker: PhantomData::default(),
+            _marker: PhantomData,
        }
    }
 }
@@ -82,13 +82,12 @@ impl<T: MetadataType> Metadata<T> {
        let data = txn.fetch_object(T::obj_id())?;
        Ok(Metadata {
            inner: Tlv::parse_single(data, T::tag())?,
-            _marker: PhantomData::default(),
+            _marker: PhantomData,
        })
    }

    /// 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);
@@ -106,7 +105,6 @@ impl<T: MetadataType> Metadata<T> {

    /// 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(), &[])
    }
@@ -130,7 +128,6 @@ impl<T: MetadataType> Metadata<T> {

    /// 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;
@@ -46,7 +46,17 @@ use des::{
    TdesEde3,
 };
 #[cfg(feature = "untested")]
-use {hmac::Hmac, pbkdf2::pbkdf2, sha1::Sha1};
+use {pbkdf2::pbkdf2_hmac, sha1::Sha1};
+
+/// YubiKey MGMT Applet Name
+#[cfg(feature = "untested")]
+pub(crate) const APPLET_NAME: &str = "YubiKey MGMT";
+
+/// MGMT Applet ID.
+///
+/// <https://developers.yubico.com/PIV/Introduction/Admin_access.html>
+#[cfg(feature = "untested")]
+pub(crate) const APPLET_ID: &[u8] = &[0xa0, 0x00, 0x00, 0x05, 0x27, 0x47, 0x11, 0x17];

 pub(crate) const ADMIN_FLAGS_1_PROTECTED_MGM: u8 = 0x02;

@@ -118,7 +128,6 @@ impl MgmKey {

    /// 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()?;

@@ -137,13 +146,12 @@ impl MgmKey {
        }

        let mut mgm = [0u8; DES_LEN_3DES];
-        pbkdf2::<Hmac<Sha1>>(pin, salt, ITER_MGM_PBKDF2, &mut mgm);
+        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()?;

@@ -174,7 +182,6 @@ impl MgmKey {
    ///
    /// 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)
    }
@@ -186,7 +193,6 @@ impl MgmKey {
    ///
    /// 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()?;

@@ -246,7 +252,6 @@ impl MgmKey {
    ///
    /// 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()?;

@@ -404,7 +409,7 @@ fn is_weak_key(key: &[u8; DES_LEN_3DES]) -> bool {
        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 });
+        tmp[i] = (key[i] & 0xFE) | u8::from(c & 0x01 != 0x01);
    }

    // check odd parity key against table by DES key block
@@ -41,7 +41,6 @@ const TAG_MSCMAP: u8 = 0x81;
 ///
 /// 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.
@@ -141,7 +140,7 @@ impl MsContainer {
        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());
+            name[i] = u16::from_le_bytes([chunk[0], chunk[1]]);
        }

        let mut cert_fingerprint = [0u8; 20];
@@ -151,11 +150,10 @@ impl MsContainer {
            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(),
-            ),
+            key_size_bits: u16::from_le_bytes([
+                bytes[name_bytes_len + 2],
+                bytes[name_bytes_len + 3],
+            ]),
            flags: bytes[name_bytes_len + 4],
            pin_id: bytes[name_bytes_len + 5],
            associated_echd_container: bytes[name_bytes_len + 6],
@@ -184,7 +182,10 @@ impl MsContainer {
        bytes.push(self.pin_id);
        bytes.push(self.associated_echd_container);
        bytes.extend_from_slice(&self.cert_fingerprint);
-        bytes.as_slice().try_into().unwrap()
+        bytes
+            .as_slice()
+            .try_into()
+            .expect("should be REC_LEN-sized")
    }
 }

@@ -57,7 +57,6 @@ const TAG_MSROOTS_MID: u8 = 0x83;
 ///
 /// 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 {
@@ -0,0 +1,5 @@
+/// YubiKey OTP Applet Name
+pub(crate) const APPLET_NAME: &str = "YubiKey OTP";
+
+/// YubiKey OTP Applet ID. Needed to query serial on YK4.
+pub(crate) const APPLET_ID: &[u8] = &[0xa0, 0x00, 0x00, 0x05, 0x27, 0x20, 0x01, 0x01];
@@ -44,7 +44,8 @@

 use crate::{
    apdu::{Ins, StatusWords},
-    certificate::{self, Certificate, PublicKeyInfo},
+    certificate::{self, Certificate},
+    consts::CB_OBJ_MAX,
    error::{Error, Result},
    policy::{PinPolicy, TouchPolicy},
    serialization::*,
@@ -52,19 +53,19 @@ use crate::{
    yubikey::YubiKey,
    Buffer, ObjectId,
 };
-use elliptic_curve::sec1::EncodedPoint as EcPublicKey;
+use elliptic_curve::{sec1::EncodedPoint as EcPublicKey, PublicKey};
 use log::{debug, error, warn};
 use p256::NistP256;
 use p384::NistP384;
-use rsa::{BigUint, RsaPublicKey};
+use rsa::{pkcs8::EncodePublicKey, BigUint, RsaPublicKey};
 use std::{
    fmt::{Display, Formatter},
    str::FromStr,
 };
+use x509_cert::{der::Decode, spki::SubjectPublicKeyInfoOwned};

 #[cfg(feature = "untested")]
 use {
-    crate::consts::CB_OBJ_MAX,
    num_bigint_dig::traits::ModInverse,
    num_integer::Integer,
    num_traits::{FromPrimitive, One},
@@ -73,6 +74,12 @@ use {
 #[cfg(feature = "untested")]
 use zeroize::Zeroizing;

+/// PIV Applet Name
+pub(crate) const APPLET_NAME: &str = "PIV";
+
+/// PIV Applet ID
+pub(crate) const APPLET_ID: &[u8] = &[0xa0, 0x00, 0x00, 0x03, 0x08];
+
 const CB_ECC_POINTP256: usize = 65;
 const CB_ECC_POINTP384: usize = 97;

@@ -126,6 +133,9 @@ pub enum SlotId {
    /// attestation of other keys generated on device with instruction `f9`. This slot is
    /// not cleared on reset, but can be overwritten.
    Attestation,
+
+    /// Thse slots are used for management. PIN PUK and Management Key.
+    Management(ManagementSlotId),
 }

 impl TryFrom<u8> for SlotId {
@@ -138,7 +148,9 @@ impl TryFrom<u8> for SlotId {
            0x9d => Ok(SlotId::KeyManagement),
            0x9e => Ok(SlotId::CardAuthentication),
            0xf9 => Ok(SlotId::Attestation),
-            _ => RetiredSlotId::try_from(value).map(SlotId::Retired),
+            _ => RetiredSlotId::try_from(value)
+                .map(SlotId::Retired)
+                .or_else(|_| ManagementSlotId::try_from(value).map(SlotId::Management)),
        }
    }
 }
@@ -152,6 +164,7 @@ impl From<SlotId> for u8 {
            SlotId::CardAuthentication => 0x9e,
            SlotId::Retired(retired) => retired.into(),
            SlotId::Attestation => 0xf9,
+            SlotId::Management(mgmt) => mgmt.into(),
        }
    }
 }
@@ -159,6 +172,7 @@ impl From<SlotId> for u8 {
 impl Display for SlotId {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
+            SlotId::Management(r) => write!(f, "{:?}", r),
            SlotId::Retired(r) => write!(f, "{:?}", r),
            _ => write!(f, "{:?}", self),
        }
@@ -175,7 +189,10 @@ impl FromStr for SlotId {
            "9d" => Ok(SlotId::KeyManagement),
            "9e" => Ok(SlotId::CardAuthentication),
            "f9" => Ok(SlotId::Attestation),
-            _ => s.parse().map(SlotId::Retired),
+            _ => s
+                .parse()
+                .map(SlotId::Management)
+                .or_else(|_| s.parse().map(SlotId::Retired)),
        }
    }
 }
@@ -189,6 +206,7 @@ impl SlotId {
            SlotId::KeyManagement => 0x005f_c10b,
            SlotId::CardAuthentication => 0x005f_c101,
            SlotId::Retired(retired) => retired.object_id(),
+            SlotId::Management(mgmt) => mgmt.object_id(),
            SlotId::Attestation => 0x005f_ff01,
        }
    }
@@ -341,11 +359,94 @@ impl RetiredSlotId {
    }
 }

+/// Management slot IDs.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Ord, PartialOrd)]
+pub enum ManagementSlotId {
+    /// Personal Identification Number (PIN).
+    Pin,
+
+    /// PIN Unblocking Key (PUK).
+    Puk,
+
+    /// Management Key.
+    Management,
+}
+
+impl TryFrom<u8> for ManagementSlotId {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            0x80 => Ok(ManagementSlotId::Pin),
+            0x81 => Ok(ManagementSlotId::Puk),
+            0x9b => Ok(ManagementSlotId::Management),
+            _ => Err(Error::InvalidObject),
+        }
+    }
+}
+
+impl FromStr for ManagementSlotId {
+    type Err = Error;
+
+    fn from_str(value: &str) -> Result<Self> {
+        match value {
+            "80" => Ok(ManagementSlotId::Pin),
+            "81" => Ok(ManagementSlotId::Puk),
+            "9b" => Ok(ManagementSlotId::Management),
+            _ => Err(Error::InvalidObject),
+        }
+    }
+}
+
+impl From<ManagementSlotId> for u8 {
+    fn from(slot: ManagementSlotId) -> u8 {
+        match slot {
+            ManagementSlotId::Pin => 0x80,
+            ManagementSlotId::Puk => 0x81,
+            ManagementSlotId::Management => 0x9b,
+        }
+    }
+}
+
+impl Display for ManagementSlotId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl ManagementSlotId {
+    /// Returns the [`ObjectId`] that corresponds to a given [`ManagementSlotId`].
+    ///
+    /// These correspond to the "BER-TLV Tag" values from Table 3 of [NIST SP 800-73-4]:
+    /// "Object Identifiers of the PIV Data Objects for Interoperable Use".
+    ///
+    /// [NIST SP 800-73-4]: https://csrc.nist.gov/publications/detail/sp/800-73/4/final
+    pub(crate) fn object_id(self) -> ObjectId {
+        match self {
+            // Data Object: "X.509 Certificate for Key Management"
+            // OID: 2.16.840.1.101.3.7.2.1.2
+            // BER-TLV Tag: '5FC10B'
+            ManagementSlotId::Pin => 0x005f_c10b,
+
+            // Data Object: "Key History Object"
+            // OID: 2.16.840.1.101.3.7.2.96.96
+            // BER-TLV Tag: '5FC10C'
+            ManagementSlotId::Puk => 0x005f_c10c,
+
+            // Data Object: "Retired X.509 Certificate for Key Management 3"
+            // OID: 2.16.840.1.101.3.7.2.16.3
+            // BER-TLV Tag: '5FC10F'
+            ManagementSlotId::Management => 0x005f_c10f,
+        }
+    }
+}
+
 /// Personal Identity Verification (PIV) key slots
-pub const SLOTS: [SlotId; 24] = [
+pub const SLOTS: [SlotId; 28] = [
    SlotId::Authentication,
    SlotId::Signature,
    SlotId::KeyManagement,
+    SlotId::Attestation,
    SlotId::Retired(RetiredSlotId::R1),
    SlotId::Retired(RetiredSlotId::R2),
    SlotId::Retired(RetiredSlotId::R3),
@@ -367,6 +468,9 @@ pub const SLOTS: [SlotId; 24] = [
    SlotId::Retired(RetiredSlotId::R19),
    SlotId::Retired(RetiredSlotId::R20),
    SlotId::CardAuthentication,
+    SlotId::Management(ManagementSlotId::Pin),
+    SlotId::Management(ManagementSlotId::Puk),
+    SlotId::Management(ManagementSlotId::Management),
 ];

 /// Algorithm identifiers
@@ -417,7 +521,6 @@ impl AlgorithmId {
    }

    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    fn get_elem_len(self) -> usize {
        match self {
            AlgorithmId::Rsa1024 => 64,
@@ -428,7 +531,6 @@ impl AlgorithmId {
    }

    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    fn get_param_tag(self) -> u8 {
        match self {
            AlgorithmId::Rsa1024 | AlgorithmId::Rsa2048 => 0x01,
@@ -489,7 +591,7 @@ pub fn generate(
    algorithm: AlgorithmId,
    pin_policy: PinPolicy,
    touch_policy: TouchPolicy,
-) -> Result<PublicKeyInfo> {
+) -> Result<SubjectPublicKeyInfoOwned> {
    // Keygen messages
    // TODO(tarcieri): extract these into an I18N-handling type?
    const SZ_SETTING_ROCA: &str = "Enable_Unsafe_Keygen_ROCA";
@@ -594,105 +696,11 @@ pub fn generate(
        }
    }

-    // 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)
-        }
-    }
+    let value = response.data();
+    read_public_key(algorithm, value, true)
 }

 #[cfg(feature = "untested")]
-#[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
 fn write_key(
    yubikey: &mut YubiKey,
    slot: SlotId,
@@ -741,7 +749,6 @@ fn write_key(

 /// 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,
@@ -757,10 +764,12 @@ pub struct RsaKeyData {

 #[cfg(feature = "untested")]
 impl RsaKeyData {
-    /// Generates a new RSA key data set from two randomly generated, secret, primes.
+    /// 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 {
+    /// # Returns
+    /// - `Ok(key_data)` if `secret_p` and `secret_q` are valid primes.
+    /// - `Err(Error::AlgorithmError)` if `secret_p`/`secret_q` are invalid primes.
+    pub fn new(secret_p: &[u8], secret_q: &[u8]) -> Result<Self> {
        let p = BigUint::from_bytes_be(secret_p);
        let q = BigUint::from_bytes_be(secret_q);

@@ -771,10 +780,10 @@ impl RsaKeyData {
            p_t.lcm(&q_t)
        };

-        let exp = BigUint::from_u64(KEYDATA_RSA_EXP).unwrap();
+        let exp = BigUint::from_u64(KEYDATA_RSA_EXP).ok_or(Error::AlgorithmError)?;

-        let d = exp.mod_inverse(&totient).unwrap();
-        let d = d.to_biguint().unwrap();
+        let d = exp.mod_inverse(&totient).ok_or(Error::AlgorithmError)?;
+        let d = d.to_biguint().ok_or(Error::AlgorithmError)?;

        // We calculate the optimization values ahead of time, instead of making the user
        // do so.
@@ -782,16 +791,16 @@ impl RsaKeyData {
        let dp = &d % (&p - BigUint::one());
        let dq = &d % (&q - BigUint::one());

-        let qinv = q.clone().mod_inverse(&p).unwrap();
+        let qinv = q.clone().mod_inverse(&p).ok_or(Error::AlgorithmError)?;
        let (_, qinv) = qinv.to_bytes_be();

-        RsaKeyData {
+        Ok(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 {
@@ -803,7 +812,6 @@ impl RsaKeyData {
 ///
 /// 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,
@@ -838,7 +846,6 @@ pub fn import_rsa_key(
 ///
 /// 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,
@@ -867,7 +874,6 @@ pub fn import_ecc_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()?;
@@ -903,7 +909,6 @@ pub fn sign_data(

 /// 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],
@@ -915,3 +920,328 @@ pub fn decrypt_data(
    // don't attempt to reselect in crypt operations to avoid problems with PIN_ALWAYS
    txn.authenticated_command(input, algorithm, key, true)
 }
+
+/// Read metadata
+pub fn metadata(yubikey: &mut YubiKey, slot: SlotId) -> Result<SlotMetadata> {
+    let txn = yubikey.begin_transaction()?;
+    let templ = [0, Ins::GetMetadata.code(), 0, slot.into()];
+
+    let response = txn.transfer_data(&templ, &[], CB_OBJ_MAX)?;
+
+    if !response.is_success() {
+        if response.status_words() == StatusWords::NotSupportedError {
+            return Err(Error::NotSupported); // Requires firmware 5.2.3
+        } else {
+            return Err(Error::GenericError);
+        }
+    }
+
+    let buf = Buffer::new(response.data().into());
+
+    SlotMetadata::try_from(buf)
+}
+
+/// Metadata from a slot
+#[derive(Debug)]
+pub struct SlotMetadata {
+    /// Algorithm / Type of key
+    pub algorithm: ManagementAlgorithmId,
+    /// PIN and touch policy
+    pub policy: Option<(PinPolicy, TouchPolicy)>,
+    /// Imported or generated key
+    pub origin: Option<Origin>,
+    /// Pub key of the key
+    pub public: Option<SubjectPublicKeyInfoOwned>,
+    /// Whether PIN PUK and management key are default
+    pub default: Option<bool>,
+    /// Number of retries left
+    pub retries: Option<Retries>,
+}
+
+impl TryFrom<Buffer> for SlotMetadata {
+    type Error = Error;
+
+    fn try_from(buf: Buffer) -> Result<Self> {
+        use nom::{
+            combinator::{eof, map_res},
+            multi::fold_many1,
+            number::complete::u8,
+        };
+
+        let out = fold_many1(
+            |input| Tlv::parse(input).map_err(|_| nom::Err::Error(())),
+            || {
+                Ok(SlotMetadata {
+                    algorithm: ManagementAlgorithmId::PinPuk,
+                    policy: None,
+                    origin: None,
+                    public: None,
+                    default: None,
+                    retries: None,
+                })
+            },
+            |acc: Result<SlotMetadata>, tlv| match acc {
+                Ok(mut metadata) => match tlv.tag {
+                    1 => {
+                        metadata.algorithm = ManagementAlgorithmId::try_from(tlv.value[0])?;
+                        Ok(metadata)
+                    }
+                    2 => {
+                        fn policy_parser(
+                            i: &[u8],
+                        ) -> nom::IResult<&[u8], (PinPolicy, TouchPolicy)> {
+                            let (i, pin) = map_res(u8, PinPolicy::try_from)(i)?;
+                            let (i, touch) = map_res(u8, TouchPolicy::try_from)(i)?;
+                            let (i, _) = eof(i)?;
+
+                            Ok((i, (pin, touch)))
+                        }
+
+                        metadata.policy =
+                            Some(policy_parser(tlv.value).map_err(|_| Error::ParseError)?.1);
+                        Ok(metadata)
+                    }
+                    3 => {
+                        fn origin_parser(i: &[u8]) -> nom::IResult<&[u8], Origin> {
+                            let (i, origin) = map_res(u8, Origin::try_from)(i)?;
+                            let (i, _) = eof(i)?;
+
+                            Ok((i, origin))
+                        }
+
+                        metadata.origin =
+                            Some(origin_parser(tlv.value).map_err(|_| Error::ParseError)?.1);
+                        Ok(metadata)
+                    }
+                    4 => {
+                        match metadata.algorithm {
+                            ManagementAlgorithmId::Asymmetric(alg) => {
+                                metadata.public = Some(read_public_key(alg, tlv.value, false)?);
+                            }
+                            _ => Err(Error::ParseError)?,
+                        }
+                        Ok(metadata)
+                    }
+                    5 => {
+                        fn default_parser(i: &[u8]) -> nom::IResult<&[u8], bool> {
+                            let (i, default) = u8(i)?;
+                            let (i, _) = eof(i)?;
+
+                            Ok((i, default == 1))
+                        }
+
+                        metadata.default =
+                            Some(default_parser(tlv.value).map_err(|_| Error::ParseError)?.1);
+                        Ok(metadata)
+                    }
+
+                    6 => {
+                        fn retries_parser(i: &[u8]) -> nom::IResult<&[u8], Retries> {
+                            let (i, retry_count) = u8(i)?;
+                            let (i, remaining_count) = u8(i)?;
+                            let (i, _) = eof(i)?;
+
+                            Ok((
+                                i,
+                                Retries {
+                                    retry_count,
+                                    remaining_count,
+                                },
+                            ))
+                        }
+
+                        metadata.retries =
+                            Some(retries_parser(tlv.value).map_err(|_| Error::ParseError)?.1);
+                        Ok(metadata)
+                    }
+
+                    _unsupported => {
+                        // New unsupported tags
+                        // https://docs.yubico.com/yesdk/users-manual/application-piv/apdu/metadata.html
+                        Ok(metadata)
+                    }
+                },
+                err => err,
+            },
+        )(buf.as_ref());
+
+        match out {
+            Ok((_, res)) => res,
+            _ => Err(Error::ParseError),
+        }
+    }
+}
+
+/// The number of retries used and remaining.
+#[derive(Debug, PartialEq, Eq)]
+pub struct Retries {
+    /// TODO
+    pub retry_count: u8,
+    /// Remaining attempts
+    pub remaining_count: u8,
+}
+
+/// Origin of a slot
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum Origin {
+    /// The key has been imported
+    Imported,
+    /// The key has been generated on the YubiKey
+    Generated,
+}
+
+impl TryFrom<u8> for Origin {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            1 => Ok(Origin::Generated),
+            2 => Ok(Origin::Imported),
+            _ => Err(Error::GenericError),
+        }
+    }
+}
+
+fn read_public_key(
+    algorithm: AlgorithmId,
+    input: &[u8],
+    skip_asn1_tag: bool,
+) -> Result<SubjectPublicKeyInfoOwned> {
+    // 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 = if skip_asn1_tag { &input[5..] } else { input };
+
+            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();
+
+            let pubkey = RsaPublicKey::new(
+                BigUint::from_bytes_be(&modulus),
+                BigUint::from_bytes_be(&exp),
+            )
+            .map_err(|_| Error::InvalidObject)?;
+            Ok(SubjectPublicKeyInfoOwned::from_der(
+                pubkey
+                    .to_public_key_der()
+                    .map_err(|_| Error::ParseError)?
+                    .as_bytes(),
+            )?)
+        }
+        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 = if skip_asn1_tag { &input[3..] } else { input };
+
+            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();
+
+            let pubkey = match algorithm {
+                AlgorithmId::EccP256 => PublicKey::<NistP256>::try_from(
+                    EcPublicKey::<NistP256>::from_bytes(point).map_err(|_| Error::InvalidObject)?,
+                )
+                .map_err(|_| Error::InvalidObject)?
+                .to_public_key_der(),
+                AlgorithmId::EccP384 => PublicKey::<NistP384>::try_from(
+                    EcPublicKey::<NistP384>::from_bytes(point).map_err(|_| Error::InvalidObject)?,
+                )
+                .map_err(|_| Error::InvalidObject)?
+                .to_public_key_der(),
+                _ => return Err(Error::AlgorithmError),
+            }
+            .map_err(|_| Error::InvalidObject)?;
+
+            Ok(SubjectPublicKeyInfoOwned::from_der(pubkey.as_bytes())?)
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+/// Algorithms as reported by the metadata command.
+pub enum ManagementAlgorithmId {
+    /// Used on PIN and PUK slots.
+    PinPuk,
+    /// Used on the key management slot.
+    ThreeDes,
+    /// Used on all other slots.
+    Asymmetric(AlgorithmId),
+}
+
+impl TryFrom<u8> for ManagementAlgorithmId {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            0xff => Ok(ManagementAlgorithmId::PinPuk),
+            0x03 => Ok(ManagementAlgorithmId::ThreeDes),
+            oth => AlgorithmId::try_from(oth).map(ManagementAlgorithmId::Asymmetric),
+        }
+    }
+}
+
+impl From<ManagementAlgorithmId> for u8 {
+    fn from(id: ManagementAlgorithmId) -> u8 {
+        match id {
+            ManagementAlgorithmId::PinPuk => 0xff,
+            ManagementAlgorithmId::ThreeDes => 0x03,
+            ManagementAlgorithmId::Asymmetric(oth) => oth.into(),
+        }
+    }
+}
@@ -1,12 +1,12 @@
 //! Enums representing key policies.

-use crate::{serialization::Tlv, Result};
+use crate::{serialization::Tlv, Error, Result};

 /// Specifies how often the PIN needs to be entered for access to the credential in a
 /// given slot.
 ///
 /// This policy must be set when keys are generated or imported, and cannot be changed later.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum PinPolicy {
    /// Use the default PIN policy for the slot. See the slot's documentation for details.
    Default,
@@ -35,6 +35,20 @@ impl From<PinPolicy> for u8 {
    }
 }

+impl TryFrom<u8> for PinPolicy {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            0 => Ok(PinPolicy::Default),
+            1 => Ok(PinPolicy::Never),
+            2 => Ok(PinPolicy::Once),
+            3 => Ok(PinPolicy::Always),
+            _ => Err(Error::GenericError),
+        }
+    }
+}
+
 impl PinPolicy {
    /// Writes the `PinPolicy` in the format the YubiKey expects during key generation or
    /// importation.
@@ -50,7 +64,7 @@ impl PinPolicy {
 /// 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)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum TouchPolicy {
    /// Use the default touch policy for the slot.
    Default,
@@ -90,3 +104,17 @@ impl TouchPolicy {
        }
    }
 }
+
+impl TryFrom<u8> for TouchPolicy {
+    type Error = Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            0 => Ok(TouchPolicy::Default),
+            1 => Ok(TouchPolicy::Never),
+            2 => Ok(TouchPolicy::Always),
+            3 => Ok(TouchPolicy::Cached),
+            _ => Err(Error::GenericError),
+        }
+    }
+}
@@ -1,9 +1,10 @@
 //! Support for enumerating available PC/SC card readers.

-use crate::{Result, YubiKey};
+use crate::{Error, Result, YubiKey};
 use std::{
    borrow::Cow,
    ffi::CStr,
+    fmt,
    sync::{Arc, Mutex},
 };

@@ -19,6 +20,12 @@ pub struct Context {
    reader_names: Vec<u8>,
 }

+impl fmt::Debug for Context {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Context").finish_non_exhaustive()
+    }
+}
+
 impl Context {
    /// Open a PC/SC context, which can be used to enumerate available PC/SC
    /// readers (which can be used to connect to YubiKeys).
@@ -36,7 +43,8 @@ impl Context {
        let Self { ctx, reader_names } = self;

        let reader_cstrs: Vec<_> = {
-            let c = ctx.lock().unwrap();
+            // TODO(tarcieri): better error?
+            let c = ctx.lock().map_err(|_| Error::GenericError)?;

            // ensure PC/SC context is valid
            c.is_valid()?;
@@ -83,7 +91,8 @@ impl<'ctx> Reader<'ctx> {

    /// Connect to this reader, returning its `pcsc::Card`.
    pub(crate) fn connect(&self) -> Result<pcsc::Card> {
-        let ctx = self.ctx.lock().unwrap();
+        // TODO(tarcieri): better error?
+        let ctx = self.ctx.lock().map_err(|_| Error::GenericError)?;
        Ok(ctx.connect(self.name, pcsc::ShareMode::Shared, pcsc::Protocols::T1)?)
    }
 }
@@ -5,7 +5,8 @@ use crate::{
    apdu::{Apdu, Ins, StatusWords},
    consts::{CB_BUF_MAX, CB_OBJ_MAX},
    error::{Error, Result},
-    piv::{AlgorithmId, SlotId},
+    otp,
+    piv::{self, AlgorithmId, SlotId},
    serialization::*,
    yubikey::*,
    Buffer, ObjectId,
@@ -16,12 +17,6 @@ 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")]
@@ -69,7 +64,7 @@ impl<'tx> Transaction<'tx> {
    pub fn select_application(&self) -> Result<()> {
        let response = Apdu::new(Ins::SelectApplication)
            .p1(0x04)
-            .data(&PIV_AID)
+            .data(piv::APPLET_ID)
            .transmit(self, 0xFF)
            .map_err(|e| {
                error!("failed communicating with card: '{}'", e);
@@ -81,7 +76,12 @@ impl<'tx> Transaction<'tx> {
                "failed selecting application: {:04x}",
                response.status_words().code()
            );
-            return Err(Error::GenericError);
+            return Err(match response.status_words() {
+                StatusWords::NotFoundError => Error::AppletNotFound {
+                    applet_name: piv::APPLET_NAME,
+                },
+                _ => Error::GenericError,
+            });
        }

        Ok(())
@@ -96,34 +96,37 @@ impl<'tx> Transaction<'tx> {
            return Err(Error::GenericError);
        }

-        if response.data().len() < 3 {
-            return Err(Error::SizeError);
-        }
-
-        Ok(Version::new(response.data()[..3].try_into().unwrap()))
+        Ok(response.data()[..3].try_into().map(Version::new)?)
    }

    /// 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
+        match version.major {
+            // YK4 requires switching to the YK applet to retrieve the serial
+            4 => {
                let sw = Apdu::new(Ins::SelectApplication)
                    .p1(0x04)
-                .data(&YK_AID)
+                    .data(otp::APPLET_ID)
                    .transmit(self, 0xFF)?
                    .status_words();

                if !sw.is_success() {
                    error!("failed selecting yk application: {:04x}", sw.code());
-                return Err(Error::GenericError);
+                    return Err(match sw {
+                        StatusWords::NotFoundError => Error::AppletNotFound {
+                            applet_name: otp::APPLET_NAME,
+                        },
+                        _ => Error::GenericError,
+                    });
                }

-            let resp = Apdu::new(0x01).p1(0x10).transmit(self, 0xFF)?;
+                let response = Apdu::new(0x01).p1(0x10).transmit(self, 0xFF)?;

-            if !resp.is_success() {
+                if !response.is_success() {
+                    // TODO(tarcieri): still reselect the PIV applet in this case?
                    error!(
                        "failed retrieving serial number: {:04x}",
-                    resp.status_words().code()
+                        response.status_words().code()
                    );
                    return Err(Error::GenericError);
                }
@@ -131,35 +134,41 @@ impl<'tx> Transaction<'tx> {
                // reselect the PIV applet
                let sw = Apdu::new(Ins::SelectApplication)
                    .p1(0x04)
-                .data(&PIV_AID)
+                    .data(piv::APPLET_ID)
                    .transmit(self, 0xFF)?
                    .status_words();

                if !sw.is_success() {
                    error!("failed selecting application: {:04x}", sw.code());
-                return Err(Error::GenericError);
+                    return Err(match sw {
+                        StatusWords::NotFoundError => Error::AppletNotFound {
+                            applet_name: piv::APPLET_NAME,
+                        },
+                        _ => Error::GenericError,
+                    });
                }

-            resp
-        } else {
-            // YK5 implements getting the serial as a PIV applet command (0xf8)
-            let resp = Apdu::new(Ins::GetSerial).transmit(self, 0xFF)?;
+                response.data().try_into()
+            }

-            if !resp.is_success() {
+            // YK5 implements getting the serial as a PIV applet command (0xf8)
+            5 => {
+                let response = Apdu::new(Ins::GetSerial).transmit(self, 0xFF)?;
+
+                if !response.is_success() {
                    error!(
                        "failed retrieving serial number: {:04x}",
-                    resp.status_words().code()
+                        response.status_words().code()
                    );
                    return Err(Error::GenericError);
                }

-            resp
-        };
+                response.data().try_into()
+            }

-        response.data()[..4]
-            .try_into()
-            .map(|serial| Serial::from(u32::from_be_bytes(serial)))
-            .map_err(|_| Error::SizeError)
+            // Other versions unsupported
+            _ => Err(Error::NotSupported),
+        }
    }

    /// Verify device PIN.
@@ -246,7 +255,7 @@ impl<'tx> Transaction<'tx> {

        let status_words = Apdu::new(Ins::SetMgmKey)
            .params(0xff, p2)
-            .data(&data)
+            .data(data)
            .transmit(self, 261)?
            .status_words();

@@ -387,11 +396,12 @@ impl<'tx> Transaction<'tx> {
                .data(&in_data[in_offset..(in_offset + this_size)])
                .transmit(self, 261)?;

-            sw = response.status_words().code();
+            sw = response.status_words();

-            if !response.is_success() && (sw >> 8 != 0x61) {
+            match sw {
+                StatusWords::Success | StatusWords::BytesRemaining { .. } => (),
                // TODO(tarcieri): is this really OK?
-                return Ok(Response::new(sw.into(), out_data));
+                _ => return Ok(Response::new(sw, out_data)),
            }

            if !out_data.is_empty() && (out_data.len() - response.data().len() > max_out) {
@@ -412,17 +422,15 @@ impl<'tx> Transaction<'tx> {
            }
        }

-        while sw >> 8 == 0x61 {
-            trace!(
-                "The card indicates there is {} bytes more data for us",
-                sw & 0xff
-            );
+        while let StatusWords::BytesRemaining { len } = sw {
+            trace!("The card indicates there is {} bytes more data for us", len);

            let response = Apdu::new(Ins::GetResponseApdu).transmit(self, 261)?;
-            sw = response.status_words().code();
+            sw = response.status_words();

-            if sw != StatusWords::Success.code() && (sw >> 8 != 0x61) {
-                return Ok(Response::new(sw.into(), vec![]));
+            match sw {
+                StatusWords::Success | StatusWords::BytesRemaining { .. } => (),
+                _ => return Ok(Response::new(sw, vec![])),
            }

            if out_data.len() + response.data().len() > max_out {
@@ -438,7 +446,7 @@ impl<'tx> Transaction<'tx> {
            out_data.extend_from_slice(&response.data()[..response.data().len()]);
        }

-        Ok(Response::new(sw.into(), out_data))
+        Ok(Response::new(sw, out_data))
    }

    /// Fetch an object.
@@ -42,7 +42,7 @@ use crate::{
    transaction::Transaction,
 };
 use log::{error, info};
-use pcsc::Card;
+use pcsc::{Card, Disposition};
 use rand_core::{OsRng, RngCore};
 use std::{
    fmt::{self, Display},
@@ -55,6 +55,7 @@ use {
        apdu::StatusWords,
        consts::{TAG_ADMIN_FLAGS_1, TAG_ADMIN_TIMESTAMP},
        metadata::AdminData,
+        mgm,
        transaction::ChangeRefAction,
        Buffer, ObjectId,
    },
@@ -71,12 +72,6 @@ pub(crate) const ALGO_3DES: u8 = 0x03;
 /// Card management key
 pub(crate) const KEY_CARDMGM: u8 = 0x9b;

-/// MGMT Applet ID.
-///
-/// <https://developers.yubico.com/PIV/Introduction/Admin_access.html>
-#[cfg(feature = "untested")]
-const MGMT_AID: [u8; 8] = [0xa0, 0x00, 0x00, 0x05, 0x27, 0x47, 0x11, 0x17];
-
 const TAG_DYN_AUTH: u8 = 0x7c;

 /// Cached YubiKey PIN.
@@ -98,6 +93,20 @@ impl From<Serial> for u32 {
    }
 }

+impl TryFrom<&[u8]> for Serial {
+    type Error = Error;
+
+    fn try_from(bytes: &[u8]) -> Result<Self> {
+        if bytes.len() > 4 {
+            return Err(Error::SizeError);
+        }
+
+        let mut arr = [0u8; 4];
+        arr[(4 - bytes.len())..].copy_from_slice(bytes);
+        Ok(Self(u32::from_be_bytes(arr)))
+    }
+}
+
 impl FromStr for Serial {
    type Err = Error;

@@ -156,64 +165,101 @@ pub struct YubiKey {
    pub(crate) serial: Serial,
 }

+impl fmt::Debug for YubiKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("YubiKey")
+            .field("name", &self.name)
+            .field("version", &self.version)
+            .field("serial", &self.serial)
+            .finish_non_exhaustive()
+    }
+}
+
 impl YubiKey {
    /// Open a connection to a YubiKey.
    ///
-    /// Returns an error if there is more than one YubiKey detected.
+    /// Returns an error if more than one YubiKey is detected (or none at all).
+    ///
+    /// NOTE: If multiple YubiKeys are connected, but we are only able to
+    /// open one of them (e.g. because the other one is in use, and the
+    /// connection doesn't allow sharing), the YubiKey that we were able to
+    /// open is returned.
    ///
    /// If you need to operate in environments with more than one YubiKey
    /// attached to the same system, use [`YubiKey::open_by_serial`] or
    /// [`yubikey::reader::Context`][`Context`] to select from the available
    /// PC/SC readers.
    pub fn open() -> Result<Self> {
-        let mut readers = Context::open().map_err(|e| match e {
-            Error::PcscError {
-                inner: Some(pcsc::Error::NoReadersAvailable),
-            } => Error::NotFound,
-            other => other,
-        })?;
-        let mut reader_iter = readers.iter()?;
+        let mut yubikey: Option<Self> = None;
+
+        let mut readers = Context::open()?;
+        for reader in readers.iter()? {
+            if let Ok(yk_found) = reader.open() {
+                if let Some(yk_stored) = yubikey {
+                    // We found two YubiKeys, so we won't use either.
+                    // Don't reset them.
+                    let _ = yk_stored.disconnect(pcsc::Disposition::LeaveCard);
+                    let _ = yk_found.disconnect(pcsc::Disposition::LeaveCard);

-        if let Some(reader) = reader_iter.next() {
-            if reader_iter.next().is_some() {
                    error!("multiple YubiKeys detected!");
                    return Err(Error::PcscError { inner: None });
+                } else {
+                    yubikey = Some(yk_found);
+                }
+            }
        }

-            return reader.open();
-        }
-
+        if let Some(yubikey) = yubikey {
+            // We found exactly one YubiKey that we could open, so we return it.
+            Ok(yubikey)
+        } else {
            error!("no YubiKey detected!");
            Err(Error::NotFound)
        }
+    }

    /// Open a YubiKey with a specific serial number.
    pub fn open_by_serial(serial: Serial) -> Result<Self> {
-        let mut readers = Context::open().map_err(|e| match e {
-            Error::PcscError {
-                inner: Some(pcsc::Error::NoReadersAvailable),
-            } => Error::NotFound,
-            other => other,
-        })?;
+        let mut readers = Context::open()?;
+
+        let mut open_error = None;

        for reader in readers.iter()? {
            let yubikey = match reader.open() {
                Ok(yk) => yk,
-                Err(_) => continue,
+                Err(e) => {
+                    // Save the first error we see that indicates we might have been able
+                    // to find a matching YubiKey.
+                    if open_error.is_none() {
+                        if let Error::PcscError {
+                            inner: Some(pcsc::Error::SharingViolation),
+                        } = e
+                        {
+                            open_error = Some(e);
+                        }
+                    }
+                    continue;
+                }
            };

            if serial == yubikey.serial() {
                return Ok(yubikey);
+            } else {
+                // We didn't want this YubiKey; don't reset it.
+                let _ = yubikey.disconnect(pcsc::Disposition::LeaveCard);
            }
        }

+        Err(if let Some(e) = open_error {
+            e
+        } else {
            error!("no YubiKey detected with serial: {}", serial);
-        Err(Error::NotFound)
+            Error::NotFound
+        })
    }

    /// Reconnect to a YubiKey.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn reconnect(&mut self) -> Result<()> {
        info!("trying to reconnect to current reader");

@@ -238,6 +284,38 @@ impl YubiKey {
        Ok(())
    }

+    /// Disconnect from the YubiKey.
+    ///
+    /// In case of error, ownership of the YubiKey is returned to the caller.
+    ///
+    /// # Note
+    ///
+    /// `YubiKey` implements `Drop` which automatically disconnects the card using
+    /// `Disposition::ResetCard`; you only need to call this function if you want to
+    /// handle errors or use a different disposition method.
+    pub fn disconnect(self, disposition: Disposition) -> core::result::Result<(), (Self, Error)> {
+        let Self {
+            card,
+            name,
+            pin,
+            version,
+            serial,
+        } = self;
+
+        card.disconnect(disposition).map_err(|(card, e)| {
+            (
+                Self {
+                    card,
+                    name,
+                    pin,
+                    version,
+                    serial,
+                },
+                e.into(),
+            )
+        })
+    }
+
    /// Begin a transaction.
    pub(crate) fn begin_transaction(&mut self) -> Result<Transaction<'_>> {
        // TODO(tarcieri): reconnect support
@@ -285,7 +363,7 @@ impl YubiKey {
        // get a challenge from the card
        let challenge = Apdu::new(Ins::Authenticate)
            .params(ALGO_3DES, KEY_CARDMGM)
-            .data(&[TAG_DYN_AUTH, 0x02, 0x80, 0x00])
+            .data([TAG_DYN_AUTH, 0x02, 0x80, 0x00])
            .transmit(&txn, 261)?;

        if !challenge.is_success() || challenge.data().len() < 12 {
@@ -293,7 +371,7 @@ impl YubiKey {
        }

        // send a response to the cards challenge and a challenge of our own.
-        let response = mgm_key.decrypt(challenge.data()[4..12].try_into().unwrap());
+        let response = mgm_key.decrypt(challenge.data()[4..12].try_into()?);

        let mut data = [0u8; 22];
        data[0] = TAG_DYN_AUTH;
@@ -310,7 +388,7 @@ impl YubiKey {

        let authentication = Apdu::new(Ins::Authenticate)
            .params(ALGO_3DES, KEY_CARDMGM)
-            .data(&data)
+            .data(data)
            .transmit(&txn, 261)?;

        if !authentication.is_success() {
@@ -335,13 +413,12 @@ impl YubiKey {

    /// Deauthenticate.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn deauthenticate(&mut self) -> Result<()> {
        let txn = self.begin_transaction()?;

        let status_words = Apdu::new(Ins::SelectApplication)
            .p1(0x04)
-            .data(MGMT_AID)
+            .data(mgm::APPLET_ID)
            .transmit(&txn, 255)?
            .status_words();

@@ -350,7 +427,12 @@ impl YubiKey {
                "Failed selecting mgmt application: {:04x}",
                status_words.code()
            );
-            return Err(Error::GenericError);
+            return Err(match status_words {
+                StatusWords::NotFoundError => Error::AppletNotFound {
+                    applet_name: mgm::APPLET_NAME,
+                },
+                _ => Error::GenericError,
+            });
        }

        Ok(())
@@ -389,7 +471,6 @@ impl YubiKey {

    /// Set the number of PIN retries.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn set_pin_retries(&mut self, pin_tries: u8, puk_tries: u8) -> Result<()> {
        // Special case: if either retry count is 0, it's a successful no-op
        if pin_tries == 0 || puk_tries == 0 {
@@ -414,7 +495,6 @@ impl YubiKey {
    ///
    /// The default PIN code is `123456`.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn change_pin(&mut self, current_pin: &[u8], new_pin: &[u8]) -> Result<()> {
        {
            let txn = self.begin_transaction()?;
@@ -430,7 +510,6 @@ impl YubiKey {

    /// Set PIN last changed.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn set_pin_last_changed(yubikey: &mut YubiKey) -> Result<()> {
        let txn = yubikey.begin_transaction()?;

@@ -438,8 +517,7 @@ impl YubiKey {

        // TODO(tarcieri): double check this is little endian
        let tnow = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
+            .duration_since(UNIX_EPOCH)?
            .as_secs()
            .to_le_bytes();

@@ -466,7 +544,6 @@ impl YubiKey {
    ///
    /// The default PUK code is `12345678`.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn change_puk(&mut self, current_puk: &[u8], new_puk: &[u8]) -> Result<()> {
        let txn = self.begin_transaction()?;
        txn.change_ref(ChangeRefAction::ChangePuk, current_puk, new_puk)
@@ -474,7 +551,6 @@ impl YubiKey {

    /// Block PUK: permanently prevent the PIN from becoming unblocked.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn block_puk(&mut self) -> Result<()> {
        let mut puk = [0x30, 0x42, 0x41, 0x44, 0x46, 0x30, 0x30, 0x44];
        let mut tries_remaining: i32 = -1;
@@ -538,7 +614,6 @@ impl YubiKey {
    /// Unblock a Personal Identification Number (PIN) using a previously
    /// configured PIN Unblocking Key (PUK).
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn unblock_pin(&mut self, puk: &[u8], new_pin: &[u8]) -> Result<()> {
        let txn = self.begin_transaction()?;
        txn.change_ref(ChangeRefAction::UnblockPin, puk, new_pin)
@@ -546,7 +621,6 @@ impl YubiKey {

    /// Fetch an object from the YubiKey.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn fetch_object(&mut self, object_id: ObjectId) -> Result<Buffer> {
        let txn = self.begin_transaction()?;
        txn.fetch_object(object_id)
@@ -554,7 +628,6 @@ impl YubiKey {

    /// Save an object.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn save_object(&mut self, object_id: ObjectId, indata: &mut [u8]) -> Result<()> {
        let txn = self.begin_transaction()?;
        txn.save_object(object_id, indata)
@@ -562,25 +635,27 @@ impl YubiKey {

    /// Get an auth challenge.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn get_auth_challenge(&mut self) -> Result<[u8; 8]> {
        let txn = self.begin_transaction()?;

        let response = Apdu::new(Ins::Authenticate)
            .params(ALGO_3DES, KEY_CARDMGM)
-            .data(&[0x7c, 0x02, 0x81, 0x00])
+            .data([0x7c, 0x02, 0x81, 0x00])
            .transmit(&txn, 261)?;

        if !response.is_success() {
            return Err(Error::AuthenticationError);
        }

-        Ok(response.data()[4..12].try_into().unwrap())
+        Ok(response
+            .data()
+            .get(4..12)
+            .ok_or(Error::SizeError)?
+            .try_into()?)
    }

    /// Verify an auth response.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn verify_auth_response(&mut self, response: [u8; 8]) -> Result<()> {
        let mut data = [0u8; 12];
        data[0] = 0x7c;
@@ -594,7 +669,7 @@ impl YubiKey {
        // send the response to the card and a challenge of our own.
        let status_words = Apdu::new(Ins::Authenticate)
            .params(ALGO_3DES, KEY_CARDMGM)
-            .data(&data)
+            .data(data)
            .transmit(&txn, 261)?
            .status_words();

@@ -611,7 +686,6 @@ impl YubiKey {
    ///
    /// The reset function is only available when both pins are blocked.
    #[cfg(feature = "untested")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "untested")))]
    pub fn reset_device(&mut self) -> Result<()> {
        let templ = [0, Ins::Reset.code(), 0, 0];
        let txn = self.begin_transaction()?;
@@ -636,15 +710,30 @@ impl<'a> TryFrom<&'a Reader<'_>> for YubiKey {

        info!("connected to reader: {}", reader.name());

-        let (version, serial) = {
+        let mut app_version_serial = || -> Result<(Version, Serial)> {
            let txn = Transaction::new(&mut card)?;
            txn.select_application()?;

            let v = txn.get_version()?;
            let s = txn.get_serial(v)?;
-            (v, s)
+            Ok((v, s))
        };

+        match app_version_serial() {
+            Err(e) => {
+                error!("Could not use reader: {}", e);
+
+                // We were unable to use the card, so we've effectively only connected as
+                // a side-effect of determining this. Avoid disrupting its internal state
+                // any further (e.g. preserve the PIN cache of whatever applet is selected
+                // currently).
+                if let Err((_, e)) = card.disconnect(pcsc::Disposition::LeaveCard) {
+                    error!("Failed to disconnect gracefully from card: {}", e);
+                }
+
+                Err(e)
+            }
+            Ok((version, serial)) => {
                let yubikey = YubiKey {
                    card,
                    name: String::from(reader.name()),
@@ -656,3 +745,5 @@ impl<'a> TryFrom<&'a Reader<'_>> for YubiKey {
                Ok(yubikey)
            }
        }
+    }
+}
@@ -0,0 +1,85 @@
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            d4:29:8f:df:8a:af:7b:c0:d7:bf:19:9d:90:d5:ef:ca
+    Signature Algorithm: sha256WithRSAEncryption
+        Issuer: CN=Ferdinand Linnenberg CA
+        Validity
+            Not Before: Feb 10 12:25:37 2022 GMT
+            Not After : May 15 12:25:37 2024 GMT
+        Subject: CN=Bob
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+                Public-Key: (2048 bit)
+                Modulus:
+                    00:d5:27:9b:99:1b:3a:36:64:36:c8:e5:78:64:b6:
+                    9d:70:9d:29:6c:0e:85:91:4b:78:3b:dc:16:c3:09:
+                    8c:d3:74:20:8c:6f:ed:c3:90:c9:1b:4d:80:d5:46:
+                    da:52:7f:d2:2f:bc:b2:f7:40:8d:ad:dd:24:b9:5c:
+                    dc:a2:21:2f:48:ec:06:93:8b:89:f0:cd:63:ff:a1:
+                    fd:ce:36:d5:07:7a:1e:0e:cf:68:a8:c1:b3:7f:62:
+                    84:b7:e1:cf:25:7b:3f:a8:3c:ac:07:1a:fd:c2:e1:
+                    e0:9e:26:24:c1:0d:6d:9d:c6:57:6a:b4:39:28:3d:
+                    88:3e:c9:6a:89:90:72:4a:7b:75:c5:5e:1b:5e:5c:
+                    32:54:a3:ff:eb:01:68:7f:89:b4:4c:01:3f:08:8e:
+                    6c:61:49:60:26:0b:26:58:81:d7:1a:57:ee:52:5c:
+                    05:47:de:da:eb:b5:92:9d:5b:ce:26:18:44:59:3e:
+                    27:d0:61:86:e2:f4:c6:d9:c7:2b:1f:cb:ea:78:f0:
+                    a1:a9:57:d7:98:4c:c1:2f:ae:6a:38:b4:34:53:2e:
+                    5a:9e:f8:58:c7:51:e7:fd:b8:27:cd:87:72:26:c1:
+                    7d:14:c7:cd:fb:f2:04:8a:c4:8f:61:cf:a8:78:bd:
+                    21:be:28:cb:e8:a8:65:29:28:82:46:2f:18:e6:ff:
+                    6f:53
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Basic Constraints: 
+                CA:FALSE
+            X509v3 Subject Key Identifier: 
+                B5:A5:F0:37:25:97:AD:BE:F1:43:52:45:4D:8B:A0:5E:E9:78:21:B8
+            X509v3 Authority Key Identifier: 
+                keyid:26:4E:EB:B0:A5:1B:08:A8:90:2A:85:04:73:84:B5:A5:2C:61:D6:91
+                DirName:/CN=Ferdinand Linnenberg CA
+                serial:8C:E0:40:D9:D8:60:E5:77
+
+            X509v3 Extended Key Usage: 
+                TLS Web Client Authentication
+            X509v3 Key Usage: 
+                Digital Signature
+    Signature Algorithm: sha256WithRSAEncryption
+         19:f3:eb:c1:95:e6:d5:a9:33:d7:2e:02:d8:3a:91:84:81:14:
+         93:fc:03:4d:b1:4b:9d:0b:9b:94:93:9f:1a:0d:87:31:a1:fa:
+         a6:c7:3a:6b:18:24:12:ab:28:fb:c8:e3:09:a2:5d:50:49:00:
+         d9:18:e6:4a:09:18:e0:1c:da:d3:19:96:3d:74:72:fe:e0:8f:
+         ee:59:54:66:2e:57:72:b8:91:55:06:13:e5:9e:89:a2:3a:13:
+         3b:45:30:d3:cd:15:0e:81:eb:4f:b0:6a:a4:6d:00:7d:5b:c0:
+         4a:7f:97:d0:27:27:31:ae:3e:72:f1:74:fe:86:8e:29:a9:42:
+         23:26:22:db:08:8b:df:e9:d3:83:8d:81:10:36:d7:33:68:5e:
+         cb:93:cb:1e:12:c8:cb:be:5e:5c:8e:58:b0:1d:06:5e:c9:98:
+         b7:f1:49:fe:c4:03:de:b4:2b:da:9d:2c:7d:98:37:1c:6c:a8:
+         95:21:6f:23:e3:2e:09:bc:6c:e5:ed:e2:50:d8:f7:da:45:39:
+         d8:34:8a:57:0c:4f:d0:0d:80:06:d6:34:63:72:27:d1:50:d1:
+         d2:21:2c:97:57:17:98:02:95:3a:96:ed:75:9f:cc:f3:b8:f1:
+         3a:85:f9:58:08:9b:a0:75:fd:9b:fd:31:dd:08:dc:14:3d:f4:
+         68:aa:d4:30
+-----BEGIN CERTIFICATE-----
+MIIDXzCCAkegAwIBAgIRANQpj9+Kr3vA178ZnZDV78owDQYJKoZIhvcNAQELBQAw
+IjEgMB4GA1UEAwwXRmVyZGluYW5kIExpbm5lbmJlcmcgQ0EwHhcNMjIwMjEwMTIy
+NTM3WhcNMjQwNTE1MTIyNTM3WjAOMQwwCgYDVQQDDANCb2IwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDVJ5uZGzo2ZDbI5Xhktp1wnSlsDoWRS3g73BbD
+CYzTdCCMb+3DkMkbTYDVRtpSf9IvvLL3QI2t3SS5XNyiIS9I7AaTi4nwzWP/of3O
+NtUHeh4Oz2iowbN/YoS34c8lez+oPKwHGv3C4eCeJiTBDW2dxldqtDkoPYg+yWqJ
+kHJKe3XFXhteXDJUo//rAWh/ibRMAT8IjmxhSWAmCyZYgdcaV+5SXAVH3trrtZKd
+W84mGERZPifQYYbi9MbZxysfy+p48KGpV9eYTMEvrmo4tDRTLlqe+FjHUef9uCfN
+h3ImwX0Ux8378gSKxI9hz6h4vSG+KMvoqGUpKIJGLxjm/29TAgMBAAGjgaMwgaAw
+CQYDVR0TBAIwADAdBgNVHQ4EFgQUtaXwNyWXrb7xQ1JFTYugXul4IbgwUgYDVR0j
+BEswSYAUJk7rsKUbCKiQKoUEc4S1pSxh1pGhJqQkMCIxIDAeBgNVBAMMF0ZlcmRp
+bmFuZCBMaW5uZW5iZXJnIENBggkAjOBA2dhg5XcwEwYDVR0lBAwwCgYIKwYBBQUH
+AwIwCwYDVR0PBAQDAgeAMA0GCSqGSIb3DQEBCwUAA4IBAQAZ8+vBlebVqTPXLgLY
+OpGEgRST/ANNsUudC5uUk58aDYcxofqmxzprGCQSqyj7yOMJol1QSQDZGOZKCRjg
+HNrTGZY9dHL+4I/uWVRmLldyuJFVBhPlnomiOhM7RTDTzRUOgetPsGqkbQB9W8BK
+f5fQJycxrj5y8XT+ho4pqUIjJiLbCIvf6dODjYEQNtczaF7Lk8seEsjLvl5cjliw
+HQZeyZi38Un+xAPetCvanSx9mDccbKiVIW8j4y4JvGzl7eJQ2PfaRTnYNIpXDE/Q
+DYAG1jRjcifRUNHSISyXVxeYApU6lu11n8zzuPE6hflYCJugdf2b/THdCNwUPfRo
+qtQw
+-----END CERTIFICATE-----
@@ -0,0 +1,30 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIIFHDBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQIi6DixMpf5PQCAggA
+MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECLgvCsIAjjXRBIIEyDAss0V4NrI5
+W7KXPRgRJ1tqvQrWZQTIFu4Crzs9Inb4TtSv5mATI9ZU2RMFF6MYXlhIxJng861P
+5IWcU6VeOjRFej8wcB3uTvD2z7NB2cyA5BZSojrZfX5OIEKL9sBzn0vinqmm5N1z
+oXhLMgf0FZssA3+zjIf04vtvmk5pxTCE6dq6vlsEIJyQ0xGc39bStIwk2a4E9wvi
+XayKNJnRFSrTahuI3DvQJPd9TdmM6sBKnrcJrDa6LvH51SrGzW8bBEjDAmC7yJdi
+mBckFTjZ6rGrSxOI6HdnF9RP+y9OiLE4ou5OJ9MbBtngq9OrTImAMZ5ftWowaqX/
+Do1UTqixi4ecWrr5fr1+A2Vch0I1drds2e/mmLR+5GEQXQXZPZKjtPMwxM/AYnTZ
+w/M3T9KtwSj0s5G6Saz4WpzaUL7wATb/UNqMr8Ifl8mHEVoFZhvoRpMWA7Yj1oPb
+cHz8lsfoSrTnK+zLR8ZK3HRu4MtpdCNVwQIJ67T6Feb8YLwYSccTNHBSqUmWRD95
+wOOqY33xcfplaQ2Y+/8+mHScGSEPNmC4f7EggDeUnG3ow0f4n95DENO+aYqGLjSF
+XdCjhD+NTNdlV0z50B6P2XWUoBZOOnPfgFf4nAgn7xQbkZZOk5bQDKo2Zu9jW9/
+uJyTHqI58tcopI3cjd5iQXOJUrM4OWpPIu3p+VWaIAA8JzJIfDN6fyQ3qsMr305L
+30JcjrH6if/6J+2g+DpMAK928JY2hfE8VNWH7096ZnArp42/hLYsNuYnSrL1eS+g
+F/4mvyZyLLTFyB0Frnic4I1QTuNkNmwSrm/B5wIWLqkS7XAyyDDXAcaTHdZCN6nM
+O2OuF7DfBsFcNMM4VagG5adPS9CYkvz0EEh6ho5XiP2yL3tZfsHyuB4njAsV3aFi
+D0Yq7QiCf5iA2d4KsYO6yr1wPfVhlsmPi3++mrHulBwwCQWHTlPgRZnjj1xgmPcQ
+00KsUVh+CMWlf20O5sKhzjvkzbwUj1K+ZfMDuuq1RbzFRSx+Gx8vIaThFg9kVyoP
+zuvzsT6qc3BGNHmaGZ3d5Re25AuGRTF4cTpDfjW0UL7Wnvnis7iMrUasDhyF7CFn
+/KG7eKzxqS08o6D4AM5S/fzZEtszoEgAga6DS2R75FVskDweWuEIsar9UGg3UlmW
+q3+rRPRf1CzrLtyYenkkLg/ajr8JOnFGqZVaLmMnegZQH6rF3aEzlQLNgbNepcuA
+ObSmAO6MR3MlQgdsH/lNzOPdj1gKcE25hOjGfmwgbOXSJv9Cz0bcBLFEyLZSNpRk
+HhNejj6BEz/Cmqg1wm7SOBHsXJGcOTnLO1Y3FBt0I7heWvWmj9rOLG9tvvx9dtrP
+pQyDbIcWonuXLrXYSPyOjmeWoQSzdH3NsCswBV4G+iOiLCJDkElR+mrwKbhtS88T
+3YeZnsCTsmH+jZpxGgPTObjIG91U4UE4Pnkwc2df355VuOKrf0rB/NK0A9hZGqsV
+nxtodjn92P6UFzmfEdt95pMcmurK9wkm1kRkP7cIyAs2lCOIdbgGsszz6Mk16Xqy
+49RdhLxJrJ4gkYZIAbY+KNGVc7uPhm/T9xGrIstbEsoUM7jy7nHMOCCDgdbwX/4X
+caMeSMZcZ+RvraDDBEbSbg==
+-----END ENCRYPTED PRIVATE KEY-----
@@ -3,37 +3,40 @@
 #![forbid(unsafe_code)]
 #![warn(missing_docs, rust_2018_idioms, trivial_casts, unused_qualifications)]

-use lazy_static::lazy_static;
 use log::trace;
+use once_cell::sync::Lazy;
 use rand_core::{OsRng, RngCore};
-use rsa::{hash::Hash::SHA2_256, PaddingScheme, PublicKey};
+use rsa::{pkcs1v15, RsaPublicKey};
 use sha2::{Digest, Sha256};
-use std::{env, sync::Mutex};
-use x509::RelativeDistinguishedName;
+use signature::hazmat::PrehashVerifier;
+use std::{env, str::FromStr, sync::Mutex, time::Duration};
+use x509_cert::{der::Encode, name::Name, serial_number::SerialNumber, time::Validity};
 use yubikey::{
-    certificate::{Certificate, PublicKeyInfo},
-    piv::{self, AlgorithmId, Key, RetiredSlotId, SlotId},
-    Error, MgmKey, PinPolicy, TouchPolicy, YubiKey,
+    certificate,
+    certificate::yubikey_signer,
+    certificate::Certificate,
+    piv::{self, AlgorithmId, Key, ManagementSlotId, RetiredSlotId, SlotId},
+    Error, MgmKey, PinPolicy, Serial, 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> {
+static YUBIKEY: Lazy<Mutex<YubiKey>> = Lazy::new(|| {
    // 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();
+    let yubikey = if let Ok(serial) = env::var("YUBIKEY_SERIAL") {
+        let serial = Serial::from_str(&serial).unwrap();
+        YubiKey::open_by_serial(serial).unwrap()
+    } else {
+        YubiKey::open().unwrap()
+    };
+
    trace!("serial: {}", yubikey.serial());
    trace!("version: {}", yubikey.version());

    Mutex::new(yubikey)
-}
+});

 //
 // CCCID support
@@ -145,7 +148,7 @@ fn test_set_mgmkey() {
 // Certificate support
 //

-fn generate_self_signed_cert(algorithm: AlgorithmId) -> Certificate {
+fn generate_self_signed_cert<KT: yubikey_signer::KeyType>() -> Certificate {
    let mut yubikey = YUBIKEY.lock().unwrap();

    assert!(yubikey.verify_pin(b"123456").is_ok());
@@ -157,25 +160,28 @@ fn generate_self_signed_cert(algorithm: AlgorithmId) -> Certificate {
    let generated = piv::generate(
        &mut yubikey,
        slot,
-        algorithm,
+        KT::ALGORITHM,
        PinPolicy::Default,
        TouchPolicy::Default,
    )
    .unwrap();

-    let mut serial = [0u8; 20];
+    // 0x80 0x00 ... (20bytes) is invalid because of high MSB (serial will keep the sign)
+    // we'll limit ourselves to 19 bytes serial.
+    let mut serial = [0u8; 19];
    OsRng.fill_bytes(&mut serial);
+    let serial = SerialNumber::new(&serial[..]).expect("serial can't be more than 20 bytes long");
+    let validity = Validity::from_now(Duration::new(500000, 0)).unwrap();

    // Generate a self-signed certificate for the new key.
-    let extensions: &[x509::Extension<'_, &[u64]>] = &[];
-    let cert_result = Certificate::generate_self_signed(
+    let cert_result = Certificate::generate_self_signed::<_, KT>(
        &mut yubikey,
        slot,
        serial,
-        None,
-        &[RelativeDistinguishedName::common_name("testSubject")],
+        validity,
+        Name::from_str("CN=testSubject").expect("parse name"),
        generated,
-        extensions,
+        |_builder| Ok(()),
    );

    assert!(cert_result.is_ok());
@@ -187,56 +193,41 @@ fn generate_self_signed_cert(algorithm: AlgorithmId) -> Certificate {
 #[test]
 #[ignore]
 fn generate_self_signed_rsa_cert() {
-    let cert = generate_self_signed_cert(AlgorithmId::Rsa1024);
+    let cert = generate_self_signed_cert::<yubikey_signer::YubiRsa<yubikey_signer::Rsa1024>>();

    //
    // Verify that the certificate is signed correctly
    //

-    let pubkey = match cert.subject_pki() {
-        PublicKeyInfo::Rsa { pubkey, .. } => pubkey,
-        _ => unreachable!(),
-    };
+    let pubkey = RsaPublicKey::try_from(cert.subject_pki()).expect("valid rsa key");
+    let pubkey = pkcs1v15::VerifyingKey::<Sha256>::new(pubkey);

-    let data = cert.as_ref();
+    let data = cert.cert.to_der().expect("serialize certificate");
    let tbs_cert_len = u16::from_be_bytes(data[6..8].try_into().unwrap()) as usize;
    let msg = &data[4..8 + tbs_cert_len];
-    let sig = &data[data.len() - 128..];
-
+    let sig = pkcs1v15::Signature::try_from(&data[data.len() - 128..]).unwrap();
    let hash = Sha256::digest(msg);

-    assert!(pubkey
-        .verify(
-            PaddingScheme::PKCS1v15Sign {
-                hash: Some(SHA2_256)
-            },
-            &hash,
-            sig
-        )
-        .is_ok());
+    assert!(pubkey.verify_prehash(&hash, &sig).is_ok());
 }

 #[test]
 #[ignore]
 fn generate_self_signed_ec_cert() {
-    let cert = generate_self_signed_cert(AlgorithmId::EccP256);
+    let cert = generate_self_signed_cert::<p256::NistP256>();

    //
    // Verify that the certificate is signed correctly
    //

-    let pubkey = match cert.subject_pki() {
-        PublicKeyInfo::EcP256(pubkey) => pubkey,
-        _ => unreachable!(),
-    };
+    let vk = p256::ecdsa::VerifyingKey::try_from(cert.subject_pki()).expect("ecdsa key expected");

-    let data = cert.as_ref();
+    let data = cert.cert.to_der().expect("serialize certificate");
    let tbs_cert_len = data[6] as usize;
    let sig_algo_len = data[7 + tbs_cert_len + 1] as usize;
    let sig_start = 7 + tbs_cert_len + 2 + sig_algo_len + 3;
    let msg = &data[4..7 + tbs_cert_len];
    let sig = p256::ecdsa::Signature::from_der(&data[sig_start..]).unwrap();
-    let vk = p256::ecdsa::VerifyingKey::from_sec1_bytes(pubkey.as_bytes()).unwrap();

    use p256::ecdsa::signature::Verifier;
    assert!(vk.verify(msg, &sig).is_ok());
@@ -273,4 +264,72 @@ fn test_slot_id_display() {
    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R18)), "R18");
    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R19)), "R19");
    assert_eq!(format!("{}", SlotId::Retired(RetiredSlotId::R20)), "R20");
+
+    assert_eq!(
+        format!("{}", SlotId::Management(ManagementSlotId::Pin)),
+        "Pin"
+    );
+    assert_eq!(
+        format!("{}", SlotId::Management(ManagementSlotId::Puk)),
+        "Puk"
+    );
+    assert_eq!(
+        format!("{}", SlotId::Management(ManagementSlotId::Management)),
+        "Management"
+    );
+}
+
+//
+// Metadata
+//
+
+#[test]
+#[ignore]
+fn test_read_metadata() {
+    let mut yubikey = 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,
+        AlgorithmId::EccP256,
+        PinPolicy::Default,
+        TouchPolicy::Default,
+    )
+    .unwrap();
+
+    match piv::metadata(&mut yubikey, slot) {
+        Ok(metadata) => assert_eq!(metadata.public, Some(generated)),
+        Err(Error::NotSupported) => {
+            // Some YubiKeys don't support metadata
+            eprintln!("metadata not supported by this YubiKey");
+        }
+        Err(err) => panic!("{}", err),
+    }
+}
+
+#[test]
+#[ignore]
+fn test_parse_cert_from_der() {
+    let bob_der = std::fs::read("tests/assets/Bob.der").expect(".der file not found");
+    let cert =
+        certificate::Certificate::from_bytes(bob_der).expect("Failed to parse valid certificate");
+    assert_eq!(
+        cert.subject(),
+        "CN=Bob",
+        "Subject is {} should be CN=Bob",
+        cert.subject()
+    );
+    assert_eq!(
+        cert.issuer(),
+        "CN=Ferdinand Linnenberg CA",
+        "Issuer is {} should be {}",
+        cert.issuer(),
+        "CN=Ferdinand Linnenberg CA"
+    );
 }
Author	SHA1	Message	Date
Tony Arcieri (iqlusion)	ee3702a65e	yubikey v0.8.0 (#518 )	2023-08-15 19:29:22 -06:00
Tony Arcieri (iqlusion)	45915e5e5a	Make `RsaKeyData::new` fallible (#517 ) Replaces unwraps with `Error::AlgorithmError`	2023-08-15 18:33:30 -06:00
Tony Arcieri (iqlusion)	75ce24a3ea	Handle metadata command not being supported in test (#516 ) Some YubiKeys don't support this command. Instead of failing the test when it happens, log a warning message instead.	2023-08-15 18:21:45 -06:00
Tony Arcieri (iqlusion)	78313360a1	Add `clippy::unwrap_used` lint (#515 ) Lints for usages of `unwrap()` in the `yubikey` crate (not CLI yet). Replaces them with `?` or `expect()` as the situation warrants.	2023-08-15 18:02:25 -06:00
Tony Arcieri (iqlusion)	d226209ea4	Use `doc_auto_cfg` (#514 ) Removes manual feature annotations for docs.rs	2023-08-15 16:39:29 -06:00
Tony Arcieri (iqlusion)	de142256d0	Bump clippy to use Rust 1.71 (#513 )	2023-08-15 16:31:13 -06:00
hko-s	485d49a6c8	Make YubiKey::open() more robust (#504 ) On systems with a physical card-reader, the previous implementation falsely reports "multiple YubiKeys detected!", even if only one YubiKey is connected. This change attempts to actually open each reader as a YubiKey, and only reports "multiple YubiKeys" if it can actually open more than one. Additionally, this change avoids resetting the YubiKeys in case we find more than one.	2023-08-15 16:20:04 -06:00
Tony Arcieri (iqlusion)	9932d05428	Remove `chrono` dependency (#512 ) It's no longer used as of #495	2023-08-15 16:18:08 -06:00
Tony Arcieri (iqlusion)	363648bbc5	Cargo.lock: bump dependencies (#511 ) Upgrades the following dependencies: $ cargo update Updating crates.io index Updating aho-corasick v0.7.20 -> v1.0.4 Adding android-tzdata v0.1.1 Adding anstream v0.3.2 Adding anstyle v1.0.1 Adding anstyle-parse v0.2.1 Adding anstyle-query v1.0.0 Adding anstyle-wincon v1.0.2 Updating base64ct v1.5.3 -> v1.6.0 Adding bitflags v2.4.0 Updating block-buffer v0.10.3 -> v0.10.4 Updating bumpalo v3.11.1 -> v3.13.0 Updating cc v1.0.78 -> v1.0.82 Updating chrono v0.4.23 -> v0.4.26 Updating cipher v0.4.3 -> v0.4.4 Updating clap v4.0.32 -> v4.3.21 Adding clap_builder v4.3.21 Updating clap_derive v4.0.21 -> v4.3.12 Updating clap_lex v0.3.0 -> v0.5.0 Removing codespan-reporting v0.11.1 Adding colorchoice v1.0.0 Updating const-oid v0.9.2 -> v0.9.5 Updating core-foundation-sys v0.8.3 -> v0.8.4 Updating cpufeatures v0.2.5 -> v0.2.9 Updating crypto-bigint v0.5.1 -> v0.5.2 Removing cxx v1.0.85 Removing cxx-build v1.0.85 Removing cxxbridge-flags v1.0.85 Removing cxxbridge-macro v1.0.85 Updating der v0.7.6 -> v0.7.8 Updating der_derive v0.7.1 -> v0.7.2 Updating digest v0.10.6 -> v0.10.7 Updating ecdsa v0.16.7 -> v0.16.8 Updating elliptic-curve v0.13.4 -> v0.13.5 Updating errno v0.2.8 -> v0.3.2 Updating generic-array v0.14.6 -> v0.14.7 Updating getrandom v0.2.8 -> v0.2.10 Updating heck v0.4.0 -> v0.4.1 Updating hermit-abi v0.2.6 -> v0.3.2 Updating iana-time-zone v0.1.53 -> v0.1.57 Updating iana-time-zone-haiku v0.1.1 -> v0.1.2 Removing io-lifetimes v1.0.3 Updating is-terminal v0.4.2 -> v0.4.9 Updating js-sys v0.3.60 -> v0.3.64 Updating libc v0.2.139 -> v0.2.147 Updating libm v0.2.6 -> v0.2.7 Removing link-cplusplus v1.0.8 Updating linux-raw-sys v0.1.4 -> v0.4.5 Updating log v0.4.17 -> v0.4.20 Updating nom v7.1.2 -> v7.1.3 Updating num-bigint-dig v0.8.2 -> v0.8.4 Updating num-traits v0.2.15 -> v0.2.16 Updating once_cell v1.17.0 -> v1.18.0 Removing os_str_bytes v6.4.1 Updating p256 v0.13.0 -> v0.13.2 Updating pbkdf2 v0.12.1 -> v0.12.2 Updating pkg-config v0.3.26 -> v0.3.27 Updating primeorder v0.13.0 -> v0.13.2 Removing proc-macro-error v1.0.4 Removing proc-macro-error-attr v1.0.4 Updating proc-macro2 v1.0.56 -> v1.0.66 Updating quote v1.0.26 -> v1.0.32 Updating regex v1.7.0 -> v1.9.3 Adding regex-automata v0.3.6 Updating regex-syntax v0.6.28 -> v0.7.4 Updating rustix v0.36.6 -> v0.38.8 Removing scratch v1.0.3 Updating sec1 v0.7.1 -> v0.7.3 Updating serde v1.0.152 -> v1.0.183 Updating sha2 v0.10.6 -> v0.10.7 Updating smallvec v1.10.0 -> v1.11.0 Updating subtle v2.4.1 -> v2.5.0 Removing syn v1.0.107 Removing syn v2.0.15 Adding syn v2.0.28 Updating termcolor v1.1.3 -> v1.2.0 Updating unicode-ident v1.0.6 -> v1.0.11 Removing unicode-width v0.1.10 Adding utf8parse v0.2.1 Updating uuid v1.2.2 -> v1.4.1 Updating wasm-bindgen v0.2.83 -> v0.2.87 Updating wasm-bindgen-backend v0.2.83 -> v0.2.87 Updating wasm-bindgen-macro v0.2.83 -> v0.2.87 Updating wasm-bindgen-macro-support v0.2.83 -> v0.2.87 Updating wasm-bindgen-shared v0.2.83 -> v0.2.87 Adding windows v0.48.0 Updating windows-sys v0.42.0 -> v0.48.0 Adding windows-targets v0.48.2 Updating windows_aarch64_gnullvm v0.42.0 -> v0.48.2 Updating windows_aarch64_msvc v0.42.0 -> v0.48.2 Updating windows_i686_gnu v0.42.0 -> v0.48.2 Updating windows_i686_msvc v0.42.0 -> v0.48.2 Updating windows_x86_64_gnu v0.42.0 -> v0.48.2 Updating windows_x86_64_gnullvm v0.42.0 -> v0.48.2 Updating windows_x86_64_msvc v0.42.0 -> v0.48.2 Updating x509-cert v0.2.3 -> v0.2.4	2023-08-14 19:07:13 -06:00
Arthur Gautier	6a1e1603ef	Use x509-cert certificate builder (#495 ) Co-authored-by: Carl Wallace <carl@redhoundsoftware.com>	2023-08-14 18:31:39 -06:00
Arthur Gautier	8cf18d2986	Bump `rsa` to 0.9.0 (#502 )	2023-05-03 06:22:45 -06:00
dependabot[bot]	07281440c0	Bump rsa from 0.9.0-pre.1 to 0.9.0-pre.2 (#500 ) Bumps [rsa](https://github.com/RustCrypto/RSA) from 0.9.0-pre.1 to 0.9.0-pre.2. - [Release notes](https://github.com/RustCrypto/RSA/releases) - [Changelog](https://github.com/RustCrypto/RSA/blob/master/CHANGELOG.md) - [Commits](https://github.com/RustCrypto/RSA/compare/v0.9.0-pre.1...v0.9.0-pre.2) --- updated-dependencies: - dependency-name: rsa dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-04-27 08:54:23 -06:00
dependabot[bot]	cd76a55318	Bump rsa from 0.9.0-pre.0 to 0.9.0-pre.1 (#497 ) Bumps [rsa](https://github.com/RustCrypto/RSA) from 0.9.0-pre.0 to 0.9.0-pre.1. - [Release notes](https://github.com/RustCrypto/RSA/releases) - [Changelog](https://github.com/RustCrypto/RSA/blob/master/CHANGELOG.md) - [Commits](https://github.com/RustCrypto/RSA/compare/v0.9.0-pre.0...v0.9.0-pre.1) --- updated-dependencies: - dependency-name: rsa dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-04-10 10:10:55 -06:00
dependabot[bot]	23bbf1b783	Bump zeroize from 1.5.7 to 1.6.0 (#496 ) Bumps [zeroize](https://github.com/RustCrypto/utils) from 1.5.7 to 1.6.0. - [Release notes](https://github.com/RustCrypto/utils/releases) - [Commits](https://github.com/RustCrypto/utils/compare/zeroize-v1.5.7...zeroize-v1.6.0) --- updated-dependencies: - dependency-name: zeroize dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-04-03 11:33:52 -06:00
Tony Arcieri (iqlusion)	cafb0b2c18	v0.8.0-pre.0 (#491 )	2023-03-14 17:17:07 -06:00
Tony Arcieri (iqlusion)	0c7441a81e	Bump asymmetric crypto dependencies; MSRV 1.65 (#490 ) Bumps the following dependencies to the latest versions: - `elliptic-curve` v0.13 - `k256` v0.13 - `p256` v0.13 - `p384` v0.13 - `pbkdf2` v0.12 - `rsa` v0.9.0-pre.0 - `signature` v2	2023-03-14 11:53:00 -06:00
str4d	a50addc15b	Fix `StatusWords::code` output for `StatusWords::VerifyFailError` (#479 ) * Fix `StatusWords::code` output for `StatusWords::VerifyFailError` Closes iqlusioninc/yubikey.rs#473. * Refactor `Transaction::transfer_data` to match on `StatusWords` This makes the code more reliable, such that it would have avoided the bug in iqlusioninc/yubikey.rs#473.	2023-02-12 12:02:22 -07:00
str4d	0809f300b7	Return errors from `YubiKey::open_by_serial` that indicate a key may exist (#477 ) * Return errors from `YubiKey::open_by_serial` that indicate a key may exist The only such error at the moment is `pcsc::Error::SharingViolation`, which indicates a transient failure to access a specific reader that could have been the one we needed (and so a future retry might succeed). Closes iqlusioninc/yubikey.rs#458. * Avoid resetting unused devices in YubiKey::open_by_serial We only connect to readers so that we can determine their serial. We now try to ensure that the order in which we connect to them doesn't have an effect on their state after we are done.	2023-02-12 10:22:05 -07:00
str4d	d55079f9a6	Enable library users to detect if a smart card doesn't support PIV (#476 ) * Enable library users to detect if a smart card doesn't support PIV Closes iqlusioninc/yubikey.rs#456. * Avoid resetting the card if we fail to select PIV or fetch version/serial	2023-02-12 10:20:34 -07:00
str4d	10241230b3	Raise minimum `pcsc` version to remove workaround (#478 ) In iqlusioninc/yubikey.rs#88 we added a workaround for what turned out to be a bug in `pcsc`, where an error was returned if no readers were available, instead of returning an empty iterator. `pcsc 2.3.1` was published in 2019, so we can safely rely on it.	2023-02-12 10:18:55 -07:00
dependabot[bot]	1e02f135f0	Bump env_logger from 0.9.3 to 0.10.0 (#452 ) Bumps [env_logger](https://github.com/rust-cli/env_logger) from 0.9.3 to 0.10.0. - [Release notes](https://github.com/rust-cli/env_logger/releases) - [Changelog](https://github.com/rust-cli/env_logger/blob/main/CHANGELOG.md) - [Commits](https://github.com/rust-cli/env_logger/compare/v0.9.3...v0.10.0) --- updated-dependencies: - dependency-name: env_logger dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-01-08 15:24:30 -07:00
Tony Arcieri (iqlusion)	0c2633ab31	transaction: comment cleanup in `get_serial` (#467 ) Moves comments about each YubiKey version number above the arms of the `match` expression	2023-01-07 13:35:52 -08:00
Tony Arcieri (iqlusion)	f49c617a9d	Improve parsing of serial numbers (#466 ) Checks the length of the data returned when querying the serial number, returning an error if it's longer than 4 bytes, and left-padding with zeroes if it's too short. This fixes some potential panics due to incorrect slice lengths as were experienced in #465	2023-01-07 08:35:37 -08:00
Tony Arcieri (iqlusion)	1d33ea1747	Cargo.lock: bump dependencies (#463 )	2023-01-02 10:22:07 -08:00
str4d	18eb4bf4f4	Add `YubiKey::disconnect` (#462 ) This exposes `pcsc::Card::disconnect` to allow alternate disposition methods.	2023-01-02 10:15:31 -08:00
str4d	10941bfb5b	Add partial `Debug` impls for `Context` and `YubiKey` (#457 ) This enables `yubikey::Result<T>` to be debug-formatted, for example when wrapping the output of an API method in `dbg!()`.	2023-01-01 11:16:10 -07:00
Tony Arcieri (iqlusion)	002491193e	Cargo.lock: bump dependencies + audit config (#451 ) This should get the security audit passing again	2022-11-28 10:19:39 -08:00
Tony Arcieri (iqlusion)	2e5139b237	yubikey-cli v0.7.0 (#446 )	2022-11-14 17:17:02 -08:00
Tony Arcieri (iqlusion)	d880faaefa	yubikey v0.7.0 (#444 )	2022-11-14 15:53:00 -08:00
Tony Arcieri (iqlusion)	cc00a10c2f	img: add logo-sq.png (#445 ) Square logo for use with rustdoc	2022-11-14 15:15:19 -08:00
Tony Arcieri (iqlusion)	0a2e798894	Switch from `subtle-encoding` to `base16ct` (#443 )	2022-11-14 14:26:07 -08:00
Tony Arcieri (iqlusion)	5c4259023f	Switch from `lazy_static` to `once_cell` (#442 ) The latter will hopefully eventually be upstreamed into `std`.	2022-11-14 12:52:27 -08:00
Tony Arcieri (iqlusion)	57bb088c7d	yubikey-cli: bump `x509-parser` to v0.14 (#441 )	2022-11-14 12:30:55 -08:00
Tony Arcieri (iqlusion)	ccf19a3668	Bump `rsa` to v0.7.1 (#440 )	2022-11-14 11:08:05 -08:00
dependabot[bot]	db13fce53b	Bump clap from 3.2.23 to 4.0.23 (#438 ) Bumps [clap](https://github.com/clap-rs/clap) from 3.2.23 to 4.0.23. - [Release notes](https://github.com/clap-rs/clap/releases) - [Changelog](https://github.com/clap-rs/clap/blob/master/CHANGELOG.md) - [Commits](https://github.com/clap-rs/clap/compare/v3.2.23...v4.0.23) --- updated-dependencies: - dependency-name: clap dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-11-14 10:44:39 -08:00
Ferdinand Linnenberg	0071566097	feat: fixed incorrect issuer for certificates & added x509 prints (#437 )	2022-11-14 10:42:07 -08:00
Tony Arcieri (iqlusion)	d8653bc6f0	Use `chrono` v0.4.23 or newer (#436 ) Addresses RUSTSEC-2020-0159	2022-11-12 15:42:34 -08:00
Tony Arcieri (iqlusion)	603b102932	Followups from #371 (#435 ) Implements the changes I suggested in that PR, which are related to naming conventions and documentation.	2022-11-12 15:41:58 -08:00
Tony Arcieri (iqlusion)	7470b1613a	Cargo.lock: bump dependencies (#434 )	2022-11-12 13:27:08 -08:00
Tony Arcieri (iqlusion)	4310cc0f9a	Fix build and clippy warnings (#433 )	2022-11-12 13:15:42 -08:00
Arthur Gautier	87ed7b2338	Adds support for metadata command (#371 ) On firmware 5.4.3, yubikey introduced a metadata command. This returns the policy attached to as slot as well as the public key of the pair in the slot. https://docs.yubico.com/yesdk/users-manual/application-piv/apdu/metadata.html	2022-11-12 11:12:10 -08:00
Shella Stephens	7866d8d53e	MSRV 1.60.0 (#423 )	2022-11-07 08:58:45 -07:00
Shella Stephens	744238fd77	Cargo.lock: update dependencies & fix audit	2022-11-07 07:56:25 -07:00
william light	bbb186f95e	Display inner PC/SC errors (#420 )	2022-10-31 15:00:21 -07:00
dependabot[bot]	c89cc5acd0	Bump sha2 from 0.10.2 to 0.10.5 (#407 ) Bumps [sha2](https://github.com/RustCrypto/hashes) from 0.10.2 to 0.10.5. - [Release notes](https://github.com/RustCrypto/hashes/releases) - [Commits](https://github.com/RustCrypto/hashes/compare/sha2-v0.10.2...sha2-v0.10.5) --- updated-dependencies: - dependency-name: sha2 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-10-18 14:29:21 -07:00
dependabot[bot]	2294c1cc3a	Bump chrono from 0.4.21 to 0.4.22 (#405 ) Bumps [chrono](https://github.com/chronotope/chrono) from 0.4.21 to 0.4.22. - [Release notes](https://github.com/chronotope/chrono/releases) - [Changelog](https://github.com/chronotope/chrono/blob/main/CHANGELOG.md) - [Commits](https://github.com/chronotope/chrono/compare/v0.4.21...v0.4.22) --- updated-dependencies: - dependency-name: chrono dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-10-18 14:29:08 -07:00
dependabot[bot]	65e201db0f	Bump uuid from 1.1.2 to 1.2.1 (#415 ) Bumps [uuid](https://github.com/uuid-rs/uuid) from 1.1.2 to 1.2.1. - [Release notes](https://github.com/uuid-rs/uuid/releases) - [Commits](https://github.com/uuid-rs/uuid/compare/1.1.2...1.2.1) --- updated-dependencies: - dependency-name: uuid dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-10-18 14:28:56 -07:00