use std::fmt;
use std::fs::{self, OpenOptions};
use std::io::{ErrorKind, Write};
use std::path::Path;
use age::secrecy::ExposeSecret;
use age::x25519::{Identity, Recipient};
use anyhow::{Context, Result, anyhow, bail};
use base64::Engine;
use base64::prelude::BASE64_STANDARD;
use ed25519_dalek::{SigningKey, VerifyingKey};
use zeroize::Zeroizing;
use super::{KeyGuard, hex};
#[cfg(unix)]
use crate::private_files::{PRIVATE_DIR_MODE, PRIVATE_FILE_MODE};
pub const DEVICE_KEY_FILE: &str = "device.key";
const SECRET_MAGIC: &[u8; 4] = b"SBDK";
const SECRET_VERSION: u8 = 1;
const SEED_LEN: usize = 32;
const SSH_KEY_TYPE: &[u8] = b"ssh-ed25519";
pub struct DeviceKeys {
age_identity: Identity,
ssh_key: SigningKey,
signing_key: SigningKey,
}
impl DeviceKeys {
pub fn generate() -> Result<Self> {
let ssh_seed = KeyGuard::<[u8; SEED_LEN]>::random()?;
let signing_seed = KeyGuard::<[u8; SEED_LEN]>::random()?;
Ok(Self {
age_identity: Identity::generate(),
ssh_key: SigningKey::from_bytes(ssh_seed.expose()),
signing_key: SigningKey::from_bytes(signing_seed.expose()),
})
}
pub fn age_identity(&self) -> &Identity {
&self.age_identity
}
pub fn age_recipient(&self) -> Recipient {
self.age_identity.to_public()
}
pub fn ssh_signing_key(&self) -> &SigningKey {
&self.ssh_key
}
pub fn ssh_public_key(&self) -> String {
ssh_public_line(&self.ssh_key.verifying_key())
}
pub fn signing_key(&self) -> &SigningKey {
&self.signing_key
}
pub fn verifying_key(&self) -> VerifyingKey {
self.signing_key.verifying_key()
}
pub fn to_secret_bytes(&self) -> Result<KeyGuard<Vec<u8>>> {
let age_secret = self.age_identity.to_string();
let age = age_secret.expose_secret().as_bytes();
let age_len = u16::try_from(age.len()).context("age identity string is too long")?;
let total = SECRET_MAGIC.len() + 1 + 2 + age.len() + 2 * SEED_LEN;
let mut out = KeyGuard::new(Vec::with_capacity(total));
let buf = out.expose_mut();
buf.extend_from_slice(SECRET_MAGIC);
buf.push(SECRET_VERSION);
buf.extend_from_slice(&age_len.to_be_bytes());
buf.extend_from_slice(age);
buf.extend_from_slice(self.ssh_key.as_bytes());
buf.extend_from_slice(self.signing_key.as_bytes());
Ok(out)
}
pub fn from_secret_bytes(bytes: &[u8]) -> Result<Self> {
let truncated = || anyhow!("device key blob is truncated");
let rest = bytes
.strip_prefix(SECRET_MAGIC)
.ok_or_else(|| anyhow!("not a device key blob"))?;
let (&version, rest) = rest.split_first().ok_or_else(truncated)?;
if version != SECRET_VERSION {
bail!("device key blob has unsupported version {version}");
}
let (age_len, rest) = rest.split_first_chunk::<2>().ok_or_else(truncated)?;
let age_len = usize::from(u16::from_be_bytes(*age_len));
if rest.len() != age_len + 2 * SEED_LEN {
bail!("device key blob has the wrong length");
}
let (age, seeds) = rest.split_at(age_len);
let (ssh_seed, signing_seed) = seeds
.split_first_chunk::<SEED_LEN>()
.ok_or_else(truncated)?;
let signing_seed: &[u8; SEED_LEN] = signing_seed.try_into().map_err(|_| truncated())?;
let age = std::str::from_utf8(age)
.map_err(|_| anyhow!("device key blob holds a non-UTF-8 age identity"))?;
let age_identity = age
.parse::<Identity>()
.map_err(|e| anyhow!("device key blob holds an invalid age identity: {e}"))?;
Ok(Self {
age_identity,
ssh_key: SigningKey::from_bytes(ssh_seed),
signing_key: SigningKey::from_bytes(signing_seed),
})
}
pub fn load(path: &Path) -> Result<Option<Self>> {
read_key_file(path)
}
pub fn load_or_create(path: &Path) -> Result<(Self, bool)> {
if let Some(keys) = read_key_file(path)? {
return Ok((keys, false));
}
let keys = Self::generate()?;
let dir = parent_dir(path);
create_private_dir(dir)?;
let secret = keys.to_secret_bytes()?;
if install_if_absent(dir, path, secret.expose())? {
return Ok((keys, true));
}
let existing = read_key_file(path)?
.ok_or_else(|| anyhow!("device key file {} vanished after creation", path.display()))?;
Ok((existing, false))
}
}
impl fmt::Debug for DeviceKeys {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DeviceKeys")
.field("age_recipient", &self.age_recipient().to_string())
.field("ssh_public_key", &self.ssh_public_key())
.field("signing_public_key", &hex(self.verifying_key().as_bytes()))
.finish()
}
}
fn read_key_file(path: &Path) -> Result<Option<DeviceKeys>> {
let bytes = match fs::read(path) {
Ok(bytes) => Zeroizing::new(bytes),
Err(e) if e.kind() == ErrorKind::NotFound => return Ok(None),
Err(e) => {
return Err(e).with_context(|| format!("reading device key file {}", path.display()));
}
};
DeviceKeys::from_secret_bytes(&bytes)
.map(Some)
.with_context(|| format!("device key file {} is corrupt", path.display()))
}
fn parent_dir(path: &Path) -> &Path {
match path.parent() {
Some(dir) if !dir.as_os_str().is_empty() => dir,
_ => Path::new("."),
}
}
pub(super) fn create_private_dir(dir: &Path) -> Result<()> {
let mut builder = fs::DirBuilder::new();
builder.recursive(true);
#[cfg(unix)]
std::os::unix::fs::DirBuilderExt::mode(&mut builder, PRIVATE_DIR_MODE);
builder
.create(dir)
.with_context(|| format!("creating key directory {}", dir.display()))
}
pub(super) fn install_if_absent(dir: &Path, path: &Path, bytes: &[u8]) -> Result<bool> {
let name = path
.file_name()
.ok_or_else(|| anyhow!("device key path {} has no file name", path.display()))?;
let temp = dir.join(format!(
".{}.{}.tmp",
name.to_string_lossy(),
uuid::Uuid::new_v4().simple()
));
if let Err(e) = write_private_file(&temp, bytes) {
return Err(with_temp_removed(e, &temp));
}
let linked = fs::hard_link(&temp, path);
fs::remove_file(&temp)
.with_context(|| format!("removing temporary key file {}", temp.display()))?;
match linked {
Ok(()) => {
sync_dir(dir)?;
Ok(true)
}
Err(e) if e.kind() == ErrorKind::AlreadyExists => Ok(false),
Err(e) => Err(e).with_context(|| format!("installing device key file {}", path.display())),
}
}
pub(super) fn write_private_file(path: &Path, bytes: &[u8]) -> Result<()> {
let mut options = OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, PRIVATE_FILE_MODE);
let mut file = options
.open(path)
.with_context(|| format!("creating temporary key file {}", path.display()))?;
file.write_all(bytes)
.and_then(|()| file.sync_all())
.with_context(|| format!("writing temporary key file {}", path.display()))
}
fn with_temp_removed(error: anyhow::Error, temp: &Path) -> anyhow::Error {
match fs::remove_file(temp) {
Ok(()) => error,
Err(e) if e.kind() == ErrorKind::NotFound => error,
Err(e) => error.context(format!(
"also failed to remove temporary key file {}: {e}",
temp.display()
)),
}
}
#[cfg(unix)]
pub(super) fn sync_dir(dir: &Path) -> Result<()> {
fs::File::open(dir)
.and_then(|d| d.sync_all())
.with_context(|| format!("syncing key directory {}", dir.display()))
}
#[cfg(not(unix))]
pub(super) fn sync_dir(_dir: &Path) -> Result<()> {
Ok(())
}
fn ssh_public_line(key: &VerifyingKey) -> String {
let public = key.as_bytes();
let mut blob = Vec::with_capacity(8 + SSH_KEY_TYPE.len() + public.len());
blob.extend_from_slice(&(SSH_KEY_TYPE.len() as u32).to_be_bytes());
blob.extend_from_slice(SSH_KEY_TYPE);
blob.extend_from_slice(&(public.len() as u32).to_be_bytes());
blob.extend_from_slice(public);
format!("ssh-ed25519 {}", BASE64_STANDARD.encode(&blob))
}
#[cfg(test)]
mod tests {
use super::*;
fn assert_zod<T: zeroize::ZeroizeOnDrop>() {}
fn public_parts(keys: &DeviceKeys) -> (String, String, [u8; 32]) {
(
keys.age_recipient().to_string(),
keys.ssh_public_key(),
keys.verifying_key().to_bytes(),
)
}
fn file_mode(path: &Path) -> u32 {
use std::os::unix::fs::PermissionsExt;
fs::metadata(path).unwrap().permissions().mode() & 0o777
}
#[test]
fn ssh_line_for_rfc8032_key_matches_openssh_encoding() {
let seed: [u8; 32] = [
0x9d, 0x61, 0xb1, 0x9d, 0xef, 0xfd, 0x5a, 0x60, 0xba, 0x84, 0x4a, 0xf4, 0x92, 0xec,
0x2c, 0xc4, 0x44, 0x49, 0xc5, 0x69, 0x7b, 0x32, 0x69, 0x19, 0x70, 0x3b, 0xac, 0x03,
0x1c, 0xae, 0x7f, 0x60,
];
let key = SigningKey::from_bytes(&seed).verifying_key();
assert_eq!(
ssh_public_line(&key),
"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINdamAGCsQq31Uv+08lkBzoO4XLz2qYjJa8CGmj3B1Ea"
);
}
#[test]
fn ssh_public_key_is_an_openssh_ed25519_line() {
let keys = DeviceKeys::generate().unwrap();
let line = keys.ssh_public_key();
let encoded = line.strip_prefix("ssh-ed25519 ").unwrap();
assert!(encoded.starts_with("AAAAC3NzaC1lZDI1NTE5AAAAI"), "{line}");
assert_eq!(encoded.len(), 68);
assert!(!encoded.contains(' ') && !encoded.contains('='));
}
#[test]
fn secret_bytes_round_trip_keeps_public_keys() {
let keys = DeviceKeys::generate().unwrap();
let secret = keys.to_secret_bytes().unwrap();
assert_eq!(secret.expose().len(), secret.expose().capacity());
let restored = DeviceKeys::from_secret_bytes(secret.expose()).unwrap();
assert_eq!(public_parts(&restored), public_parts(&keys));
assert_eq!(
restored.ssh_signing_key().to_bytes(),
keys.ssh_signing_key().to_bytes()
);
assert_eq!(
restored.signing_key().to_bytes(),
keys.signing_key().to_bytes()
);
}
#[test]
fn the_three_device_keys_are_distinct() {
let keys = DeviceKeys::generate().unwrap();
assert_ne!(keys.ssh_signing_key().verifying_key(), keys.verifying_key());
assert_ne!(
keys.age_identity().to_public().to_string(),
DeviceKeys::generate().unwrap().age_recipient().to_string()
);
assert_ne!(
keys.ssh_signing_key().to_bytes(),
keys.signing_key().to_bytes()
);
}
#[test]
fn secret_blob_is_parsed_strictly() {
let keys = DeviceKeys::generate().unwrap();
let good = keys.to_secret_bytes().unwrap().expose().clone();
let mut wrong_magic = good.clone();
wrong_magic[0] = b'X';
let mut wrong_version = good.clone();
wrong_version[4] = 2;
let mut wrong_len_field = good.clone();
wrong_len_field[6] = wrong_len_field[6].wrapping_add(1);
let mut extra = good.clone();
extra.push(0);
let mut bad_age = good.clone();
bad_age[7] = b'?';
let cases: [(&str, &[u8]); 8] = [
("empty", &[]),
("magic only", &good[..4]),
("truncated", &good[..good.len() - 1]),
("wrong magic", wrong_magic.as_slice()),
("wrong version", wrong_version.as_slice()),
("wrong length field", wrong_len_field.as_slice()),
("trailing byte", extra.as_slice()),
("bad age string", bad_age.as_slice()),
];
let age_secret = keys.age_identity().to_string();
for (name, bytes) in cases {
let err = DeviceKeys::from_secret_bytes(bytes).unwrap_err();
let shown = format!("{err:#}");
assert!(
!shown.contains(age_secret.expose_secret()),
"{name} leaks the secret"
);
}
}
#[test]
fn debug_shows_only_public_parts() {
let keys = DeviceKeys::generate().unwrap();
let shown = format!("{keys:?}");
assert!(shown.contains(&keys.age_recipient().to_string()));
assert!(shown.contains(&keys.ssh_public_key()));
assert!(!shown.contains("AGE-SECRET-KEY-"));
assert!(!shown.contains(&hex(keys.ssh_signing_key().as_bytes())));
assert!(!shown.contains(&hex(keys.signing_key().as_bytes())));
}
#[test]
fn load_or_create_creates_once_then_reloads() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join(DEVICE_KEY_FILE);
let (created, was_created) = DeviceKeys::load_or_create(&path).unwrap();
assert!(was_created);
assert_eq!(file_mode(&path), 0o600);
let on_disk = fs::read(&path).unwrap();
let (loaded, was_created) = DeviceKeys::load_or_create(&path).unwrap();
assert!(!was_created);
assert_eq!(public_parts(&loaded), public_parts(&created));
assert_eq!(fs::read(&path).unwrap(), on_disk);
let names: Vec<String> = fs::read_dir(dir.path())
.unwrap()
.map(|e| e.unwrap().file_name().into_string().unwrap())
.collect();
assert_eq!(names, [DEVICE_KEY_FILE]);
}
#[test]
fn load_or_create_makes_a_private_parent_dir() {
let dir = tempfile::tempdir().unwrap();
let nested = dir.path().join("data");
let path = nested.join(DEVICE_KEY_FILE);
let (_, was_created) = DeviceKeys::load_or_create(&path).unwrap();
assert!(was_created);
assert_eq!(file_mode(&nested), 0o700);
assert_eq!(file_mode(&path), 0o600);
}
#[test]
fn load_or_create_refuses_a_corrupt_file_and_leaves_it() {
let good = DeviceKeys::generate()
.unwrap()
.to_secret_bytes()
.unwrap()
.expose()
.clone();
let mut wrong_magic = good.clone();
wrong_magic[..4].copy_from_slice(b"NOPE");
for contents in [good[..good.len() / 2].to_vec(), wrong_magic, Vec::new()] {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join(DEVICE_KEY_FILE);
fs::write(&path, &contents).unwrap();
let err = DeviceKeys::load_or_create(&path).unwrap_err();
assert!(format!("{err:#}").contains("corrupt"), "{err:#}");
assert_eq!(fs::read(&path).unwrap(), contents);
assert_eq!(fs::read_dir(dir.path()).unwrap().count(), 1);
}
}
#[test]
fn install_keeps_a_file_that_appeared_first() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join(DEVICE_KEY_FILE);
let winner = DeviceKeys::generate().unwrap();
fs::write(&path, winner.to_secret_bytes().unwrap().expose()).unwrap();
let loser = DeviceKeys::generate().unwrap();
let installed =
install_if_absent(dir.path(), &path, loser.to_secret_bytes().unwrap().expose())
.unwrap();
assert!(!installed);
assert_eq!(fs::read_dir(dir.path()).unwrap().count(), 1);
let (loaded, was_created) = DeviceKeys::load_or_create(&path).unwrap();
assert!(!was_created);
assert_eq!(public_parts(&loaded), public_parts(&winner));
}
#[test]
fn secrets_live_in_zeroize_on_drop_types() {
assert_zod::<SigningKey>();
assert_zod::<KeyGuard<Vec<u8>>>();
}
}