2582559800

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/google/OpenSK/commit/<a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/9bb9363ffbcfb93d68b81258ec15a5b688cba71a">9bb9363ff">&lt;a href=&quot;https://github.com/google/OpenSK/commit/</a><a class="double-link" href="https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/9bb9363ffbcfb93d68b81258ec15a5b688cba71a">9bb9363ff</a><a href="https://github.com/google/OpenSK/commit/9bb9363ffbcfb93d68b81258ec15a5b688cba71a">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/9bb9363ffbcfb93d68b81258ec15a5b688cba71a&quot;&gt;9bb9363ff&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/9bb9363ffbcfb93d68b81258ec15a5b688cba71a&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/OpenSK/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #509: Add a key store to avoid storing secrets in the store

Run Details

72 of 72 new or added lines in 5 files covered. (100.0%)

13849 of 15629 relevant lines covered (88.61%)

518643.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.23

/src/api/key_store.rs

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use alloc::vec::Vec;
use crypto::ecdsa::SecKey;
use persistent_store::StoreError;
use rng256::Rng256;

use crate::env::Env;

/// Provides storage for secret keys.
///
/// Implementations may use the environment store: [`STORE_KEY`] is reserved for this usage.
pub trait KeyStore {
    /// Returns the AES key for key handles encryption.
    fn kh_encryption(&mut self) -> Result<[u8; 32], Error>;

    /// Returns the key for key handles authentication.
    fn kh_authentication(&mut self) -> Result<[u8; 32], Error>;

    /// Derives an ECDSA private key from a seed.
    ///
    /// The result is big-endian.
    fn derive_ecdsa(&mut self, seed: &[u8; 32]) -> Result<[u8; 32], Error>;

    /// Generates a seed to derive an ECDSA private key.
    fn generate_ecdsa_seed(&mut self) -> Result<[u8; 32], Error>;

    /// Resets the key store.
    fn reset(&mut self) -> Result<(), Error>;
}

/// Key store errors.
///
/// They are deliberately indistinguishable from each other to avoid leaking information.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Error;

/// Key of the environment store reserved for the key store.
pub const STORE_KEY: usize = 2046;

impl<T: Env> KeyStore for T {
    fn kh_encryption(&mut self) -> Result<[u8; 32], Error> {
        Ok(get_master_keys(self)?.encryption)
    }

    fn kh_authentication(&mut self) -> Result<[u8; 32], Error> {
        Ok(get_master_keys(self)?.authentication)
    }

    fn derive_ecdsa(&mut self, seed: &[u8; 32]) -> Result<[u8; 32], Error> {
        match SecKey::from_bytes(seed) {
            None => Err(Error),
            Some(_) => Ok(*seed),
        }
    }

    fn generate_ecdsa_seed(&mut self) -> Result<[u8; 32], Error> {
        let mut seed = [0; 32];
        SecKey::gensk(self.rng()).to_bytes(&mut seed);
        Ok(seed)
    }

    fn reset(&mut self) -> Result<(), Error> {
        Ok(self.store().remove(STORE_KEY)?)
    }
}

/// Wrapper for master keys.
struct MasterKeys {
    /// Master encryption key.
    encryption: [u8; 32],

    /// Master authentication key.
    authentication: [u8; 32],
}

fn get_master_keys(env: &mut impl Env) -> Result<MasterKeys, Error> {
    let master_keys = match env.store().find(STORE_KEY)? {
        Some(x) => x,
        None => {
            let master_encryption_key = env.rng().gen_uniform_u8x32();
            let master_authentication_key = env.rng().gen_uniform_u8x32();
            let mut master_keys = Vec::with_capacity(64);
            master_keys.extend_from_slice(&master_encryption_key);
            master_keys.extend_from_slice(&master_authentication_key);
            env.store().insert(STORE_KEY, &master_keys)?;
            master_keys
        }
    };
    if master_keys.len() != 64 {
        return Err(Error);
    }
    Ok(MasterKeys {
        encryption: *array_ref![master_keys, 0, 32],
        authentication: *array_ref![master_keys, 32, 32],
    })
}

impl From<StoreError> for Error {
    fn from(_: StoreError) -> Self {
        Error
    }
}

#[test]
fn test_key_store() {
    let mut env = crate::env::test::TestEnv::new();
    let key_store = env.key_store();

    // Master keys are well-defined and stable.
    let encryption_key = key_store.kh_encryption().unwrap();
    let authentication_key = key_store.kh_authentication().unwrap();
    assert_eq!(key_store.kh_encryption(), Ok(encryption_key));
    assert_eq!(key_store.kh_authentication(), Ok(authentication_key));

    // ECDSA seeds are well-defined and stable.
    let ecdsa_seed = key_store.generate_ecdsa_seed().unwrap();
    let ecdsa_key = key_store.derive_ecdsa(&ecdsa_seed).unwrap();
    assert_eq!(key_store.derive_ecdsa(&ecdsa_seed), Ok(ecdsa_key));

    // Master keys change after reset. We don't require this for ECDSA seeds because it's not the
    // case, but it might be better.
    key_store.reset().unwrap();
    assert!(key_store.kh_encryption().unwrap() != encryption_key);
    assert!(key_store.kh_authentication().unwrap() != authentication_key);
}

