From c88c986aea290e49c55728020be85c3bb16d0778 Mon Sep 17 00:00:00 2001 From: bunnie Date: Sat, 14 Aug 2021 19:46:42 +0800 Subject: [PATCH] clean up key signing routines, finally everything "seems" to work --- services/root-keys/locales/i18n.json | 14 +- services/root-keys/src/api.rs | 4 +- services/root-keys/src/implementation.rs | 286 +++++++++++++++-------- services/root-keys/src/lib.rs | 7 +- services/root-keys/src/main.rs | 107 ++++++++- 5 files changed, 316 insertions(+), 102 deletions(-) diff --git a/services/root-keys/locales/i18n.json b/services/root-keys/locales/i18n.json index d96b363ac..a20a1d9e9 100644 --- a/services/root-keys/locales/i18n.json +++ b/services/root-keys/locales/i18n.json @@ -90,7 +90,7 @@ "en-audio": "Verification failed, aborting" }, "rootkeys.init.fail_key": { - "en": "FPGA key is wrong:\nPerhaps the update password\nwas entered incorrectly?", + "en": "FPGA key is wrong:\nPerhaps the update\npassword was entered\nincorrectly?", "zh": "*missing*正在初始化失败,中止!", "en-audio": "FPGA key is wrong, perhaps the update password was entered incorrectly?" }, @@ -177,7 +177,17 @@ "rootkeys.gwup.finished": { "en": "Gateware update finished.\nReboot to apply.", "zh": "更新完成重启应用", - "en-audio": "Gatewaer update finished. Reboot to apply." + "en-audio": "Gateware update finished. Reboot to apply." + }, + "rootkeys.get_signing_password": { + "en": "Password request\nSoftware update key\nSecurity: Critical\nWhy: Sign Xous", + "zh": "输入密码\n软件更新\n安全含义:至关重要 ", + "en-audio": "Enter update password, in order to authorize a gateware update." + }, + "rootkeys.signxous.finished": { + "en": "Xous signing finished.\nReboot to apply.", + "zh": "更新完成重启应用", + "en-audio": "Xous signing finished. Reboot to apply." }, "rootkeys.policy_request": { "en": "Please pick a password\nretention policy:", diff --git a/services/root-keys/src/api.rs b/services/root-keys/src/api.rs index 7b1c2f231..2fd07d694 100644 --- a/services/root-keys/src/api.rs +++ b/services/root-keys/src/api.rs @@ -35,11 +35,11 @@ pub(crate) enum Opcode { UxUpdateGwDecidePassword, UxUpdateGwPasswordPolicy, UxUpdateGwRun, - // UxUpdateGatewarePasswordReturn, - // UxUpdateGatwareDisplayInfo, /// self-sign kernel/loader UxSelfSignXous, + UxSignXousPasswordPolicy, + UxSignXousRun, // General Ux calls UxGutter, // NOP for UX calls that require a destination diff --git a/services/root-keys/src/implementation.rs b/services/root-keys/src/implementation.rs index 378d7f4d5..ca3ced3cc 100644 --- a/services/root-keys/src/implementation.rs +++ b/services/root-keys/src/implementation.rs @@ -200,17 +200,15 @@ impl<'a> BitstreamOracle<'a> { log::error!("Padding is incorrect on the bitstream. Check append_csr.py for padding and make sure you are burning gateware with --raw-binary, and not --bitstream as the latter strips padding from the top of the file."); return Err(RootkeyResult::AlignmentError) } - log::info!("ciphertext len: {} bytes, start: 0x{:08x}", ciphertext_len, ciphertext_start); + log::debug!("ciphertext len: {} bytes, start: 0x{:08x}", ciphertext_len, ciphertext_start); let ciphertext = &bitstream[ciphertext_start..ciphertext_start + ciphertext_len as usize]; let mut iv_bytes: [u8; AES_BLOCKSIZE] = [0; AES_BLOCKSIZE]; bitflip(&bitstream[iv_pos..iv_pos + AES_BLOCKSIZE], &mut iv_bytes); - log::info!("recovered iv (pre-flip): {:x?}", &bitstream[iv_pos..iv_pos + AES_BLOCKSIZE]); - log::info!("recovered iv : {:x?}", &iv_bytes); + log::debug!("recovered iv (pre-flip): {:x?}", &bitstream[iv_pos..iv_pos + AES_BLOCKSIZE]); + log::debug!("recovered iv : {:x?}", &iv_bytes); - log::info!("AES decryption key: {:x?}", dec_key); let dec_cipher = Aes256::new(dec_key.try_into().unwrap()); - log::info!("AES encryption key: {:x?}", enc_key); let enc_cipher = Aes256::new(enc_key.try_into().unwrap()); let mut oracle = BitstreamOracle { @@ -265,7 +263,7 @@ impl<'a> BitstreamOracle<'a> { } oracle.type2_absolute_offset = pt_pos + ciphertext_start; oracle.type2_ciphertext_offset = pt_pos; - log::info!("type2 absolute: {}, relative to ct start: {}", oracle.type2_absolute_offset, oracle.type2_ciphertext_offset); + log::debug!("type2 absolute: {}, relative to ct start: {}", oracle.type2_absolute_offset, oracle.type2_ciphertext_offset); // read the boot source out of the ciphertext let mut bytes = first_block.chunks(4).into_iter(); @@ -433,16 +431,12 @@ impl<'a> BitstreamOracle<'a> { pos += 4; // the bit we want to patch is in MSB of the value, just patch it directly since // the pos pointer is at this byte. - log::info!("patching pt header orig: {:x}", output_sector[pos]); - log::info!("output_sector: {:x?}", &output_sector[pos..pos+4]); - log::info!("source {:?}", self.dec_from_key); - log::info!("target {:?}", self.enc_to_key); + log::debug!("output_sector: {:x?}", &output_sector[pos..pos+4]); match self.enc_to_key { FpgaKeySource::Bbram => output_sector[pos] &= 0x7f, FpgaKeySource::Efuse => output_sector[pos] |= 0x80, } - log::info!("patching pt header patched: {:x}", output_sector[pos]); - log::info!("{:x?}", &output_sector[pos..pos+4]); + log::debug!("patched {:x?}", &output_sector[pos..pos+4]); patchcount += 1; if patchcount >= 2 { break; // short circuit the checking when we're done @@ -460,18 +454,15 @@ impl<'a> BitstreamOracle<'a> { pos += 4; // the bit we want to patch is in MSB of the value, just patch it directly since // the pos pointer is at this byte. - log::info!("patching ct header orig: {:x}", input_plaintext[pos+3]); - log::info!("{:x?}", &input_plaintext[pos..pos+4]); - log::info!("source {:?}", self.dec_from_key); - log::info!("target {:?}", self.enc_to_key); + log::debug!("patching ct header orig: {:x}", input_plaintext[pos+3]); + log::debug!("{:x?}", &input_plaintext[pos..pos+4]); if cwd == BITSTREAM_CTL0_CMD_FLIP { match self.enc_to_key { FpgaKeySource::Bbram => input_plaintext[pos+3] &= 0xfe, FpgaKeySource::Efuse => input_plaintext[pos+3] |= 0x01, // bit 31 is at byte 3 "lsb" in the flipped version } } - log::info!("patching ct header patched: {:x}", input_plaintext[pos+3]); - log::info!("{:x?}", &input_plaintext[pos..pos+4]); + log::debug!("{:x?}", &input_plaintext[pos..pos+4]); break; } pos += 4; @@ -483,22 +474,24 @@ impl<'a> BitstreamOracle<'a> { } // 3. search for the encryption key source setting only in the last blocks - if from > 0x21_5000 { - log::info!("type2 count: {} offset: {}", self.type2_count, self.type2_ciphertext_offset); - log::info!("searching for second key setting starting from 0x{:x}", from); + if from > ((self.type2_count as i32 * 4 + self.type2_ciphertext_offset as i32) & 0x7FFF_F000) - 0x1000 { + // maybe that complex math above would be better replaced with the the constant 0x21_5000. it never changes...? + // I guess it might be helpful if someone ported this code to a new FPGA type. + log::debug!("type2 count: {} offset: {}", self.type2_count, self.type2_ciphertext_offset); + log::debug!("searching for second key setting starting from 0x{:x}", from); let mut bytes = input_plaintext.chunks_mut(4).into_iter(); loop { if let Some(b) = bytes.next() { let word = u32::from_be_bytes(b[..4].try_into().unwrap()); if word == BITSTREAM_CTL0_CMD_FLIP { - log::info!("patching the second key setting inside block starting at 0x{:x}", from); + log::debug!("patching the second key setting inside block starting at 0x{:x}", from); if let Some(val) = bytes.next() { - log::info!("{:x?}", val); + log::debug!("{:x?}", val); match self.enc_to_key { FpgaKeySource::Bbram => val[3] &= 0xfe, FpgaKeySource::Efuse => val[3] |= 0x01, // bit 31 is at byte 3 "lsb" in the flipped version } - log::info!("{:x?}", val); + log::debug!("{:x?}", val); } else { log::error!("didn't decrypt enough memory to find the ctl0 encrypted settings"); } @@ -998,6 +991,7 @@ impl<'a> RootKeys { // get access to the pcache and generate a keypair let pcache: &mut PasswordCache = unsafe{&mut *(self.pass_cache.as_mut_ptr() as *mut PasswordCache)}; let keypair = if true { // true for production, false for debug (uses dev keys, so we can compare results) + // keypair zeroizes on drop Keypair::generate(&mut self.trng) } else { Keypair::from_bytes( @@ -1034,7 +1028,7 @@ impl<'a> RootKeys { // allocate a decryption oracle for the FPGA bitstream. This will fail early if the FPGA key is wrong. assert!(pcache.fpga_key_valid == 1); - log::info!("making destination oracle"); + log::debug!("making destination oracle"); let mut dst_oracle = match BitstreamOracle::new(&pcache.fpga_key, &pcache.fpga_key, self.gateware(), self.gateware_base()) { Ok(o) => o, Err(e) => { @@ -1051,7 +1045,7 @@ impl<'a> RootKeys { .zip(self.sensitive_data.borrow_mut().as_slice_mut::()[KeyRomLocs::SELFSIGN_PUBKEY as usize..KeyRomLocs::SELFSIGN_PUBKEY as usize + 256/(size_of::()*8)].iter_mut()) { *dst = u32::from_be_bytes(src.try_into().unwrap()) } - log::info!("public key as computed: {:x?}", public_key); + log::debug!("public key as computed: {:x?}", public_key); // extract the update password key from the cache, and apply it to the private key #[cfg(feature = "hazardous-debug")] @@ -1061,7 +1055,7 @@ impl<'a> RootKeys { } // private key must XOR with password before storing let mut private_key_enc: [u8; ed25519_dalek::SECRET_KEY_LENGTH] = [0; ed25519_dalek::SECRET_KEY_LENGTH]; - // we do this from to try and avoid making as few copies of the hashed password as possible + // I don't think this loop should make any extra copies of the secret key, but might be good to check in godbolt! for (dst, (plain, key)) in private_key_enc.iter_mut() .zip(keypair.secret.to_bytes().iter() @@ -1119,8 +1113,8 @@ impl<'a> RootKeys { #[cfg(feature = "hazardous-debug")] { - log::info!("Self private key: {:x?}", keypair.secret.to_bytes()); - log::info!("Self public key: {:x?}", keypair.public.to_bytes()); + log::debug!("Self private key: {:x?}", keypair.secret.to_bytes()); + log::debug!("Self public key: {:x?}", keypair.public.to_bytes()); self.debug_staging(); } @@ -1131,7 +1125,7 @@ impl<'a> RootKeys { pb.rebase_subtask_percentage(30, 50); self.make_gateware_backup(Some(&mut pb))?; - log::info!("making source oracle"); + log::debug!("making source oracle"); let mut src_oracle = match BitstreamOracle::new(&pcache.fpga_key, &pcache.fpga_key, self.staging(), self.staging_base()) { Ok(o) => o, Err(e) => { @@ -1166,23 +1160,24 @@ impl<'a> RootKeys { self.commit_signature(kernel_sig, kernel_len, SignatureType::Kernel)?; pb.set_percentage(95); - // as a sanity check, check the kernel self signature - if !self.verify_selfsign_kernel() { - log::error!("kernel signature failed to verify, probably should not try to reboot!"); - src_oracle.clear(); - dst_oracle.clear(); - return Err(RootkeyResult::IntegrityError); - } - - // sign the gateware - pb.set_percentage(98); - let (gateware_sig, gateware_len) = self.sign_gateware(&keypair); - log::debug!("gateware signature ({}): {:x?}", gateware_len, gateware_sig.to_bytes()); - self.commit_signature(gateware_sig, gateware_len, SignatureType::Gateware)?; - - // clean up the oracles + // clean up the oracles as soon as we're done to avoid some borrow checker issues src_oracle.clear(); dst_oracle.clear(); + + // as a sanity check, check the kernel self signature + let ret = if !self.verify_selfsign_kernel(false) { + log::error!("kernel signature failed to verify, probably should not try to reboot!"); + Err(RootkeyResult::IntegrityError) + } else { + // sign the gateware + pb.set_percentage(98); + let (gateware_sig, gateware_len) = self.sign_gateware(&keypair); + log::debug!("gateware signature ({}): {:x?}", gateware_len, gateware_sig.to_bytes()); + self.commit_signature(gateware_sig, gateware_len, SignatureType::Gateware)?; + Ok(()) + }; + + // clear the write protects self.spinor.set_staging_write_protect(false).expect("couldn't un-protect the staging area"); // finalize the progress bar on exit -- always leave at 100% @@ -1191,14 +1186,15 @@ impl<'a> RootKeys { self.ticktimer.sleep_ms(500).expect("couldn't show final message"); // always purge, we're going to reboot; and if we don't, then there's shenanigans - for w in private_key_enc.iter_mut() { + for w in private_key_enc.iter_mut() { // it's encrypted. but i still want it turned to zeroes. *w = 0; } self.purge_password(PasswordType::Boot); self.purge_password(PasswordType::Update); self.purge_sensitive_data(); + // ed25519 keypair zeroizes on drop - Ok(()) + ret } #[allow(dead_code)] @@ -1235,26 +1231,26 @@ impl<'a> RootKeys { // decrypt the FPGA key using the stored password let pcache: &mut PasswordCache = unsafe{&mut *(self.pass_cache.as_mut_ptr() as *mut PasswordCache)}; if pcache.hashed_update_pw_valid == 0 { + self.purge_password(PasswordType::Update); log::error!("no password was set going into the update routine"); #[cfg(feature = "hazardous-debug")] - log::info!("key: {:x?}", pcache.hashed_update_pw); - log::info!("valid: {}", pcache.hashed_update_pw_valid); + log::debug!("key: {:x?}", pcache.hashed_update_pw); + log::debug!("valid: {}", pcache.hashed_update_pw_valid); return Err(RootkeyResult::KeyError); } for (&src, dst) in self.read_key_256(KeyRomLocs::FPGA_KEY).iter().zip(pcache.fpga_key.iter_mut()) { *dst = src; } - log::info!("fpga key (encrypted): {:x?}", &pcache.fpga_key); + log::debug!("fpga key (encrypted): {:x?}", &pcache.fpga_key); for (fkey, &pw) in pcache.fpga_key.iter_mut().zip(pcache.hashed_update_pw.iter()) { *fkey = *fkey ^ pw; } pcache.fpga_key_valid = 1; #[cfg(feature = "hazardous-debug")] - log::info!("fpga key (reconstituted): {:x?}", &pcache.fpga_key); + log::debug!("fpga key (reconstituted): {:x?}", &pcache.fpga_key); // derive signing key - // probably should consider a way to resolve the ed25519 temporaries and ensure they get cleared... let mut keypair_bytes: [u8; ed25519_dalek::KEYPAIR_LENGTH] = [0; ed25519_dalek::KEYPAIR_LENGTH]; let enc_signing_key = self.read_key_256(KeyRomLocs::SELFSIGN_PRIVKEY); for (key, (&enc_key, &pw)) in @@ -1267,38 +1263,41 @@ impl<'a> RootKeys { *key = src; } #[cfg(feature = "hazardous-debug")] - log::info!("trying to make a keypair from {:x?}", keypair_bytes); + log::debug!("trying to make a keypair from {:x?}", keypair_bytes); + // Keypair zeroizes on drop let keypair = Keypair::from_bytes(&keypair_bytes).map_err(|_| RootkeyResult::KeyError)?; - log::info!("keypair success"); + log::debug!("keypair success"); // stage the keyrom data for patching self.populate_sensitive_data(); pb.set_percentage(3); - log::info!("making destination oracle"); + log::debug!("making destination oracle"); let mut dst_oracle = match BitstreamOracle::new(&pcache.fpga_key, &pcache.fpga_key, self.gateware(), self.gateware_base()) { Ok(o) => o, Err(e) => { + self.purge_password(PasswordType::Update); log::error!("couldn't create oracle (most likely FPGA key mismatch): {:?}", e); return Err(e); } }; - log::info!("destination oracle success"); + log::debug!("destination oracle success"); let keysource = dst_oracle.get_original_key_type(); dst_oracle.set_target_key_type(keysource); pb.set_percentage(6); // updates are always encrypted with the null key. let dummy_key: [u8; 32] = [0; 32]; - log::info!("making source oracle"); + log::debug!("making source oracle"); let mut src_oracle = match BitstreamOracle::new(&dummy_key, &pcache.fpga_key, self.staging(), self.staging_base()) { Ok(o) => o, Err(e) => { log::error!("couldn't create oracle (most likely FPGA key mismatch): {:?}", e); dst_oracle.clear(); + self.purge_password(PasswordType::Update); return Err(e); } }; - log::info!("source oracle success"); + log::debug!("source oracle success"); pb.set_percentage(10); pb.update_text(t!("rootkeys.init.patching_keys", xous::LANG)); @@ -1313,7 +1312,7 @@ impl<'a> RootKeys { // verify that the patch worked pb.update_text(t!("rootkeys.init.verifying_gateware", xous::LANG)); pb.rebase_subtask_percentage(60, 90); - log::info!("making verification oracle"); + log::debug!("making verification oracle"); let verify_oracle = match BitstreamOracle::new(&pcache.fpga_key, &pcache.fpga_key, self.gateware(), self.gateware_base()) { Ok(o) => o, Err(e) => { @@ -1321,11 +1320,6 @@ impl<'a> RootKeys { return Err(e); } }; - // dump first page or so of data for checking - log::info!("check data"); - for b in self.gateware()[..4352].chunks(128).into_iter() { - log::info!("{:3?}", b); - } self.verify_gateware(&verify_oracle, Some(&mut pb))?; @@ -1346,6 +1340,8 @@ impl<'a> RootKeys { for b in keypair_bytes.iter_mut() { *b = 0; } + // ed25519 keypair zeroizes on drop + // check signatures pb.set_percentage(96); if !self.verify_gateware_self_signature() { @@ -1361,6 +1357,110 @@ impl<'a> RootKeys { Ok(()) } + pub fn do_sign_xous(&mut self, rootkeys_modal: &mut Modal, main_cid: xous::CID) -> Result<(), RootkeyResult> { + // make sure the system is sane + self.xns_interlock(); + + // setup Ux + let mut progress_action = Slider::new(main_cid, Opcode::UxGutter.to_u32().unwrap(), + 0, 100, 10, Some("%"), 0, true, true + ); + progress_action.set_is_password(true); + // now show the init wait note... + rootkeys_modal.modify( + Some(ActionType::Slider(progress_action)), + Some(t!("rootkeys.gwup_starting", xous::LANG)), false, + None, true, None); + rootkeys_modal.activate(); + xous::yield_slice(); // give some time to the GAM to render + let mut pb = ProgressBar::new(rootkeys_modal, &mut progress_action); + pb.set_percentage(1); + + // derive signing key + let pcache: &mut PasswordCache = unsafe{&mut *(self.pass_cache.as_mut_ptr() as *mut PasswordCache)}; + if pcache.hashed_update_pw_valid == 0 { + self.purge_password(PasswordType::Update); + log::error!("no password was set going into the update routine"); + #[cfg(feature = "hazardous-debug")] + log::debug!("key: {:x?}", pcache.hashed_update_pw); + log::debug!("valid: {}", pcache.hashed_update_pw_valid); + + return Err(RootkeyResult::KeyError); + } + let mut keypair_bytes: [u8; ed25519_dalek::KEYPAIR_LENGTH] = [0; ed25519_dalek::KEYPAIR_LENGTH]; + let enc_signing_key = self.read_key_256(KeyRomLocs::SELFSIGN_PRIVKEY); + for (key, (&enc_key, &pw)) in + keypair_bytes[..ed25519_dalek::SECRET_KEY_LENGTH].iter_mut() + .zip(enc_signing_key.iter().zip(pcache.hashed_update_pw.iter())) { + *key = enc_key ^ pw; + } + for (key, &src) in keypair_bytes[ed25519_dalek::SECRET_KEY_LENGTH..].iter_mut() + .zip(self.read_key_256(KeyRomLocs::SELFSIGN_PUBKEY).iter()) { + *key = src; + } + // Keypair zeroizes the secret key on drop. + let keypair = Keypair::from_bytes(&keypair_bytes).map_err(|_| RootkeyResult::KeyError)?; + + // check if the keypair is valid by signing and verifying a short message + let test_data = "whiskey made me do it"; + let test_sig = keypair.sign(test_data.as_bytes()); + match keypair.verify(&test_data.as_bytes(), &test_sig) { + Ok(_) => (), + Err(e) => { + log::warn!("update password was not connect ({:?})", e); + self.purge_password(PasswordType::Update); + for b in keypair_bytes.iter_mut() { + *b = 0; + } + return Err(RootkeyResult::KeyError); + } + } + + // sign the kernel + pb.update_text(t!("rootkeys.init.signing_kernel", xous::LANG)); + pb.set_percentage(35); + let (kernel_sig, kernel_len) = self.sign_kernel(&keypair); + + // sign the loader + pb.update_text(t!("rootkeys.init.signing_loader", xous::LANG)); + pb.rebase_subtask_percentage(35, 85); + let (loader_sig, loader_len) = self.sign_loader(&keypair, Some(&mut pb)); + log::debug!("loader signature: {:x?}", loader_sig.to_bytes()); + log::debug!("loader len: {} bytes", loader_len); + + // commit the signatures + pb.update_text(t!("rootkeys.init.commit_signatures", xous::LANG)); + self.commit_signature(loader_sig, loader_len, SignatureType::Loader)?; + log::debug!("loader {} bytes, sig: {:x?}", loader_len, loader_sig.to_bytes()); + pb.set_percentage(90); + self.commit_signature(kernel_sig, kernel_len, SignatureType::Kernel)?; + pb.set_percentage(92); + + // as a sanity check, check the kernel self signature + let ret = if !self.verify_selfsign_kernel(true) { + log::error!("kernel signature failed to verify, probably should not try to reboot!"); + Err(RootkeyResult::IntegrityError) + } else { + Ok(()) + }; + + // check if we're to purge the password on completion + if self.update_password_policy == PasswordRetentionPolicy::AlwaysPurge { + self.purge_password(PasswordType::Update); + } + // purge the temporaries that we can + for b in keypair_bytes.iter_mut() { + *b = 0; + } + // ed25519 keypair zeroizes on drop + + pb.set_percentage(100); + self.ticktimer.sleep_ms(250).expect("couldn't show final message"); + + ret + } + + pub fn test(&mut self, rootkeys_modal: &mut Modal, main_cid: xous::CID) -> Result<(), RootkeyResult> { let mut progress_action = Slider::new(main_cid, Opcode::UxGutter.to_u32().unwrap(), 0, 100, 10, Some("%"), 0, true, true @@ -1450,7 +1550,7 @@ impl<'a> RootKeys { /// ASSUME: CSR appendix does not change during the copy (it is not copied/updated) fn gateware_copy_and_patch(&self, src_oracle: &BitstreamOracle, dst_oracle: &BitstreamOracle, mut maybe_pb: Option<&mut ProgressBar>) -> Result<(), RootkeyResult> { - log::info!("sanity checks: src_offset {}, dst_offset {}, src_len {}, dst_len {}", + log::debug!("sanity checks: src_offset {}, dst_offset {}, src_len {}, dst_len {}", src_oracle.ciphertext_offset(), dst_oracle.ciphertext_offset(), src_oracle.ciphertext_len(), dst_oracle.ciphertext_len()); // start with a naive implementation that simple goes through and re-encrypts and patches everything. @@ -1476,8 +1576,8 @@ impl<'a> RootKeys { .zip(pt_sector[0..32].iter().zip(pt_sector[32..64].iter())) { *dst = hm1 ^ mask; } - log::info!("recovered hmac: {:x?}", hmac_code); - log::info!("hmac constant: {:x?}", &pt_sector[32..64]); + log::debug!("recovered hmac: {:x?}", hmac_code); + log::debug!("hmac constant: {:x?}", &pt_sector[32..64]); let mut bytes_hashed = spinor::SPINOR_ERASE_SIZE as usize - src_oracle.ciphertext_offset(); // encrypt and patch the data to disk @@ -1492,8 +1592,8 @@ impl<'a> RootKeys { bitflip(&pt_sector[..bytes_hashed], &mut flipper[..bytes_hashed]); hasher.update(&flipper[..bytes_hashed]); - log::info!("sector 0 patch len: {}", bytes_hashed); - log::info!("sector 0 header: {:x?}", &ct_sector[..dst_oracle.ciphertext_offset()]); + log::debug!("sector 0 patch len: {}", bytes_hashed); + log::debug!("sector 0 header: {:x?}", &ct_sector[..dst_oracle.ciphertext_offset()]); self.spinor.patch(dst_oracle.bitstream, dst_oracle.base(), &ct_sector, 0) .map_err(|_| RootkeyResult::FlashError)?; @@ -1650,9 +1750,9 @@ impl<'a> RootKeys { .zip(hmac_area[0..32].iter().zip(hmac_area[32..64].iter())) { *dst = hm1 ^ mask; } - log::info!("hmac code: {:x?}", hmac_code); + log::debug!("hmac code: {:x?}", hmac_code); - log::info!("verifying gateware"); + log::debug!("verifying gateware"); let mut hasher = Sha256::new(); // magic number alert: // 160 = reserved space for the 2nd hash @@ -1675,7 +1775,7 @@ impl<'a> RootKeys { } } let h1_digest: [u8; 32] = hasher.finalize().try_into().unwrap(); - log::info!("computed hash of {} bytes: {:x?}", tot_len, h1_digest); + log::debug!("computed hash of {} bytes: {:x?}", tot_len, h1_digest); let mut hasher2 = Sha256::new(); let footer_mask: [u8; 32] = [0x3A; 32]; @@ -1685,8 +1785,8 @@ impl<'a> RootKeys { .zip(hmac_code.iter().zip(footer_mask.iter())) { *dst = hm2 ^ mask; } - log::info!("masked_footer: {:x?}", masked_footer); - log::info!("footer_mask: {:x?}", footer_mask); + log::debug!("masked_footer: {:x?}", masked_footer); + log::debug!("footer_mask: {:x?}", footer_mask); let mut masked_footer_flipped: [u8; 32] = [0; 32]; bitflip(&masked_footer, &mut masked_footer_flipped); let mut footer_mask_flipped: [u8; 32] = [0; 32]; @@ -1696,13 +1796,13 @@ impl<'a> RootKeys { hasher2.update(h1_digest); let h2_digest: [u8; 32] = hasher2.finalize().try_into().unwrap(); - log::info!("h2 hash: {:x?}", h2_digest); + log::debug!("h2 hash: {:x?}", h2_digest); let mut ref_digest_flipped: [u8; 32] = [0; 32]; oracle.decrypt(oracle.ciphertext_len() - 32, &mut ref_digest_flipped); let mut ref_digest: [u8; 32] = [0; 32]; - log::info!("ref digest (flipped): {:x?}", ref_digest_flipped); + log::debug!("ref digest (flipped): {:x?}", ref_digest_flipped); bitflip(&ref_digest_flipped, &mut ref_digest); - log::info!("ref digest : {:x?}", ref_digest); + log::debug!("ref digest : {:x?}", ref_digest); let mut matching = true; for (&l, &r) in ref_digest.iter().zip(h2_digest.iter()) { @@ -1712,7 +1812,7 @@ impl<'a> RootKeys { } if matching { - log::info!("gateware verified"); + log::debug!("gateware verified"); Ok(()) } else { log::error!("gateware failed to verify"); @@ -1902,21 +2002,25 @@ impl<'a> RootKeys { (signing_key.sign(&kernel_region[SIGBLOCK_SIZE as usize..]), kernel_len as u32) } - /// the public key must already be in the cache - pub fn verify_selfsign_kernel(&self) -> bool { - if self.sensitive_data.borrow_mut().as_slice::()[KeyRomLocs::CONFIG as usize] & keyrom_config::INITIALIZED.ms(1) == 0 { - log::warn!("key cache was not initialized, can't verify the kernel with our self-signing key"); - return false; - } - - // read the public key directly out of the keyrom + /// the public key must already be in the cache -- this version is used by the init routine, before the keys are written + pub fn verify_selfsign_kernel(&mut self, is_system_initialized: bool) -> bool { let mut key: [u8; 32] = [0; 32]; - log::debug!("reading public key from cached area"); - for (word, &keyword) in key.chunks_mut(4).into_iter() - .zip(self.sensitive_data.borrow_mut().as_slice::()[KeyRomLocs::SELFSIGN_PUBKEY as usize..KeyRomLocs::SELFSIGN_PUBKEY as usize + 256/(size_of::()*8)].iter()) { - for (&byte, dst) in keyword.to_be_bytes().iter().zip(word.iter_mut()) { - *dst = byte; + if !is_system_initialized { + if self.sensitive_data.borrow_mut().as_slice::()[KeyRomLocs::CONFIG as usize] & keyrom_config::INITIALIZED.ms(1) == 0 { + log::warn!("key cache was not initialized, can't verify the kernel with our self-signing key"); + return false; } + + // read the public key directly out of the keyrom + log::debug!("reading public key from cached area"); + for (word, &keyword) in key.chunks_mut(4).into_iter() + .zip(self.sensitive_data.borrow_mut().as_slice::()[KeyRomLocs::SELFSIGN_PUBKEY as usize..KeyRomLocs::SELFSIGN_PUBKEY as usize + 256/(size_of::()*8)].iter()) { + for (&byte, dst) in keyword.to_be_bytes().iter().zip(word.iter_mut()) { + *dst = byte; + } + } + } else { + key = self.read_key_256(KeyRomLocs::SELFSIGN_PUBKEY); } log::debug!("pubkey as reconstituted: {:x?}", key); let pubkey = PublicKey::from_bytes(&key).expect("public key was not valid"); diff --git a/services/root-keys/src/lib.rs b/services/root-keys/src/lib.rs index 6ed53b217..bd9c26531 100644 --- a/services/root-keys/src/lib.rs +++ b/services/root-keys/src/lib.rs @@ -102,12 +102,7 @@ impl RootKeys { } /// this initiates an attempt to update passwords. User must unlock their device first, and can cancel out if not expected. - pub fn try_update_password(&mut self, which: PasswordType) -> Result<(), xous::Error> { - unimplemented!(); - } - - //// initiates a self-signing of the firmwares using the ed25519 private key stored in the enclave - pub fn self_sign(&mut self, which: ImageType) -> Result<(), xous::Error> { + pub fn try_update_password(&mut self, _which: PasswordType) -> Result<(), xous::Error> { unimplemented!(); } diff --git a/services/root-keys/src/main.rs b/services/root-keys/src/main.rs index dcba7344e..1b12b8724 100644 --- a/services/root-keys/src/main.rs +++ b/services/root-keys/src/main.rs @@ -796,8 +796,113 @@ fn xmain() -> ! { } } Some(Opcode::UxSelfSignXous) => { - unimplemented!(); + if keys.is_pcache_update_password_valid() { + // indicate that there should be no change to the policy + let payload = gam::RadioButtonPayload::new("no change"); + let buf = Buffer::into_buf(payload).expect("couldn't convert message to payload"); + buf.send(main_cid, Opcode::UxSignXousRun.to_u32().unwrap()) + .map(|_| ()).expect("couldn't send action message"); + } else { + keys.set_ux_password_type(Some(PasswordType::Update)); + password_action.set_action_opcode(Opcode::UxSignXousPasswordPolicy.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::TextEntry(password_action)), + Some(t!("rootkeys.get_signing_password", xous::LANG)), false, + None, true, None + ); + rootkeys_modal.activate(); + } }, + Some(Opcode::UxSignXousPasswordPolicy) => { + let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let mut plaintext_pw = buf.to_original::().unwrap(); + + keys.hash_and_save_password(plaintext_pw.as_str()); + plaintext_pw.volatile_clear(); // ensure the data is destroyed after sending to the keys enclave + buf.volatile_clear(); + + let mut confirm_radiobox = gam::modal::RadioButtons::new( + main_cid, + Opcode::UxSignXousRun.to_u32().unwrap() + ); + confirm_radiobox.is_password = true; + confirm_radiobox.add_item(ItemName::new(t!("rootkeys.policy_clear", xous::LANG))); + confirm_radiobox.add_item(ItemName::new(t!("rootkeys.policy_suspend", xous::LANG))); + confirm_radiobox.add_item(ItemName::new(t!("rootkeys.policy_keep", xous::LANG))); + rootkeys_modal.modify( + Some(ActionType::RadioButtons(confirm_radiobox)), + Some(t!("rootkeys.policy_request", xous::LANG)), false, + None, true, None); + rootkeys_modal.activate(); + }, + Some(Opcode::UxSignXousRun) => { + let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let payload = buffer.to_original::().unwrap(); + if payload.as_str() == t!("rootkeys.policy_keep", xous::LANG) { + keys.update_policy(Some(PasswordRetentionPolicy::AlwaysKeep)); + } else if payload.as_str() == t!("rootkeys.policy_suspend", xous::LANG) { + keys.update_policy(Some(PasswordRetentionPolicy::EraseOnSuspend)); + } else if payload.as_str() == "no change" { + // don't change the policy + } else { + keys.update_policy(Some(PasswordRetentionPolicy::AlwaysPurge)); // default to the most paranoid level + } + keys.set_ux_password_type(None); + + let result = keys.do_sign_xous(&mut rootkeys_modal, main_cid); + // the stop emoji, when sent to the slider action bar in progress mode, will cause it to close and relinquish focus + rootkeys_modal.key_event(['🛑', '\u{0000}', '\u{0000}', '\u{0000}']); + + match result { + Ok(_) => { + dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::Notification(dismiss_modal_action)), + Some(t!("rootkeys.signxous.finished", xous::LANG)), false, + None, false, None); + rootkeys_modal.activate(); + xous::yield_slice(); + } + Err(RootkeyResult::AlignmentError) => { + dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::Notification(dismiss_modal_action)), + Some(t!("rootkeys.init.fail_alignment", xous::LANG)), false, + None, false, None); + rootkeys_modal.activate(); + xous::yield_slice(); + } + Err(RootkeyResult::KeyError) => { + // probably a bad password, purge it, so the user can try again + keys.purge_password(PasswordType::Update); + dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::Notification(dismiss_modal_action)), + Some(t!("rootkeys.init.fail_key", xous::LANG)), false, + None, false, None); + rootkeys_modal.activate(); + xous::yield_slice(); + } + Err(RootkeyResult::IntegrityError) => { + dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::Notification(dismiss_modal_action)), + Some(t!("rootkeys.init.fail_verify", xous::LANG)), false, + None, false, None); + rootkeys_modal.activate(); + xous::yield_slice(); + } + Err(RootkeyResult::FlashError) => { + dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::Notification(dismiss_modal_action)), + Some(t!("rootkeys.init.fail_burn", xous::LANG)), false, + None, false, None); + rootkeys_modal.activate(); + xous::yield_slice(); + } + } + } Some(Opcode::CheckGatewareSignature) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { if keys.is_initialized() { if keys.verify_gateware_self_signature() {