1use super::AuditEvent;
4use std::sync::atomic::{AtomicU64, Ordering};
5
6pub trait AuditIntegrity: Send + Sync {
8 fn add_integrity(&self, event: &mut AuditEvent);
10
11 fn verify(&self, event: &AuditEvent) -> bool {
13 let _ = event;
14 true }
16}
17
18#[derive(Debug, Clone, Copy, Default)]
20pub struct NoIntegrity;
21
22impl AuditIntegrity for NoIntegrity {
23 fn add_integrity(&self, _event: &mut AuditEvent) {
24 }
26}
27
28#[derive(Debug)]
30pub struct SequenceIntegrity {
31 sequence: AtomicU64,
32}
33
34impl SequenceIntegrity {
35 #[must_use]
37 pub fn new() -> Self {
38 Self {
39 sequence: AtomicU64::new(0),
40 }
41 }
42
43 #[must_use]
45 pub fn with_start(start: u64) -> Self {
46 Self {
47 sequence: AtomicU64::new(start),
48 }
49 }
50
51 pub fn current(&self) -> u64 {
53 self.sequence.load(Ordering::SeqCst)
54 }
55
56 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 event.metadata.contains_key("sequence")
77 }
78}
79
80#[derive(Debug, Clone, Copy, Default)]
82pub struct ChecksumIntegrity;
83
84impl ChecksumIntegrity {
85 #[must_use]
87 pub fn new() -> Self {
88 Self
89 }
90
91 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 format!("{:?}", event.event_type).hash(&mut hasher);
101
102 if let Some(ref id) = event.correlation_id {
104 id.hash(&mut hasher);
105 }
106
107 if let Some(ref principal) = event.principal {
109 principal.hash(&mut hasher);
110 }
111
112 if let Some(ref method) = event.method {
114 method.hash(&mut hasher);
115 }
116
117 format!("{:?}", event.result).hash(&mut hasher);
119
120 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 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 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
155pub struct CombinedIntegrity {
157 mechanisms: Vec<Box<dyn AuditIntegrity>>,
158}
159
160impl CombinedIntegrity {
161 #[must_use]
163 pub fn new(mechanisms: Vec<Box<dyn AuditIntegrity>>) -> Self {
164 Self { mechanisms }
165 }
166
167 #[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#[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 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 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}