363 lines
13 KiB
Rust
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(¶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<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(())
|
|
}
|
|
}
|