openpgp_piv_sequoia/

lib.rs

//! Library for PIV HSM usage with Sequoia PGP.
//!
//! Example use, performing an OpenPGP decryption operation on a PIV device:
//!
//! ```no_run
//! use openpgp_piv_sequoia::Opiv;
//! use sequoia_openpgp::{parse::Parse, Cert};
//! use yubikey::piv::SlotId;
//!
//! let mut opiv = Opiv::open(16019180)?;
//! opiv.verify_pin("123456".as_bytes())?;
//!
//! let cert = Cert::from_file("example-cert.asc")?;
//!
//! opiv.decrypt(
//!     SlotId::KeyManagement,
//!     &mut std::io::stdin(),
//!     &mut std::io::stdout(),
//!     cert,
//! )?;
//!
//! # Ok::<(), anyhow::Error>(())
//! ```

use std::sync::{Arc, Mutex};

use anyhow::Context;
use openpgp_x509_sequoia::types::{AlgorithmId, PublicKeyInfo};
use sequoia_openpgp::crypto::mpi;
use sequoia_openpgp::packet::key::{PublicParts, SecretKeyMaterial, SecretParts, UnspecifiedRole};
use sequoia_openpgp::packet::Key;
use sequoia_openpgp::parse::stream::DecryptorBuilder;
use sequoia_openpgp::parse::Parse;
use sequoia_openpgp::policy::NullPolicy;
use sequoia_openpgp::types::Curve;
use sequoia_openpgp::Cert;
use x509_certificate::X509Certificate;
use yubikey::certificate::CertInfo;
use yubikey::piv::SlotId;
use yubikey::{MgmKey, PinPolicy, TouchPolicy, YubiKey};

use crate::decryptor::Helper;

mod decryptor;
mod signer;
mod util;

/// OpenPGP PIV device
pub struct Opiv {
    yk: YubiKey,
}

impl From<YubiKey> for Opiv {
    fn from(yk: YubiKey) -> Self {
        Self { yk }
    }
}

impl Opiv {
    /// Open PIV device by serial
    pub fn open(serial: u32) -> anyhow::Result<Self> {
        let yk =
            YubiKey::open_by_serial(yubikey::Serial::from(serial)).context("card not found")?;

        Ok(Opiv { yk })
    }

    /// Verify device PIN
    pub fn verify_pin(&mut self, pin: &[u8]) -> anyhow::Result<()> {
        Ok(self.yk.verify_pin(pin)?)
    }

    /// Find OpenPGP [`Key`] that corresponds to the key data in `slot`.
    ///
    /// A matching key is determined by comparing MPIs with the component keys
    /// in `cert`.
    pub fn key(
        &mut self,
        slot: SlotId,
        cert: Cert,
    ) -> anyhow::Result<Key<PublicParts, UnspecifiedRole>> {
        if let Ok(ykcert) = yubikey::Certificate::read(&mut self.yk, slot) {
            let x509 = ykcert.into_buffer();
            let x509cert: X509Certificate = X509Certificate::from_der(x509.as_slice())?;

            openpgp_x509_sequoia::find_key_by_x509cert(&x509cert, &cert)
        } else {
            Err(anyhow::anyhow!(
                "Couldn't read certificate for slot {:?}",
                slot
            ))
        }
    }

    /// Get a [`PivKeyPair`] that can perform OpenPGP signing or decryption
    /// operations using the key material in `slot`.
    ///
    /// `cert` is required as a source of OpenPGP metadata (it must contain
    /// a component key that matches the key material in `slot`).
    pub fn keypair(mut self, slot: SlotId, cert: Cert) -> anyhow::Result<PivKeyPair> {
        let key = self.key(slot, cert)?;

        let yk = Arc::new(Mutex::new(self.yk));
        Ok(PivKeyPair::new(key, slot, yk))
    }

    /// Perform a signing operation on the card, using the key material in
    /// `slot`.
    ///
    /// `cert` is required as a source of OpenPGP metadata (it must contain
    /// a component key that matches the key material in `slot`).
    pub fn sign(
        self,
        slot: SlotId,
        input: &mut (dyn std::io::Read + Send + Sync),
        output: &mut (dyn std::io::Write + Send + Sync),
        cert: Cert,
    ) -> anyhow::Result<()> {
        let keypair = self.keypair(slot, cert)?;

        signer::sign_on_card(keypair, input, output)
    }

