//! Crash-safe device TLS rotation only; never rotates the helper's signing pin. //! The process must hold the existing exclusive agent-state lock while using this //! store. Install returns a mandatory reconnect/Sync signal, not effect authority. use anyhow::{Context, Result, ensure}; use openssl::{ asn1::Asn1Time, ec::{EcGroup, EcKey}, hash::MessageDigest, nid::Nid, pkey::PKey, stack::Stack, x509::{ X509, X509NameBuilder, X509PurposeId, X509Req, X509StoreContext, store::X509StoreBuilder, verify::X509VerifyParam, }, }; use serde::{Deserialize, Serialize}; use std::{ fs::{self, File, OpenOptions}, io::Write, net::SocketAddr, os::unix::fs::{OpenOptionsExt, PermissionsExt}, path::{Path, PathBuf}, }; use uuid::Uuid; const DAY: i64 = 86400; #[derive(Clone, Copy)] pub struct RotationPolicy { pub begin_after_seconds: i64, pub renew_before_seconds: i64, } impl Default for RotationPolicy { fn default() -> Self { Self { begin_after_seconds: 20 * DAY, renew_before_seconds: 10 * DAY, } } } #[derive(Serialize, Deserialize, Clone)] #[serde(deny_unknown_fields)] pub struct Selector { pub schema_version: u32, pub agent_id: Uuid, pub enrollment_generation: u64, pub version: Uuid, pub previous_version: Option, pub previous_until: Option, } #[derive(Serialize, Deserialize)] #[serde(deny_unknown_fields)] struct Pending { schema_version: u32, version: Uuid, base_version: Uuid, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct RenewalResponse { agent_id: Uuid, certificate_pem: String, overlap_seconds: u32, } pub struct DeviceIdentity { pub selector: Selector, pub certificate_pem: Vec, pub private_key_pem: Vec, } pub struct RotationOutcome { pub needs_reconnect: bool, pub enrollment_generation: u64, } pub struct RotationStore { root: PathBuf, ca: Vec, agent: Uuid, enrollment: u64, } fn private_dir(path: &Path) -> Result<()> { if !path.exists() { let mut builder = fs::DirBuilder::new(); use std::os::unix::fs::DirBuilderExt; builder.mode(0o700).create(path)?; } let metadata = fs::symlink_metadata(path)?; ensure!( metadata.is_dir() && !metadata.file_type().is_symlink() && metadata.permissions().mode() & 0o777 == 0o700, "ROTATION_DIRECTORY_NOT_PRIVATE" ); Ok(()) } fn secret(path: &Path) -> Result> { let metadata = fs::symlink_metadata(path)?; ensure!( metadata.is_file() && !metadata.file_type().is_symlink() && metadata.permissions().mode() & 0o777 == 0o600 && metadata.len() <= 65536, "ROTATION_FILE_NOT_PRIVATE" ); Ok(fs::read(path)?) } fn create(path: &Path, data: &[u8]) -> Result<()> { let mut file = OpenOptions::new() .write(true) .create_new(true) .mode(0o600) .open(path)?; file.write_all(data)?; file.sync_all()?; Ok(()) } fn atomic_json(root: &Path, name: &str, value: &T) -> Result<()> { let temp = root.join(format!(".{}.tmp", Uuid::new_v4())); create(&temp, &serde_json::to_vec(value)?)?; fs::rename(temp, root.join(name))?; File::open(root)?.sync_all()?; Ok(()) } impl RotationStore { /// Bootstrap from the existing enrolled key/certificate, not a new identity. /// Existing current.json is never overwritten by bootstrap input. pub fn open(root: &Path, ca: &[u8], agent: Uuid, enrollment: u64) -> Result { ensure!(enrollment > 0, "ROTATION_IDENTITY_INVALID"); private_dir(root)?; private_dir(&root.join("versions"))?; Ok(Self { root: root.into(), ca: ca.into(), agent, enrollment, }) } fn version(&self, id: Uuid) -> PathBuf { self.root.join("versions").join(id.to_string()) } pub fn initialize(&self, cert: &[u8], key: &[u8], now: i64) -> Result<()> { ensure!( !self.root.join("current.json").exists(), "ROTATION_ALREADY_INITIALIZED" ); self.verify(cert, key, now)?; let version = Uuid::new_v4(); let dir = self.version(version); private_dir(&dir)?; create(&dir.join("device.key"), key)?; create(&dir.join("device.pem"), cert)?; File::open(&dir)?.sync_all()?; File::open(self.root.join("versions"))?.sync_all()?; atomic_json( &self.root, "current.json", &Selector { schema_version: 1, agent_id: self.agent, enrollment_generation: self.enrollment, version, previous_version: None, previous_until: None, }, ) } pub fn current(&self, now: i64) -> Result { let selector: Selector = serde_json::from_slice(&secret(&self.root.join("current.json"))?)?; ensure!( selector.schema_version == 1 && selector.agent_id == self.agent && selector.enrollment_generation == self.enrollment, "ROTATION_IDENTITY_CHANGED" ); let dir = self.version(selector.version); private_dir(&dir)?; let certificate_pem = secret(&dir.join("device.pem"))?; let private_key_pem = secret(&dir.join("device.key"))?; self.verify(&certificate_pem, &private_key_pem, now)?; Ok(DeviceIdentity { selector, certificate_pem, private_key_pem, }) } /// Checks full chain, current validity, clientAuth purpose, key and exact CN. /// X509 SSL_CLIENT purpose rejects server-only certificates and CA leaves. fn verify(&self, pem: &[u8], key: &[u8], now: i64) -> Result<()> { let chain = X509::stack_from_pem(pem)?; let leaf = chain.first().context("ROTATION_CERTIFICATE_MISSING")?; let key = PKey::private_key_from_pem(key)?; ensure!(leaf.public_key()?.public_eq(&key), "ROTATION_KEY_MISMATCH"); let names = leaf .subject_name() .entries_by_nid(Nid::COMMONNAME) .collect::>(); ensure!( names.len() == 1 && names[0].data().as_slice() == self.agent.to_string().as_bytes(), "ROTATION_AGENT_MISMATCH" ); let time = Asn1Time::from_unix(now)?; ensure!( leaf.not_before() <= time && leaf.not_after() > time, "ROTATION_EXPIRED_OR_NOT_YET_VALID_RECOVERY_REQUIRED" ); let mut builder = X509StoreBuilder::new()?; for ca in X509::stack_from_pem(&self.ca)? { builder.add_cert(ca)?; } let mut param = X509VerifyParam::new()?; param.set_time(now); param.set_purpose(X509PurposeId::SSL_CLIENT)?; builder.set_param(¶m)?; let mut intermediates = Stack::new()?; for cert in chain.iter().skip(1) { intermediates.push(cert.clone())?; } let mut context = X509StoreContext::new()?; ensure!( context.init(&builder.build(), leaf, &intermediates, |c| c.verify_cert())?, "ROTATION_CERTIFICATE_UNTRUSTED" ); Ok(()) } pub fn due(&self, policy: RotationPolicy, now: i64) -> Result { ensure!( policy.begin_after_seconds > 0 && policy.renew_before_seconds > 0, "ROTATION_POLICY_INVALID" ); let identity = self.current(now)?; let cert = X509::from_pem(&identity.certificate_pem)?; let time = Asn1Time::from_unix(now)?; let age = cert.not_before().diff(&time)?; let left = time.diff(cert.not_after())?; Ok( i64::from(age.days) * DAY + i64::from(age.secs) >= policy.begin_after_seconds || i64::from(left.days) * DAY + i64::from(left.secs) <= policy.renew_before_seconds || self.root.join("pending.json").exists(), ) } /// Persist both key and exact CSR before publishing the pending selector. /// Orphaned versions after a crash are harmless and never selected. fn pending(&self, current: &Selector) -> Result { let path = self.root.join("pending.json"); if path.exists() { let pending: Pending = serde_json::from_slice(&secret(&path)?)?; ensure!( pending.schema_version == 1 && (pending.base_version == current.version || pending.version == current.version), "ROTATION_PENDING_CONFLICT" ); return Ok(pending); } let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1)?; let key = PKey::from_ec_key(EcKey::generate(&group)?)?; let mut name = X509NameBuilder::new()?; name.append_entry_by_text("CN", &self.agent.to_string())?; let mut csr = X509Req::builder()?; csr.set_subject_name(&name.build())?; csr.set_pubkey(&key)?; csr.sign(&key, MessageDigest::sha256())?; let version = Uuid::new_v4(); let dir = self.version(version); private_dir(&dir)?; create(&dir.join("device.key"), &key.private_key_to_pem_pkcs8()?)?; create(&dir.join("request.pem"), &csr.build().to_pem()?)?; File::open(dir)?.sync_all()?; File::open(self.root.join("versions"))?.sync_all()?; let pending = Pending { schema_version: 1, version, base_version: current.version, }; atomic_json(&self.root, "pending.json", &pending)?; Ok(pending) } /// Retry after response loss uses the original key/CSR and old valid mTLS /// identity. Expiry/revocation remains blocked; no automatic re-enrollment. pub async fn renew(&self, address: SocketAddr, now: i64) -> Result { let old = self.current(now)?; let pending = self.pending(&old.selector)?; if pending.version == old.selector.version { self.clear_pending()?; return Ok(RotationOutcome { needs_reconnect: true, enrollment_generation: self.enrollment, }); } let dir = self.version(pending.version); private_dir(&dir)?; let key = secret(&dir.join("device.key"))?; let csr = secret(&dir.join("request.pem"))?; let parsed = X509Req::from_pem(&csr)?; let public = parsed.public_key()?; let private = PKey::private_key_from_pem(&key)?; ensure!( parsed.verify(&public)? && public.public_eq(&private), "ROTATION_PENDING_KEY_MISMATCH" ); let client = crate::https_channel::mtls_client( address, &self.ca, &old.certificate_pem, &old.private_key_pem, )?; let response = client .post(format!( "https://{}:{}/agent/v1/certificates/renew", crate::https_channel::server_name()?, address.port() )) .json(&serde_json::json!({"csr_pem": String::from_utf8(csr)?})) .send() .await?; let bytes = crate::https_channel::bounded_body(response, 65536, "application/json").await?; let response: RenewalResponse = serde_json::from_slice(&bytes)?; ensure!( response.agent_id == self.agent && response.overlap_seconds == 300, "ROTATION_RESPONSE_BINDING_INVALID" ); // Never install a certificate which expired during the network request. let verified_at = now.max(chrono::Utc::now().timestamp()); self.verify(response.certificate_pem.as_bytes(), &key, verified_at)?; // A crash after writing a response but before selector commit retries the // same CSR. A mismatching response must not overwrite staged evidence. let cert_path = dir.join("device.pem"); if cert_path.exists() { ensure!( secret(&cert_path)? == response.certificate_pem.as_bytes(), "ROTATION_RESPONSE_CHANGED" ); } else { create(&cert_path, response.certificate_pem.as_bytes())?; } File::open(&dir)?.sync_all()?; atomic_json( &self.root, "current.json", &Selector { schema_version: 1, agent_id: self.agent, enrollment_generation: self.enrollment, version: pending.version, previous_version: Some(old.selector.version), previous_until: Some(verified_at + 300), }, )?; // Old version is retained, but is never automatically selected on failure. self.clear_pending()?; Ok(RotationOutcome { needs_reconnect: true, enrollment_generation: self.enrollment, }) } fn clear_pending(&self) -> Result<()> { fs::remove_file(self.root.join("pending.json"))?; File::open(&self.root)?.sync_all()?; Ok(()) } }