YubiKey plugin protocol

src/yubikey.rs

@@ -1,14 +1,28 @@
 //! Structs for handling YubiKeys.
 
+use age_core::{
+    format::{FileKey, FILE_KEY_BYTES},
+    primitives::{aead_decrypt, hkdf},
+};
+use age_plugin::{identity, Callbacks};
 use bech32::{ToBase32, Variant};
 use dialoguer::Password;
+use secrecy::ExposeSecret;
+use std::convert::TryInto;
 use std::fmt;
+use std::io;
 use std::thread::sleep;
 use std::time::{Duration, SystemTime};
-use yubikey_piv::{key::RetiredSlotId, yubikey::Serial, MgmKey, Readers, YubiKey};
+use yubikey_piv::{
+    certificate::{Certificate, PublicKeyInfo},
+    key::{decrypt_data, AlgorithmId, RetiredSlotId, SlotId},
+    yubikey::Serial,
+    MgmKey, Readers, YubiKey,
+};
 
 use crate::{
     error::Error,
+    format::{RecipientLine, STANZA_KEY_LABEL},
     p256::{Recipient, TAG_BYTES},
     IDENTITY_PREFIX,
 };
@@ -145,6 +159,12 @@ impl fmt::Display for Stub {
     }
 }
 
+impl PartialEq for Stub {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_bytes().eq(&other.to_bytes())
+    }
+}
+
 impl Stub {
     /// Returns a key stub and recipient for this `(Serial, SlotId, PublicKey)` tuple.
     ///
@@ -159,6 +179,17 @@ impl Stub {
         }
     }
 