    /// Perform a decryption operation on the card, using the key material in
    /// `slot`.
    ///
    /// `cert` is required as a source of OpenPGP metadata (it must contain
    /// a component key that matches the key material in `slot`).
    pub fn decrypt(
        mut self,
        slot: SlotId,
        input: &mut (dyn std::io::Read + Send + Sync),
        output: &mut (dyn std::io::Write + Send + Sync),
        cert: Cert,
    ) -> anyhow::Result<()> {
        // Get matching OpenPGP public key for id from cert
        let public = self.key(slot, cert)?;

        let helper = Helper {
            yk: Arc::new(Mutex::new(self.yk)),
            slot,
            public: &public,
        };

        // Now, create a decryptor with a helper using the given Certs.
        let policy = &NullPolicy::new();
        let mut decryptor =
            DecryptorBuilder::from_reader(input)?.with_policy(policy, None, helper)?;

        // Decrypt the data.
        std::io::copy(&mut decryptor, output)?;

        Ok(())
    }

    /// Upload key material from OpenPGP `key` to the specified `slot`.
    ///
    /// Also sets the corresponding public key data and a self-signed
    /// certificate for the slot.
    pub fn upload_key(
        &mut self,
        key: &Key<SecretParts, UnspecifiedRole>,
        slot: SlotId,
        common_name: &str,
        pin: &[u8],
        mgm_key: MgmKey,
    ) -> anyhow::Result<()> {
        // -- Transform the subkey 'key' into piv data structures --

        // Handle private cryptographic material
        let unenc = if let SecretKeyMaterial::Unencrypted(ref u) = key.secret() {
            u
        } else {
            return Err(anyhow::anyhow!("Can't access private key material"));
        };

        // Container to temporarily keep private key material
        enum PrivateKey {
            R(yubikey::piv::RsaKeyData),
            E(mpi::ProtectedMPI),
        }

        let secret_key_material = unenc.map(|mpis| mpis.clone());
        let privkey = match secret_key_material {
            mpi::SecretKeyMaterial::RSA { p, q, .. } => {
                PrivateKey::R(yubikey::piv::RsaKeyData::new(p.value(), q.value()))
            }
            mpi::SecretKeyMaterial::ECDSA { scalar } | mpi::SecretKeyMaterial::ECDH { scalar } => {
                PrivateKey::E(scalar)
            }
            s => {
                return Err(anyhow::anyhow!(
                    "Unsupported type of SecretKeyMaterial: {:?}",
                    s.algo()
                ))
            }
        };

        // - make yubikey::certificate::PublicKeyInfo
        let pub_key_info = match key.parts_as_public().mpis() {
            mpi::PublicKey::RSA { e, n } => {
                match n.value().len() {
                    // Rsa2048 (allow for some leading 0 bits)
                    248..=256 => {
                        let rsa_pub = rsa::RsaPublicKey::new(
                            rsa::BigUint::from_bytes_be(n.value()),
                            rsa::BigUint::from_bytes_be(e.value()),
                        )?;

                        PublicKeyInfo::Rsa {
                            algorithm: AlgorithmId::Rsa2048,
                            pubkey: rsa_pub,
                        }
                    }
                    len => {
                        return Err(anyhow::anyhow!("Unexpected RSA modulus length {}", len * 8))
                    }
                }
            }
            mpi::PublicKey::ECDH { curve, q, .. } | mpi::PublicKey::ECDSA { curve, q, .. } => {
                match curve {
                    Curve::NistP256 => {
                        let p256 = p256::EncodedPoint::from_bytes(q.value()).map_err(|e| {
                            anyhow::anyhow!("Error while creating EncodedPoint: {e:?}")
                        })?;

                        PublicKeyInfo::EcP256(p256)
                    }
                    Curve::NistP384 => {
                        let p384 = p384::EncodedPoint::from_bytes(q.value()).map_err(|e| {
                            anyhow::anyhow!("Error while creating EncodedPoint: {e:?}")
                        })?;

                        PublicKeyInfo::EcP384(p384)
                    }
                    _ => return Err(anyhow::anyhow!("Unsupported curve {curve:?}")),
                }
            }

            pk => return Err(anyhow::anyhow!("Unexpected public key {:?}", pk)),
        };

        let reader_name = self.yk.name();
        log::trace!("Using '{reader_name}' [{}]", self.yk.version());

        self.yk.authenticate(mgm_key)?;
        log::trace!("MgmKey authenticated");

        // -- upload priv key to card in Slot 'slot' --
        log::trace!("Upload private key");
        match privkey {
            PrivateKey::R(rsa) => yubikey::piv::import_rsa_key(
                &mut self.yk,
                slot,
                // Only Rsa2048 can arrive here
                yubikey::piv::AlgorithmId::Rsa2048,
                rsa,
                TouchPolicy::Default,
                PinPolicy::Default,
            )?,
            PrivateKey::E(scalar) => {
                let algo = match pub_key_info {
                    PublicKeyInfo::EcP256(_) => yubikey::piv::AlgorithmId::EccP256,
                    PublicKeyInfo::EcP384(_) => yubikey::piv::AlgorithmId::EccP384,
                    _ => {
                        return Err(anyhow::anyhow!(
                            "Unexpected ECC algorithm {:?}",
                            pub_key_info.algorithm()
                        ))
                    }
                };

                yubikey::piv::import_ecc_key(
                    &mut self.yk,
                    slot,
                    algo,
                    scalar.value(),
                    TouchPolicy::Default,
                    PinPolicy::Default,
                )?
            }
        }

        // -- generate and upload certificate --
        let tbs_cert = openpgp_x509_sequoia::generate_x509(&pub_key_info, key, common_name, &[]);

        self.yk.verify_pin(pin)?;
        log::trace!("PIN verified\n");

        // function to self-sign
        let mut signer = |data: &[u8], algo: AlgorithmId| {
            let data = match algo {
                AlgorithmId::Rsa2048 => {
                    let em_len = 2048 / 8;
                    util::pad_pkcs1_5(data, em_len)?
                }
                _ => data.to_vec(),
            };

            let algo: yubikey::piv::AlgorithmId = match algo {
                AlgorithmId::Rsa2048 => Ok(yubikey::piv::AlgorithmId::Rsa2048),
                AlgorithmId::EccP256 => Ok(yubikey::piv::AlgorithmId::EccP256),
                AlgorithmId::EccP384 => Ok(yubikey::piv::AlgorithmId::EccP384),
                _ => Err(anyhow::anyhow!("Unsupported algo {algo:?}")),
            }?;

            yubikey::piv::sign_data(&mut self.yk, &data, algo, slot)
                .map(|b| b.to_vec())
                .map_err(|e| e.into())
        };

        // - assemble cert -
        let cert =
            openpgp_x509_sequoia::self_sign_x509(tbs_cert, pub_key_info.algorithm(), &mut signer)?;

        // Write cert to card
        let cert = yubikey::Buffer::from(cert);
        let cert = yubikey::certificate::Certificate::from_bytes(cert)?;

        cert.write(&mut self.yk, slot, CertInfo::Uncompressed)?;
        log::debug!("created certificate object");

        Ok(())
    }

