diff --git a/Cargo.lock b/Cargo.lock index b7184adba..af1a9b177 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -274,9 +274,9 @@ checksum = "9c59e7af012c713f529e7a3ee57ce9b31ddd858d4b512923602f74608b009631" [[package]] name = "byteorder" -version = "1.4.2" +version = "1.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae44d1a3d5a19df61dd0c8beb138458ac2a53a7ac09eba97d55592540004306b" +checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" [[package]] name = "bzip2" @@ -1880,6 +1880,7 @@ version = "0.1.0" dependencies = [ "aes", "blowfish", + "byteorder", "cipher", "com", "curve25519-dalek", diff --git a/services/keyboard/src/mappings.rs b/services/keyboard/src/mappings.rs index 2a9d3b93a..040a5fed7 100644 --- a/services/keyboard/src/mappings.rs +++ b/services/keyboard/src/mappings.rs @@ -1,3 +1,5 @@ +#![allow(dead_code)] // because hosted mode doesn't use mappings +#![allow(unused_imports)] mod qwerty; pub (crate) use qwerty::*; mod qwertz; diff --git a/services/pddb/src/backend/hw.rs b/services/pddb/src/backend/hw.rs index f0ed8250f..3db914457 100644 --- a/services/pddb/src/backend/hw.rs +++ b/services/pddb/src/backend/hw.rs @@ -33,14 +33,25 @@ pub const PAGE_SIZE: usize = spinor::SPINOR_ERASE_SIZE as usize; /// size of a virtual page -- after the AES encryption and journaling overhead is subtracted pub const VPAGE_SIZE: usize = PAGE_SIZE - size_of::() - size_of::() - size_of::(); +const WRAPPED_AES_KEYSIZE: usize = AES_KEYSIZE + 8; +const SCD_VERSION: u32 = 1; #[repr(C)] // this can map directly into Flash pub(crate) struct StaticCryptoData { - /// aes-256 key of the system basis, encrypted with the User0 root key - pub(crate) system_key: [u8; AES_KEYSIZE], - /// check data to confirm the password was entered correctly; it is the encryption of the first 128 bits of the salt below. - pub(crate) check_data: [u8; BLOCK_SIZE], - /// a pool of fixed data used to pick salts, based on a hash of the basis name - pub(crate) salt_base: [u8; 4048], + /// a version number for the block + pub(crate) version: u32, + /// aes-256 key of the system basis, encrypted with the User0 root key, and wrapped using NIST SP800-38F + pub(crate) system_key: [u8; WRAPPED_AES_KEYSIZE], + /// a pool of fixed data used as a salt + pub(crate) salt_base: [u8; 4096 - WRAPPED_AES_KEYSIZE - size_of::()], +} +impl StaticCryptoData { + pub fn default() -> StaticCryptoData { + StaticCryptoData { + version: SCD_VERSION, + system_key: [0u8; WRAPPED_AES_KEYSIZE], + salt_base: [0u8; 4096 - WRAPPED_AES_KEYSIZE - size_of::()], + } + } } impl Deref for StaticCryptoData { type Target = [u8]; @@ -79,6 +90,7 @@ pub(crate) struct PddbOs { /// free space circular buffer base -- location in FLASH, offset from physical bottom of pddb_mr fscb_phys_base: PageAlignedPa, data_phys_base: PageAlignedPa, + /// We keep a copy of the raw key around because we have to combine this with the AAD of a block to derive the AES-GCM-SIV cipher. system_basis_key: Option<[u8; AES_KEYSIZE]>, /// derived cipher for handling fastspace -- cache it, so we can save the time cost of constructing the cipher key schedule cipher_ecb: Option, @@ -452,69 +464,43 @@ impl PddbOs { pub(crate) fn clear_password(&self) { self.rootkeys.clear_password(AesRootkeyType::User0); } - pub (crate) fn try_login(&mut self) -> bool { + pub (crate) fn try_login(&mut self) -> PasswordState { if self.system_basis_key.is_none() || self.cipher_ecb.is_none() { let scd = self.static_crypto_data_get(); - let mut system_key: [u8; AES_KEYSIZE] = [0; AES_KEYSIZE]; - let mut blank = true; - for (&src, dst) in scd.system_key.iter().zip(system_key.iter_mut()) { - *dst = src; - if src != 0xFF { - blank = false; - } + if scd.version == 0xFFFF_FFFF { // system is in the blank state + return PasswordState::Uninit } - for block in system_key.chunks_mut(aes::BLOCK_SIZE) { - self.rootkeys.decrypt_block(block.try_into().unwrap()); + if scd.version != SCD_VERSION { + log::error!("Version mismatch for keystore, declaring database as uninitialized"); + return PasswordState::Uninit; } - if !blank { - // form the ECB cipher and check the check data - let cipher = Aes256::new(GenericArray::from_slice(&system_key)); - let mut block = [0u8; BLOCK_SIZE]; - for (&src, dst) in scd.check_data[0..BLOCK_SIZE].iter().zip(block.iter_mut()) { - *dst = src; - } - let ga = GenericArray::from_mut_slice(&mut block); - //log::info!("test block before: {:x?}", ga); - cipher.decrypt_block(ga); - //log::info!("test block after check: {:x?}", ga); - let mut success = true; - let mut checkedlen = 0; - for (&a, &b) in scd.salt_base[0..BLOCK_SIZE].iter().zip(ga.iter()) { - if a != b { - success = false; - } - checkedlen += 1; - } - if checkedlen != BLOCK_SIZE { - success = false; - } - if success { + match self.rootkeys.unwrap_key(&scd.system_key, AES_KEYSIZE) { + Ok(mut syskey) => { + let cipher = Aes256::new(GenericArray::from_slice(&syskey)); + self.cipher_ecb = Some(cipher); let mut system_key: [u8; AES_KEYSIZE] = [0; AES_KEYSIZE]; - for (&src, dst) in scd.system_key.iter().zip(system_key.iter_mut()) { + for (&src, dst) in syskey.iter().zip(system_key.iter_mut()) { *dst = src; } - for block in system_key.chunks_mut(aes::BLOCK_SIZE) { - self.rootkeys.decrypt_block(block.try_into().unwrap()); - } self.system_basis_key = Some(system_key); - self.cipher_ecb = Some(cipher); + // erase the old vector completely + let nuke = syskey.as_mut_ptr(); + for i in 0..syskey.len() { + unsafe{nuke.add(i).write_volatile(0)}; + } + PasswordState::Correct + } + Err(e) => { + log::error!("Couldn't unwrap our system key: {:?}", e); + PasswordState::Incorrect } - success - } else { - // the system is in a blank state -- use the bogus key so that the later test for - // mounting the PDDB doesn't fail on account of a lack of key matter. We'll deal - // with setting the key correctly later. - self.system_basis_key = Some(system_key); - let cipher = Aes256::new(GenericArray::from_slice(&system_key)); - self.cipher_ecb = Some(cipher); - true } } else { - true + PasswordState::Correct } } fn syskey_ensure(&mut self) { - while !self.try_login() { + while self.try_login() != PasswordState::Correct { self.clear_password(); // clear the bad password entry let xns = xous_names::XousNames::new().unwrap(); let modals = modals::Modals::new(&xns).expect("can't connect to Modals server"); @@ -1202,6 +1188,10 @@ impl PddbOs { if let Some(modals) = progress { let mut success = false; while !success { + // the "same password check" is accomplished by just encrypting the all-zeros block twice + // with the cipher after clearing the password and re-entering it, and then comparing that + // the results are identical. The test blocks are never committed or stored anywhere. + // The actual creation of the "real" key material is done in step 3. let mut checkblock_a = [0u8; BLOCK_SIZE]; self.rootkeys.decrypt_block(GenericArray::from_mut_slice(&mut checkblock_a)); @@ -1301,40 +1291,27 @@ impl PddbOs { assert!(size_of::() == PAGE_SIZE, "StaticCryptoData structure is not correctly sized"); let mut system_basis_key: [u8; AES_KEYSIZE] = [0; AES_KEYSIZE]; self.entropy.borrow_mut().get_slice(&mut system_basis_key); - let mut basis_key_aes: [u8; AES_KEYSIZE] = system_basis_key.clone(); - self.cipher_ecb = Some(Aes256::new(GenericArray::from_slice(&basis_key_aes))); // build the ECB cipher for page table entries - let cipher = Aes256::new(GenericArray::from_slice(&basis_key_aes)); - self.system_basis_key = Some(system_basis_key); // causes system_basis_key to be owned by self - for block in basis_key_aes.chunks_mut(aes::BLOCK_SIZE) { - self.rootkeys.encrypt_block(block.try_into().unwrap()); - } - let mut crypto_keys = StaticCryptoData { - system_key: [0; AES_KEYSIZE], - check_data: [0; BLOCK_SIZE], - salt_base: [0; 4048], - }; + // build the ECB cipher for page table entries + self.cipher_ecb = Some(Aes256::new(GenericArray::from_slice(&system_basis_key))); + let cipher_ecb = Aes256::new(GenericArray::from_slice(&system_basis_key)); // a second copy for patching the page table later in this routine interior mutability blah blah work around oops + // now wrap the key for storage + let wrapped_key = self.rootkeys.wrap_key(&system_basis_key).expect("Internal error wrapping our encryption key"); + self.system_basis_key = Some(system_basis_key); // this causes system_basis_key to be owned by self and go out of scope + let mut crypto_keys = StaticCryptoData::default(); + crypto_keys.version = SCD_VERSION; // should already be set by `default()` but let's be sure. if let Some(modals) = progress { modals.update_progress(50).expect("couldn't update progress bar"); self.tt.sleep_ms(100).unwrap(); } // copy the encrypted key into the data structure for commit to Flash - for (&src, dst) in basis_key_aes.iter().zip(crypto_keys.system_key.iter_mut()) { + // the wrapped key should have a well-defined length of 40 bytes + assert!(wrapped_key.len() == 40, "wrapped key did not have the expected length"); + for (&src, dst) in wrapped_key.iter().zip(crypto_keys.system_key.iter_mut()) { *dst = src; } + // initialize the salt self.entropy.borrow_mut().get_slice(&mut crypto_keys.salt_base); - let cipher_ecb = self.cipher_ecb.as_ref().unwrap(); - let mut block = [0u8; BLOCK_SIZE]; - // the test data is just the first 128 bits of the salt base - for (&src, dst) in crypto_keys.salt_base[0..BLOCK_SIZE].iter().zip(block.iter_mut()) { - *dst = src; - } - let ga = GenericArray::from_mut_slice(&mut block); - log::info!("test block before: {:x?}", ga); - cipher_ecb.encrypt_block(ga); - for (&src, dst) in ga.iter().zip(crypto_keys.check_data.iter_mut()) { - *dst = src; - } - log::info!("test block after: {:x?}", crypto_keys.check_data); + // commit keys self.patch_keys(crypto_keys.deref(), 0); if let Some(modals) = progress { modals.update_progress(100).expect("couldn't update progress bar"); @@ -1484,7 +1461,7 @@ impl PddbOs { // step 9. generate & write initial page table entries for (&virt, phys) in basis_v2p_map.iter_mut() { - self.pt_patch_mapping(virt, phys.page_number(), &cipher); + self.pt_patch_mapping(virt, phys.page_number(), &cipher_ecb); // mark the entry as clean, as it has been sync'd to disk phys.set_clean(true); } diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index cf1125398..c4ecffedd 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -396,6 +396,12 @@ pub(crate) struct BasisRequestPassword { db_name: xous_ipc::String::<{crate::api::BASIS_NAME_LEN}>, plaintext_pw: Option>, } +#[derive(Debug, PartialEq, Eq)] +pub(crate) enum PasswordState { + Correct, + Incorrect, + Uninit, +} struct TokenRecord { pub dict: String, @@ -466,8 +472,14 @@ fn xmain() -> ! { #[cfg(not(any(windows, unix)))] // skip this step if running in hosted mode, for now... if pddb_os.rootkeys_initialized() { tt.sleep_ms(1000).unwrap(); // wait 1 second after boot before attempting to mount, to let the boot screen finish redrawing (cometic issue). - if ensure_password(&modals, &mut pddb_os) { - try_mount_or_format(&modals, &mut pddb_os, &mut basis_cache); + match ensure_password(&modals, &mut pddb_os) { + PasswordState::Correct => { + try_mount_or_format(&modals, &mut pddb_os, &mut basis_cache, PasswordState::Correct); + }, + PasswordState::Uninit => { + try_mount_or_format(&modals, &mut pddb_os, &mut basis_cache, PasswordState::Uninit); + }, + _ => (), // continue without mounting if the user opts out } } // main server loop @@ -502,8 +514,8 @@ fn xmain() -> ! { // can't mount if we have no root keys xous::return_scalar(msg.sender, 0).expect("could't return scalar"); } else { - if ensure_password(&modals, &mut pddb_os) { - if try_mount_or_format(&modals, &mut pddb_os, &mut basis_cache) { + if ensure_password(&modals, &mut pddb_os) == PasswordState::Correct { + if try_mount_or_format(&modals, &mut pddb_os, &mut basis_cache, PasswordState::Correct) { xous::return_scalar(msg.sender, 1).expect("couldn't return scalar"); } else { xous::return_scalar(msg.sender, 0).expect("couldn't return scalar"); @@ -1055,40 +1067,48 @@ fn xmain() -> ! { xous::terminate_process(0) } -fn ensure_password(modals: &modals::Modals, pddb_os: &mut PddbOs) -> bool { +fn ensure_password(modals: &modals::Modals, pddb_os: &mut PddbOs) -> PasswordState { log::info!("Requesting login password"); - let mut done = false; - let mut skip = false; - while !done { - done = pddb_os.try_login(); - if !done { - pddb_os.clear_password(); // clear the bad password entry - modals.add_list_item(t!("pddb.yes", xous::LANG)).expect("couldn't build radio item list"); - modals.add_list_item(t!("pddb.no", xous::LANG)).expect("couldn't build radio item list"); - match modals.get_radiobutton(t!("pddb.badpass", xous::LANG)) { - Ok(response) => { - if response.as_str() == t!("pddb.yes", xous::LANG) { - done = false; - } else if response.as_str() == t!("pddb.no", xous::LANG) { - done = true; - skip = true; - } else { - panic!("Got unexpected return from radiobutton"); + loop { + match pddb_os.try_login() { + PasswordState::Correct => { + return PasswordState::Correct + } + PasswordState::Incorrect => { + pddb_os.clear_password(); // clear the bad password entry + // check if the user wants to re-try or not. + modals.add_list_item(t!("pddb.yes", xous::LANG)).expect("couldn't build radio item list"); + modals.add_list_item(t!("pddb.no", xous::LANG)).expect("couldn't build radio item list"); + match modals.get_radiobutton(t!("pddb.badpass", xous::LANG)) { + Ok(response) => { + if response.as_str() == t!("pddb.yes", xous::LANG) { + continue; + } else if response.as_str() == t!("pddb.no", xous::LANG) { + return PasswordState::Incorrect; + } else { + panic!("Got unexpected return from radiobutton"); + } } + _ => panic!("get_radiobutton failed"), } - _ => panic!("get_radiobutton failed"), + } + PasswordState::Uninit => { + return PasswordState::Uninit; } } } - !skip } -fn try_mount_or_format(modals: &modals::Modals, pddb_os: &mut PddbOs, basis_cache: &mut BasisCache) -> bool { +fn try_mount_or_format(modals: &modals::Modals, pddb_os: &mut PddbOs, basis_cache: &mut BasisCache, pw_state: PasswordState) -> bool { log::info!("Attempting to mount the PDDB"); - if let Some(sys_basis) = pddb_os.pddb_mount() { - log::info!("PDDB mount operation finished successfully"); - basis_cache.basis_add(sys_basis); - true - } else { + if pw_state == PasswordState::Correct { + if let Some(sys_basis) = pddb_os.pddb_mount() { + log::info!("PDDB mount operation finished successfully"); + basis_cache.basis_add(sys_basis); + return true + } + } + // correct password but no mount -> offer to format; uninit -> offer to format + if pw_state == PasswordState::Correct || pw_state == PasswordState::Uninit { #[cfg(any(target_os = "none", target_os = "xous"))] { log::debug!("PDDB did not mount; requesting format"); @@ -1162,6 +1182,9 @@ fn try_mount_or_format(modals: &modals::Modals, pddb_os: &mut PddbOs, basis_cach false } } + } else { + // password was incorrect, don't try anything just return false + false } } diff --git a/services/root-keys/Cargo.toml b/services/root-keys/Cargo.toml index 470dd0ed9..0304d644f 100644 --- a/services/root-keys/Cargo.toml +++ b/services/root-keys/Cargo.toml @@ -46,6 +46,7 @@ sha2 = {path = "../engine-sha512"} digest = "0.9.0" aes={path="../aes"} engine-25519 = {path="../engine-25519"} +byteorder = "1.4.3" # used by keywrap # hardware acceleration adaptations are inserted into a fork of the main branch. rand_core = "0.5.1" hex = {version = "0.4.3", default-features = false, features = []} diff --git a/services/root-keys/src/api.rs b/services/root-keys/src/api.rs index 51b5bb16a..8c62c65fa 100644 --- a/services/root-keys/src/api.rs +++ b/services/root-keys/src/api.rs @@ -15,6 +15,8 @@ pub(crate) enum Opcode { IsJtagWorking, /// initiate an AES oracle operation AesOracle, + /// initiate key wrapper operation + AesKwp, /// create new FPGA keys; provisioning requires a slave device to be connected that can run the JTAG sequence BbramProvision, /// clear a cached password @@ -151,4 +153,53 @@ impl AesOp { } } } +} + +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Zeroize, Eq, PartialEq, Copy, Clone)] +pub enum KeywrapError { + /// Input is too big. + TooBig, + /// Input is too small. + TooSmall, + /// Ciphertext has invalid padding. + Unpadded, + /// The ciphertext is not valid for the expected length. + InvalidExpectedLen, + /// The ciphertext couldn't be authenticated. + AuthenticationFailed, +} +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Zeroize, Eq, PartialEq)] +pub enum KeyWrapOp { + Wrap, + Unwrap, +} + +use std::error::Error; +impl Error for KeywrapError {} + +use std::fmt; +impl fmt::Display for KeywrapError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { + match self { + KeywrapError::TooBig => f.write_str("Input too big"), + KeywrapError::TooSmall => f.write_str("Input too small"), + KeywrapError::Unpadded => f.write_str("Padding error"), + KeywrapError::InvalidExpectedLen => f.write_str("Invalid expected lengthr"), + KeywrapError::AuthenticationFailed => f.write_str("Authentication failed"), + } + } +} + +pub(crate) const MAX_WRAP_DATA: usize = 2048; +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Zeroize)] +#[zeroize(drop)] +pub (crate) struct KeyWrapper { + pub data: [u8; MAX_WRAP_DATA + 8], + // used to specify the length of the data used in the fixed-length array above + pub len: u32, + pub key_index: u8, + pub op: KeyWrapOp, + pub result: Option, + // used by the unwrap side + pub expected_len: u32, } \ No newline at end of file diff --git a/services/root-keys/src/implementation.rs b/services/root-keys/src/implementation.rs index 9b02fc11e..4c43cbce5 100644 --- a/services/root-keys/src/implementation.rs +++ b/services/root-keys/src/implementation.rs @@ -1,5 +1,7 @@ mod oracle; use oracle::*; +mod keywrap; +use keywrap::*; pub use oracle::FpgaKeySource; use utralib::generated::*; @@ -349,6 +351,63 @@ impl<'a> RootKeys { } } } + pub fn kwp_op(&mut self, kwp: &mut KeyWrapper) { + let key = match kwp.key_index { + KeyRomLocs::USER_KEY => { + let mut key_enc = self.read_key_256(KeyRomLocs::USER_KEY); + let pcache: &PasswordCache = unsafe{& *(self.pass_cache.as_ptr() as *const PasswordCache)}; + if pcache.hashed_boot_pw_valid == 0 { + self.purge_password(PasswordType::Boot); + log::warn!("boot password isn't valid! Returning bogus results."); + } + for (key, &pw) in + key_enc.iter_mut().zip(pcache.hashed_boot_pw.iter()) { + *key = *key ^ pw; + } + if self.boot_password_policy == PasswordRetentionPolicy::AlwaysPurge { + self.purge_password(PasswordType::Boot); + } + key_enc + }, + _ => { + self.fake_key[0] = kwp.key_index; + self.fake_key + } + }; + let keywrapper = Aes256KeyWrap::new(&key); + match kwp.op { + KeyWrapOp::Wrap => { + match keywrapper.encapsulate(&kwp.data[..kwp.len as usize]) { + Ok(wrapped) => { + for (&src, dst) in wrapped.iter().zip(kwp.data.iter_mut()) { + *dst = src; + } + kwp.len = wrapped.len() as u32; + kwp.result = None; + // this is an un-used field but...why not? + kwp.expected_len = wrapped.len() as u32; + } + Err(e) => { + kwp.result = Some(e); + } + } + } + KeyWrapOp::Unwrap => { + match keywrapper.decapsulate(&kwp.data[..kwp.len as usize], kwp.expected_len as usize) { + Ok(unwrapped) => { + for (&src, dst) in unwrapped.iter().zip(kwp.data.iter_mut()) { + *dst = src; + } + kwp.len = unwrapped.len() as u32; + kwp.result = None; + } + Err(e) => { + kwp.result = Some(e); + } + } + } + } + } /// returns None if there is an obvious problem with the JTAG interface /// otherwise returns the result. "secured" would be the most paranoid setting diff --git a/services/root-keys/src/implementation/keywrap.rs b/services/root-keys/src/implementation/keywrap.rs new file mode 100644 index 000000000..5ab95c32f --- /dev/null +++ b/services/root-keys/src/implementation/keywrap.rs @@ -0,0 +1,180 @@ +#![forbid(unsafe_code)] + +/// this code is vendored in from https://github.com/jedisct1/rust-aes-keywrap +/// From its original README: +/// AES Key Wrap for Rust +/// +/// AES Key Wrap is a construction to encrypt secret keys using a master key. +/// +/// This is an AES-KWP (NIST SP800-38F) implementation for Rust. +/// +/// It is essentially a 5 round Feistel network using AES as the core function. +/// One half of each AES block is used to encrypt the key, and the second half +/// of the last permutation is used to compute a 64-bit MAC. +/// +/// It doesn't require nonces, but still allows key reuse. +/// +/// This is a NIST-blessed construction. Other than that, AES Key Wrap is inefficient +/// and is generally not very useful. + +use aes::cipher::generic_array::GenericArray; +use aes::Aes256; +use aes::{BlockDecrypt, BlockEncrypt, NewBlockCipher}; +use byteorder::{BigEndian, ByteOrder}; + +use crate::api::KeywrapError; + +const FEISTEL_ROUNDS: usize = 5; + +#[derive(Debug)] +pub struct Aes256KeyWrap { + aes: Aes256, +} + +impl Aes256KeyWrap { + pub const KEY_BYTES: usize = 32; + pub const MAC_BYTES: usize = 8; + + pub fn new(key: &[u8; Self::KEY_BYTES]) -> Self { + Aes256KeyWrap { + aes: Aes256::new(key.into()), + } + } + + pub fn encapsulate(&self, input: &[u8]) -> Result, KeywrapError> { + if input.len() > std::u32::MAX as usize + || input.len() as u64 >= std::u64::MAX / FEISTEL_ROUNDS as u64 + { + return Err(KeywrapError::TooBig); + } + let mut aiv: [u8; 8] = [0xa6u8, 0x59, 0x59, 0xa6, 0, 0, 0, 0]; + BigEndian::write_u32(&mut aiv[4..8], input.len() as u32); + let mut block = [0u8; 16]; + let mut block = GenericArray::from_mut_slice(&mut block); + block[0..8].copy_from_slice(&aiv); + + if input.len() == 8 { + block[8..16].copy_from_slice(input); + self.aes.encrypt_block(&mut block); + return Ok(block.to_vec()); + } + + let mut counter = 0u64; + let mut counter_bin = [0u8; 8]; + let mut output = vec![0u8; ((input.len() + 7) & !7) + Self::MAC_BYTES]; + output[8..][..input.len()].copy_from_slice(input); + for _ in 0..FEISTEL_ROUNDS { + let mut i = 8; + while i <= (input.len() + 7) & !7 { + block[8..16].copy_from_slice(&output[i..][0..8]); + self.aes.encrypt_block(&mut block); + counter += 1; + BigEndian::write_u64(&mut counter_bin, counter); + block[8..16] + .iter_mut() + .zip(counter_bin.iter()) + .for_each(|(a, b)| *a ^= b); + output[i..i + 8].copy_from_slice(&block[8..16]); + i += 8; + } + } + output[0..8].copy_from_slice(&block[0..8]); + Ok(output) + } + + pub fn decapsulate(&self, input: &[u8], expected_len: usize) -> Result, KeywrapError> { + if input.len() % 8 != 0 { + return Err(KeywrapError::Unpadded); + } + let output_len = input + .len() + .checked_sub(Self::MAC_BYTES) + .ok_or(KeywrapError::TooSmall)?; + if output_len > std::u32::MAX as usize + || output_len as u64 >= std::u64::MAX / FEISTEL_ROUNDS as u64 + { + return Err(KeywrapError::TooBig); + } + if expected_len > output_len || (expected_len & !7) > output_len { + return Err(KeywrapError::InvalidExpectedLen); + } + let mut output = vec![0u8; output_len]; + let mut aiv: [u8; 8] = [0xa6u8, 0x59, 0x59, 0xa6, 0, 0, 0, 0]; + BigEndian::write_u32(&mut aiv[4..8], expected_len as u32); + + let mut block = [0u8; 16]; + let mut block = GenericArray::from_mut_slice(&mut block); + + if output.len() == 8 { + block.copy_from_slice(input); + self.aes.decrypt_block(&mut block); + let c = block[0..8] + .iter() + .zip(aiv.iter()) + .fold(0, |acc, (a, b)| acc | (a ^ b)); + if c != 0 { + return Err(KeywrapError::AuthenticationFailed); + } + output[0..8].copy_from_slice(&block[8..16]); + return Ok(output); + } + + output.copy_from_slice(&input[8..]); + block[0..8].copy_from_slice(&input[0..8]); + let mut counter = (FEISTEL_ROUNDS * output.len() / 8) as u64; + let mut counter_bin = [0u8; 8]; + for _ in 0..FEISTEL_ROUNDS { + let mut i = output.len(); + while i >= 8 { + i -= 8; + block[8..16].copy_from_slice(&output[i..][0..8]); + BigEndian::write_u64(&mut counter_bin, counter); + counter -= 1; + block[8..16] + .iter_mut() + .zip(counter_bin.iter()) + .for_each(|(a, b)| *a ^= b); + self.aes.decrypt_block(&mut block); + output[i..][0..8].copy_from_slice(&block[8..16]); + } + } + let c = block[0..8] + .iter() + .zip(aiv.iter()) + .fold(0, |acc, (a, b)| acc | (a ^ b)); + if c != 0 { + return Err(KeywrapError::AuthenticationFailed); + } + Ok(output) + } +} + +#[test] +fn aligned() { + let secret = b"1234567812345678"; + let key = [42u8; 32]; + let kw = Aes256KeyWrap::new(&key); + let wrapped = kw.encapsulate(secret).unwrap(); + let unwrapped = kw.decapsulate(&wrapped, secret.len()).unwrap(); + assert_eq!(secret, unwrapped.as_slice()); +} + +#[test] +fn not_aligned() { + let secret = b"1234567812345"; + let key = [42u8; 32]; + let kw = Aes256KeyWrap::new(&key); + let wrapped = kw.encapsulate(secret).unwrap(); + let unwrapped = kw.decapsulate(&wrapped, secret.len()).unwrap(); + assert_eq!(secret, &unwrapped.as_slice()[..secret.len()]); +} + +#[test] +fn singleblock() { + let secret = b"12345678"; + let key = [42u8; 32]; + let kw = Aes256KeyWrap::new(&key); + let wrapped = kw.encapsulate(secret).unwrap(); + let unwrapped = kw.decapsulate(&wrapped, secret.len()).unwrap(); + assert_eq!(secret, unwrapped.as_slice()); +} \ No newline at end of file diff --git a/services/root-keys/src/lib.rs b/services/root-keys/src/lib.rs index 507e8672f..7e7d0326c 100644 --- a/services/root-keys/src/lib.rs +++ b/services/root-keys/src/lib.rs @@ -168,6 +168,93 @@ impl RootKeys { pass_type.to_usize().unwrap(), 0, 0, 0) ).expect("couldn't send bbram provision message"); } + + pub fn wrap_key(&self, input: &[u8]) -> Result, KeywrapError> { + if input.len() > api::MAX_WRAP_DATA { + // of course, the underlying crypto can handle a much larger piece of data, + // but the intention of this API is to wrap crypto keys -- not bulk data. So for simplicity + // we're going to limit the size of wrapped data to 2kiB (typically it's envisioned you're + // wrapping data on the order of 32-512 bytes) + return Err(KeywrapError::TooBig) + } + if !self.ensure_aes_password() { + return Err(KeywrapError::AuthenticationFailed); + } + let mut alloc = KeyWrapper { + data: [0u8; MAX_WRAP_DATA + 8], + len: input.len() as u32, + key_index: self.key_index.to_u8().unwrap(), + op: KeyWrapOp::Wrap, + result: Some(KeywrapError::AuthenticationFailed), // initialize to a default value that throws an error if it wasn't modified by the recipient + // this field is ignored on the Wrap side + expected_len: 0, + }; + for (&src, dst) in input.iter().zip(alloc.data.iter_mut()) { + *dst = src; + } + let mut buf = Buffer::into_buf(alloc).or(Err(KeywrapError::AuthenticationFailed))?; + buf.lend_mut(self.conn, Opcode::AesKwp.to_u32().unwrap()).or(Err(KeywrapError::AuthenticationFailed))?; + let ret = buf.to_original::().unwrap(); + match ret.result { + None => { // no error, proceed + Ok(ret.data[..ret.len as usize].to_vec(),) + } + Some(err) => { + Err(err) + } + } + } + pub fn unwrap_key(&self, wrapped: &[u8], expected_len: usize) -> Result, KeywrapError> { + if wrapped.len() > api::MAX_WRAP_DATA + 8 { + return Err(KeywrapError::TooBig) + } + if !self.ensure_aes_password() { + return Err(KeywrapError::AuthenticationFailed); + } + let mut alloc = KeyWrapper { + data: [0u8; MAX_WRAP_DATA + 8], + len: wrapped.len() as u32, + key_index: self.key_index.to_u8().unwrap(), + op: KeyWrapOp::Unwrap, + result: Some(KeywrapError::AuthenticationFailed), // initialize to a default value that throws an error if it wasn't modified by the recipient + expected_len: expected_len as u32, + }; + for (&src, dst) in wrapped.iter().zip(alloc.data.iter_mut()) { + *dst = src; + } + let mut buf = Buffer::into_buf(alloc).or(Err(KeywrapError::AuthenticationFailed))?; + buf.lend_mut(self.conn, Opcode::AesKwp.to_u32().unwrap()).or(Err(KeywrapError::AuthenticationFailed))?; + let ret = buf.to_original::().unwrap(); + match ret.result { + None => { // no error, proceed + if ret.len as usize != expected_len { + // The key wrapper will return a vector that is rounded to the nearest 8-bytes, with + // a zero-pad on the excess data. Ensure that the zero-pad is intact before lopping it off. + if (ret.len as usize) < expected_len { + Err(KeywrapError::InvalidExpectedLen) + } else { + let mut all_zeroes = true; + for &d in ret.data[expected_len..ret.len as usize].iter() { + if d != 0 { + all_zeroes = false; + break; + } + } + if all_zeroes { + Ok(ret.data[..expected_len as usize].to_vec(),) + } else { + Err(KeywrapError::InvalidExpectedLen) + } + } + } else { + Ok(ret.data[..expected_len as usize].to_vec(),) + } + } + Some(err) => { + Err(err) + } + } + } } use core::sync::atomic::{AtomicU32, Ordering}; diff --git a/services/root-keys/src/main.rs b/services/root-keys/src/main.rs index 583bf13b6..44c3a1045 100644 --- a/services/root-keys/src/main.rs +++ b/services/root-keys/src/main.rs @@ -80,6 +80,8 @@ pub struct MetadataInFlash { // a stub to try to avoid breaking hosted mode for as long as possible. #[cfg(not(any(target_os = "none", target_os = "xous")))] mod implementation { + mod keywrap; + use keywrap::*; use crate::PasswordRetentionPolicy; use crate::PasswordType; use gam::modal::{Modal, Slider}; @@ -99,7 +101,7 @@ mod implementation { Efuse, } #[allow(dead_code)] - pub struct RootKeys { + pub(crate) struct RootKeys { password_type: Option, jtag: jtag::Jtag, xns: xous_names::XousNames, @@ -252,6 +254,41 @@ mod implementation { } } } + pub fn kwp_op(&mut self, kwp: &mut KeyWrapper) { + let keywrapper = Aes256KeyWrap::new(&[0u8; 32]); + match kwp.op { + KeyWrapOp::Wrap => { + match keywrapper.encapsulate(&kwp.data[..kwp.len as usize]) { + Ok(wrapped) => { + for (&src, dst) in wrapped.iter().zip(kwp.data.iter_mut()) { + *dst = src; + } + kwp.len = wrapped.len() as u32; + kwp.result = None; + // this is an un-used field but...why not? + kwp.expected_len = wrapped.len() as u32; + } + Err(e) => { + kwp.result = Some(e); + } + } + } + KeyWrapOp::Unwrap => { + match keywrapper.decapsulate(&kwp.data[..kwp.len as usize], kwp.expected_len as usize) { + Ok(unwrapped) => { + for (&src, dst) in unwrapped.iter().zip(kwp.data.iter_mut()) { + *dst = src; + } + kwp.len = unwrapped.len() as u32; + kwp.result = None; + } + Err(e) => { + kwp.result = Some(e); + } + } + } + } + } } } @@ -914,6 +951,12 @@ fn xmain() -> ! { }; buffer.replace(aes_op).unwrap(); }, + Some(Opcode::AesKwp) => { + let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; + let mut kwp = buffer.to_original::().unwrap(); + keys.kwp_op(&mut kwp); + buffer.replace(kwp).unwrap(); + } Some(Opcode::BbramProvision) => { modals.show_notification(t!("rootkeys.bbram.confirm", xous::LANG)).expect("modals error"); diff --git a/xtask/src/main.rs b/xtask/src/main.rs index b2f7bba07..0f9c23fe5 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -351,6 +351,7 @@ Various debug configurations: wycheproof-import generate binary test vectors for engine-25519 from whycheproof-import/x25519.json pddb-dev PDDB testing only for live hardware pddb-hosted PDDB testing in a hosted environment + pddb-ci PDDB config for CI testing (eg: TRNG->deterministic for reproducible errors) " )