mega_security_rs/
client.rs

1use rand::prelude::*;
2
3use rsa::RsaPublicKey;
4use sha2::{Digest, Sha256};
5
6use crate::{errors::ClientError, keys::{KeysDecrypted, KeysPayload}, session::{SessionId, SessionIdEncrypted}, utils::{_compute_derived_key, _salt}};
7
8#[derive(Debug, Clone)]
9pub struct ClientRegistration {
10    pub id: String,
11    random_number: Vec<u8>,
12    hashed_auth_key: Vec<u8>,
13    pub rsa_public_key: RsaPublicKey,
14    pub encrypted_keys: KeysPayload,
15}
16
17impl ClientRegistration {
18    pub fn new_from_creds(id: &str, password: &str, domain: Option<&str>) -> Result<Self, ClientError> {
19        let mut rng = rand::thread_rng();
20
21        let mut master_key = [0u8;16];
22        rng.fill_bytes(&mut master_key);
23
24        let mut random_value = [0u8;16];
25        rng.fill_bytes(&mut random_value);
26
27        let salt = if let Some(d) = domain { 
28            _salt(d, &random_value)
29        } else {
30            _salt(id, &random_value)
31        };
32
33        let derived_key = _compute_derived_key(&salt, password);
34
35        let derived_encryption_key = &derived_key[0..16];
36        let second_half = &derived_key[17..32];
37
38        let mut auth_key_hasher = Sha256::new();
39        auth_key_hasher.update(second_half);
40        let hashed_auth_key = &auth_key_hasher.finalize()[..16];
41
42        let (encrypted_keys, rsa_public_key) = KeysPayload::new(&master_key, &derived_encryption_key)?;
43
44        Ok(Self {
45            id: id.to_owned(),
46            random_number: random_value.to_vec(),
47            hashed_auth_key: hashed_auth_key.to_vec(),
48            encrypted_keys,
49            rsa_public_key,
50        })
51    }
52
53
54    pub fn random_number(&self) -> &Vec<u8> {
55        &self.random_number
56    }
57
58    pub fn hashed_auth_key(&self) -> &Vec<u8> {
59        &self.hashed_auth_key
60    }
61}
62
63
64#[derive(Debug, Default)]
65pub struct AuthClient {
66    pub id: String,
67    password: String,
68    salt: Option<Vec<u8>>,
69    derived_encryption_key: Option<Vec<u8>>,
70    autentication_key: Option<Vec<u8>>,
71    pub decrypted_keys: Option<KeysDecrypted>,
72    pub session: Option<SessionId>,
73}
74
75impl AuthClient {
76    pub fn new_from_creds(id: &str, password: &str) -> Self {
77        Self {
78            id: id.to_owned(),
79            password: password.to_owned(),
80            ..Default::default()
81        }
82    }
83
84    pub fn compute_derived_key(&mut self, salt: &[u8]) {
85        let derived_key = _compute_derived_key(salt, &self.password);
86        self.salt = Some(salt.to_vec());
87        self.derived_encryption_key = Some(derived_key[..16].to_vec());
88        self.autentication_key = Some(derived_key[17..32].to_vec());
89    }
90
91    pub fn autentication_key(&self) -> &Option<Vec<u8>> {
92        &self.autentication_key
93    }
94
95    pub fn decrypt_keys(&mut self, mut encrypted_keys: KeysPayload, session_id_enc: SessionIdEncrypted) -> Result<(), ClientError> {
96        let dek = if let Some(dek) = &self.derived_encryption_key { dek } 
97            else { return Err( ClientError::KeyNotPresent("Derived Encryption Key".to_owned())) } ;
98
99
100        self.decrypted_keys = 
101            Some(
102                KeysDecrypted::from_encrypted(
103                    &mut encrypted_keys, 
104                    dek
105                )?
106            );
107
108        let uneck = if let Some(uneck) = &self.decrypted_keys { uneck } 
109            else { return Err( ClientError::KeyNotPresent("decrypted keys".to_owned())) } ;
110
111        let pk = uneck.rsa.clone();
112        self.session = Some(
113            SessionId::from_encrypted(
114                session_id_enc, 
115                &pk
116            ));
117        Ok(())
118    }
119}
120
mega_security_rs/client.rs

mega_security_rs/
client.rs
