Files
rust-discovery/crates/agent/src/certificate_rotation.rs
T
2026-11-13 13:49:11 +01:00

363 lines
13 KiB
Rust

//! 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<Uuid>,
pub previous_until: Option<i64>,
}
#[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<u8>,
pub private_key_pem: Vec<u8>,
}
pub struct RotationOutcome {
pub needs_reconnect: bool,
pub enrollment_generation: u64,
}
pub struct RotationStore {
root: PathBuf,
ca: Vec<u8>,
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<Vec<u8>> {
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<T: Serialize>(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<Self> {
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<DeviceIdentity> {
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::<Vec<_>>();
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(&param)?;
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<bool> {
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<Pending> {
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<RotationOutcome> {
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(())
}
}