+    pub(crate) fn from_bytes(bytes: &[u8], identity_index: usize) -> Option<Self> {
+        let serial = Serial::from(u32::from_le_bytes(bytes[0..4].try_into().unwrap()));
+        let slot: RetiredSlotId = bytes[4].try_into().ok()?;
+        Some(Stub {
+            serial,
+            slot,
+            tag: bytes[5..9].try_into().unwrap(),
+            identity_index,
+        })
+    }
+
     fn to_bytes(&self) -> Vec<u8> {
         let mut bytes = Vec::with_capacity(9);
         bytes.extend_from_slice(&self.serial.0.to_le_bytes());
@@ -166,4 +197,176 @@ impl Stub {
         bytes.extend_from_slice(&self.tag);
         bytes
     }
+
+    pub(crate) fn matches(&self, line: &RecipientLine) -> bool {
+        self.tag == line.tag
+    }
+
+    pub(crate) fn connect<E>(
+        &self,
+        callbacks: &mut dyn Callbacks<E>,
+    ) -> io::Result<Result<Connection, identity::Error>> {
+        let mut yubikey = match YubiKey::open_by_serial(self.serial) {
+            Ok(yk) => yk,
+            Err(yubikey_piv::Error::NotFound) => {
+                if callbacks
+                    .message(&format!(
+                        "Please insert YubiKey with serial {}",
+                        self.serial
+                    ))?
+                    .is_err()
+                {
+                    return Ok(Err(identity::Error::Identity {
+                        index: self.identity_index,
+                        message: format!("Could not find YubiKey with serial {}", self.serial),
+                    }));
+                }
+
+                // Start a 15-second timer waiting for the YubiKey to be inserted
+                let start = SystemTime::now();
+                loop {
+                    match YubiKey::open_by_serial(self.serial) {
+                        Ok(yubikey) => break yubikey,
+                        Err(yubikey_piv::Error::NotFound) => (),
+                        Err(_) => {
+                            return Ok(Err(identity::Error::Identity {
+                                index: self.identity_index,
+                                message: format!(
+                                    "Could not open YubiKey with serial {}",
+                                    self.serial
+                                ),
+                            }));
+                        }
+                    }
+
+                    match SystemTime::now().duration_since(start) {
+                        Ok(end) if end >= FIFTEEN_SECONDS => {
+                            return Ok(Err(identity::Error::Identity {
+                                index: self.identity_index,
+                                message: format!(
+                                "Timed out while waiting for YubiKey with serial {} to be inserted",
+                                self.serial
+                            ),
+                            }))
+                        }
+                        _ => sleep(ONE_SECOND),
+                    }
+                }
+            }
+            Err(_) => {
+                return Ok(Err(identity::Error::Identity {
+                    index: self.identity_index,
+                    message: format!("Could not open YubiKey with serial {}", self.serial),
+                }))
+            }
+        };
+
+        // Read the pubkey from the YubiKey slot and check it still matches.
+        let pk = match Certificate::read(&mut yubikey, SlotId::Retired(self.slot))
+            .ok()
+            .and_then(|cert| match cert.subject_pki() {
+                PublicKeyInfo::EcP256(pubkey) => {
+                    Recipient::from_encoded(pubkey).filter(|pk| pk.tag() == self.tag)
+                }
+                _ => None,
+            }) {
+            Some(pk) => pk,
+            None => {
+                return Ok(Err(identity::Error::Identity {
+                    index: self.identity_index,
+                    message: "A YubiKey stub did not match the YubiKey".to_owned(),
+                }))
+            }
+        };
+
+        let pin = match callbacks.request_secret(&format!(
+            "Enter PIN for YubiKey with serial {}",
+            self.serial
+        ))? {
+            Ok(pin) => pin,
+            Err(_) => {
+                return Ok(Err(identity::Error::Identity {
+                    index: self.identity_index,
+                    message: format!("A PIN is required for YubiKey with serial {}", self.serial),
+                }))
+            }
+        };
+        if yubikey.verify_pin(pin.expose_secret().as_bytes()).is_err() {
+            return Ok(Err(identity::Error::Identity {
+                index: self.identity_index,
+                message: "Invalid YubiKey PIN".to_owned(),
+            }));
+        }
+
+        Ok(Ok(Connection {
+            yubikey,
+            pk,
+            slot: self.slot,
+            tag: self.tag,
+        }))
+    }
+}
+
+pub(crate) struct Connection {
+    yubikey: YubiKey,
+    pk: Recipient,
+    slot: RetiredSlotId,
+    tag: [u8; 4],
+}
+
+impl Connection {
+    pub(crate) fn recipient(&self) -> &Recipient {
+        &self.pk
+    }
+
+    pub(crate) fn unwrap_file_key(&mut self, line: &RecipientLine) -> Result<FileKey, ()> {
+        assert_eq!(self.tag, line.tag);
+
+        // The YubiKey API for performing scalar multiplication takes the point in its
+        // uncompressed SEC-1 encoding.
+        let shared_secret = match decrypt_data(
+            &mut self.yubikey,
+            line.epk_bytes.decompress().as_bytes(),
+            AlgorithmId::EccP256,
+            SlotId::Retired(self.slot),
+        ) {
+            Ok(res) => res,
+            Err(_) => return Err(()),
+        };
+
+        let mut salt = vec![];
+        salt.extend_from_slice(line.epk_bytes.as_bytes());
+        salt.extend_from_slice(self.pk.to_encoded().as_bytes());
+
+        let enc_key = hkdf(&salt, STANZA_KEY_LABEL, shared_secret.as_ref());
+
+        // A failure to decrypt is fatal, because we assume that we won't
+        // encounter 32-bit collisions on the key tag embedded in the header.
+        match aead_decrypt(&enc_key, FILE_KEY_BYTES, &line.encrypted_file_key) {
+            Ok(pt) => Ok(TryInto::<[u8; FILE_KEY_BYTES]>::try_into(&pt[..])
+                .unwrap()
+                .into()),
+            Err(_) => Err(()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use yubikey_piv::{key::RetiredSlotId, Serial};
+
+    use super::Stub;
+
+    #[test]
+    fn stub_round_trip() {
+        let stub = Stub {
+            serial: Serial::from(42),
+            slot: RetiredSlotId::R1,
+            tag: [7; 4],
+            identity_index: 0,
+        };
+
+        let encoded = stub.to_bytes();
+        assert_eq!(Stub::from_bytes(&encoded, 0), Some(stub));
+    }
 }