oxidize_pdf/encryption/
standard_security.rs

1//! Standard Security Handler implementation according to ISO 32000-1
2
3#![allow(clippy::needless_range_loop)]
4
5use crate::encryption::{generate_iv, Aes, AesKey, Permissions, Rc4, Rc4Key};
6use crate::error::Result;
7use crate::objects::ObjectId;
8
9/// Padding used in password processing
10const PADDING: [u8; 32] = [
11    0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,
12    0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80, 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A,
13];
14
15/// User password
16#[derive(Debug, Clone)]
17pub struct UserPassword(pub String);
18
19/// Owner password
20#[derive(Debug, Clone)]
21pub struct OwnerPassword(pub String);
22
23/// Encryption key
24#[derive(Debug, Clone)]
25pub struct EncryptionKey {
26    /// Key bytes
27    pub key: Vec<u8>,
28}
29
30impl EncryptionKey {
31    /// Create from bytes
32    pub fn new(key: Vec<u8>) -> Self {
33        Self { key }
34    }
35
36    /// Get key length in bytes
37    pub fn len(&self) -> usize {
38        self.key.len()
39    }
40
41    /// Check if empty
42    pub fn is_empty(&self) -> bool {
43        self.key.is_empty()
44    }
45
46    /// Get key as bytes
47    pub fn as_bytes(&self) -> &[u8] {
48        &self.key
49    }
50}
51
52/// Security handler revision
53#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
54pub enum SecurityHandlerRevision {
55    /// Revision 2 (RC4 40-bit)
56    R2 = 2,
57    /// Revision 3 (RC4 128-bit)
58    R3 = 3,
59    /// Revision 4 (RC4 128-bit with metadata encryption control)
60    R4 = 4,
61    /// Revision 5 (AES-256 with improved password validation)
62    R5 = 5,
63    /// Revision 6 (AES-256 with Unicode password support)
64    R6 = 6,
65}
66
67/// Standard Security Handler
68pub struct StandardSecurityHandler {
69    /// Revision
70    pub revision: SecurityHandlerRevision,
71    /// Key length in bytes
72    pub key_length: usize,
73}
74
75impl StandardSecurityHandler {
76    /// Create handler for RC4 40-bit encryption
77    pub fn rc4_40bit() -> Self {
78        Self {
79            revision: SecurityHandlerRevision::R2,
80            key_length: 5,
81        }
82    }
83
84    /// Create handler for RC4 128-bit encryption
85    pub fn rc4_128bit() -> Self {
86        Self {
87            revision: SecurityHandlerRevision::R3,
88            key_length: 16,
89        }
90    }
91
92    /// Create handler for AES-256 encryption (Revision 5)
93    pub fn aes_256_r5() -> Self {
94        Self {
95            revision: SecurityHandlerRevision::R5,
96            key_length: 32,
97        }
98    }
99
100    /// Create handler for AES-256 encryption (Revision 6)
101    pub fn aes_256_r6() -> Self {
102        Self {
103            revision: SecurityHandlerRevision::R6,
104            key_length: 32,
105        }
106    }
107
108    /// Pad or truncate password to 32 bytes
109    fn pad_password(password: &str) -> [u8; 32] {
110        let mut padded = [0u8; 32];
111        let password_bytes = password.as_bytes();
112        let len = password_bytes.len().min(32);
113
114        // Copy password bytes
115        padded[..len].copy_from_slice(&password_bytes[..len]);
116
117        // Fill remaining with padding
118        if len < 32 {
119            padded[len..].copy_from_slice(&PADDING[..32 - len]);
120        }
121
122        padded
123    }
124
125    /// Compute owner password hash (O entry)
126    pub fn compute_owner_hash(
127        &self,
128        owner_password: &OwnerPassword,
129        user_password: &UserPassword,
130    ) -> Vec<u8> {
131        // Step 1: Pad passwords
132        let owner_pad = Self::pad_password(&owner_password.0);
133        let user_pad = Self::pad_password(&user_password.0);
134
135        // Step 2: Create MD5 hash of owner password
136        let mut hash = md5::compute(&owner_pad).to_vec();
137
138        // Step 3: For revision 3+, do 50 additional iterations
139        if self.revision >= SecurityHandlerRevision::R3 {
140            for _ in 0..50 {
141                hash = md5::compute(&hash).to_vec();
142            }
143        }
144
145        // Step 4: Create RC4 key from hash (truncated to key length)
146        let rc4_key = Rc4Key::from_slice(&hash[..self.key_length]);
147
148        // Step 5: Encrypt user password with RC4
149        let mut result = rc4_encrypt(&rc4_key, &user_pad);
150
151        // Step 6: For revision 3+, do 19 additional iterations
152        if self.revision >= SecurityHandlerRevision::R3 {
153            for i in 1..=19 {
154                let mut key_bytes = hash[..self.key_length].to_vec();
155                for j in 0..self.key_length {
156                    key_bytes[j] ^= i as u8;
157                }
158                let iter_key = Rc4Key::from_slice(&key_bytes);
159                result = rc4_encrypt(&iter_key, &result);
160            }
161        }
162
163        result
164    }
165
166    /// Compute user password hash (U entry)
167    pub fn compute_user_hash(
168        &self,
169        user_password: &UserPassword,
170        owner_hash: &[u8],
171        permissions: Permissions,
172        file_id: Option<&[u8]>,
173    ) -> Result<Vec<u8>> {
174        // Compute encryption key
175        let key = self.compute_encryption_key(user_password, owner_hash, permissions, file_id)?;
176
177        match self.revision {
178            SecurityHandlerRevision::R2 => {
179                // For R2, encrypt padding with key
180                let rc4_key = Rc4Key::from_slice(&key.key);
181                Ok(rc4_encrypt(&rc4_key, &PADDING))
182            }
183            SecurityHandlerRevision::R3 | SecurityHandlerRevision::R4 => {
184                // For R3/R4, compute MD5 hash including file ID
185                let mut data = Vec::new();
186                data.extend_from_slice(&PADDING);
187
188                if let Some(id) = file_id {
189                    data.extend_from_slice(id);
190                }
191
192                let hash = md5::compute(&data);
193
194                // Encrypt hash with RC4
195                let rc4_key = Rc4Key::from_slice(&key.key);
196                let mut result = rc4_encrypt(&rc4_key, hash.as_ref());
197
198                // Do 19 additional iterations
199                for i in 1..=19 {
200                    let mut key_bytes = key.key.clone();
201                    for j in 0..key_bytes.len() {
202                        key_bytes[j] ^= i as u8;
203                    }
204                    let iter_key = Rc4Key::from_slice(&key_bytes);
205                    result = rc4_encrypt(&iter_key, &result);
206                }
207
208                // Result is 32 bytes (16 bytes encrypted hash + 16 bytes arbitrary data)
209                result.resize(32, 0);
210                Ok(result)
211            }
212            SecurityHandlerRevision::R5 | SecurityHandlerRevision::R6 => {
213                // For R5/R6, use AES-based hash computation
214                let aes_key = self.compute_aes_encryption_key(
215                    user_password,
216                    owner_hash,
217                    permissions,
218                    file_id,
219                )?;
220                let hash = sha256(&aes_key.key);
221
222                // For AES revisions, return the hash directly (simplified)
223                Ok(hash)
224            }
225        }
226    }
227
228    /// Compute encryption key from user password
229    pub fn compute_encryption_key(
230        &self,
231        user_password: &UserPassword,
232        owner_hash: &[u8],
233        permissions: Permissions,
234        file_id: Option<&[u8]>,
235    ) -> Result<EncryptionKey> {
236        match self.revision {
237            SecurityHandlerRevision::R5 | SecurityHandlerRevision::R6 => {
238                // For AES revisions, use AES-specific key computation
239                self.compute_aes_encryption_key(user_password, owner_hash, permissions, file_id)
240            }
241            _ => {
242                // For RC4 revisions, use MD5-based key computation
243                // Step 1: Pad password
244                let padded = Self::pad_password(&user_password.0);
245
246                // Step 2: Create hash input
247                let mut data = Vec::new();
248                data.extend_from_slice(&padded);
249                data.extend_from_slice(owner_hash);
250                data.extend_from_slice(&permissions.bits().to_le_bytes());
251
252                if let Some(id) = file_id {
253                    data.extend_from_slice(id);
254                }
255
256                #[cfg(debug_assertions)]
257                {
258                    eprintln!("[DEBUG compute_key] padded[0..8]: {:02x?}", &padded[..8]);
259                    eprintln!("[DEBUG compute_key] owner_hash len: {}", owner_hash.len());
260                    eprintln!(
261                        "[DEBUG compute_key] P bytes: {:02x?}",
262                        permissions.bits().to_le_bytes()
263                    );
264                    eprintln!("[DEBUG compute_key] data len before MD5: {}", data.len());
265                    // Print full data for comparison
266                    let data_hex: String = data.iter().map(|b| format!("{:02x}", b)).collect();
267                    eprintln!("[DEBUG compute_key] full data hex: {}", data_hex);
268
269                    // Verify specific expected hash for debugging
270                    if data_hex == "7573657228bf4e5e4e758a4164004e56fffa01082e2e00b6d0683e802f0ca9fe94e8094419662a774442fb072e3d9f19e9d130ec09a4d0061e78fe920f7ab62ffcffffff9c5b2a0606f918182e6c5cc0cac374d6" {
271                        eprintln!("[DEBUG compute_key] DATA MATCHES EXPECTED - should produce eee5568378306e35...");
272                    }
273                }
274
275                // For R4 with metadata not encrypted, add extra bytes
276                if self.revision == SecurityHandlerRevision::R4 {
277                    // In a full implementation, check EncryptMetadata flag
278                    // For now, assume metadata is encrypted
279                }
280
281                // Step 3: Create MD5 hash
282                let mut hash = md5::compute(&data).to_vec();
283
284                #[cfg(debug_assertions)]
285                {
286                    eprintln!(
287                        "[DEBUG compute_key] initial hash[0..8]: {:02x?}",
288                        &hash[..8]
289                    );
290                    let hash_hex: String = hash.iter().map(|b| format!("{:02x}", b)).collect();
291                    eprintln!("[DEBUG compute_key] full hash: {}", hash_hex);
292                    eprintln!("[DEBUG compute_key] key_length: {}", self.key_length);
293                }
294
295                // Step 4: For revision 3+, do 50 additional iterations
296                if self.revision >= SecurityHandlerRevision::R3 {
297                    for _ in 0..50 {
298                        hash = md5::compute(&hash[..self.key_length]).to_vec();
299                    }
300                }
301
302                // Step 5: Truncate to key length
303                hash.truncate(self.key_length);
304
305                #[cfg(debug_assertions)]
306                {
307                    eprintln!("[DEBUG compute_key] final key: {:02x?}", &hash);
308                }
309
310                Ok(EncryptionKey::new(hash))
311            }
312        }
313    }
314
315    /// Encrypt a string
316    pub fn encrypt_string(&self, data: &[u8], key: &EncryptionKey, obj_id: &ObjectId) -> Vec<u8> {
317        match self.revision {
318            SecurityHandlerRevision::R5 | SecurityHandlerRevision::R6 => {
319                // For AES, use encrypt_aes and handle the Result
320                self.encrypt_aes(data, key, obj_id).unwrap_or_default()
321            }
322            _ => {
323                // For RC4
324                let obj_key = self.compute_object_key(key, obj_id);
325                let rc4_key = Rc4Key::from_slice(&obj_key);
326                rc4_encrypt(&rc4_key, data)
327            }
328        }
329    }
330
331    /// Decrypt a string
332    pub fn decrypt_string(&self, data: &[u8], key: &EncryptionKey, obj_id: &ObjectId) -> Vec<u8> {
333        match self.revision {
334            SecurityHandlerRevision::R5 | SecurityHandlerRevision::R6 => {
335                // For AES, use decrypt_aes and handle the Result
336                self.decrypt_aes(data, key, obj_id).unwrap_or_default()
337            }
338            _ => {
339                // RC4 is symmetric
340                self.encrypt_string(data, key, obj_id)
341            }
342        }
343    }
344
345    /// Encrypt a stream
346    pub fn encrypt_stream(&self, data: &[u8], key: &EncryptionKey, obj_id: &ObjectId) -> Vec<u8> {
347        // For both RC4 and AES, stream encryption is the same as string encryption
348        self.encrypt_string(data, key, obj_id)
349    }
350
351    /// Decrypt a stream
352    pub fn decrypt_stream(&self, data: &[u8], key: &EncryptionKey, obj_id: &ObjectId) -> Vec<u8> {
353        match self.revision {
354            SecurityHandlerRevision::R5 | SecurityHandlerRevision::R6 => {
355                // For AES, use decrypt_aes and handle the Result
356                self.decrypt_aes(data, key, obj_id).unwrap_or_default()
357            }
358            _ => {
359                // For RC4, decrypt is same as encrypt
360                self.decrypt_string(data, key, obj_id)
361            }
362        }
363    }
364
365    /// Encrypt data using AES (for Rev 5/6)
366    pub fn encrypt_aes(
367        &self,
368        data: &[u8],
369        key: &EncryptionKey,
370        obj_id: &ObjectId,
371    ) -> Result<Vec<u8>> {
372        if self.revision < SecurityHandlerRevision::R5 {
373            return Err(crate::error::PdfError::EncryptionError(
374                "AES encryption only supported for Rev 5+".to_string(),
375            ));
376        }
377
378        let obj_key = self.compute_aes_object_key(key, obj_id)?;
379        let aes_key = AesKey::new_256(obj_key)?;
380        let aes = Aes::new(aes_key);
381
382        let iv = generate_iv();
383        let mut result = Vec::new();
384        result.extend_from_slice(&iv);
385
386        let encrypted = aes.encrypt_cbc(data, &iv).map_err(|e| {
387            crate::error::PdfError::EncryptionError(format!("AES encryption failed: {e}"))
388        })?;
389
390        result.extend_from_slice(&encrypted);
391        Ok(result)
392    }
393
394    /// Decrypt data using AES (for Rev 5/6)
395    pub fn decrypt_aes(
396        &self,
397        data: &[u8],
398        key: &EncryptionKey,
399        obj_id: &ObjectId,
400    ) -> Result<Vec<u8>> {
401        if self.revision < SecurityHandlerRevision::R5 {
402            return Err(crate::error::PdfError::EncryptionError(
403                "AES decryption only supported for Rev 5+".to_string(),
404            ));
405        }
406
407        if data.len() < 16 {
408            return Err(crate::error::PdfError::EncryptionError(
409                "AES encrypted data must be at least 16 bytes (IV)".to_string(),
410            ));
411        }
412
413        let iv = &data[0..16];
414        let encrypted_data = &data[16..];
415
416        let obj_key = self.compute_aes_object_key(key, obj_id)?;
417        let aes_key = AesKey::new_256(obj_key)?;
418        let aes = Aes::new(aes_key);
419
420        aes.decrypt_cbc(encrypted_data, iv).map_err(|e| {
421            crate::error::PdfError::EncryptionError(format!("AES decryption failed: {e}"))
422        })
423    }
424
425    /// Compute AES object-specific encryption key for Rev 5/6
426    fn compute_aes_object_key(&self, key: &EncryptionKey, obj_id: &ObjectId) -> Result<Vec<u8>> {
427        if self.revision < SecurityHandlerRevision::R5 {
428            return Err(crate::error::PdfError::EncryptionError(
429                "AES object key computation only for Rev 5+".to_string(),
430            ));
431        }
432
433        // For Rev 5/6, use SHA-256 for key derivation
434        let mut data = Vec::new();
435        data.extend_from_slice(&key.key);
436        data.extend_from_slice(&obj_id.number().to_le_bytes());
437        data.extend_from_slice(&obj_id.generation().to_le_bytes());
438
439        // Add salt for AES
440        data.extend_from_slice(b"sAlT"); // Standard salt for AES
441
442        Ok(sha256(&data))
443    }
444
445    /// Compute encryption key for AES Rev 5/6
446    pub fn compute_aes_encryption_key(
447        &self,
448        user_password: &UserPassword,
449        owner_hash: &[u8],
450        permissions: Permissions,
451        file_id: Option<&[u8]>,
452    ) -> Result<EncryptionKey> {
453        if self.revision < SecurityHandlerRevision::R5 {
454            return Err(crate::error::PdfError::EncryptionError(
455                "AES key computation only for Rev 5+".to_string(),
456            ));
457        }
458
459        // For Rev 5/6, use more secure key derivation
460        let mut data = Vec::new();
461
462        // Use UTF-8 encoding for passwords in Rev 5/6
463        let password_bytes = user_password.0.as_bytes();
464        data.extend_from_slice(password_bytes);
465
466        // Add validation data
467        data.extend_from_slice(owner_hash);
468        data.extend_from_slice(&permissions.bits().to_le_bytes());
469
470        if let Some(id) = file_id {
471            data.extend_from_slice(id);
472        }
473
474        // Use SHA-256 for stronger hashing
475        let mut hash = sha256(&data);
476
477        // Perform additional iterations for Rev 5/6 (simplified)
478        for _ in 0..100 {
479            hash = sha256(&hash);
480        }
481
482        // AES-256 requires 32 bytes
483        hash.truncate(32);
484
485        Ok(EncryptionKey::new(hash))
486    }
487
488    /// Validate user password for AES Rev 5/6
489    pub fn validate_aes_user_password(
490        &self,
491        password: &UserPassword,
492        user_hash: &[u8],
493        permissions: Permissions,
494        file_id: Option<&[u8]>,
495    ) -> Result<bool> {
496        if self.revision < SecurityHandlerRevision::R5 {
497            return Err(crate::error::PdfError::EncryptionError(
498                "AES password validation only for Rev 5+".to_string(),
499            ));
500        }
501
502        let computed_key =
503            self.compute_aes_encryption_key(password, user_hash, permissions, file_id)?;
504
505        // Compare first 32 bytes of computed hash with stored hash
506        let computed_hash = sha256(&computed_key.key);
507
508        Ok(user_hash.len() >= 32 && computed_hash[..32] == user_hash[..32])
509    }
510
511    /// Compute object-specific encryption key (Algorithm 1, ISO 32000-1 §7.6.2)
512    pub fn compute_object_key(&self, key: &EncryptionKey, obj_id: &ObjectId) -> Vec<u8> {
513        let mut data = Vec::new();
514        data.extend_from_slice(&key.key);
515        data.extend_from_slice(&obj_id.number().to_le_bytes()[..3]); // Low 3 bytes
516        data.extend_from_slice(&obj_id.generation().to_le_bytes()[..2]); // Low 2 bytes
517
518        let hash = md5::compute(&data);
519        let key_len = (key.len() + 5).min(16);
520        hash[..key_len].to_vec()
521    }
522
523    /// Validate user password (Algorithm 6, ISO 32000-1 §7.6.3.4)
524    ///
525    /// Returns Ok(true) if password is correct, Ok(false) if incorrect.
526    /// Returns Err only on internal errors.
527    pub fn validate_user_password(
528        &self,
529        password: &UserPassword,
530        user_hash: &[u8],
531        owner_hash: &[u8],
532        permissions: Permissions,
533        file_id: Option<&[u8]>,
534    ) -> Result<bool> {
535        // Compute encryption key from provided password
536        let key = self.compute_encryption_key(password, owner_hash, permissions, file_id)?;
537
538        match self.revision {
539            SecurityHandlerRevision::R2 => {
540                // For R2: Encrypt padding with key and compare with U
541                let rc4_key = Rc4Key::from_slice(&key.key);
542                let encrypted_padding = rc4_encrypt(&rc4_key, &PADDING);
543
544                // Compare with stored user hash
545                Ok(user_hash.len() >= 32 && encrypted_padding[..] == user_hash[..32])
546            }
547            SecurityHandlerRevision::R3 | SecurityHandlerRevision::R4 => {
548                // For R3/R4: Compute MD5 hash including file ID
549                let mut data = Vec::new();
550                data.extend_from_slice(&PADDING);
551
552                if let Some(id) = file_id {
553                    data.extend_from_slice(id);
554                }
555
556                let hash = md5::compute(&data);
557
558                // Encrypt hash with RC4
559                let rc4_key = Rc4Key::from_slice(&key.key);
560                let mut encrypted = rc4_encrypt(&rc4_key, hash.as_ref());
561
562                // Do 19 additional iterations with modified keys
563                for i in 1..=19 {
564                    let mut key_bytes = key.key.clone();
565                    for byte in &mut key_bytes {
566                        *byte ^= i as u8;
567                    }
568                    let iter_key = Rc4Key::from_slice(&key_bytes);
569                    encrypted = rc4_encrypt(&iter_key, &encrypted);
570                }
571
572                // Compare first 16 bytes of result with first 16 bytes of U
573                Ok(user_hash.len() >= 16 && encrypted[..16] == user_hash[..16])
574            }
575            SecurityHandlerRevision::R5 | SecurityHandlerRevision::R6 => {
576                // For R5/R6, use AES-based validation
577                self.validate_aes_user_password(password, user_hash, permissions, file_id)
578            }
579        }
580    }
581
582    /// Validate owner password (Algorithm 7, ISO 32000-1 §7.6.3.4)
583    ///
584    /// Returns Ok(true) if password is correct, Ok(false) if incorrect.
585    /// Returns Err only on internal errors.
586    ///
587    /// Note: For owner password validation, we first decrypt the user password
588    /// from the owner hash, then validate that user password.
589    pub fn validate_owner_password(
590        &self,
591        owner_password: &OwnerPassword,
592        owner_hash: &[u8],
593        _user_password: &UserPassword, // Will be recovered from owner_hash
594        _permissions: Permissions,
595        _file_id: Option<&[u8]>,
596    ) -> Result<bool> {
597        match self.revision {
598            SecurityHandlerRevision::R2
599            | SecurityHandlerRevision::R3
600            | SecurityHandlerRevision::R4 => {
601                // Step 1: Pad owner password
602                let owner_pad = Self::pad_password(&owner_password.0);
603
604                // Step 2: Create MD5 hash of owner password
605                let mut hash = md5::compute(&owner_pad).to_vec();
606
607                // Step 3: For revision 3+, do 50 additional iterations
608                if self.revision >= SecurityHandlerRevision::R3 {
609                    for _ in 0..50 {
610                        hash = md5::compute(&hash).to_vec();
611                    }
612                }
613
614                // Step 4: Create RC4 key from hash (truncated to key length)
615                let rc4_key = Rc4Key::from_slice(&hash[..self.key_length]);
616
617                // Step 5: Decrypt owner hash to get user password
618                let mut decrypted = owner_hash[..32].to_vec();
619
620                // For R3+, do 19 iterations in reverse
621                if self.revision >= SecurityHandlerRevision::R3 {
622                    for i in (0..20).rev() {
623                        let mut key_bytes = hash[..self.key_length].to_vec();
624                        for byte in &mut key_bytes {
625                            *byte ^= i as u8;
626                        }
627                        let iter_key = Rc4Key::from_slice(&key_bytes);
628                        decrypted = rc4_encrypt(&iter_key, &decrypted);
629                    }
630                } else {
631                    // For R2, single decryption
632                    decrypted = rc4_encrypt(&rc4_key, &decrypted);
633                }
634
635                // Step 6: The decrypted data should be the padded user password
636                // Try to validate by computing what the owner hash SHOULD be
637                // with this owner password, and compare
638
639                // Extract potential user password (remove padding)
640                let user_pwd_bytes = decrypted
641                    .iter()
642                    .take_while(|&&b| b != 0x28 || decrypted.starts_with(&PADDING))
643                    .copied()
644                    .collect::<Vec<u8>>();
645
646                let recovered_user =
647                    UserPassword(String::from_utf8_lossy(&user_pwd_bytes).to_string());
648
649                // Compute what owner hash should be with this owner password
650                let computed_owner = self.compute_owner_hash(owner_password, &recovered_user);
651
652                // Compare with stored owner hash
653                Ok(computed_owner[..32] == owner_hash[..32])
654            }
655            SecurityHandlerRevision::R5 | SecurityHandlerRevision::R6 => {
656                // For R5/R6, owner password validation is different
657                // This is a simplified check - full R5/R6 is more complex
658                // For now, return false (not implemented)
659                Ok(false)
660            }
661        }
662    }
663}
664
665/// Helper function for RC4 encryption
666fn rc4_encrypt(key: &Rc4Key, data: &[u8]) -> Vec<u8> {
667    let mut cipher = Rc4::new(key);
668    cipher.process(data)
669}
670
671// Use the md5 crate for actual MD5 hashing (required for PDF encryption)
672
673/// SHA-256 implementation (simplified for example)
674fn sha256(data: &[u8]) -> Vec<u8> {
675    // In production, use a proper SHA-256 implementation like the `sha2` crate
676    // This is a placeholder that provides 32 bytes of deterministic output
677    use std::collections::hash_map::DefaultHasher;
678    use std::hash::{Hash, Hasher};
679
680    let mut hasher = DefaultHasher::new();
681    data.hash(&mut hasher);
682    let hash_value = hasher.finish();
683
684    let mut result = Vec::with_capacity(32);
685
686    // Create 32 bytes from the hash value
687    for i in 0..4 {
688        let shifted = hash_value
689            .wrapping_mul((i + 1) as u64)
690            .wrapping_add(i as u64);
691        result.extend_from_slice(&shifted.to_le_bytes());
692    }
693
694    result
695}
696
697#[cfg(test)]
698mod tests {
699    use super::*;
700
701    #[test]
702    fn test_pad_password() {
703        let padded = StandardSecurityHandler::pad_password("test");
704        assert_eq!(padded.len(), 32);
705        assert_eq!(&padded[..4], b"test");
706        assert_eq!(&padded[4..8], &PADDING[..4]);
707    }
708
709    #[test]
710    fn test_pad_password_long() {
711        let long_password = "a".repeat(40);
712        let padded = StandardSecurityHandler::pad_password(&long_password);
713        assert_eq!(padded.len(), 32);
714        assert_eq!(&padded[..32], &long_password.as_bytes()[..32]);
715    }
716
717    #[test]
718    fn test_rc4_40bit_handler() {
719        let handler = StandardSecurityHandler::rc4_40bit();
720        assert_eq!(handler.revision, SecurityHandlerRevision::R2);
721        assert_eq!(handler.key_length, 5);
722    }
723
724    #[test]
725    fn test_rc4_128bit_handler() {
726        let handler = StandardSecurityHandler::rc4_128bit();
727        assert_eq!(handler.revision, SecurityHandlerRevision::R3);
728        assert_eq!(handler.key_length, 16);
729    }
730
731    #[test]
732    fn test_owner_hash_computation() {
733        let handler = StandardSecurityHandler::rc4_40bit();
734        let owner_pwd = OwnerPassword("owner".to_string());
735        let user_pwd = UserPassword("user".to_string());
736
737        let hash = handler.compute_owner_hash(&owner_pwd, &user_pwd);
738        assert_eq!(hash.len(), 32);
739    }
740
741    #[test]
742    fn test_encryption_key_computation() {
743        let handler = StandardSecurityHandler::rc4_40bit();
744        let user_pwd = UserPassword("user".to_string());
745        let owner_hash = vec![0u8; 32];
746        let permissions = Permissions::new();
747
748        let key = handler
749            .compute_encryption_key(&user_pwd, &owner_hash, permissions, None)
750            .unwrap();
751
752        assert_eq!(key.len(), 5);
753    }
754
755    #[test]
756    fn test_aes_256_r5_handler() {
757        let handler = StandardSecurityHandler::aes_256_r5();
758        assert_eq!(handler.revision, SecurityHandlerRevision::R5);
759        assert_eq!(handler.key_length, 32);
760    }
761
762    #[test]
763    fn test_aes_256_r6_handler() {
764        let handler = StandardSecurityHandler::aes_256_r6();
765        assert_eq!(handler.revision, SecurityHandlerRevision::R6);
766        assert_eq!(handler.key_length, 32);
767    }
768
769    #[test]
770    fn test_aes_encryption_key_computation() {
771        let handler = StandardSecurityHandler::aes_256_r5();
772        let user_pwd = UserPassword("testuser".to_string());
773        let owner_hash = vec![0u8; 32];
774        let permissions = Permissions::new();
775
776        let key = handler
777            .compute_aes_encryption_key(&user_pwd, &owner_hash, permissions, None)
778            .unwrap();
779
780        assert_eq!(key.len(), 32);
781    }
782
783    #[test]
784    fn test_aes_encrypt_decrypt() {
785        let handler = StandardSecurityHandler::aes_256_r5();
786        let key = EncryptionKey::new(vec![0u8; 32]);
787        let obj_id = ObjectId::new(1, 0);
788        let data = b"Hello AES encryption!";
789
790        let encrypted = handler.encrypt_aes(data, &key, &obj_id).unwrap();
791        assert_ne!(encrypted.as_slice(), data);
792        assert!(encrypted.len() > data.len()); // Should include IV
793
794        // Note: This simplified AES implementation is for demonstration only
795        let _decrypted = handler.decrypt_aes(&encrypted, &key, &obj_id);
796        // For now, just test that the operations complete without panicking
797    }
798
799    #[test]
800    fn test_aes_with_rc4_handler_fails() {
801        let handler = StandardSecurityHandler::rc4_128bit();
802        let key = EncryptionKey::new(vec![0u8; 16]);
803        let obj_id = ObjectId::new(1, 0);
804        let data = b"test data";
805
806        // Should fail because handler is not Rev 5+
807        assert!(handler.encrypt_aes(data, &key, &obj_id).is_err());
808        assert!(handler.decrypt_aes(data, &key, &obj_id).is_err());
809    }
810
811    #[test]
812    fn test_aes_decrypt_invalid_data() {
813        let handler = StandardSecurityHandler::aes_256_r5();
814        let key = EncryptionKey::new(vec![0u8; 32]);
815        let obj_id = ObjectId::new(1, 0);
816
817        // Data too short (no IV)
818        let short_data = vec![0u8; 10];
819        assert!(handler.decrypt_aes(&short_data, &key, &obj_id).is_err());
820    }
821
822    #[test]
823    fn test_sha256_deterministic() {
824        let data1 = b"test data";
825        let data2 = b"test data";
826        let data3 = b"different data";
827
828        let hash1 = sha256(data1);
829        let hash2 = sha256(data2);
830        let hash3 = sha256(data3);
831
832        assert_eq!(hash1.len(), 32);
833        assert_eq!(hash2.len(), 32);
834        assert_eq!(hash3.len(), 32);
835
836        assert_eq!(hash1, hash2); // Same input should give same output
837        assert_ne!(hash1, hash3); // Different input should give different output
838    }
839
840    #[test]
841    fn test_security_handler_revision_ordering() {
842        assert!(SecurityHandlerRevision::R2 < SecurityHandlerRevision::R3);
843        assert!(SecurityHandlerRevision::R3 < SecurityHandlerRevision::R4);
844        assert!(SecurityHandlerRevision::R4 < SecurityHandlerRevision::R5);
845        assert!(SecurityHandlerRevision::R5 < SecurityHandlerRevision::R6);
846    }
847
848    #[test]
849    fn test_aes_password_validation() {
850        let handler = StandardSecurityHandler::aes_256_r5();
851        let password = UserPassword("testpassword".to_string());
852        let user_hash = vec![0u8; 32]; // Simplified hash
853        let permissions = Permissions::new();
854
855        // This is a basic test - in practice, the validation would be more complex
856        let result = handler.validate_aes_user_password(&password, &user_hash, permissions, None);
857        assert!(result.is_ok());
858    }
859
860    // ===== Additional Comprehensive Tests =====
861
862    #[test]
863    fn test_user_password_debug() {
864        let pwd = UserPassword("debug_test".to_string());
865        let debug_str = format!("{pwd:?}");
866        assert!(debug_str.contains("UserPassword"));
867        assert!(debug_str.contains("debug_test"));
868    }
869
870    #[test]
871    fn test_owner_password_debug() {
872        let pwd = OwnerPassword("owner_debug".to_string());
873        let debug_str = format!("{pwd:?}");
874        assert!(debug_str.contains("OwnerPassword"));
875        assert!(debug_str.contains("owner_debug"));
876    }
877
878    #[test]
879    fn test_encryption_key_debug() {
880        let key = EncryptionKey::new(vec![0x01, 0x02, 0x03]);
881        let debug_str = format!("{key:?}");
882        assert!(debug_str.contains("EncryptionKey"));
883    }
884
885    #[test]
886    fn test_security_handler_revision_equality() {
887        assert_eq!(SecurityHandlerRevision::R2, SecurityHandlerRevision::R2);
888        assert_ne!(SecurityHandlerRevision::R2, SecurityHandlerRevision::R3);
889    }
890
891    #[test]
892    fn test_security_handler_revision_values() {
893        assert_eq!(SecurityHandlerRevision::R2 as u8, 2);
894        assert_eq!(SecurityHandlerRevision::R3 as u8, 3);
895        assert_eq!(SecurityHandlerRevision::R4 as u8, 4);
896        assert_eq!(SecurityHandlerRevision::R5 as u8, 5);
897        assert_eq!(SecurityHandlerRevision::R6 as u8, 6);
898    }
899
900    #[test]
901    fn test_pad_password_various_lengths() {
902        for len in 0..=40 {
903            let password = "x".repeat(len);
904            let padded = StandardSecurityHandler::pad_password(&password);
905            assert_eq!(padded.len(), 32);
906
907            if len <= 32 {
908                assert_eq!(&padded[..len], password.as_bytes());
909            } else {
910                assert_eq!(&padded[..], &password.as_bytes()[..32]);
911            }
912        }
913    }
914
915    #[test]
916    fn test_pad_password_unicode() {
917        let padded = StandardSecurityHandler::pad_password("café");
918        assert_eq!(padded.len(), 32);
919        // UTF-8 encoding of "café" is 5 bytes
920        assert_eq!(&padded[..5], "café".as_bytes());
921    }
922
923    #[test]
924    fn test_compute_owner_hash_different_users() {
925        let handler = StandardSecurityHandler::rc4_128bit();
926        let owner = OwnerPassword("owner".to_string());
927        let user1 = UserPassword("user1".to_string());
928        let user2 = UserPassword("user2".to_string());
929
930        let hash1 = handler.compute_owner_hash(&owner, &user1);
931        let hash2 = handler.compute_owner_hash(&owner, &user2);
932
933        assert_ne!(hash1, hash2); // Different user passwords should produce different hashes
934    }
935
936    #[test]
937    fn test_compute_user_hash_r4() {
938        let handler = StandardSecurityHandler {
939            revision: SecurityHandlerRevision::R4,
940            key_length: 16,
941        };
942        let user = UserPassword("r4test".to_string());
943        let owner_hash = vec![0xAA; 32];
944        let permissions = Permissions::new();
945
946        let hash = handler
947            .compute_user_hash(&user, &owner_hash, permissions, None)
948            .unwrap();
949        assert_eq!(hash.len(), 32);
950    }
951
952    #[test]
953    fn test_compute_user_hash_r6() {
954        let handler = StandardSecurityHandler::aes_256_r6();
955        let user = UserPassword("r6test".to_string());
956        let owner_hash = vec![0xBB; 32];
957        let permissions = Permissions::all();
958
959        let hash = handler
960            .compute_user_hash(&user, &owner_hash, permissions, None)
961            .unwrap();
962        assert_eq!(hash.len(), 32);
963    }
964
965    #[test]
966    fn test_encryption_key_with_file_id_affects_result() {
967        let handler = StandardSecurityHandler::rc4_128bit();
968        let user = UserPassword("test".to_string());
969        let owner_hash = vec![0xFF; 32];
970        let permissions = Permissions::new();
971        let file_id = b"unique_file_id_12345";
972
973        let key_with_id = handler
974            .compute_encryption_key(&user, &owner_hash, permissions, Some(file_id))
975            .unwrap();
976        let key_without_id = handler
977            .compute_encryption_key(&user, &owner_hash, permissions, None)
978            .unwrap();
979
980        assert_ne!(key_with_id.key, key_without_id.key);
981    }
982
983    #[test]
984    fn test_encrypt_string_empty() {
985        let handler = StandardSecurityHandler::rc4_40bit();
986        let key = EncryptionKey::new(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
987        let obj_id = ObjectId::new(1, 0);
988
989        let encrypted = handler.encrypt_string(b"", &key, &obj_id);
990        assert_eq!(encrypted.len(), 0);
991    }
992
993    #[test]
994    fn test_encrypt_decrypt_large_data() {
995        let handler = StandardSecurityHandler::rc4_128bit();
996        let key = EncryptionKey::new(vec![0xAA; 16]);
997        let obj_id = ObjectId::new(42, 0);
998        let large_data = vec![0x55; 10000]; // 10KB
999
1000        let encrypted = handler.encrypt_string(&large_data, &key, &obj_id);
1001        assert_eq!(encrypted.len(), large_data.len());
1002        assert_ne!(encrypted, large_data);
1003
1004        let decrypted = handler.decrypt_string(&encrypted, &key, &obj_id);
1005        assert_eq!(decrypted, large_data);
1006    }
1007
1008    #[test]
1009    fn test_stream_encryption_different_from_string() {
1010        // For current implementation they're the same, but test separately
1011        let handler = StandardSecurityHandler::rc4_128bit();
1012        let key = EncryptionKey::new(vec![0x11; 16]);
1013        let obj_id = ObjectId::new(5, 1);
1014        let data = b"Stream content test";
1015
1016        let encrypted_string = handler.encrypt_string(data, &key, &obj_id);
1017        let encrypted_stream = handler.encrypt_stream(data, &key, &obj_id);
1018
1019        assert_eq!(encrypted_string, encrypted_stream); // Currently same implementation
1020    }
1021
1022    #[test]
1023    fn test_aes_encryption_with_different_object_ids() {
1024        let handler = StandardSecurityHandler::aes_256_r5();
1025        let key = EncryptionKey::new(vec![0x77; 32]);
1026        let obj_id1 = ObjectId::new(10, 0);
1027        let obj_id2 = ObjectId::new(11, 0);
1028        let data = b"AES test data";
1029
1030        let encrypted1 = handler.encrypt_aes(data, &key, &obj_id1).unwrap();
1031        let encrypted2 = handler.encrypt_aes(data, &key, &obj_id2).unwrap();
1032
1033        // Different object IDs should produce different ciphertexts
1034        assert_ne!(encrypted1, encrypted2);
1035    }
1036
1037    #[test]
1038    fn test_aes_decrypt_invalid_iv_length() {
1039        let handler = StandardSecurityHandler::aes_256_r5();
1040        let key = EncryptionKey::new(vec![0x88; 32]);
1041        let obj_id = ObjectId::new(1, 0);
1042
1043        // Data too short to contain IV
1044        let short_data = vec![0u8; 10];
1045        assert!(handler.decrypt_aes(&short_data, &key, &obj_id).is_err());
1046
1047        // Exactly 16 bytes (only IV, no encrypted data)
1048        let iv_only = vec![0u8; 16];
1049        let result = handler.decrypt_aes(&iv_only, &key, &obj_id);
1050        // This might succeed with empty decrypted data or fail depending on implementation
1051        if let Ok(decrypted) = result {
1052            assert_eq!(decrypted.len(), 0);
1053        }
1054    }
1055
1056    #[test]
1057    fn test_aes_validate_password_wrong_hash_length() {
1058        let handler = StandardSecurityHandler::aes_256_r5();
1059        let password = UserPassword("test".to_string());
1060        let short_hash = vec![0u8; 16]; // Too short
1061        let permissions = Permissions::new();
1062
1063        let result = handler
1064            .validate_aes_user_password(&password, &short_hash, permissions, None)
1065            .unwrap();
1066        assert!(!result); // Should return false for invalid hash
1067    }
1068
1069    #[test]
1070    fn test_permissions_affect_encryption_key() {
1071        let handler = StandardSecurityHandler::rc4_128bit();
1072        let user = UserPassword("same_user".to_string());
1073        let owner_hash = vec![0xCC; 32];
1074
1075        let perms1 = Permissions::new();
1076        let perms2 = Permissions::all();
1077
1078        let key1 = handler
1079            .compute_encryption_key(&user, &owner_hash, perms1, None)
1080            .unwrap();
1081        let key2 = handler
1082            .compute_encryption_key(&user, &owner_hash, perms2, None)
1083            .unwrap();
1084
1085        assert_ne!(key1.key, key2.key); // Different permissions should affect the key
1086    }
1087
1088    #[test]
1089    fn test_different_handlers_produce_different_keys() {
1090        let user = UserPassword("test".to_string());
1091        let owner_hash = vec![0xDD; 32];
1092        let permissions = Permissions::new();
1093
1094        let handler_r2 = StandardSecurityHandler::rc4_40bit();
1095        let handler_r3 = StandardSecurityHandler::rc4_128bit();
1096
1097        let key_r2 = handler_r2
1098            .compute_encryption_key(&user, &owner_hash, permissions, None)
1099            .unwrap();
1100        let key_r3 = handler_r3
1101            .compute_encryption_key(&user, &owner_hash, permissions, None)
1102            .unwrap();
1103
1104        assert_ne!(key_r2.len(), key_r3.len()); // Different key lengths
1105        assert_eq!(key_r2.len(), 5);
1106        assert_eq!(key_r3.len(), 16);
1107    }
1108
1109    #[test]
1110    fn test_full_workflow_aes_r6() {
1111        let handler = StandardSecurityHandler::aes_256_r6();
1112        let user_pwd = UserPassword("user_r6".to_string());
1113        let permissions = Permissions::new();
1114        let file_id = b"test_file_r6";
1115
1116        // For AES R5/R6, owner hash computation is different - use a dummy hash
1117        let owner_hash = vec![0x42; 32]; // AES uses 32-byte hashes
1118
1119        // Compute user hash
1120        let user_hash = handler
1121            .compute_user_hash(&user_pwd, &owner_hash, permissions, Some(file_id))
1122            .unwrap();
1123        assert_eq!(user_hash.len(), 32);
1124
1125        // Compute encryption key
1126        let key = handler
1127            .compute_aes_encryption_key(&user_pwd, &owner_hash, permissions, Some(file_id))
1128            .unwrap();
1129        assert_eq!(key.len(), 32);
1130
1131        // Test string encryption (uses AES for R6)
1132        let obj_id = ObjectId::new(100, 5);
1133        let content = b"R6 AES encryption test";
1134        let encrypted = handler.encrypt_string(content, &key, &obj_id);
1135
1136        // With AES, encrypted should be empty on error or have data
1137        if !encrypted.is_empty() {
1138            assert_ne!(encrypted.as_slice(), content);
1139        }
1140    }
1141
1142    #[test]
1143    fn test_md5_compute_consistency() {
1144        let data = b"consistent data for md5";
1145        let hash1 = md5::compute(data);
1146        let hash2 = md5::compute(data);
1147
1148        assert_eq!(hash1, hash2);
1149        assert_eq!(hash1.len(), 16);
1150    }
1151
1152    #[test]
1153    fn test_sha256_consistency() {
1154        let data = b"consistent data for sha256";
1155        let hash1 = sha256(data);
1156        let hash2 = sha256(data);
1157
1158        assert_eq!(hash1, hash2);
1159        assert_eq!(hash1.len(), 32);
1160    }
1161
1162    #[test]
1163    fn test_rc4_encrypt_helper() {
1164        let key = Rc4Key::from_slice(&[0x01, 0x02, 0x03, 0x04, 0x05]);
1165        let data = b"test rc4 helper";
1166
1167        let encrypted = rc4_encrypt(&key, data);
1168        assert_ne!(encrypted.as_slice(), data);
1169
1170        // RC4 is symmetric
1171        let decrypted = rc4_encrypt(&key, &encrypted);
1172        assert_eq!(decrypted.as_slice(), data);
1173    }
1174
1175    #[test]
1176    fn test_edge_case_max_object_generation() {
1177        let handler = StandardSecurityHandler::rc4_128bit();
1178        let key = EncryptionKey::new(vec![0xEE; 16]);
1179        let obj_id = ObjectId::new(0xFFFFFF, 0xFFFF); // Max values
1180        let data = b"edge case";
1181
1182        let encrypted = handler.encrypt_string(data, &key, &obj_id);
1183        let decrypted = handler.decrypt_string(&encrypted, &key, &obj_id);
1184        assert_eq!(decrypted.as_slice(), data);
1185    }
1186}
oxidize_pdf/encryption/standard_security.rs

oxidize_pdf/encryption/
standard_security.rs
