idprova-core 0.1.1

Core library for IDProva — AI agent identity, delegation, and audit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use serde::{Deserialize, Serialize};
use std::fmt;

/// Trust levels for IDProva agent identities.
///
/// Higher levels require more verification and provide stronger guarantees.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub enum TrustLevel {
    /// Self-declared identity. No verification. Any agent can claim L0.
    L0,
    /// Domain-verified. DNS TXT record proves domain ownership.
    L1,
    /// Organization-verified. CA-like verification of the controlling organization.
    L2,
    /// Audited. Third-party security audit of the agent and its environment.
    L3,
    /// Continuously monitored. Real-time behavior analysis and compliance checking.
    L4,
}

impl TrustLevel {
    /// Parse from string (e.g., "L0", "L1", "L2", "L3", "L4").
    pub fn from_str_repr(s: &str) -> Option<Self> {
        match s {
            "L0" => Some(Self::L0),
            "L1" => Some(Self::L1),
            "L2" => Some(Self::L2),
            "L3" => Some(Self::L3),
            "L4" => Some(Self::L4),
            _ => None,
        }
    }

    /// Convert to string representation.
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::L0 => "L0",
            Self::L1 => "L1",
            Self::L2 => "L2",
            Self::L3 => "L3",
            Self::L4 => "L4",
        }
    }

    /// Human-readable description of the trust level.
    pub fn description(&self) -> &'static str {
        match self {
            Self::L0 => "Self-declared — unverified identity claim",
            Self::L1 => "Domain-verified — DNS TXT record confirms domain ownership",
            Self::L2 => "Organization-verified — CA-like verification of controlling entity",
            Self::L3 => "Audited — third-party security audit completed",
            Self::L4 => "Continuously monitored — real-time behavior and compliance analysis",
        }
    }

    /// Check if this trust level meets a minimum requirement.
    pub fn meets_minimum(&self, required: TrustLevel) -> bool {
        *self >= required
    }
}

impl fmt::Display for TrustLevel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_trust_ordering() {
        assert!(TrustLevel::L0 < TrustLevel::L1);
        assert!(TrustLevel::L1 < TrustLevel::L2);
        assert!(TrustLevel::L2 < TrustLevel::L3);
        assert!(TrustLevel::L3 < TrustLevel::L4);
    }

    #[test]
    fn test_meets_minimum() {
        assert!(TrustLevel::L2.meets_minimum(TrustLevel::L1));
        assert!(TrustLevel::L1.meets_minimum(TrustLevel::L1));
        assert!(!TrustLevel::L0.meets_minimum(TrustLevel::L1));
    }

    #[test]
    fn test_parse_roundtrip() {
        for level in [
            TrustLevel::L0,
            TrustLevel::L1,
            TrustLevel::L2,
            TrustLevel::L3,
            TrustLevel::L4,
        ] {
            let s = level.as_str();
            let parsed = TrustLevel::from_str_repr(s).unwrap();
            assert_eq!(parsed, level);
        }
    }
}