zesven 1.1.0

A pure Rust implementation of the 7z archive format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Password handling for 7z encryption.

use zeroize::Zeroizing;

/// A password for archive encryption/decryption.
///
/// This type stores the password securely and provides conversion to UTF-16LE
/// as required by 7z's key derivation function.
#[derive(Clone)]
pub struct Password {
    inner: Zeroizing<String>,
}

impl Password {
    /// Creates a new password from a string.
    pub fn new<S: Into<String>>(password: S) -> Self {
        Self {
            inner: Zeroizing::new(password.into()),
        }
    }

    /// Returns the password as UTF-16LE bytes for key derivation.
    ///
    /// 7z uses UTF-16LE encoding for passwords in its key derivation function.
    pub fn as_utf16_le(&self) -> Vec<u8> {
        self.inner
            .encode_utf16()
            .flat_map(|c| c.to_le_bytes())
            .collect()
    }

    /// Returns the password as a string slice.
    pub fn as_str(&self) -> &str {
        &self.inner
    }

    /// Returns true if the password is empty.
    pub fn is_empty(&self) -> bool {
        self.inner.is_empty()
    }

    /// Returns the length of the password in characters.
    pub fn len(&self) -> usize {
        self.inner.chars().count()
    }
}

impl std::fmt::Debug for Password {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // Don't expose the actual password in debug output
        f.debug_struct("Password")
            .field("len", &self.inner.len())
            .finish()
    }
}

impl From<&str> for Password {
    fn from(s: &str) -> Self {
        Self::new(s)
    }
}

impl From<String> for Password {
    fn from(s: String) -> Self {
        Self::new(s)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_password_utf16le_ascii() {
        let password = Password::new("test");
        let bytes = password.as_utf16_le();
        // "test" in UTF-16LE: t(0x74 0x00) e(0x65 0x00) s(0x73 0x00) t(0x74 0x00)
        assert_eq!(bytes, vec![0x74, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00]);
    }

    #[test]
    fn test_password_utf16le_unicode() {
        let password = Password::new("пароль"); // Russian word for "password"
        let bytes = password.as_utf16_le();
        // Each Cyrillic character uses 2 bytes in UTF-16LE
        assert_eq!(bytes.len(), 12); // 6 characters * 2 bytes
    }

    #[test]
    fn test_password_utf16le_empty() {
        let password = Password::new("");
        let bytes = password.as_utf16_le();
        assert!(bytes.is_empty());
    }

    #[test]
    fn test_password_debug() {
        let password = Password::new("secret");
        let debug = format!("{:?}", password);
        // Debug output should not contain the actual password
        assert!(!debug.contains("secret"));
        assert!(debug.contains("len"));
    }

    #[test]
    fn test_password_from_str() {
        let password: Password = "test".into();
        assert_eq!(password.as_str(), "test");
    }

    #[test]
    fn test_password_from_string() {
        let password: Password = String::from("test").into();
        assert_eq!(password.as_str(), "test");
    }

    #[test]
    fn test_password_len() {
        let password = Password::new("test");
        assert_eq!(password.len(), 4);
        assert!(!password.is_empty());

        let empty = Password::new("");
        assert_eq!(empty.len(), 0);
        assert!(empty.is_empty());
    }
}