use crate::policy::{Policy, Requirement};
use crate::state::VerifiedState;
use proof_verify::PolicyDecision;
use std::collections::HashSet;
#[derive(Debug, Clone, Default)]
pub struct RevocationSet {
pub revoked: HashSet<String>,
}
impl RevocationSet {
pub fn empty() -> Self {
Self::default()
}
pub fn new(ids: impl IntoIterator<Item = String>) -> Self {
Self {
revoked: ids.into_iter().collect(),
}
}
}
#[derive(Debug, Clone)]
pub struct EvalInputs {
pub trusted_issuers: Vec<String>,
pub revocations: RevocationSet,
pub verified_at: u64,
pub skew_leeway: u64,
}
impl Default for EvalInputs {
fn default() -> Self {
Self {
trusted_issuers: vec![],
revocations: RevocationSet::empty(),
verified_at: 0,
skew_leeway: 300,
}
}
}
#[derive(Debug, Clone)]
pub struct RequirementResult {
pub requirement: String,
pub passed: bool,
pub message: String,
}
#[derive(Debug, Clone)]
pub struct PolicyOutcome {
pub policy_id: String,
pub decision: PolicyDecision,
pub note: Option<String>,
pub results: Vec<RequirementResult>,
}
fn pass(req: &str, message: impl Into<String>) -> RequirementResult {
RequirementResult {
requirement: req.into(),
passed: true,
message: message.into(),
}
}
fn fail(req: &str, message: impl Into<String>) -> RequirementResult {
RequirementResult {
requirement: req.into(),
passed: false,
message: message.into(),
}
}
pub fn evaluate_policy(
state: &VerifiedState,
policy: &Policy,
inputs: &EvalInputs,
) -> PolicyOutcome {
if !state.crypto_valid || !state.evidence_valid {
return PolicyOutcome {
policy_id: policy.id.clone(),
decision: PolicyDecision::Indeterminate,
note: Some(format!(
"proof not valid (crypto={}, evidence={}); policy not evaluated",
onoff(state.crypto_valid),
onoff(state.evidence_valid)
)),
results: vec![],
};
}
let mut results = Vec::with_capacity(policy.requirements.len());
for req in &policy.requirements {
results.push(eval_one(req, state, inputs));
}
let decision = if results.iter().all(|r| r.passed) {
PolicyDecision::Pass
} else {
PolicyDecision::Fail
};
PolicyOutcome {
policy_id: policy.id.clone(),
decision,
note: None,
results,
}
}
fn onoff(b: bool) -> &'static str {
if b {
"valid"
} else {
"invalid"
}
}
fn eval_one(req: &Requirement, state: &VerifiedState, inputs: &EvalInputs) -> RequirementResult {
let name = req.describe();
match req {
Requirement::SignatureValid => pass(
&name,
"pipeline established cryptographic validity for this proof",
),
Requirement::IssuerTrusted { issuer } => {
let listed = inputs.trusted_issuers.iter().any(|t| t == issuer);
let present = state.verified_issuers.iter().any(|i| i == issuer);
match (listed, present) {
(true, true) => pass(&name, format!("issuer {issuer} verified and trusted")),
(false, _) => fail(&name, format!("issuer {issuer} not in trust list")),
(true, false) => fail(
&name,
format!("trusted issuer {issuer} has no verified attestation here"),
),
}
}
Requirement::IssuerExcluded { issuer } => {
if state.verified_issuers.iter().any(|i| i == issuer) {
fail(
&name,
format!("excluded issuer {issuer} has a verified attestation in this proof"),
)
} else {
pass(
&name,
format!("excluded issuer {issuer} absent from this proof"),
)
}
}
Requirement::RelationshipExists { relationship } => {
if state.rel_types.contains(relationship) {
pass(
&name,
format!("edge {} present in validated graph", relationship.as_str()),
)
} else {
fail(
&name,
format!("no {} edge in validated graph", relationship.as_str()),
)
}
}
Requirement::NotExpired => {
for (id, (issued, expires)) in state
.attestation_ids
.iter()
.zip(state.attestation_times.iter())
{
if *issued > inputs.verified_at.saturating_add(inputs.skew_leeway) {
return fail(
&name,
format!("attestation {id} issued in the future relative to verifier clock"),
);
}
if let Some(exp) = expires {
if inputs.verified_at > exp.saturating_add(inputs.skew_leeway) {
return fail(&name, format!("attestation {id} expired"));
}
}
}
pass(
&name,
format!(
"{} attestation(s) within validity at {}",
state.attestation_ids.len(),
inputs.verified_at
),
)
}
Requirement::NotRevoked => {
for id in &state.attestation_ids {
if inputs.revocations.revoked.contains(id) {
return fail(&name, format!("attestation {id} revoked"));
}
}
pass(
&name,
format!(
"no known revocation among {} attestation(s)",
state.attestation_ids.len()
),
)
}
Requirement::NotSuperseded => {
if state.superseded_ids.is_empty() {
pass(&name, "no attestation in this proof is superseded")
} else {
fail(
&name,
format!(
"superseded attestation(s) present: {}",
state.superseded_ids.join(", ")
),
)
}
}
Requirement::EvidencePresent { kind } => {
if state.evidence_kinds.contains(kind) {
pass(&name, format!("evidence {} present", kind.as_str()))
} else {
fail(&name, format!("evidence {} missing", kind.as_str()))
}
}
Requirement::TransparencyPresent => {
if state.has_transparency() {
pass(&name, "transparency_receipt present")
} else {
fail(&name, "no transparency_receipt in proof")
}
}
Requirement::ProofFresh { max_age_seconds } => {
let age = inputs.verified_at.saturating_sub(state.proof_created_at);
if age <= *max_age_seconds {
pass(&name, format!("proof age {age}s <= {max_age_seconds}s"))
} else {
fail(&name, format!("proof too old: {age}s > {max_age_seconds}s"))
}
}
}
}