sal_vault/keyspace/
session_manager.rs

1use once_cell::sync::Lazy;
2use std::sync::Mutex;
3
4use crate::error::CryptoError;
5use crate::keyspace::keypair_types::{KeyPair, KeySpace};
6
7/// Session state for the current key space and selected keypair.
8pub struct Session {
9    pub current_space: Option<KeySpace>,
10    pub selected_keypair: Option<String>,
11}
12
13impl Default for Session {
14    fn default() -> Self {
15        Session {
16            current_space: None,
17            selected_keypair: None,
18        }
19    }
20}
21
22/// Global session state.
23pub static SESSION: Lazy<Mutex<Session>> = Lazy::new(|| Mutex::new(Session::default()));
24
25// Session management and selected keypair operation functions will be added here
26/// Creates a new key space with the given name.
27pub fn create_space(name: &str) -> Result<(), CryptoError> {
28    let mut session = SESSION.lock().unwrap();
29
30    // Create a new space
31    let space = KeySpace::new(name);
32
33    // Set as current space
34    session.current_space = Some(space);
35    session.selected_keypair = None;
36
37    Ok(())
38}
39
40/// Sets the current key space.
41pub fn set_current_space(space: KeySpace) -> Result<(), CryptoError> {
42    let mut session = SESSION.lock().unwrap();
43    session.current_space = Some(space);
44    session.selected_keypair = None;
45    Ok(())
46}
47
48/// Gets the current key space.
49pub fn get_current_space() -> Result<KeySpace, CryptoError> {
50    let session = SESSION.lock().unwrap();
51    session
52        .current_space
53        .clone()
54        .ok_or(CryptoError::NoActiveSpace)
55}
56
57/// Clears the current session (logout).
58pub fn clear_session() {
59    let mut session = SESSION.lock().unwrap();
60    session.current_space = None;
61    session.selected_keypair = None;
62}
63
64/// Creates a new keypair in the current space.
65pub fn create_keypair(name: &str) -> Result<(), CryptoError> {
66    let mut session = SESSION.lock().unwrap();
67
68    if let Some(ref mut space) = session.current_space {
69        if space.keypairs.contains_key(name) {
70            return Err(CryptoError::KeypairAlreadyExists(name.to_string()));
71        }
72
73        let keypair = KeyPair::new(name);
74        space.keypairs.insert(name.to_string(), keypair);
75
76        // Automatically select the new keypair
77        session.selected_keypair = Some(name.to_string());
78
79        Ok(())
80    } else {
81        Err(CryptoError::NoActiveSpace)
82    }
83}
84
85/// Selects a keypair for use.
86pub fn select_keypair(name: &str) -> Result<(), CryptoError> {
87    let mut session = SESSION.lock().unwrap();
88
89    if let Some(ref space) = session.current_space {
90        if !space.keypairs.contains_key(name) {
91            return Err(CryptoError::KeypairNotFound(name.to_string()));
92        }
93
94        session.selected_keypair = Some(name.to_string());
95        Ok(())
96    } else {
97        Err(CryptoError::NoActiveSpace)
98    }
99}
100
101/// Gets the currently selected keypair.
102pub fn get_selected_keypair() -> Result<KeyPair, CryptoError> {
103    let session = SESSION.lock().unwrap();
104
105    if let Some(ref space) = session.current_space {
106        if let Some(ref keypair_name) = session.selected_keypair {
107            if let Some(keypair) = space.keypairs.get(keypair_name) {
108                return Ok(keypair.clone());
109            }
110            return Err(CryptoError::KeypairNotFound(keypair_name.clone()));
111        }
112        return Err(CryptoError::NoKeypairSelected);
113    }
114
115    Err(CryptoError::NoActiveSpace)
116}
117
118/// Lists all keypair names in the current space.
119pub fn list_keypairs() -> Result<Vec<String>, CryptoError> {
120    let session = SESSION.lock().unwrap();
121
122    if let Some(ref space) = session.current_space {
123        Ok(space.keypairs.keys().cloned().collect())
124    } else {
125        Err(CryptoError::NoActiveSpace)
126    }
127}
128
129/// Gets the public key of the selected keypair.
130pub fn keypair_pub_key() -> Result<Vec<u8>, CryptoError> {
131    let keypair = get_selected_keypair()?;
132    Ok(keypair.pub_key())
133}
134
135/// Derives a public key from a private key.
136pub fn derive_public_key(private_key: &[u8]) -> Result<Vec<u8>, CryptoError> {
137    KeyPair::pub_key_from_private(private_key)
138}
139
140/// Signs a message with the selected keypair.
141pub fn keypair_sign(message: &[u8]) -> Result<Vec<u8>, CryptoError> {
142    let keypair = get_selected_keypair()?;
143    Ok(keypair.sign(message))
144}
145
146/// Verifies a message signature with the selected keypair.
147pub fn keypair_verify(message: &[u8], signature_bytes: &[u8]) -> Result<bool, CryptoError> {
148    let keypair = get_selected_keypair()?;
149    keypair.verify(message, signature_bytes)
150}
151
152/// Verifies a message signature with a public key.
153pub fn verify_with_public_key(
154    public_key: &[u8],
155    message: &[u8],
156    signature_bytes: &[u8],
157) -> Result<bool, CryptoError> {
158    KeyPair::verify_with_public_key(public_key, message, signature_bytes)
159}
160
161/// Encrypts a message for a recipient using their public key.
162pub fn encrypt_asymmetric(
163    recipient_public_key: &[u8],
164    message: &[u8],
165) -> Result<Vec<u8>, CryptoError> {
166    let keypair = get_selected_keypair()?;
167    keypair.encrypt_asymmetric(recipient_public_key, message)
168}
169
170/// Decrypts a message that was encrypted with the current keypair's public key.
171pub fn decrypt_asymmetric(ciphertext: &[u8]) -> Result<Vec<u8>, CryptoError> {
172    let keypair = get_selected_keypair()?;
173    keypair.decrypt_asymmetric(ciphertext)
174}
sal_vault/keyspace/session_manager.rs

sal_vault/keyspace/
session_manager.rs
