| use crate::types::{BehavioralTelemetry, TrustState};
|
| use thiserror::Error;
|
|
|
| #[derive(Error, Debug)]
|
| pub enum StateMachineError {
|
| #[error("Invalid transition from {from:?} to {to:?}: {reason}")]
|
| InvalidTransition {
|
| from: TrustState,
|
| to: TrustState,
|
| reason: String,
|
| },
|
| #[error("System is locked in Compromised state (T_-1). Operation rejected.")]
|
| CompromiseLockout,
|
| }
|
|
|
| pub struct SystemStateMachine {
|
| current_state: TrustState,
|
| anomaly_threshold: f32,
|
| }
|
|
|
| impl SystemStateMachine {
|
| pub fn new(anomaly_threshold: f32) -> Self {
|
| Self {
|
| current_state: TrustState::Unauthenticated,
|
| anomaly_threshold,
|
| }
|
| }
|
|
|
| pub fn current_state(&self) -> TrustState {
|
| self.current_state
|
| }
|
|
|
| pub fn handle_device_authenticated(&mut self) -> Result<TrustState, StateMachineError> {
|
| self.assert_not_compromised()?;
|
| if self.current_state != TrustState::Unauthenticated {
|
| return Err(StateMachineError::InvalidTransition {
|
| from: self.current_state,
|
| to: TrustState::DeviceAuthenticated,
|
| reason: "Device authentication is only valid from T0".into(),
|
| });
|
| }
|
| self.current_state = TrustState::DeviceAuthenticated;
|
| Ok(self.current_state)
|
| }
|
|
|
| pub fn handle_behavioral_assertion(
|
| &mut self,
|
| telemetry: &BehavioralTelemetry,
|
| ) -> Result<TrustState, StateMachineError> {
|
| self.assert_not_compromised()?;
|
|
|
| if telemetry.anomaly_score >= self.anomaly_threshold {
|
| self.trigger_compromise();
|
| return Err(StateMachineError::CompromiseLockout);
|
| }
|
|
|
| if self.current_state == TrustState::DeviceAuthenticated && telemetry.anomaly_score < 0.25 {
|
| self.current_state = TrustState::BehavioralContinuity;
|
| }
|
| Ok(self.current_state)
|
| }
|
|
|
| pub fn handle_step_up_auth(&mut self) -> Result<TrustState, StateMachineError> {
|
| self.assert_not_compromised()?;
|
| if self.current_state != TrustState::BehavioralContinuity {
|
| return Err(StateMachineError::InvalidTransition {
|
| from: self.current_state,
|
| to: TrustState::HighAssurance,
|
| reason: "Step-up authentication requires active T2 state".into(),
|
| });
|
| }
|
| self.current_state = TrustState::HighAssurance;
|
| Ok(self.current_state)
|
| }
|
|
|
| pub fn handle_critical_elevation(&mut self) -> Result<TrustState, StateMachineError> {
|
| self.assert_not_compromised()?;
|
| if self.current_state != TrustState::HighAssurance {
|
| return Err(StateMachineError::InvalidTransition {
|
| from: self.current_state,
|
| to: TrustState::CriticalElevation,
|
| reason: "Critical elevation requires active T3 state".into(),
|
| });
|
| }
|
| self.current_state = TrustState::CriticalElevation;
|
| Ok(self.current_state)
|
| }
|
|
|
| pub fn trigger_compromise(&mut self) -> TrustState {
|
| self.current_state = TrustState::Compromised;
|
| TrustState::Compromised
|
| }
|
|
|
| pub fn handle_hardware_recovery_reset(&mut self) -> Result<TrustState, StateMachineError> {
|
| if self.current_state != TrustState::Compromised {
|
| return Err(StateMachineError::InvalidTransition {
|
| from: self.current_state,
|
| to: TrustState::Unauthenticated,
|
| reason: "Recovery reset is only valid from T_-1 state".into(),
|
| });
|
| }
|
| self.current_state = TrustState::Unauthenticated;
|
| Ok(self.current_state)
|
| }
|
|
|
| fn assert_not_compromised(&self) -> Result<(), StateMachineError> {
|
| if self.current_state == TrustState::Compromised {
|
| Err(StateMachineError::CompromiseLockout)
|
| } else {
|
| Ok(())
|
| }
|
| }
|
| }
|
|
|
| #[cfg(test)]
|
| mod tests {
|
| use super::*;
|
|
|
| fn low_risk_telemetry() -> BehavioralTelemetry {
|
| BehavioralTelemetry {
|
| anomaly_score: 0.05,
|
| cadence_entropy: 0.95,
|
| spatial_risk_factor: 0.01,
|
| timestamp: 0,
|
| }
|
| }
|
|
|
| #[test]
|
| fn starts_unauthenticated() {
|
| let sm = SystemStateMachine::new(0.7);
|
| assert_eq!(sm.current_state(), TrustState::Unauthenticated);
|
| }
|
|
|
| #[test]
|
| fn full_happy_path_escalation() {
|
| let mut sm = SystemStateMachine::new(0.7);
|
| sm.handle_device_authenticated().unwrap();
|
| assert_eq!(sm.current_state(), TrustState::DeviceAuthenticated);
|
|
|
| sm.handle_behavioral_assertion(&low_risk_telemetry())
|
| .unwrap();
|
| assert_eq!(sm.current_state(), TrustState::BehavioralContinuity);
|
|
|
| sm.handle_step_up_auth().unwrap();
|
| assert_eq!(sm.current_state(), TrustState::HighAssurance);
|
|
|
| sm.handle_critical_elevation().unwrap();
|
| assert_eq!(sm.current_state(), TrustState::CriticalElevation);
|
| }
|
|
|
| #[test]
|
| fn cannot_skip_states() {
|
| let mut sm = SystemStateMachine::new(0.7);
|
| assert!(sm.handle_step_up_auth().is_err());
|
| assert!(sm.handle_critical_elevation().is_err());
|
| }
|
|
|
| #[test]
|
| fn high_anomaly_triggers_compromise() {
|
| let mut sm = SystemStateMachine::new(0.5);
|
| sm.handle_device_authenticated().unwrap();
|
|
|
| let risky = BehavioralTelemetry {
|
| anomaly_score: 0.9,
|
| cadence_entropy: 0.1,
|
| spatial_risk_factor: 0.8,
|
| timestamp: 0,
|
| };
|
| let result = sm.handle_behavioral_assertion(&risky);
|
| assert!(matches!(result, Err(StateMachineError::CompromiseLockout)));
|
| assert_eq!(sm.current_state(), TrustState::Compromised);
|
| }
|
|
|
| #[test]
|
| fn compromised_state_blocks_all_transitions_until_reset() {
|
| let mut sm = SystemStateMachine::new(0.5);
|
| sm.trigger_compromise();
|
|
|
| assert!(sm.handle_device_authenticated().is_err());
|
| assert!(sm
|
| .handle_behavioral_assertion(&low_risk_telemetry())
|
| .is_err());
|
| assert!(sm.handle_step_up_auth().is_err());
|
| assert!(sm.handle_critical_elevation().is_err());
|
|
|
| sm.handle_hardware_recovery_reset().unwrap();
|
| assert_eq!(sm.current_state(), TrustState::Unauthenticated);
|
| }
|
|
|
| #[test]
|
| fn recovery_reset_only_valid_from_compromised() {
|
| let mut sm = SystemStateMachine::new(0.5);
|
| assert!(sm.handle_hardware_recovery_reset().is_err());
|
| }
|
| }
|
|
|