1	// Copyright 2022 Google LLC
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	use alloc::vec::Vec;
16	use crypto::ecdsa::SecKey;
17	use persistent_store::StoreError;
18	use rng256::Rng256;
19
20	use crate::env::Env;
21
22	/// Provides storage for secret keys.
23	///
24	/// Implementations may use the environment store: [`STORE_KEY`] is reserved for this usage.
25	pub trait KeyStore {
26	/// Returns the AES key for key handles encryption.
27	fn kh_encryption(&mut self) -> Result<[u8; 32], Error>;
28
29	/// Returns the key for key handles authentication.
30	fn kh_authentication(&mut self) -> Result<[u8; 32], Error>;
31
32	/// Derives an ECDSA private key from a seed.
33	///
34	/// The result is big-endian.
35	fn derive_ecdsa(&mut self, seed: &[u8; 32]) -> Result<[u8; 32], Error>;
36
37	/// Generates a seed to derive an ECDSA private key.
38	fn generate_ecdsa_seed(&mut self) -> Result<[u8; 32], Error>;
39
40	/// Resets the key store.
41	fn reset(&mut self) -> Result<(), Error>;
42	}
43
44	/// Key store errors.
45	///
46	/// They are deliberately indistinguishable from each other to avoid leaking information.
47	#[derive(Copy, Clone, Debug, PartialEq, Eq)]	×
48	pub struct Error;
49
50	/// Key of the environment store reserved for the key store.
51	pub const STORE_KEY: usize = 2046;
52
53	impl<T: Env> KeyStore for T {
54	fn kh_encryption(&mut self) -> Result<[u8; 32], Error> {	42✔
55	Ok(get_master_keys(self)?.encryption)	42✔
56	}	42✔
57
58	fn kh_authentication(&mut self) -> Result<[u8; 32], Error> {	271✔
59	Ok(get_master_keys(self)?.authentication)	271✔
60	}	271✔
61
62	fn derive_ecdsa(&mut self, seed: &[u8; 32]) -> Result<[u8; 32], Error> {	2✔
63	match SecKey::from_bytes(seed) {	2✔
64	None => Err(Error),	2✔
65	Some(_) => Ok(*seed),	2✔
66	}
67	}	2✔
68
69	fn generate_ecdsa_seed(&mut self) -> Result<[u8; 32], Error> {	1✔
70	let mut seed = [0; 32];	1✔
71	SecKey::gensk(self.rng()).to_bytes(&mut seed);	1✔
72	Ok(seed)	1✔
73	}	1✔
74
75	fn reset(&mut self) -> Result<(), Error> {	7✔
76	Ok(self.store().remove(STORE_KEY)?)	7✔
77	}	7✔
78	}
79
80	/// Wrapper for master keys.
81	struct MasterKeys {
82	/// Master encryption key.
83	encryption: [u8; 32],
84
85	/// Master authentication key.
86	authentication: [u8; 32],
87	}
88
89	fn get_master_keys(env: &mut impl Env) -> Result<MasterKeys, Error> {	313✔
90	let master_keys = match env.store().find(STORE_KEY)? {	313✔
91	Some(x) => x,	286✔
92	None => {
93	let master_encryption_key = env.rng().gen_uniform_u8x32();	27✔
94	let master_authentication_key = env.rng().gen_uniform_u8x32();	27✔
95	let mut master_keys = Vec::with_capacity(64);	27✔
96	master_keys.extend_from_slice(&master_encryption_key);	27✔
97	master_keys.extend_from_slice(&master_authentication_key);	27✔
98	env.store().insert(STORE_KEY, &master_keys)?;	27✔
99	master_keys	27✔
100	}
101	};
102	if master_keys.len() != 64 {	313✔
103	return Err(Error);	×
104	}	313✔
105	Ok(MasterKeys {	313✔
106	encryption: *array_ref![master_keys, 0, 32],	313✔
107	authentication: *array_ref![master_keys, 32, 32],	313✔
108	})	313✔
109	}	313✔
110
111	impl From<StoreError> for Error {
112	fn from(_: StoreError) -> Self {	×
113	Error	×
114	}	×
115	}
116
117	#[test]
118	fn test_key_store() {	1✔
119	let mut env = crate::env::test::TestEnv::new();	1✔
120	let key_store = env.key_store();	1✔
121		1✔
122	// Master keys are well-defined and stable.	1✔
123	let encryption_key = key_store.kh_encryption().unwrap();	1✔
124	let authentication_key = key_store.kh_authentication().unwrap();	1✔
125	assert_eq!(key_store.kh_encryption(), Ok(encryption_key));	1✔
126	assert_eq!(key_store.kh_authentication(), Ok(authentication_key));	1✔
127
128	// ECDSA seeds are well-defined and stable.
129	let ecdsa_seed = key_store.generate_ecdsa_seed().unwrap();	1✔
130	let ecdsa_key = key_store.derive_ecdsa(&ecdsa_seed).unwrap();	1✔
131	assert_eq!(key_store.derive_ecdsa(&ecdsa_seed), Ok(ecdsa_key));	1✔
132
133	// Master keys change after reset. We don't require this for ECDSA seeds because it's not the
134	// case, but it might be better.
135	key_store.reset().unwrap();	1✔
136	assert!(key_store.kh_encryption().unwrap() != encryption_key);	1✔
137	assert!(key_store.kh_authentication().unwrap() != authentication_key);	1✔
138	}	1✔

google / OpenSK / 2582559800

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous