From 91c480c27467c19db652b50d1668d4b23fa24144 Mon Sep 17 00:00:00 2001 From: Kevin Yue Date: Tue, 29 Sep 2026 20:42:27 +0800 Subject: [PATCH] feat: persist opaque device anchors --- Cargo.lock | 3 +- apps/gpservice/Cargo.toml | 2 + apps/gpservice/src/device_anchor.rs | 251 +++++++++++++++++- crates/gpapi/Cargo.toml | 1 - crates/gpapi/src/device_anchor/mod.rs | 85 ++++-- .../gpapi/src/service/transport/credential.rs | 26 +- 6 files changed, 337 insertions(+), 31 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4eb13a9..1a584c9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1850,7 +1850,6 @@ dependencies = [ "humantime", "log", "log-reload", - "mac_address", "md5", "netdev", "openssl", @@ -1976,9 +1975,11 @@ dependencies = [ "compile-time", "env_logger", "futures", + "getrandom 0.4.3", "gpapi", "gphip", "log", + "mac_address", "nix 0.31.3", "openconnect", "serde", diff --git a/apps/gpservice/Cargo.toml b/apps/gpservice/Cargo.toml index 4158522..0122f0f 100644 --- a/apps/gpservice/Cargo.toml +++ b/apps/gpservice/Cargo.toml @@ -28,6 +28,8 @@ thiserror.workspace = true uuid = { workspace = true, features = ["v4"] } zeroize.workspace = true tempfile.workspace = true +getrandom = "0.4" +mac_address = "1" [target.'cfg(unix)'.dependencies] nix = { version = "0.31", features = ["fs", "socket", "user"] } diff --git a/apps/gpservice/src/device_anchor.rs b/apps/gpservice/src/device_anchor.rs index 40d2a48..ed907aa 100644 --- a/apps/gpservice/src/device_anchor.rs +++ b/apps/gpservice/src/device_anchor.rs @@ -17,8 +17,28 @@ struct Record { } pub fn resolve() -> anyhow::Result { - resolve_in(Path::new("/var/lib/gp"), 0, gpapi::device_anchor::collect_unix) - .context("cannot resolve persistent GUI device anchor") + resolve_in(Path::new("/var/lib/gp"), 0, collect_unix).context("cannot resolve persistent GUI device anchor") +} + +fn collect_unix() -> anyhow::Result { + collect_from(mac_address::get_mac_address()?, || { + let mut random = [0_u8; 32]; + getrandom::fill(&mut random).map_err(|_| anyhow::anyhow!("cannot initialize device anchor"))?; + Ok(random) + }) +} + +fn collect_from( + mac: Option, + random: impl FnOnce() -> anyhow::Result<[u8; 32]>, +) -> anyhow::Result { + if let Some(mac) = mac { + let bytes = mac.bytes(); + if bytes != [0; 6] && bytes[0] & 1 == 0 { + return Ok(DeviceAnchor::derive(AnchorSource::UnixMac, bytes)); + } + } + Ok(DeviceAnchor::derive(AnchorSource::UnixRandom, random()?)) } fn validate_metadata(metadata: &fs::Metadata, owner: u32, directory: bool) -> anyhow::Result<()> { @@ -61,7 +81,7 @@ fn read_record(path: &Path, owner: u32) -> anyhow::Result> "unsupported or invalid device anchor record" ); ensure!( - matches!(record.anchor.source, AnchorSource::LinuxMac | AnchorSource::LinuxRandom), + matches!(record.anchor.source, AnchorSource::UnixMac | AnchorSource::UnixRandom), "invalid Unix device anchor source" ); Ok(Some(record.anchor)) @@ -98,7 +118,7 @@ fn resolve_in( } let anchor = collect()?; ensure!( - anchor.validate() && matches!(anchor.source, AnchorSource::LinuxMac | AnchorSource::LinuxRandom), + anchor.validate() && matches!(anchor.source, AnchorSource::UnixMac | AnchorSource::UnixRandom), "invalid collected Unix device anchor" ); let mut temporary = tempfile::NamedTempFile::new_in(directory)?; @@ -120,7 +140,7 @@ mod tests { fn anchor() -> anyhow::Result { Ok(DeviceAnchor { hardware_id: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".to_owned(), - source: AnchorSource::LinuxMac, + source: AnchorSource::UnixMac, }) } @@ -136,4 +156,225 @@ mod tests { anchor().unwrap() ); } + + #[test] + fn collector_preserves_an_eligible_mac_and_randomizes_ineligible_addresses() { + use mac_address::MacAddress; + + let eligible = collect_from(Some(MacAddress::new([0, 17, 34, 51, 68, 85])), || { + anyhow::bail!("must not randomize") + }) + .unwrap(); + assert_eq!( + eligible, + DeviceAnchor::derive(AnchorSource::UnixMac, [0, 17, 34, 51, 68, 85]) + ); + + for rejected in [[0; 6], [1, 2, 3, 4, 5, 6], [0xff; 6]] { + assert_eq!( + collect_from(Some(MacAddress::new(rejected)), || Ok([9; 32])).unwrap(), + DeviceAnchor::derive(AnchorSource::UnixRandom, [9; 32]) + ); + } + assert_eq!( + collect_from(None, || Ok([8; 32])).unwrap(), + DeviceAnchor::derive(AnchorSource::UnixRandom, [8; 32]) + ); + } + + #[test] + fn deleting_the_record_recreates_the_same_mac_anchor() { + let temporary = tempfile::tempdir().unwrap(); + let path = temporary.path().join("state"); + let owner = nix::unistd::Uid::current().as_raw(); + let first = resolve_in(&path, owner, anchor).unwrap(); + fs::remove_file(path.join("hardware-id")).unwrap(); + assert_eq!(resolve_in(&path, owner, anchor).unwrap(), first); + } + + #[test] + fn parallel_first_start_converges_on_one_record() { + use std::sync::{Arc, Barrier}; + + let temporary = tempfile::tempdir().unwrap(); + let path = Arc::new(temporary.path().join("state")); + fs::create_dir(&*path).unwrap(); + fs::set_permissions(&*path, fs::Permissions::from_mode(0o700)).unwrap(); + let owner = nix::unistd::Uid::current().as_raw(); + let barrier = Arc::new(Barrier::new(2)); + let handles: Vec<_> = [AnchorSource::UnixMac, AnchorSource::UnixRandom] + .into_iter() + .map(|source| { + let path = Arc::clone(&path); + let barrier = Arc::clone(&barrier); + std::thread::spawn(move || { + barrier.wait(); + resolve_in(&path, owner, || Ok(DeviceAnchor::derive(source, [source.into()]))) + }) + }) + .collect(); + let results: Vec<_> = handles + .into_iter() + .map(|handle| handle.join().unwrap().unwrap()) + .collect(); + assert_eq!(results[0], results[1]); + assert_eq!( + read_record(&path.join("hardware-id"), owner).unwrap(), + Some(results[0].clone()) + ); + } + + #[test] + fn rejects_malformed_linked_and_unsafe_records() { + use std::os::unix::fs::symlink; + + let owner = nix::unistd::Uid::current().as_raw(); + for case in ["malformed", "symlink", "hard-link", "permissions"] { + let temporary = tempfile::tempdir().unwrap(); + let directory = temporary.path().join("state"); + fs::create_dir(&directory).unwrap(); + fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap(); + let record = directory.join("hardware-id"); + match case { + "malformed" => fs::write(&record, b"not-json").unwrap(), + "symlink" => { + let target = temporary.path().join("target"); + fs::write( + &target, + serde_json::to_vec(&Record { + version: 1, + anchor: anchor().unwrap(), + }) + .unwrap(), + ) + .unwrap(); + symlink(target, &record).unwrap(); + } + "hard-link" => { + fs::write( + &record, + serde_json::to_vec(&Record { + version: 1, + anchor: anchor().unwrap(), + }) + .unwrap(), + ) + .unwrap(); + fs::hard_link(&record, temporary.path().join("second-link")).unwrap(); + } + "permissions" => { + fs::write( + &record, + serde_json::to_vec(&Record { + version: 1, + anchor: anchor().unwrap(), + }) + .unwrap(), + ) + .unwrap(); + fs::set_permissions(&record, fs::Permissions::from_mode(0o644)).unwrap(); + } + _ => unreachable!(), + } + if case != "symlink" && case != "permissions" { + fs::set_permissions(&record, fs::Permissions::from_mode(0o600)).unwrap(); + } + assert!(resolve_in(&directory, owner, anchor).is_err(), "accepted {case}"); + } + } + + #[test] + fn recovers_with_an_interrupted_temporary_file_present() { + let temporary = tempfile::tempdir().unwrap(); + let directory = temporary.path().join("state"); + fs::create_dir(&directory).unwrap(); + fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap(); + fs::write(directory.join(".hardware-id.interrupted"), b"partial").unwrap(); + assert_eq!( + resolve_in(&directory, nix::unistd::Uid::current().as_raw(), anchor).unwrap(), + anchor().unwrap() + ); + } + + #[test] + fn rejects_unsafe_directory_and_lock_metadata_and_read_only_storage() { + use std::os::unix::fs::symlink; + + let owner = nix::unistd::Uid::current().as_raw(); + + let temporary = tempfile::tempdir().unwrap(); + let directory = temporary.path().join("state"); + fs::create_dir(&directory).unwrap(); + fs::set_permissions(&directory, fs::Permissions::from_mode(0o755)).unwrap(); + assert!(resolve_in(&directory, owner, anchor).is_err()); + + let temporary = tempfile::tempdir().unwrap(); + let directory = temporary.path().join("state"); + fs::create_dir(&directory).unwrap(); + fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap(); + assert!(resolve_in(&directory, owner.wrapping_add(1), anchor).is_err()); + + let temporary = tempfile::tempdir().unwrap(); + let directory = temporary.path().join("state"); + fs::write(&directory, b"not-a-directory").unwrap(); + assert!(resolve_in(&directory, owner, anchor).is_err()); + + for case in ["symlink", "hard-link", "permissions"] { + let temporary = tempfile::tempdir().unwrap(); + let directory = temporary.path().join("state"); + fs::create_dir(&directory).unwrap(); + fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap(); + let lock = directory.join("hardware-id.lock"); + match case { + "symlink" => { + let target = temporary.path().join("target"); + fs::write(&target, b"").unwrap(); + symlink(target, &lock).unwrap(); + } + "hard-link" => { + fs::write(&lock, b"").unwrap(); + fs::set_permissions(&lock, fs::Permissions::from_mode(0o600)).unwrap(); + fs::hard_link(&lock, temporary.path().join("second-link")).unwrap(); + } + "permissions" => { + fs::write(&lock, b"").unwrap(); + fs::set_permissions(&lock, fs::Permissions::from_mode(0o644)).unwrap(); + } + _ => unreachable!(), + } + assert!(resolve_in(&directory, owner, anchor).is_err(), "accepted {case} lock"); + } + + let temporary = tempfile::tempdir().unwrap(); + let directory = temporary.path().join("state"); + fs::create_dir(&directory).unwrap(); + fs::set_permissions(&directory, fs::Permissions::from_mode(0o500)).unwrap(); + assert!(resolve_in(&directory, owner, anchor).is_err()); + fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap(); + } + + #[test] + fn record_serializes_source_as_a_number_and_rejects_unknown_codes() { + let record = Record { + version: 1, + anchor: anchor().unwrap(), + }; + let json = serde_json::to_value(&record).unwrap(); + assert_eq!(json["anchor"]["source"], 1); + assert_eq!( + serde_json::to_string(&record).unwrap(), + r#"{"version":1,"anchor":{"hardware_id":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","source":1}}"# + ); + + for source in [0, 4] { + let json = serde_json::json!({ + "version": 1, + "anchor": { + "hardware_id": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "source": source + } + }); + assert!(serde_json::from_value::(json).is_err()); + } + } } diff --git a/crates/gpapi/Cargo.toml b/crates/gpapi/Cargo.toml index a164319..20521c7 100644 --- a/crates/gpapi/Cargo.toml +++ b/crates/gpapi/Cargo.toml @@ -9,7 +9,6 @@ license = "MIT" common = { path = "../common" } anyhow.workspace = true base64.workspace = true -mac_address = "1" dns-lookup.workspace = true log.workspace = true reqwest.workspace = true diff --git a/crates/gpapi/src/device_anchor/mod.rs b/crates/gpapi/src/device_anchor/mod.rs index c7aaed5..012f42e 100644 --- a/crates/gpapi/src/device_anchor/mod.rs +++ b/crates/gpapi/src/device_anchor/mod.rs @@ -1,15 +1,50 @@ -//! Neutral device-anchor transport model and Linux collection. +//! Neutral device-anchor transport model and deterministic derivation. use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; use serde::{Deserialize, Serialize}; +use std::fmt; #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "snake_case")] +#[serde(try_from = "u8", into = "u8")] pub enum AnchorSource { - LinuxMac, - LinuxRandom, + UnixMac, + UnixRandom, MacosIokit, } +impl From for u8 { + fn from(source: AnchorSource) -> Self { + match source { + AnchorSource::UnixMac => 1, + AnchorSource::UnixRandom => 2, + AnchorSource::MacosIokit => 3, + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InvalidAnchorSource(u8); + +impl fmt::Display for InvalidAnchorSource { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "unsupported device anchor source {}", self.0) + } +} + +impl std::error::Error for InvalidAnchorSource {} + +impl TryFrom for AnchorSource { + type Error = InvalidAnchorSource; + + fn try_from(value: u8) -> Result { + match value { + 1 => Ok(Self::UnixMac), + 2 => Ok(Self::UnixRandom), + 3 => Ok(Self::MacosIokit), + value => Err(InvalidAnchorSource(value)), + } + } +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct DeviceAnchor { @@ -26,8 +61,8 @@ impl DeviceAnchor { pub fn derive(source: AnchorSource, seed: impl AsRef<[u8]>) -> Self { let domain = match source { - AnchorSource::LinuxMac => b"gp-device-anchor:v1:linux-mac:".as_slice(), - AnchorSource::LinuxRandom => b"gp-device-anchor:v1:linux-random:".as_slice(), + AnchorSource::UnixMac => b"gp-device-anchor:v1:unix-mac:".as_slice(), + AnchorSource::UnixRandom => b"gp-device-anchor:v1:unix-random:".as_slice(), AnchorSource::MacosIokit => b"gp-device-anchor:v1:macos-platform-uuid:".as_slice(), }; let mut input = domain.to_vec(); @@ -39,30 +74,36 @@ impl DeviceAnchor { } } -#[cfg(unix)] -pub fn collect_unix() -> anyhow::Result { - if let Some(mac) = mac_address::get_mac_address()? { - let bytes = mac.bytes(); - if bytes != [0; 6] && bytes[0] & 1 == 0 { - return Ok(DeviceAnchor::derive(AnchorSource::LinuxMac, bytes)); - } - } - let mut random = [0_u8; 32]; - getrandom::fill(&mut random).map_err(|_| anyhow::anyhow!("cannot initialize device anchor"))?; - Ok(DeviceAnchor::derive(AnchorSource::LinuxRandom, random)) -} - #[cfg(test)] mod tests { use super::*; #[test] - fn hashes_are_domain_separated_and_canonical() { - let mac = DeviceAnchor::derive(AnchorSource::LinuxMac, [0, 17, 34, 51, 68, 85]); + fn hashes_original_seed_order_with_stable_domain_separation() { + let mac = DeviceAnchor::derive(AnchorSource::UnixMac, [0, 17, 34, 51, 68, 85]); assert!(mac.validate()); + assert_eq!(mac.hardware_id, "UWDOx4AVJEuCAYfJBaPioyGtRfAkJBhMYSi8LuFsE1A"); assert_ne!( mac.hardware_id, - DeviceAnchor::derive(AnchorSource::LinuxRandom, [0, 17, 34, 51, 68, 85]).hardware_id + DeviceAnchor::derive(AnchorSource::UnixMac, [85, 68, 51, 34, 17, 0]).hardware_id + ); + assert_ne!( + mac.hardware_id, + DeviceAnchor::derive(AnchorSource::UnixRandom, [0, 17, 34, 51, 68, 85]).hardware_id ); } + + #[test] + fn source_uses_stable_numeric_json_codes() { + assert_eq!(serde_json::to_string(&AnchorSource::UnixMac).unwrap(), "1"); + assert_eq!(serde_json::to_string(&AnchorSource::UnixRandom).unwrap(), "2"); + assert_eq!(serde_json::to_string(&AnchorSource::MacosIokit).unwrap(), "3"); + assert_eq!( + serde_json::from_str::("1").unwrap(), + AnchorSource::UnixMac + ); + assert!(serde_json::from_str::("0").is_err()); + assert!(serde_json::from_str::("4").is_err()); + assert!(serde_json::from_str::(r#""unix_mac""#).is_err()); + } } diff --git a/crates/gpapi/src/service/transport/credential.rs b/crates/gpapi/src/service/transport/credential.rs index fdb2ee7..aa11140 100644 --- a/crates/gpapi/src/service/transport/credential.rs +++ b/crates/gpapi/src/service/transport/credential.rs @@ -189,13 +189,35 @@ mod tests { fn credential_round_trips_a_validated_device_anchor() { let anchor = DeviceAnchor { hardware_id: general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]), - source: crate::device_anchor::AnchorSource::LinuxMac, + source: crate::device_anchor::AnchorSource::UnixMac, }; let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5") .unwrap() .with_device_anchor(anchor.clone()) .unwrap(); - let decoded = SessionCredential::decode_frame(&credential.encode_frame().unwrap()).unwrap(); + let frame = credential.encode_frame().unwrap(); + let payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap(); + assert_eq!(payload["device_anchor"]["source"], 1); + let decoded = SessionCredential::decode_frame(&frame).unwrap(); assert_eq!(decoded.device_anchor(), Some(&anchor)); } + + #[test] + fn credential_rejects_reserved_and_unknown_anchor_sources() { + let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5").unwrap(); + let frame = credential.encode_frame().unwrap(); + let mut payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap(); + let hardware_id = general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]); + + for source in [0, 4] { + payload["device_anchor"] = serde_json::json!({ + "hardware_id": hardware_id, + "source": source + }); + let bytes = serde_json::to_vec(&payload).unwrap(); + let mut invalid_frame = (bytes.len() as u16).to_be_bytes().to_vec(); + invalid_frame.extend_from_slice(&bytes); + assert!(SessionCredential::decode_frame(&invalid_frame).is_err()); + } + } }