sentc_crypto_core/
cryptomat.rs

1use alloc::vec::Vec;
2
3use sha2::digest::Digest;
4
5use crate::Error;
6
7pub trait CryptoAlg
8{
9	fn get_alg_str(&self) -> &'static str;
10}
11
12//__________________________________________________________________________________________________
13//symmetric
14
15pub trait SymKey: CryptoAlg + AsRef<[u8]>
16{
17	fn encrypt_key_with_master_key<M: Pk>(&self, master_key: &M) -> Result<Vec<u8>, Error>
18	{
19		master_key.encrypt(self.as_ref())
20	}
21
22	fn encrypt_with_sym_key<M: SymKey>(&self, master_key: &M) -> Result<Vec<u8>, Error>
23	{
24		master_key.encrypt(self.as_ref())
25	}
26
27	fn sign_key<S: SignK>(&self, sign_key: &S) -> Result<S::Signature, Error>
28	{
29		sign_key.sign_only(self.as_ref())
30	}
31
32	fn verify_key<V: VerifyK>(&self, verify_key: &V, sig: &V::Signature) -> Result<bool, Error>
33	{
34		verify_key.verify_only(sig, self.as_ref())
35	}
36
37	fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
38
39	fn decrypt(&self, ciphertext: &[u8]) -> Result<Vec<u8>, Error>;
40
41	fn encrypt_with_aad(&self, data: &[u8], aad: &[u8]) -> Result<Vec<u8>, Error>;
42
43	fn decrypt_with_aad(&self, ciphertext: &[u8], aad: &[u8]) -> Result<Vec<u8>, Error>;
44}
45
46pub trait SymKeyGen
47{
48	type SymmetricKey: SymKey;
49
50	fn generate() -> Result<Self::SymmetricKey, Error>;
51
52	fn generate_symmetric_with_sym_key<M: SymKey>(master_key: &M) -> Result<(Vec<u8>, Self::SymmetricKey), Error>
53	{
54		let out = Self::generate()?;
55
56		let encrypted_sym_key = out.encrypt_with_sym_key(master_key)?;
57
58		Ok((encrypted_sym_key, out))
59	}
60
61	fn generate_symmetric_with_public_key<M: Pk>(master_key: &M) -> Result<(Vec<u8>, Self::SymmetricKey), Error>
62	{
63		let out = Self::generate()?;
64
65		let encrypted_sym_key = out.encrypt_key_with_master_key(master_key)?;
66
67		Ok((encrypted_sym_key, out))
68	}
69}
70
71pub trait SymKeyComposer
72{
73	type SymmetricKey: SymKey;
74
75	fn from_bytes_owned(bytes: Vec<u8>, alg_str: &str) -> Result<Self::SymmetricKey, Error>;
76
77	fn decrypt_key_by_master_key<M: Sk>(master_key: &M, encrypted_key: &[u8], alg_str: &str) -> Result<Self::SymmetricKey, Error>
78	{
79		let decrypted_bytes = master_key.decrypt(encrypted_key)?;
80
81		Self::from_bytes_owned(decrypted_bytes, alg_str)
82	}
83
84	fn decrypt_key_by_sym_key<M: SymKey>(master_key: &M, encrypted_key: &[u8], alg_str: &str) -> Result<Self::SymmetricKey, Error>
85	{
86		let decrypted_bytes = master_key.decrypt(encrypted_key)?;
87
88		Self::from_bytes_owned(decrypted_bytes, alg_str)
89	}
90}
91
92//__________________________________________________________________________________________________
93//asymmetric
94
95pub trait Pk: CryptoAlg + Clone
96{
97	fn sign_public_key<S: SignK>(&self, sign_key: &S) -> Result<S::Signature, Error>;
98
99	fn verify_public_key<V: VerifyK>(&self, verify_key: &V, sig: &V::Signature) -> Result<bool, Error>;
100
101	fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
102}
103
104pub trait Sk: CryptoAlg
105{
106	fn encrypt_by_master_key<M: SymKey>(&self, master_key: &M) -> Result<Vec<u8>, Error>;
107
108	fn decrypt(&self, ciphertext: &[u8]) -> Result<Vec<u8>, Error>;
109}
110
111pub trait StaticKeyPair
112{
113	type SecretKey: Sk;
114	type PublicKey: Pk;
115
116	fn generate_static_keypair() -> Result<(Self::SecretKey, Self::PublicKey), Error>;
117}
118
119pub trait SkComposer
120{
121	type SecretKey: Sk;
122
123	fn decrypt_by_master_key<M: SymKey>(master_key: &M, encrypted_key: &[u8], alg_str: &str) -> Result<Self::SecretKey, Error>;
124}
125
126//__________________________________________________________________________________________________
127//sign
128
129pub trait SignK: CryptoAlg
130{
131	type Signature: Sig;
132
133	fn encrypt_by_master_key<M: SymKey>(&self, master_key: &M) -> Result<Vec<u8>, Error>;
134
135	fn sign(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
136
137	fn sign_only<D: AsRef<[u8]>>(&self, data: D) -> Result<Self::Signature, Error>;
138}
139
140pub trait VerifyK: CryptoAlg
141{
142	type Signature: Sig;
143
144	fn verify<'a>(&self, data_with_sig: &'a [u8]) -> Result<(&'a [u8], bool), Error>;
145
146	fn verify_only(&self, sig: &Self::Signature, data: &[u8]) -> Result<bool, Error>;
147
148	fn create_hash<D: Digest>(&self, hasher: &mut D);
149}
150
151pub trait SignKeyPair
152{
153	type SignKey: SignK;
154	type VerifyKey: VerifyK;
155
156	fn generate_key_pair() -> Result<(Self::SignKey, Self::VerifyKey), Error>;
157}
158
159pub trait SignKeyComposer
160{
161	type Key: SignK;
162
163	fn decrypt_by_master_key<M: SymKey>(master_key: &M, encrypted_key: &[u8], alg_str: &str) -> Result<Self::Key, Error>;
164}
165
166pub trait Sig: CryptoAlg + Into<Vec<u8>> {}
167
168//__________________________________________________________________________________________________
169//searchable
170
171pub trait SearchableKey: CryptoAlg
172{
173	fn encrypt_key_with_master_key<M: SymKey>(&self, master_key: &M) -> Result<Vec<u8>, Error>;
174
175	fn encrypt_searchable(&self, data: &[u8]) -> Result<Vec<u8>, Error>;
176
177	fn verify_encrypted_searchable(&self, data: &[u8], check: &[u8]) -> Result<bool, Error>;
178}
179
180pub trait SearchableKeyGen
181{
182	type SearchableKey: SearchableKey;
183
184	fn generate() -> Result<Self::SearchableKey, Error>;
185}
186
187pub trait SearchableKeyComposer
188{
189	type Key: SearchableKey;
190
191	fn decrypt_by_master_key<M: SymKey>(master_key: &M, encrypted_key: &[u8], alg_str: &str) -> Result<Self::Key, Error>;
192}
193
194//__________________________________________________________________________________________________
195//sortable
196
197pub trait SortableKey: CryptoAlg
198{
199	fn encrypt_key_with_master_key<M: SymKey>(&self, master_key: &M) -> Result<Vec<u8>, Error>;
200
201	fn encrypt_sortable(&self, data: u64) -> Result<u64, Error>;
202}
203
204pub trait SortableKeyGen
205{
206	type SortableKey: SortableKey;
207
208	fn generate() -> Result<Self::SortableKey, Error>;
209}
210
211pub trait SortableKeyComposer
212{
213	type Key: SortableKey;
214
215	fn decrypt_by_master_key<M: SymKey>(master_key: &M, encrypted_key: &[u8], alg_str: &str) -> Result<Self::Key, Error>;
216}
217
218//__________________________________________________________________________________________________
219//pw hash
220
221pub trait PwHash
222{
223	type CRV: ClientRandomValue;
224	type HAK: HashedAuthenticationKey;
225	type DMK: DeriveMasterKeyForAuth;
226	type DAK: DeriveAuthKeyForAuth;
227	type PWS: PasswordEncryptSalt;
228
229	/**
230	# Prepare registration
231
232	 */
233	#[allow(clippy::type_complexity)]
234	fn derived_keys_from_password<M: SymKey>(
235		password: &[u8],
236		master_key: &M,
237		alg: Option<&str>, //when None then use default hasher. when set try to get the hasher that created the alg
238	) -> Result<
239		(
240			Self::CRV,
241			Self::HAK,
242			Vec<u8>,      //encrypted master key
243			&'static str, //describe how the master key is encrypted
244		),
245		Error,
246	>;
247
248	/**
249	# Prepare the login
250
251	1. Takes the salt from the api (after sending the username)
252	2. derived the encryption key (for the master key) and the auth key from the password and the salt
253	3. return the encryption key and
254		return the auth key to send it to the server so the server can check the hashed auth key
255
256	@return: first is the master key, 2nd the auth key
257	 */
258	fn derive_keys_for_auth(password: &[u8], salt_bytes: &[u8], alg: &str) -> Result<(Self::DMK, Self::DAK), Error>;
259
260	fn password_to_encrypt(password: &[u8]) -> Result<(Self::PWS, impl SymKey), Error>;
261
262	fn password_to_decrypt(password: &[u8], salt: &[u8]) -> Result<impl SymKey, Error>;
263}
264
265pub trait PwPrepareExport
266{
267	fn prepare_export(&self) -> &[u8];
268}
269
270pub trait ClientRandomValue: CryptoAlg + PwPrepareExport
271{
272	fn generate_salt(self, add_str: &str) -> Vec<u8>;
273}
274
275pub trait ClientRandomValueComposer
276{
277	type Value: ClientRandomValue;
278
279	fn from_bytes(vec: Vec<u8>, alg: &str) -> Result<Self::Value, Error>;
280}
281
282pub trait HashedAuthenticationKey: PwPrepareExport {}
283
284pub trait DeriveMasterKeyForAuth: PwPrepareExport
285{
286	fn get_master_key(&self, encrypted_master_key: &[u8]) -> Result<impl SymKey, Error>;
287}
288
289pub trait DeriveAuthKeyForAuth: PwPrepareExport
290{
291	fn hash_auth_key(&self) -> Result<Vec<u8>, Error>;
292}
293
294pub trait DeriveAuthKeyForAuthComposer
295{
296	type Value: DeriveAuthKeyForAuth;
297
298	fn from_bytes(vec: Vec<u8>, alg: &str) -> Result<Self::Value, Error>;
299}
300
301pub trait PasswordEncryptSalt: PwPrepareExport {}
302
303//__________________________________________________________________________________________________
304
305#[macro_export]
306macro_rules! crypto_alg_str_impl {
307	($st:ty,$alg:ident) => {
308		impl $crate::cryptomat::CryptoAlg for $st
309		{
310			fn get_alg_str(&self) -> &'static str
311			{
312				$alg
313			}
314		}
315	};
316}
317
318#[macro_export]
319macro_rules! try_from_bytes_single_value {
320	($st:ty) => {
321		impl<'a> TryFrom<&'a [u8]> for $st
322		{
323			type Error = $crate::Error;
324
325			fn try_from(value: &'a [u8]) -> Result<Self, Self::Error>
326			{
327				Ok(Self(
328					value
329						.try_into()
330						.map_err(|_| $crate::Error::KeyDecryptFailed)?,
331				))
332			}
333		}
334	};
335}
336
337#[macro_export]
338macro_rules! try_from_bytes_owned_single_value {
339	($st:ty) => {
340		impl TryFrom<Vec<u8>> for $st
341		{
342			type Error = $crate::Error;
343
344			fn try_from(value: Vec<u8>) -> Result<Self, Self::Error>
345			{
346				Ok(Self(
347					value
348						.try_into()
349						.map_err(|_| $crate::Error::KeyDecryptFailed)?,
350				))
351			}
352		}
353	};
354}
355
356#[macro_export]
357macro_rules! from_bytes_owned_single_value {
358	($st:ty) => {
359		impl From<Vec<u8>> for $st
360		{
361			fn from(value: Vec<u8>) -> Self
362			{
363				Self(value)
364			}
365		}
366	};
367}
368
369#[macro_export]
370macro_rules! as_ref_bytes_single_value {
371	($st:ty) => {
372		impl AsRef<[u8]> for $st
373		{
374			fn as_ref(&self) -> &[u8]
375			{
376				&self.0
377			}
378		}
379	};
380}
381
382#[macro_export]
383macro_rules! into_bytes_single_value {
384	($st:ty) => {
385		impl Into<Vec<u8>> for $st
386		{
387			fn into(self) -> Vec<u8>
388			{
389				Vec::from(self.0)
390			}
391		}
392	};
393}
394
395#[macro_export]
396macro_rules! into_bytes_from_bytes_inner {
397	($st:ty) => {
398		impl Into<Vec<u8>> for $st
399		{
400			fn into(self) -> Vec<u8>
401			{
402				self.0
403			}
404		}
405	};
406}
sentc_crypto_core/cryptomat.rs

sentc_crypto_core/
cryptomat.rs