    /// Reset PIV device
    pub fn reset(&mut self) -> anyhow::Result<()> {
        const BAD_PIV_PIN: &[u8] = &[1, 1, 1]; // FIXME

        // Block pin and puk
        for _ in 1..5 {
            let _ = self.yk.verify_pin(BAD_PIV_PIN); // "verify" with wrong PIN to block
        }
        self.yk.block_puk()?;

        self.yk.reset_device().context("Reset failed")
    }

    /// XXX: escape hatch for direct device access (will be removed)
    pub fn as_yk(&self) -> &YubiKey {
        &self.yk
    }

    /// XXX: escape hatch for direct device access (will be removed)
    pub fn as_yk_mut(&mut self) -> &mut YubiKey {
        &mut self.yk
    }

    /// XXX: escape hatch for direct device access (will be removed)
    pub fn into_yk(self) -> YubiKey {
        self.yk
    }
}

/// PIV implementation of [`sequoia_openpgp::crypto::Signer`]
/// and [`sequoia_openpgp::crypto::Decryptor`].
pub struct PivKeyPair {
    public: Key<PublicParts, UnspecifiedRole>,
    slot: SlotId,
    yk: Arc<Mutex<YubiKey>>,
}

impl PivKeyPair {
    pub fn new(
        public: Key<PublicParts, UnspecifiedRole>,
        slot: SlotId,
        yk: Arc<Mutex<YubiKey>>,
    ) -> Self {
        Self { public, slot, yk }
    }
}