use std::collections::{BTreeMap, BTreeSet};
use time::{Duration, OffsetDateTime};
use uuid::Uuid;
use kaniop_operator::crd::SecretRotation;
pub const ORPHAN_GRACE: Duration = Duration::minutes(10);
pub const MAX_TOKENS: usize = 4;
pub const SAFETY_MARGIN: Duration = Duration::days(1);
pub const EXPIRY_WARNING: Duration = Duration::days(2);
const MAX_PERIOD_DAYS: i64 = 365;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ObservedToken {
pub id: Uuid,
pub issued_at: OffsetDateTime,
pub expiry: Option<OffsetDateTime>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ObservedSecret {
pub name: String,
pub token_id: Option<String>,
pub rotation_request: Option<String>,
pub bearer_readable: bool,
pub created_at: Option<OffsetDateTime>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TemplateRef {
pub token_id: Option<String>,
pub config_secret: Option<String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum ConsumerKind {
ReplicaSet,
Pod,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Consumer {
pub kind: ConsumerKind,
pub name: String,
pub token_id: Option<String>,
pub config_secrets: Vec<String>,
}
impl Consumer {
pub fn label(&self) -> String {
let kind = match self.kind {
ConsumerKind::ReplicaSet => "replicaset",
ConsumerKind::Pod => "pod",
};
format!("{kind}/{}", self.name)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TokenWorld {
pub tokens: Vec<ObservedToken>,
pub secrets: Vec<ObservedSecret>,
pub template: Option<TemplateRef>,
pub consumers: Vec<Consumer>,
pub rotate_request: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TokenPolicy {
pub rotation_period: Option<Duration>,
pub safety_margin: Duration,
pub orphan_grace: Duration,
pub max_tokens: usize,
}
impl TokenPolicy {
pub fn from_spec(rotation: Option<&SecretRotation>) -> Self {
let rotation_period = rotation
.filter(|r| r.enabled)
.map(|r| Duration::days(i64::from(r.period_days).clamp(1, MAX_PERIOD_DAYS)));
Self {
rotation_period,
safety_margin: SAFETY_MARGIN,
orphan_grace: ORPHAN_GRACE,
max_tokens: MAX_TOKENS,
}
}
pub fn new_token_expiry(&self, now: OffsetDateTime) -> Option<OffsetDateTime> {
let period = self.rotation_period?;
now.checked_add(period.checked_mul(2)?)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MintReason {
Initial,
BearerLost,
Expired,
Due,
Requested,
}
impl MintReason {
pub fn reason(self) -> &'static str {
match self {
Self::Initial => "Initial",
Self::BearerLost => "BearerLost",
Self::Expired => "Expired",
Self::Due => "Due",
Self::Requested => "Requested",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CurrentToken {
Keep(Uuid),
Mint(MintReason),
Blocked,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TokenPlan {
pub current: CurrentToken,
pub revoke: Vec<Uuid>,
pub gc_secrets: Vec<String>,
pub retiring: Vec<Uuid>,
pub unresolved_consumers: Vec<String>,
}
pub fn plan_tokens(world: &TokenWorld, policy: &TokenPolicy, now: OffsetDateTime) -> TokenPlan {
let tokens: BTreeMap<Uuid, &ObservedToken> = world.tokens.iter().map(|t| (t.id, t)).collect();
let secrets: BTreeMap<&str, &ObservedSecret> =
world.secrets.iter().map(|s| (s.name.as_str(), s)).collect();
let usage = resolve_usage(world, &secrets);
let current = match current_token(world, policy, now, &tokens, &secrets) {
Ok(id) => CurrentToken::Keep(id),
Err(_) if tokens.len() >= policy.max_tokens => CurrentToken::Blocked,
Err(reason) => CurrentToken::Mint(reason),
};
let keep_id = match current {
CurrentToken::Keep(id) => Some(id),
CurrentToken::Mint(_) | CurrentToken::Blocked => None,
};
let young = |t: &ObservedToken| !reached(t.issued_at, policy.orphan_grace, now);
let mut revoke = Vec::new();
let mut retiring = Vec::new();
for (id, t) in &tokens {
if Some(*id) == keep_id {
continue;
}
if usage.unresolved.is_empty() && !usage.in_use.contains(id) && !young(t) {
revoke.push(*id);
} else {
retiring.push(*id);
}
}
let gc_secrets = secrets
.values()
.filter(|s| !usage.referenced_secrets.contains(s.name.as_str()))
.filter(|s| {
parse_id(s.token_id.as_deref())
.and_then(|id| tokens.get(&id))
.is_none_or(|t| !young(t))
})
.map(|s| s.name.clone())
.collect();
TokenPlan {
current,
revoke,
gc_secrets,
retiring,
unresolved_consumers: usage.unresolved.into_iter().collect(),
}
}
struct Usage<'a> {
in_use: BTreeSet<Uuid>,
referenced_secrets: BTreeSet<&'a str>,
unresolved: BTreeSet<String>,
}
fn resolve_usage<'a>(
world: &'a TokenWorld,
secrets: &BTreeMap<&str, &ObservedSecret>,
) -> Usage<'a> {
let mut usage = Usage {
in_use: BTreeSet::new(),
referenced_secrets: BTreeSet::new(),
unresolved: BTreeSet::new(),
};
let template = world.template.as_ref().map(|t| {
(
"template".to_string(),
t.token_id.as_deref(),
t.config_secret
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
)
});
let consumers = world.consumers.iter().map(|c| {
(
c.label(),
c.token_id.as_deref(),
c.config_secrets.iter().map(String::as_str).collect(),
)
});
for (label, annotation, mounted) in template.into_iter().chain(consumers) {
let mut resolved_any = false;
let mut all_resolved = true;
let ids = annotation
.map(|raw| Uuid::parse_str(raw).ok())
.into_iter()
.chain(mounted.iter().map(|name| {
usage.referenced_secrets.insert(name);
secrets
.get(name)
.and_then(|s| parse_id(s.token_id.as_deref()))
}));
for id in ids {
match id {
Some(id) => {
usage.in_use.insert(id);
resolved_any = true;
}
None => all_resolved = false,
}
}
if !(resolved_any && all_resolved) {
usage.unresolved.insert(label);
}
}
usage
}
fn current_token(
world: &TokenWorld,
policy: &TokenPolicy,
now: OffsetDateTime,
tokens: &BTreeMap<Uuid, &ObservedToken>,
secrets: &BTreeMap<&str, &ObservedSecret>,
) -> Result<Uuid, MintReason> {
let template = world.template.as_ref().ok_or(MintReason::Initial)?;
let Some(secret_name) = template.config_secret.as_deref() else {
return Err(match template.token_id {
None => MintReason::Initial,
Some(_) => MintReason::BearerLost,
});
};
let secret = secrets
.get(secret_name)
.filter(|s| s.bearer_readable)
.ok_or(MintReason::BearerLost)?;
let id = parse_id(secret.token_id.as_deref()).ok_or(MintReason::BearerLost)?;
let Some(token) = tokens.get(&id) else {
if !written_within_grace(world, id, policy, now) {
return Err(MintReason::BearerLost);
}
if rotation_requested(world, secret) {
return Err(MintReason::Requested);
}
return Ok(id);
};
let expiring = token.expiry.is_some_and(|expiry| {
expiry
.checked_sub(policy.safety_margin)
.is_none_or(|limit| now >= limit)
});
if expiring {
return Err(MintReason::Expired);
}
if policy
.rotation_period
.is_some_and(|period| reached(token.issued_at, period, now))
{
return Err(MintReason::Due);
}
if rotation_requested(world, secret) {
return Err(MintReason::Requested);
}
Ok(id)
}
fn rotation_requested(world: &TokenWorld, secret: &ObservedSecret) -> bool {
non_empty(world.rotate_request.as_deref())
.is_some_and(|wanted| non_empty(secret.rotation_request.as_deref()) != Some(wanted))
}
fn written_within_grace(
world: &TokenWorld,
id: Uuid,
policy: &TokenPolicy,
now: OffsetDateTime,
) -> bool {
world
.secrets
.iter()
.filter(|s| parse_id(s.token_id.as_deref()) == Some(id))
.all(|s| {
s.created_at
.is_some_and(|created| !reached(created, policy.orphan_grace, now))
})
}
pub fn expires_within_warning(expiry: OffsetDateTime, now: OffsetDateTime) -> bool {
expiry
.checked_sub(EXPIRY_WARNING)
.is_none_or(|limit| now >= limit)
}
fn reached(start: OffsetDateTime, span: Duration, now: OffsetDateTime) -> bool {
start.checked_add(span).is_some_and(|at| now >= at)
}
fn parse_id(raw: Option<&str>) -> Option<Uuid> {
raw.and_then(|r| Uuid::parse_str(r).ok())
}
fn non_empty(value: Option<&str>) -> Option<&str> {
value.filter(|v| !v.is_empty())
}
#[cfg(test)]
mod tests {
use super::*;
const A: Uuid = Uuid::from_u128(0xa);
const B: Uuid = Uuid::from_u128(0xb);
const C: Uuid = Uuid::from_u128(0xc);
const D: Uuid = Uuid::from_u128(0xd);
const E: Uuid = Uuid::from_u128(0xe);
fn now() -> OffsetDateTime {
OffsetDateTime::from_unix_timestamp(1_793_448_000).expect("valid timestamp")
}
fn ago(d: Duration) -> OffsetDateTime {
now() - d
}
fn token(id: Uuid, issued: OffsetDateTime) -> ObservedToken {
ObservedToken {
id,
issued_at: issued,
expiry: None,
}
}
fn token_exp(id: Uuid, issued: OffsetDateTime, expiry: OffsetDateTime) -> ObservedToken {
ObservedToken {
id,
issued_at: issued,
expiry: Some(expiry),
}
}
fn secret(name: &str, id: Uuid) -> ObservedSecret {
ObservedSecret {
name: name.to_string(),
token_id: Some(id.to_string()),
rotation_request: None,
bearer_readable: true,
created_at: None,
}
}
fn secret_at(name: &str, id: Uuid, created: OffsetDateTime) -> ObservedSecret {
ObservedSecret {
created_at: Some(created),
..secret(name, id)
}
}
fn lagging(secret_b_age: Duration) -> TokenWorld {
TokenWorld {
tokens: vec![token(A, ago(Duration::days(3)))],
secrets: vec![
secret_at("s-a", A, ago(Duration::days(3))),
secret_at("s-b", B, ago(secret_b_age)),
],
template: template(B, "s-b"),
consumers: vec![pod("p-a", Some(&A.to_string()), &["s-a"])],
rotate_request: None,
}
}
fn template(id: Uuid, secret: &str) -> Option<TemplateRef> {
Some(TemplateRef {
token_id: Some(id.to_string()),
config_secret: Some(secret.to_string()),
})
}
fn pod(name: &str, id: Option<&str>, secrets: &[&str]) -> Consumer {
Consumer {
kind: ConsumerKind::Pod,
name: name.to_string(),
token_id: id.map(str::to_string),
config_secrets: secrets.iter().map(|s| s.to_string()).collect(),
}
}
fn rs(name: &str, id: Uuid, secret: &str) -> Consumer {
Consumer {
kind: ConsumerKind::ReplicaSet,
name: name.to_string(),
token_id: Some(id.to_string()),
config_secrets: vec![secret.to_string()],
}
}
fn rotation(days: u32) -> TokenPolicy {
TokenPolicy::from_spec(Some(&SecretRotation {
enabled: true,
period_days: days,
}))
}
fn no_rotation() -> TokenPolicy {
TokenPolicy::from_spec(None)
}
fn steady(issued: OffsetDateTime) -> TokenWorld {
TokenWorld {
tokens: vec![token(A, issued)],
secrets: vec![secret("s-a", A)],
template: template(A, "s-a"),
consumers: vec![
rs("rs-a", A, "s-a"),
pod("p-a", Some(&A.to_string()), &["s-a"]),
],
rotate_request: None,
}
}
struct Case {
name: &'static str,
world: TokenWorld,
policy: TokenPolicy,
current: CurrentToken,
revoke: Vec<Uuid>,
gc: Vec<&'static str>,
}
fn cases() -> Vec<Case> {
let old = ago(Duration::days(3));
vec![
Case {
name: "empty world mints Initial",
world: TokenWorld::default(),
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Initial),
revoke: vec![],
gc: vec![],
},
Case {
name: "status loss with valid template token keeps it",
world: steady(old),
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "config change keeps the token while old pods drain",
world: TokenWorld {
tokens: vec![token(A, old)],
secrets: vec![secret("s-a1", A), secret("s-a2", A)],
template: template(A, "s-a2"),
consumers: vec![
rs("rs-old", A, "s-a1"),
pod("p-old", Some(&A.to_string()), &["s-a1"]),
pod("p-new", Some(&A.to_string()), &["s-a2"]),
],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "config change after drain collects old Secret, never the token",
world: TokenWorld {
tokens: vec![token(A, old)],
secrets: vec![secret("s-a1", A), secret("s-a2", A)],
template: template(A, "s-a2"),
consumers: vec![pod("p-new", Some(&A.to_string()), &["s-a2"])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec!["s-a1"],
},
Case {
name: "rotation due mints Due",
world: steady(ago(Duration::days(31))),
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Due),
revoke: vec![],
gc: vec![],
},
Case {
name: "rotation due exactly at the period boundary",
world: steady(ago(Duration::days(30))),
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Due),
revoke: vec![],
gc: vec![],
},
Case {
name: "one second before due keeps",
world: steady(ago(Duration::days(30) - Duration::seconds(1))),
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "expired token mints Expired",
world: TokenWorld {
tokens: vec![token_exp(A, old, ago(Duration::hours(1)))],
..steady(old)
},
policy: no_rotation(),
current: CurrentToken::Mint(MintReason::Expired),
revoke: vec![],
gc: vec![],
},
Case {
name: "expiry within safety margin mints Expired",
world: TokenWorld {
tokens: vec![token_exp(A, old, now() + Duration::hours(23))],
..steady(old)
},
policy: no_rotation(),
current: CurrentToken::Mint(MintReason::Expired),
revoke: vec![],
gc: vec![],
},
Case {
name: "expiry beyond safety margin keeps",
world: TokenWorld {
tokens: vec![token_exp(A, old, now() + Duration::hours(25))],
..steady(old)
},
policy: no_rotation(),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "rotate annotation differing from Secret mints Requested",
world: TokenWorld {
rotate_request: Some("leak-2026-10-31".into()),
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Requested),
revoke: vec![],
gc: vec![],
},
Case {
name: "rotate annotation equal to Secret keeps",
world: TokenWorld {
secrets: vec![ObservedSecret {
rotation_request: Some("leak-1".into()),
..secret("s-a", A)
}],
rotate_request: Some("leak-1".into()),
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "removing the rotate annotation does not rotate",
world: TokenWorld {
secrets: vec![ObservedSecret {
rotation_request: Some("leak-1".into()),
..secret("s-a", A)
}],
rotate_request: None,
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "unreadable bearer mints BearerLost",
world: TokenWorld {
secrets: vec![ObservedSecret {
bearer_readable: false,
..secret("s-a", A)
}],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "deleted config Secret mints BearerLost and holds the token",
world: TokenWorld {
secrets: vec![],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "token revoked out of band mints BearerLost; dangling Secret kept while used",
world: TokenWorld {
tokens: vec![],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "dangling Secret of an out-of-band revoked token is collected once unused",
world: TokenWorld {
tokens: vec![token(B, old)],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![pod("p-b", Some(&B.to_string()), &["s-b"])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec!["s-a"],
},
Case {
name: "old token held while only the template references it",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: Some(TemplateRef {
token_id: Some(A.to_string()),
config_secret: Some("s-b".into()),
}),
consumers: vec![],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec!["s-a"],
},
Case {
name: "old token held while a ReplicaSet uses it",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![rs("rs-a", A, "s-a")],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "old token held while a Terminating pod mounts its Secret (no annotation)",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![pod("p-a-terminating", None, &["s-a"])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "old token held while a pod carries only its annotation",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![pod("p-a", Some(&A.to_string()), &[])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "two tokens both referenced by pods during rollout are both held",
world: TokenWorld {
tokens: vec![token(A, old), token(B, ago(Duration::minutes(1)))],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![
rs("rs-a", A, "s-a"),
rs("rs-b", B, "s-b"),
pod("p-a", Some(&A.to_string()), &["s-a"]),
pod("p-b", Some(&B.to_string()), &["s-b"]),
],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "retired token revoked once unused and its Secret collected",
world: TokenWorld {
tokens: vec![token(A, old), token(B, ago(Duration::hours(1)))],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![pod("p-b", Some(&B.to_string()), &["s-b"])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![A],
gc: vec!["s-a"],
},
Case {
name: "orphan younger than grace is kept",
world: TokenWorld {
tokens: vec![token(A, old), token(B, ago(Duration::minutes(9)))],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "orphan exactly at grace is revoked",
world: TokenWorld {
tokens: vec![token(A, old), token(B, ago(Duration::minutes(10)))],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![B],
gc: vec![],
},
Case {
name: "orphan older than grace is revoked",
world: TokenWorld {
tokens: vec![token(A, old), token(B, ago(Duration::hours(2)))],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![B],
gc: vec![],
},
Case {
name: "young retired token and its Secret from a crash before apply are held",
world: TokenWorld {
tokens: vec![token(A, old), token(B, ago(Duration::minutes(2)))],
secrets: vec![secret("s-a", A), secret("s-b", B)],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "orphan issued in the future (Kanidm clock ahead) is kept",
world: TokenWorld {
tokens: vec![token(A, old), token(B, now() + Duration::minutes(5))],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "more than max tokens blocks minting but still revokes unused ones",
world: TokenWorld {
tokens: vec![
token(A, ago(Duration::days(40))),
token(B, old),
token(C, old),
token(D, ago(Duration::minutes(1))),
token(E, ago(Duration::minutes(1))),
],
..steady(ago(Duration::days(40)))
},
policy: rotation(30),
current: CurrentToken::Blocked,
revoke: vec![B, C],
gc: vec![],
},
Case {
name: "exactly max tokens blocks a mint that would exceed it",
world: TokenWorld {
tokens: vec![
token(A, old),
token(B, ago(Duration::minutes(1))),
token(C, ago(Duration::minutes(1))),
token(D, ago(Duration::minutes(1))),
],
rotate_request: Some("leak".into()),
..steady(old)
},
policy: no_rotation(),
current: CurrentToken::Blocked,
revoke: vec![],
gc: vec![],
},
Case {
name: "more than max tokens does not block a Keep",
world: TokenWorld {
tokens: vec![
token(A, old),
token(B, ago(Duration::minutes(1))),
token(C, ago(Duration::minutes(1))),
token(D, ago(Duration::minutes(1))),
token(E, ago(Duration::minutes(1))),
],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "current never revoked even when template annotation names another token",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![secret("s-b", B)],
template: Some(TemplateRef {
token_id: Some(A.to_string()),
config_secret: Some("s-b".into()),
}),
consumers: vec![pod("p-b", Some(&A.to_string()), &["s-b"])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "current never revoked when a stray Secret claims it and nobody mounts it",
world: TokenWorld {
tokens: vec![token(A, old)],
secrets: vec![secret("s-a", A), secret("stray", A)],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec!["stray"],
},
Case {
name: "unparsable pod annotation blocks every revocation",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![pod("p-weird", Some("not-a-uuid"), &[])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec!["s-a"],
},
Case {
name: "pod mounting a Secret with an unparsable token id blocks every revocation",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![
ObservedSecret {
token_id: Some("garbage".into()),
..secret("s-x", A)
},
secret("s-b", B),
],
template: template(B, "s-b"),
consumers: vec![pod("p-x", None, &["s-x"])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "pod mounting a deleted config Secret blocks every revocation",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old), token(C, old)],
secrets: vec![secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![pod("p-gone", Some(&A.to_string()), &["s-a-deleted"])],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "non-canonical UUID spelling in a pod annotation still holds the token",
world: TokenWorld {
tokens: vec![token(A, old), token(B, old)],
secrets: vec![secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![pod(
"p-a",
Some(&A.simple().to_string().to_uppercase()),
&[],
)],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "unparsable token id on the template Secret mints BearerLost",
world: TokenWorld {
secrets: vec![ObservedSecret {
token_id: Some("nope".into()),
..secret("s-a", A)
}],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "template with a token annotation but no Secret mints BearerLost",
world: TokenWorld {
tokens: vec![token(A, old)],
secrets: vec![],
template: Some(TemplateRef {
token_id: Some(A.to_string()),
config_secret: None,
}),
consumers: vec![],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "template without any reference mints Initial and revokes nothing",
world: TokenWorld {
tokens: vec![token(A, old)],
secrets: vec![],
template: Some(TemplateRef::default()),
consumers: vec![],
rotate_request: None,
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Initial),
revoke: vec![],
gc: vec![],
},
Case {
name: "deployment gone mints Initial and holds tokens pods still use",
world: TokenWorld {
template: None,
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Initial),
revoke: vec![],
gc: vec![],
},
Case {
name: "rotation disabled and no expiry keeps forever",
world: steady(ago(Duration::days(3650))),
policy: no_rotation(),
current: CurrentToken::Keep(A),
revoke: vec![],
gc: vec![],
},
Case {
name: "expired takes precedence over due",
world: TokenWorld {
tokens: vec![token_exp(
A,
ago(Duration::days(61)),
ago(Duration::days(1)),
)],
..steady(ago(Duration::days(61)))
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Expired),
revoke: vec![],
gc: vec![],
},
Case {
name: "replication lag: current token missing inside the grace is kept",
world: lagging(Duration::minutes(2)),
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "replication lag: one second before the grace is still kept",
world: lagging(ORPHAN_GRACE - Duration::seconds(1)),
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec![],
},
Case {
name: "replication lag: current token missing at the grace mints BearerLost",
world: lagging(ORPHAN_GRACE),
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "replication lag: current token missing after the grace mints BearerLost",
world: lagging(Duration::hours(1)),
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "replication lag: unused old token is still revoked inside the grace",
world: TokenWorld {
consumers: vec![pod("p-b", Some(&B.to_string()), &["s-b"])],
..lagging(Duration::minutes(2))
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![A],
gc: vec!["s-a"],
},
Case {
name: "replication lag: an unresolved consumer still holds every revocation",
world: TokenWorld {
consumers: vec![
pod("p-b", Some(&B.to_string()), &["s-b"]),
pod("p-gone", None, &["s-deleted"]),
],
..lagging(Duration::minutes(2))
},
policy: rotation(30),
current: CurrentToken::Keep(B),
revoke: vec![],
gc: vec!["s-a"],
},
Case {
name: "replication lag: a rotation request is still honoured",
world: TokenWorld {
rotate_request: Some("leak".into()),
..lagging(Duration::minutes(2))
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::Requested),
revoke: vec![],
gc: vec![],
},
Case {
name: "replication lag: an older Secret of the same token decides its age",
world: TokenWorld {
secrets: vec![
secret_at("s-a", A, ago(Duration::days(3))),
secret_at("s-b1", B, ago(Duration::days(2))),
secret_at("s-b", B, ago(Duration::minutes(2))),
],
..lagging(Duration::minutes(2))
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec!["s-b1"],
},
Case {
name: "replication lag: a Secret without creation time is not young",
world: TokenWorld {
secrets: vec![
secret_at("s-a", A, ago(Duration::days(3))),
secret("s-b", B),
],
..lagging(Duration::minutes(2))
},
policy: rotation(30),
current: CurrentToken::Mint(MintReason::BearerLost),
revoke: vec![],
gc: vec![],
},
Case {
name: "expired unused tokens are revoked",
world: TokenWorld {
tokens: vec![
token(A, old),
token_exp(B, ago(Duration::days(70)), ago(Duration::days(10))),
],
..steady(old)
},
policy: rotation(30),
current: CurrentToken::Keep(A),
revoke: vec![B],
gc: vec![],
},
]
}
#[test]
fn planner_table() {
let mut failures = Vec::new();
for case in cases() {
let plan = plan_tokens(&case.world, &case.policy, now());
let gc: Vec<String> = case.gc.iter().map(|s| s.to_string()).collect();
if plan.current != case.current || plan.revoke != case.revoke || plan.gc_secrets != gc {
failures.push(format!(
"{}:\n expected current={:?} revoke={:?} gc={:?}\n got current={:?} revoke={:?} gc={:?}",
case.name,
case.current,
case.revoke,
gc,
plan.current,
plan.revoke,
plan.gc_secrets
));
}
}
assert!(failures.is_empty(), "{}", failures.join("\n"));
}
#[test]
fn invariants_hold_for_every_case() {
for case in cases() {
let plan = plan_tokens(&case.world, &case.policy, now());
let revoke: BTreeSet<Uuid> = plan.revoke.iter().copied().collect();
if let CurrentToken::Keep(id) = plan.current {
assert!(!revoke.contains(&id), "{}: current revoked", case.name);
}
let mut referenced: Vec<&Option<String>> =
case.world.consumers.iter().map(|c| &c.token_id).collect();
if let Some(t) = &case.world.template {
referenced.push(&t.token_id);
}
for raw in referenced.into_iter().flatten() {
if let Ok(id) = Uuid::parse_str(raw) {
assert!(!revoke.contains(&id), "{}: in-use {id} revoked", case.name);
}
}
for t in &case.world.tokens {
if revoke.contains(&t.id) {
assert!(
now() - t.issued_at >= ORPHAN_GRACE,
"{}: young token revoked",
case.name
);
}
}
if !plan.unresolved_consumers.is_empty() {
assert!(
plan.revoke.is_empty(),
"{}: revoked while unresolved",
case.name
);
}
if matches!(plan.current, CurrentToken::Mint(_)) {
assert!(
case.world.tokens.len() < case.policy.max_tokens,
"{}: mint would exceed max tokens",
case.name
);
}
let mut sorted = plan.revoke.clone();
sorted.sort();
assert_eq!(sorted, plan.revoke, "{}: revoke unsorted", case.name);
let mut sorted = plan.gc_secrets.clone();
sorted.sort();
assert_eq!(sorted, plan.gc_secrets, "{}: gc unsorted", case.name);
}
}
#[test]
fn output_is_independent_of_input_order() {
for case in cases() {
let mut reversed = case.world.clone();
reversed.tokens.reverse();
reversed.secrets.reverse();
reversed.consumers.reverse();
assert_eq!(
plan_tokens(&case.world, &case.policy, now()),
plan_tokens(&reversed, &case.policy, now()),
"{}",
case.name
);
}
}
#[test]
fn retiring_lists_kept_non_current_tokens() {
let world = TokenWorld {
tokens: vec![
token(A, ago(Duration::days(3))),
token(B, ago(Duration::hours(1))),
],
secrets: vec![secret("s-a", A), secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![rs("rs-a", A, "s-a")],
rotate_request: None,
};
let plan = plan_tokens(&world, &rotation(30), now());
assert_eq!(plan.current, CurrentToken::Keep(B));
assert_eq!(plan.retiring, vec![A]);
assert!(plan.unresolved_consumers.is_empty());
}
#[test]
fn replication_lag_keeps_the_old_token_retiring() {
let plan = plan_tokens(&lagging(Duration::minutes(2)), &rotation(30), now());
assert_eq!(plan.current, CurrentToken::Keep(B));
assert_eq!(plan.retiring, vec![A]);
assert!(plan.revoke.is_empty());
assert!(plan.unresolved_consumers.is_empty());
}
#[test]
fn unresolved_consumers_are_reported_sorted() {
let world = TokenWorld {
tokens: vec![token(A, ago(Duration::days(3)))],
secrets: vec![],
template: Some(TemplateRef {
token_id: Some("bad".into()),
config_secret: None,
}),
consumers: vec![
pod("z", Some("bad"), &[]),
pod("a", None, &["missing"]),
Consumer {
kind: ConsumerKind::ReplicaSet,
name: "r".into(),
token_id: None,
config_secrets: vec![],
},
],
rotate_request: None,
};
let plan = plan_tokens(&world, &rotation(30), now());
assert_eq!(
plan.unresolved_consumers,
vec!["pod/a", "pod/z", "replicaset/r", "template"]
);
assert!(plan.revoke.is_empty());
}
#[test]
fn duplicate_token_entries_count_once() {
let mut world = steady(ago(Duration::days(40)));
world.tokens = vec![
token(A, ago(Duration::days(40))),
token(A, ago(Duration::days(40))),
token(B, ago(Duration::minutes(1))),
token(B, ago(Duration::minutes(1))),
token(C, ago(Duration::minutes(1))),
token(C, ago(Duration::minutes(1))),
];
let plan = plan_tokens(&world, &rotation(30), now());
assert_eq!(plan.current, CurrentToken::Mint(MintReason::Due));
}
#[test]
fn extreme_dates_do_not_panic() {
let world = TokenWorld {
tokens: vec![
token_exp(
A,
OffsetDateTime::new_utc(time::Date::MIN, time::Time::MIDNIGHT),
OffsetDateTime::new_utc(time::Date::MIN, time::Time::MIDNIGHT),
),
token(
B,
OffsetDateTime::new_utc(time::Date::MAX, time::Time::MIDNIGHT),
),
],
secrets: vec![secret("s-b", B)],
template: template(B, "s-b"),
consumers: vec![],
rotate_request: None,
};
let plan = plan_tokens(&world, &rotation(365), now());
assert_eq!(plan.current, CurrentToken::Keep(B));
assert_eq!(plan.revoke, vec![A]);
let world = TokenWorld {
tokens: vec![token_exp(
A,
ago(Duration::days(1)),
OffsetDateTime::new_utc(time::Date::MIN, time::Time::MIDNIGHT),
)],
..steady(ago(Duration::days(1)))
};
assert_eq!(
plan_tokens(&world, &no_rotation(), now()).current,
CurrentToken::Mint(MintReason::Expired)
);
let max = OffsetDateTime::new_utc(time::Date::MAX, time::Time::MIDNIGHT);
assert_eq!(rotation(365).new_token_expiry(max), None);
}
#[test]
fn policy_from_spec() {
assert_eq!(no_rotation().rotation_period, None);
assert_eq!(
TokenPolicy::from_spec(Some(&SecretRotation {
enabled: false,
period_days: 7,
}))
.rotation_period,
None
);
assert_eq!(rotation(7).rotation_period, Some(Duration::days(7)));
assert_eq!(rotation(0).rotation_period, Some(Duration::days(1)));
assert_eq!(
rotation(u32::MAX).rotation_period,
Some(Duration::days(365))
);
assert_eq!(no_rotation().orphan_grace, Duration::minutes(10));
assert_eq!(no_rotation().max_tokens, 4);
}
#[test]
fn new_token_expiry_is_twice_the_period() {
assert_eq!(no_rotation().new_token_expiry(now()), None);
assert_eq!(
rotation(30).new_token_expiry(now()),
Some(now() + Duration::days(60))
);
}
#[test]
fn due_always_precedes_expiry_margin() {
for days in 1..=365 {
let policy = rotation(days);
let issued = now();
let expiry = policy.new_token_expiry(issued).expect("expiry");
let world = TokenWorld {
tokens: vec![token_exp(A, issued, expiry)],
..steady(issued)
};
let at_due = issued + Duration::days(i64::from(days));
assert_eq!(
plan_tokens(&world, &policy, at_due - Duration::seconds(1)).current,
CurrentToken::Keep(A),
"period {days}"
);
let at_margin = expiry - policy.safety_margin;
assert!(at_due <= at_margin, "period {days}");
}
}
#[test]
fn expiry_warning_is_twice_the_safety_margin() {
assert_eq!(EXPIRY_WARNING, SAFETY_MARGIN * 2);
let expiry = now() + EXPIRY_WARNING;
assert!(expires_within_warning(expiry, now()));
assert!(!expires_within_warning(
expiry + Duration::seconds(1),
now()
));
assert!(expires_within_warning(ago(Duration::days(1)), now()));
let min = OffsetDateTime::new_utc(time::Date::MIN, time::Time::MIDNIGHT);
assert!(expires_within_warning(min, now()));
}
#[test]
fn consumer_labels_name_kind_and_object() {
assert_eq!(pod("p-a", None, &[]).label(), "pod/p-a");
assert_eq!(rs("rs-a", A, "s-a").label(), "replicaset/rs-a");
}
#[test]
fn reasons_are_stable() {
assert_eq!(MintReason::Initial.reason(), "Initial");
assert_eq!(MintReason::BearerLost.reason(), "BearerLost");
assert_eq!(MintReason::Expired.reason(), "Expired");
assert_eq!(MintReason::Due.reason(), "Due");
assert_eq!(MintReason::Requested.reason(), "Requested");
}
}