ncrypt-me 0.3.0

Dead simple encryption library
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

use super::error::CredentialsError;
use secure_types::SecureString;

/// The credentials needed to encrypt and decrypt a file.
///
/// Credentials are erased from memory when they are dropped.
///
/// But they can also be erased manually by calling the [Credentials::erase()]
#[derive(Clone)]
pub struct Credentials {
   pub username: SecureString,
   pub password: SecureString,
   pub confirm_password: SecureString,
}

impl Credentials {
   pub fn new(
      username: SecureString,
      password: SecureString,
      confirm_password: SecureString,
   ) -> Self {
      Self {
         username,
         password,
         confirm_password,
      }
   }

   /// Creates a new `Credentials` instance with the specified capacity.
   pub fn new_with_capacity(capacity: usize) -> Result<Self, CredentialsError> {
      let username = SecureString::new_with_capacity(capacity)
         .map_err(|e| CredentialsError::Custom(e.to_string()))?;

      let password = SecureString::new_with_capacity(capacity)
         .map_err(|e| CredentialsError::Custom(e.to_string()))?;

      let confirm_password = SecureString::new_with_capacity(capacity)
         .map_err(|e| CredentialsError::Custom(e.to_string()))?;
      Ok(Self {
         username,
         password,
         confirm_password,
      })
   }

   /// Erases the credentials from memory by zeroizing the username and password fields.
   ///
   /// This method is automatically called when the `Credentials` instance is dropped.
   pub fn erase(&mut self) {
      self.username.erase();
      self.password.erase();
      self.confirm_password.erase();
   }

   /// Copy password to confirm password
   pub fn copy_passwd_to_confirm(&mut self) {
      self.password.unlock_str(|str| {
         self.confirm_password.erase();
         self.confirm_password.push_str(str);
      });
   }

   pub fn is_valid(&self) -> Result<(), CredentialsError> {
      if self.username.char_len() == 0 {
         return Err(CredentialsError::UsernameEmpty);
      }

      if self.password.char_len() == 0 {
         return Err(CredentialsError::PasswordEmpty);
      }

      if self.confirm_password.char_len() == 0 {
         return Err(CredentialsError::ConfirmPasswordEmpty);
      }

      let res = self.password.unlock_str(|password| {
         self.confirm_password.unlock_str(|confirm_password| {
            if password != confirm_password {
               return Err(CredentialsError::PasswordsDoNotMatch);
            } else {
               Ok(())
            }
         })
      });
      res
   }
}

impl Default for Credentials {
   fn default() -> Self {
      Self::new(
         SecureString::from(""),
         SecureString::from(""),
         SecureString::from(""),
      )
   }
}

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

   #[test]
   fn test_copy_passwd_to_confirm() {
      let mut credentials = Credentials::new(
         SecureString::from("username"),
         SecureString::from("password"),
         SecureString::from("something_else"),
      );

      credentials.copy_passwd_to_confirm();
      assert!(credentials.is_valid().is_ok());
   }
}