qualia_core_db/specialized_libs/cryptographic_library/
hashing.rs

1// Part of the cryptographic_library module (split from the former mod.rs monolith
2// per CLAUDE.md §11 — pure code motion, no behaviour change).
3use super::*;
4
5/// Hash engine for cryptographic hashing
6pub struct HashEngine {
7    hash_algorithms: HashMap<String, HashAlgorithmImpl>,
8    pub(super) hash_storage: HashStorage,
9    pub(super) performance_optimizer: HashPerformanceOptimizer,
10}
11
12/// Hash algorithm implementation
13#[derive(Debug, Clone)]
14pub struct HashAlgorithmImpl {
15    pub algorithm_id: String,
16    pub algorithm: String,
17    pub output_size: usize,
18    pub block_size: usize,
19    pub parameters: HashParameters,
20}
21
22/// Hash parameters
23#[derive(Debug, Clone)]
24pub struct HashParameters {
25    pub rounds: u32,
26    pub personalization: Option<Vec<u8>>,
27    pub salt: Option<Vec<u8>>,
28    pub custom_params: HashMap<String, Vec<u8>>,
29}
30
31/// Hash storage
32pub struct HashStorage {
33    hashes: HashMap<String, HashResult>,
34    verification_records: HashMap<String, HashVerificationRecord>,
35    pub(super) audit_log: HashAuditLog,
36}
37
38/// Hash record
39#[derive(Debug, Clone)]
40pub struct HashRecord {
41    pub hash_id: String,
42    pub algorithm: String,
43    pub input_data: Vec<u8>,
44    pub hash_value: Vec<u8>,
45    pub timestamp: u64,
46    pub metadata: HashMetadata,
47}
48
49/// Hash metadata
50#[derive(Debug, Clone)]
51pub struct HashMetadata {
52    pub creator_id: String,
53    pub purpose: String,
54    pub context: Vec<String>,
55    pub data_size: usize,
56}
57
58/// Hash verification record
59#[derive(Debug, Clone)]
60pub struct HashVerificationRecord {
61    pub verification_id: String,
62    pub hash_id: String,
63    pub verifier_id: String,
64    pub result: HashVerificationResult,
65    pub timestamp: u64,
66}
67
68/// Hash verification result
69#[derive(Debug, Clone)]
70pub struct HashVerificationResult {
71    pub valid: bool,
72    pub error_message: Option<String>,
73    pub verification_time: u64,
74}
75
76/// Hash audit log
77pub struct HashAuditLog {
78    entries: Vec<HashAuditEntry>,
79    retention_policy: RetentionPolicy,
80}
81
82/// Hash audit entry
83#[derive(Debug, Clone)]
84pub struct HashAuditEntry {
85    pub entry_id: String,
86    pub timestamp: u64,
87    pub hash_id: String,
88    pub operation: HashOperation,
89    pub user_id: String,
90    pub ip_address: String,
91    pub success: bool,
92}
93
94/// Hash operations
95#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
96pub enum HashOperation {
97    Compute,
98    Verify,
99    Update,
100    Delete,
101}
102
103/// Hash performance optimizer
104pub struct HashPerformanceOptimizer {
105    optimization_strategies: Vec<HashOptimizationStrategy>,
106    performance_metrics: HashPerformanceMetrics,
107}
108
109/// Hash optimization strategies
110#[derive(Debug, Clone, PartialEq)]
111pub enum HashOptimizationStrategy {
112    BatchHashing,
113    ParallelProcessing,
114    HardwareAcceleration,
115    Caching,
116    MemoryOptimization,
117}
118
119/// Hash performance metrics
120#[derive(Debug, Clone)]
121pub struct HashPerformanceMetrics {
122    pub average_hash_time: f64,
123    pub throughput: f64,
124    pub memory_usage: u64,
125    pub cache_hit_rate: f64,
126}
127impl HashEngine {
128    pub fn new() -> Self {
129        Self {
130            hash_algorithms: HashMap::new(),
131            hash_storage: HashStorage::new(),
132            performance_optimizer: HashPerformanceOptimizer::new(),
133        }
134    }
135
136    pub fn initialize(&mut self) -> Result<(), CryptographicError> {
137        self.hash_storage.initialize()?;
138        self.performance_optimizer.initialize()?;
139        Ok(())
140    }
141
142    /// Register a hash algorithm implementation.
143    pub fn add_hash_algorithm(&mut self, name: String, implementation: HashAlgorithmImpl) {
144        self.hash_algorithms.insert(name, implementation);
145    }
146
147    /// Look up a hash algorithm implementation by name.
148    pub fn get_hash_algorithm(&self, name: &str) -> Option<&HashAlgorithmImpl> {
149        self.hash_algorithms.get(name)
150    }
151
152    /// Iterate over all registered hash algorithm implementations.
153    pub fn list_hash_algorithms(&self) -> impl Iterator<Item = &HashAlgorithmImpl> {
154        self.hash_algorithms.values()
155    }
156
157    pub fn compute_hash(
158        &mut self,
159        algorithm: &str,
160        data: &[u8],
161    ) -> Result<HashResult, CryptographicError> {
162        let start_time = std::time::Instant::now();
163
164        // Compute hash
165        let hash_value = match algorithm {
166            "SHA256" => {
167                use sha2::{Digest, Sha256};
168                let mut hasher = Sha256::new();
169                hasher.update(data);
170                hasher.finalize().to_vec()
171            }
172            "SHA512" => {
173                use sha2::{Digest, Sha512};
174                let mut hasher = Sha512::new();
175                hasher.update(data);
176                hasher.finalize().to_vec()
177            }
178            "BLAKE3" => blake3::hash(data).as_bytes().to_vec(),
179            _ => {
180                return Err(CryptographicError::UnsupportedAlgorithm(
181                    "Hash algorithm not supported".to_string(),
182                ))
183            }
184        };
185
186        let hash_result = HashResult {
187            hash_id: format!(
188                "hash_{}",
189                std::time::SystemTime::now()
190                    .duration_since(std::time::UNIX_EPOCH)
191                    .unwrap()
192                    .as_secs()
193            ),
194            algorithm: algorithm.to_string(),
195            input_data: data.to_vec(),
196            hash_value,
197            timestamp: start_time.elapsed().as_millis() as u64,
198        };
199
200        // Store hash
201        self.hash_storage.store_hash(hash_result.clone())?;
202
203        // Audit log the hash computation
204        self.hash_storage.audit_log.log_entry(
205            &hash_result.hash_id,
206            HashOperation::Compute,
207            "system",
208            true,
209        );
210
211        // Record performance metrics
212        self.performance_optimizer
213            .record_hash_time(start_time.elapsed().as_millis() as f64);
214
215        Ok(hash_result)
216    }
217}
218
219impl HashStorage {
220    pub fn new() -> Self {
221        Self {
222            hashes: HashMap::new(),
223            verification_records: HashMap::new(),
224            audit_log: HashAuditLog::new(),
225        }
226    }
227
228    pub fn initialize(&mut self) -> Result<(), CryptographicError> {
229        Ok(())
230    }
231
232    pub fn store_hash(&mut self, hash: HashResult) -> Result<(), CryptographicError> {
233        self.hashes.insert(hash.hash_id.clone(), hash);
234        Ok(())
235    }
236
237    /// Store a hash verification record.
238    pub fn store_verification_record(
239        &mut self,
240        record: HashVerificationRecord,
241    ) -> Result<(), CryptographicError> {
242        self.verification_records
243            .insert(record.verification_id.clone(), record);
244        Ok(())
245    }
246
247    /// Look up a hash verification record by id.
248    pub fn get_verification_record(&self, id: &str) -> Option<&HashVerificationRecord> {
249        self.verification_records.get(id)
250    }
251
252    /// Iterate over all stored hash verification records.
253    pub fn list_verification_records(&self) -> impl Iterator<Item = &HashVerificationRecord> {
254        self.verification_records.values()
255    }
256}
257
258impl HashAuditLog {
259    pub fn new() -> Self {
260        Self {
261            entries: Vec::new(),
262            retention_policy: RetentionPolicy {
263                retention_days: 365,
264                auto_delete: true,
265                archive_before_delete: true,
266            },
267        }
268    }
269
270    /// Record a hash operation (compute, verify, update, delete).
271    pub fn log_entry(
272        &mut self,
273        hash_id: &str,
274        operation: HashOperation,
275        user_id: &str,
276        success: bool,
277    ) {
278        let timestamp = std::time::SystemTime::now()
279            .duration_since(std::time::UNIX_EPOCH)
280            .unwrap_or_default()
281            .as_secs();
282        let entry = HashAuditEntry {
283            entry_id: format!("hash_{}_{}", timestamp, self.entries.len()),
284            timestamp,
285            hash_id: hash_id.to_string(),
286            operation,
287            user_id: user_id.to_string(),
288            ip_address: String::new(),
289            success,
290        };
291        self.entries.push(entry);
292        let cutoff =
293            timestamp.saturating_sub((self.retention_policy.retention_days as u64) * 86400);
294        self.entries.retain(|e| e.timestamp >= cutoff);
295    }
296
297    /// Number of logged entries.
298    pub fn entry_count(&self) -> usize {
299        self.entries.len()
300    }
301
302    /// Iterate over entries.
303    pub fn entries(&self) -> &[HashAuditEntry] {
304        &self.entries
305    }
306}
307
308impl HashPerformanceOptimizer {
309    pub fn new() -> Self {
310        Self {
311            optimization_strategies: vec![
312                HashOptimizationStrategy::BatchHashing,
313                HashOptimizationStrategy::ParallelProcessing,
314            ],
315            performance_metrics: HashPerformanceMetrics {
316                average_hash_time: 0.0,
317                throughput: 0.0,
318                memory_usage: 0,
319                cache_hit_rate: 0.0,
320            },
321        }
322    }
323
324    pub fn initialize(&mut self) -> Result<(), CryptographicError> {
325        Ok(())
326    }
327
328    /// Get the configured optimization strategies.
329    pub fn optimization_strategies(&self) -> &[HashOptimizationStrategy] {
330        &self.optimization_strategies
331    }
332
333    /// Add an optimization strategy if not already present.
334    pub fn add_optimization_strategy(&mut self, strategy: HashOptimizationStrategy) {
335        if !self.optimization_strategies.contains(&strategy) {
336            self.optimization_strategies.push(strategy);
337        }
338    }
339
340    /// Record a hash computation duration (milliseconds).
341    pub fn record_hash_time(&mut self, duration_ms: f64) {
342        let m = &mut self.performance_metrics;
343        if m.average_hash_time == 0.0 {
344            m.average_hash_time = duration_ms;
345        } else {
346            m.average_hash_time = 0.9 * m.average_hash_time + 0.1 * duration_ms;
347        }
348        if m.average_hash_time > 0.0 {
349            m.throughput = 1000.0 / m.average_hash_time;
350        }
351    }
352
353    /// Get a snapshot of the current performance metrics.
354    pub fn metrics(&self) -> &HashPerformanceMetrics {
355        &self.performance_metrics
356    }
357}
358
359impl HashPerformanceMetrics {
360    pub fn new() -> Self {
361        Self {
362            average_hash_time: 0.0,
363            throughput: 0.0,
364            memory_usage: 0,
365            cache_hit_rate: 0.0,
366        }
367    }
368}
qualia_core_db/specialized_libs/cryptographic_library/hashing.rs

qualia_core_db/specialized_libs/cryptographic_library/
hashing.rs
