Skip to main content

ash_log/
integrity.rs

1//! Integrity verification mechanisms using sequence numbers, checksums, or combined checks.
2
3use super::AuditEvent;
4use std::sync::atomic::{AtomicU64, Ordering};
5
6/// Audit integrity verification trait
7pub trait AuditIntegrity: Send + Sync {
8    /// Add integrity metadata to event
9    fn add_integrity(&self, event: &mut AuditEvent);
10
11    /// Verify event integrity (default: always passes)
12    fn verify(&self, event: &AuditEvent) -> bool {
13        let _ = event;
14        true // Default: always pass
15    }
16}
17
18/// No integrity checking
19#[derive(Debug, Clone, Copy, Default)]
20pub struct NoIntegrity;
21
22impl AuditIntegrity for NoIntegrity {
23    fn add_integrity(&self, _event: &mut AuditEvent) {
24        // Intentionally no-op
25    }
26}
27
28/// Adds monotonically increasing sequence numbers to detect gaps or duplicates
29#[derive(Debug)]
30pub struct SequenceIntegrity {
31    sequence: AtomicU64,
32}
33
34impl SequenceIntegrity {
35    /// Create a new sequence integrity checker starting at sequence 0
36    #[must_use]
37    pub fn new() -> Self {
38        Self {
39            sequence: AtomicU64::new(0),
40        }
41    }
42
43    /// Create a new sequence integrity checker starting at a specific sequence number
44    #[must_use]
45    pub fn with_start(start: u64) -> Self {
46        Self {
47            sequence: AtomicU64::new(start),
48        }
49    }
50
51    /// Get the current sequence number without incrementing
52    pub fn current(&self) -> u64 {
53        self.sequence.load(Ordering::SeqCst)
54    }
55
56    /// Reset the sequence number
57    pub fn reset(&self, value: u64) {
58        self.sequence.store(value, Ordering::SeqCst);
59    }
60}
61
62impl Default for SequenceIntegrity {
63    fn default() -> Self {
64        Self::new()
65    }
66}
67
68impl AuditIntegrity for SequenceIntegrity {
69    fn add_integrity(&self, event: &mut AuditEvent) {
70        let seq = self.sequence.fetch_add(1, Ordering::SeqCst);
71        event.add_metadata("sequence", seq);
72    }
73
74    fn verify(&self, event: &AuditEvent) -> bool {
75        // Basic verification: ensure sequence number exists
76        event.metadata.contains_key("sequence")
77    }
78}
79
80/// Adds checksum of event fields to detect tampering
81#[derive(Debug, Clone, Copy, Default)]
82pub struct ChecksumIntegrity;
83
84impl ChecksumIntegrity {
85    /// Create a new checksum integrity checker
86    #[must_use]
87    pub fn new() -> Self {
88        Self
89    }
90
91    /// Calculate checksum for an event
92    fn calculate_checksum(event: &AuditEvent) -> u64 {
93        use std::collections::hash_map::DefaultHasher;
94        use std::hash::{Hash, Hasher};
95        use std::time::UNIX_EPOCH;
96
97        let mut hasher = DefaultHasher::new();
98
99        // Hash event type
100        format!("{:?}", event.event_type).hash(&mut hasher);
101
102        // Hash correlation ID
103        if let Some(ref id) = event.correlation_id {
104            id.hash(&mut hasher);
105        }
106
107        // Hash principal
108        if let Some(ref principal) = event.principal {
109            principal.hash(&mut hasher);
110        }
111
112        // Hash method
113        if let Some(ref method) = event.method {
114            method.hash(&mut hasher);
115        }
116
117        // Hash result
118        format!("{:?}", event.result).hash(&mut hasher);
119
120        // Hash timestamp
121        if let Ok(duration) = event.timestamp.duration_since(UNIX_EPOCH) {
122            duration.as_nanos().hash(&mut hasher);
123        }
124
125        hasher.finish()
126    }
127}
128
129impl AuditIntegrity for ChecksumIntegrity {
130    fn add_integrity(&self, event: &mut AuditEvent) {
131        let checksum = Self::calculate_checksum(event);
132        event.add_metadata("checksum", checksum);
133    }
134
135    fn verify(&self, event: &AuditEvent) -> bool {
136        // Extract stored checksum
137        let stored_checksum = match event.metadata.get("checksum") {
138            Some(serde_json::Value::Number(n)) => n.as_u64(),
139            _ => return false,
140        };
141
142        if let Some(stored) = stored_checksum {
143            // Create a temporary event without the checksum for verification
144            let mut temp_event = event.clone();
145            temp_event.metadata.remove("checksum");
146
147            let calculated = Self::calculate_checksum(&temp_event);
148            stored == calculated
149        } else {
150            false
151        }
152    }
153}
154
155/// Combines multiple integrity mechanisms
156pub struct CombinedIntegrity {
157    mechanisms: Vec<Box<dyn AuditIntegrity>>,
158}
159
160impl CombinedIntegrity {
161    /// Create a new combined integrity checker
162    #[must_use]
163    pub fn new(mechanisms: Vec<Box<dyn AuditIntegrity>>) -> Self {
164        Self { mechanisms }
165    }
166
167    /// Create a new combined integrity checker from Arc-wrapped mechanisms
168    #[must_use]
169    pub fn from_arcs(mechanisms: Vec<std::sync::Arc<dyn AuditIntegrity>>) -> Self {
170        Self {
171            mechanisms: mechanisms
172                .into_iter()
173                .map(|m| -> Box<dyn AuditIntegrity> { Box::new(ArcIntegrityWrapper(m)) })
174                .collect(),
175        }
176    }
177}
178
179impl AuditIntegrity for CombinedIntegrity {
180    fn add_integrity(&self, event: &mut AuditEvent) {
181        for mechanism in &self.mechanisms {
182            mechanism.add_integrity(event);
183        }
184    }
185
186    fn verify(&self, event: &AuditEvent) -> bool {
187        self.mechanisms.iter().all(|m| m.verify(event))
188    }
189}
190
191/// Wrapper to make Arc<dyn AuditIntegrity> work with Box<dyn AuditIntegrity>
192#[derive(Clone)]
193struct ArcIntegrityWrapper(std::sync::Arc<dyn AuditIntegrity>);
194
195impl AuditIntegrity for ArcIntegrityWrapper {
196    fn add_integrity(&self, event: &mut AuditEvent) {
197        self.0.add_integrity(event);
198    }
199
200    fn verify(&self, event: &AuditEvent) -> bool {
201        self.0.verify(event)
202    }
203}
204
205#[cfg(test)]
206mod tests {
207    use super::*;
208    use crate::{AuditEventType, AuditResult};
209
210    #[test]
211    fn test_no_integrity() {
212        let integrity = NoIntegrity;
213        let mut event = AuditEvent::builder()
214            .event_type(AuditEventType::MethodInvocation)
215            .result(AuditResult::Success)
216            .build();
217
218        integrity.add_integrity(&mut event);
219        assert!(event.metadata.is_empty());
220        assert!(integrity.verify(&event));
221    }
222
223    #[test]
224    fn test_sequence_integrity() {
225        let integrity = SequenceIntegrity::new();
226
227        let mut event1 = AuditEvent::builder()
228            .event_type(AuditEventType::MethodInvocation)
229            .result(AuditResult::Success)
230            .build();
231        integrity.add_integrity(&mut event1);
232
233        let mut event2 = AuditEvent::builder()
234            .event_type(AuditEventType::MethodInvocation)
235            .result(AuditResult::Success)
236            .build();
237        integrity.add_integrity(&mut event2);
238
239        // Check sequence numbers
240        let seq1 = event1.metadata.get("sequence").unwrap().as_u64().unwrap();
241        let seq2 = event2.metadata.get("sequence").unwrap().as_u64().unwrap();
242
243        assert_eq!(seq1, 0);
244        assert_eq!(seq2, 1);
245        assert!(integrity.verify(&event1));
246        assert!(integrity.verify(&event2));
247    }
248
249    #[test]
250    fn test_checksum_integrity() {
251        let integrity = ChecksumIntegrity::new();
252
253        let mut event = AuditEvent::builder()
254            .event_type(AuditEventType::AuthenticationAttempt)
255            .principal("user@example.com")
256            .method("login")
257            .result(AuditResult::Success)
258            .build();
259
260        integrity.add_integrity(&mut event);
261        assert!(event.metadata.contains_key("checksum"));
262        assert!(integrity.verify(&event));
263
264        // Tamper with the event
265        event.principal = Some("attacker@example.com".to_string());
266        assert!(!integrity.verify(&event));
267    }
268
269    #[test]
270    fn test_combined_integrity() {
271        let combined = CombinedIntegrity::new(vec![
272            Box::new(SequenceIntegrity::new()),
273            Box::new(ChecksumIntegrity::new()),
274        ]);
275
276        let mut event = AuditEvent::builder()
277            .event_type(AuditEventType::MethodInvocation)
278            .result(AuditResult::Success)
279            .build();
280
281        combined.add_integrity(&mut event);
282        assert!(event.metadata.contains_key("sequence"));
283        assert!(event.metadata.contains_key("checksum"));
284        assert!(combined.verify(&event));
285    }
286}