From 5e455b60eb9a5112ef5056c86445d65d386ea716 Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 12 Aug 2022 20:10:19 +0800 Subject: [PATCH 1/6] add debug to backalyzer to dump encrypted private key --- tools/backalyzer.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/backalyzer.py b/tools/backalyzer.py index 922b4d451..2a5181375 100755 --- a/tools/backalyzer.py +++ b/tools/backalyzer.py @@ -192,6 +192,7 @@ def main(): bcrypter = bcrypt.BCrypt() # logging.debug("{}".format(boot_pw_array[:pw_len])) logging.debug("user_key_enc: {}".format(list(user_key_enc))) + logging.debug("private_key_enc: {}".format(list(get_key(8, keyrom, 32)))) logging.debug("salt: {}".format(list(pepper))) hashed_pw = bcrypter.crypt_raw(boot_pw_array[:pw_len], pepper, 7) logging.debug("hashed_pw: {}".format(list(hashed_pw))) From 912218690097ea4ee36e92b90ca55fbed0de3f9a Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 12 Aug 2022 20:18:32 +0800 Subject: [PATCH 2/6] eliminate rendundant boot PIN request; fix bug in boot key generation - boot PIN is not requested on root password init. it's redundant, as it is actually set when you format the PDDB - boot key was mistakenly a copy of the encrypted private key for ed25519 key signing. "oops". didn't catch that bug until now... i don't think it has a big impact on existing user base, because the key is never exposed outside the rootkey server, and the ed25519 key itself is encrypted with the root password and then used as the boot key. But still -- that's just not what was intended. - root password is requested twice to check the validity of the password --- services/root-keys/locales/i18n.json | 28 +++++--- services/root-keys/src/api.rs | 2 +- services/root-keys/src/implementation.rs | 85 ++++++++++++++-------- services/root-keys/src/main.rs | 89 ++++++++++++++++++------ 4 files changed, 144 insertions(+), 60 deletions(-) diff --git a/services/root-keys/locales/i18n.json b/services/root-keys/locales/i18n.json index 04ef68352..9b2c16f78 100644 --- a/services/root-keys/locales/i18n.json +++ b/services/root-keys/locales/i18n.json @@ -95,18 +95,24 @@ "zh": "执行备份的内部错误。 进程中止。", "en-tts": "Internal error performing backup. Process aborted." }, - "rootkeys.bootpass": { - "en": "Create a PIN code for device unlock.", - "ja": "デバイスのロックを解除するためのPINコードを作成します。", - "zh": "输入密码 解锁 安全含义:低", - "en-tts": "Enter unlock password" - }, - "rootkeys.updatepass": { + "rootkeys.updatefirstpass": { "en": "⚠ Critical Password ⚠\nCreate a strong root password for authorizing system updates.", "ja": "重要なパスワード\nシステムアップデートを認証するための強力なパスフレーズを作成します。", "zh": "输入密码 软件更新 安全含义:至关重要 ", "en-tts": "Enter a root password. This should be a strong password." }, + "rootkeys.updatepass": { + "en": "⚠ Critical Password ⚠\nPlease confirm the root password.", + "ja": "ルートパスワードを確認してください。", + "zh": "请确认root密码。", + "en-tts": "Please confirm the root password." + }, + "rootkeys.updatepass_fail": { + "en": "Passwords did not match. Try again?", + "ja": "パスワードが間違っています。 再試行?", + "zh": "密码不匹配。 再试一次?", + "en-tts": "Passwords did not match. Try again?" + }, "rootkeys.blind_update": { "en": "No device keys detected. Shall we copy the staged gateware anyways, overwriting the current image?", "ja": "ルートキーが検出されませんでした。 とにかくステージングされたゲートウェアをコピーして、現在のイメージを上書きしませんか?", @@ -126,10 +132,10 @@ "en-tts": "Device keys already initialized." }, "rootkeys.confirm": { - "en": "🔐 Setup passwords for Precursor 🔐\n\nYou will be prompted for two passwords:\n\t1. Device unlock PIN code\n\t2. Root passphrase.\n\nAre you ready?", - "ja": "これにより、Precursorデバイスのルートキーが初期化されます。\n\n2つのパスワードの入力を求められます。\n\t1.デバイスのロック解除PINコード\n\t2.システムアップデートパスフレーズ。\n\n準備はいいですか?", - "zh": "仅当您准备好信 任此设备时才 应继续", - "en-tts": "Setup passwords for Precursor. You will create two passwords, a PIN code, and a root password." + "en": "🔐 Setup passwords for Precursor 🔐\n\nYou will be prompted for a root passphrase that must be secure and cannot be changed.\n\nAre you ready?", + "ja": "🔐 Precursor のパスワードを設定する 🔐\n\nルート パスフレーズの入力を求めるメッセージが表示されます。ルート パスフレーズは安全である必要があり、変更することはできません。\n\n準備はできていますか?", + "zh": "🔐 为 Precursor 设置密码 🔐\n\n系统将提示您输入必须安全且无法更改的根密码。\n\n您准备好了吗?", + "en-tts": "Setup passwords for Precursor\n\nYou will be prompted for a root passphrase that must be secure and cannot be changed.\n\nAre you ready?" }, "rootkeys.confirm.yes": { "en": "I'm ready!", diff --git a/services/root-keys/src/api.rs b/services/root-keys/src/api.rs index 81c35a058..811bf42b2 100644 --- a/services/root-keys/src/api.rs +++ b/services/root-keys/src/api.rs @@ -29,7 +29,7 @@ pub(crate) enum Opcode { /// attempt to initialize keys on a brand new system. Does nothing if the keys are already provisioned. UxTryInitKeys = 9, - UxInitBootPasswordReturn = 10, + UxInitUpdateFirstPasswordReturn = 10, UxInitUpdatePasswordReturn = 11, /// provision a gateware update with our secret data diff --git a/services/root-keys/src/implementation.rs b/services/root-keys/src/implementation.rs index e30364ed8..7b2f6a950 100644 --- a/services/root-keys/src/implementation.rs +++ b/services/root-keys/src/implementation.rs @@ -722,12 +722,12 @@ impl<'a> RootKeys { /// Plaintext password is passed as a &str. Any copies internally are destroyed. Caller is responsible for destroying the &str original. /// Performs a bcrypt hash of the password, with the currently set salt; does not store the plaintext after exit. - pub fn hash_and_save_password(&mut self, pw: &str) { + pub fn hash_and_save_password(&mut self, pw: &str, verify: bool) -> bool { let pw_type = if let Some(cur_type) = self.cur_password_type { cur_type } else { log::error!("got an unexpected password from the UX"); - return; + return false; }; let mut hashed_password: [u8; 24] = [0; 24]; let mut salt = self.get_salt(); @@ -751,19 +751,51 @@ impl<'a> RootKeys { let digest = hasher.finalize(); let pcache_ptr: *mut PasswordCache = self.pass_cache.as_mut_ptr() as *mut PasswordCache; - unsafe { - match pw_type { - PasswordType::Boot => { - for (&src, dst) in digest.iter().zip((*pcache_ptr).hashed_boot_pw.iter_mut()) { - *dst = src; + if !verify { + unsafe { + match pw_type { + PasswordType::Boot => { + for (&src, dst) in digest.iter().zip((*pcache_ptr).hashed_boot_pw.iter_mut()) { + *dst = src; + } + (*pcache_ptr).hashed_boot_pw_valid = 1; + } + PasswordType::Update => { + for (&src, dst) in digest.iter().zip((*pcache_ptr).hashed_update_pw.iter_mut()) { + *dst = src; + } + (*pcache_ptr).hashed_update_pw_valid = 1; } - (*pcache_ptr).hashed_boot_pw_valid = 1; } - PasswordType::Update => { - for (&src, dst) in digest.iter().zip((*pcache_ptr).hashed_update_pw.iter_mut()) { - *dst = src; + } + true + } else { + unsafe { + match pw_type { + PasswordType::Boot => { + if (*pcache_ptr).hashed_boot_pw_valid == 1 { + for (&src, &dst) in digest.iter().zip((*pcache_ptr).hashed_boot_pw.iter()) { + if dst != src { + return false + } + } + true + } else { + false + } + } + PasswordType::Update => { + if (*pcache_ptr).hashed_update_pw_valid == 1 { + for (&src, &dst) in digest.iter().zip((*pcache_ptr).hashed_update_pw.iter()) { + if dst != src { + return false + } + } + true + } else { + false + } } - (*pcache_ptr).hashed_update_pw_valid = 1; } } } @@ -1063,7 +1095,6 @@ impl<'a> RootKeys { // extract the update password key from the cache, and apply it to the private key #[cfg(feature = "hazardous-debug")] { - log::debug!("cached boot passwords {:x?}", pcache.hashed_boot_pw); log::debug!("cached update password: {:x?}", pcache.hashed_update_pw); } // private key must XOR with password before storing @@ -1081,30 +1112,28 @@ impl<'a> RootKeys { .zip(self.sensitive_data.borrow_mut().as_slice_mut::()[KeyRomLocs::SELFSIGN_PRIVKEY as usize..KeyRomLocs::SELFSIGN_PRIVKEY as usize + 256/(size_of::()*8)].iter_mut()) { *dst = u32::from_be_bytes(src.try_into().unwrap()) } + #[cfg(feature = "hazardous-debug")] + log::debug!("private_key_enc: {:?}", private_key_enc); pb.set_percentage(10); - // generate and store a root key (aka boot key), this is what is unlocked by the "boot password" - // ironically, it's a "lower security" key because it just acts as a gatekeeper to further - // keys that would have a stronger password applied to them, based upon the importance of the secret - // think of this more as a user PIN login confirmation, than as a significant cryptographic event + // generate the "boot key". This is just a random number that eventually gets XOR'd with a PIN + // by the PDDB to derive the final PDDB .System unlock key. let mut boot_key_enc: [u8; 32] = [0; 32]; - for (dst, key) in - boot_key_enc.chunks_mut(4).into_iter() - .zip(pcache.hashed_boot_pw.chunks(4).into_iter()) { + for dst in + boot_key_enc.chunks_mut(4).into_iter() { let key_word = self.trng.get_u32().unwrap().to_be_bytes(); // just unroll this loop, it's fast and easy enough - (*dst)[0] = key[0] ^ key_word[0]; - (*dst)[1] = key[1] ^ key_word[1]; - (*dst)[2] = key[2] ^ key_word[2]; - (*dst)[3] = key[3] ^ key_word[3]; - // also note that interestingly, we don't have to XOR it with the hashed boot password -- - // this key isn't used by this routine, just initialized, so really, it only matters to - // XOR it with the password when you use it the first time to encrypt something. + (*dst)[0] = key_word[0]; + (*dst)[1] = key_word[1]; + (*dst)[2] = key_word[2]; + (*dst)[3] = key_word[3]; } + #[cfg(feature = "hazardous-debug")] + log::debug!("boot_key_enc: {:?}", boot_key_enc); // store the boot key to the keyrom staging area - for (src, dst) in private_key_enc.chunks(4).into_iter() + for (src, dst) in boot_key_enc.chunks(4).into_iter() .zip(self.sensitive_data.borrow_mut().as_slice_mut::()[KeyRomLocs::USER_KEY as usize..KeyRomLocs::USER_KEY as usize + 256/(size_of::()*8)].iter_mut()) { *dst = u32::from_be_bytes(src.try_into().unwrap()) } diff --git a/services/root-keys/src/main.rs b/services/root-keys/src/main.rs index 5c0cbb792..2c085c84b 100644 --- a/services/root-keys/src/main.rs +++ b/services/root-keys/src/main.rs @@ -147,7 +147,7 @@ mod implementation { pub fn update_policy(&mut self, policy: Option) { log::info!("policy updated: {:?}", policy); } - pub fn hash_and_save_password(&mut self, pw: &str) { + pub fn hash_and_save_password(&mut self, pw: &str, _verify: bool) { log::info!("got password plaintext: {}", pw); } pub fn set_ux_password_type(&mut self, cur_type: Option) { @@ -405,7 +405,7 @@ fn main() -> ! { use crate::implementation::RootKeys; log_server::init_wait().unwrap(); - log::set_max_level(log::LevelFilter::Info); + log::set_max_level(log::LevelFilter::Debug); log::info!("my PID is {}", xous::process::id()); let xns = xous_names::XousNames::new().unwrap(); @@ -470,7 +470,7 @@ fn main() -> ! { true, TextEntryVisibility::LastChars, main_cid, - Opcode::UxInitBootPasswordReturn.to_u32().unwrap(), + Opcode::UxInitUpdateFirstPasswordReturn.to_u32().unwrap(), vec![TextEntryPayload::new()], None, ); @@ -481,7 +481,7 @@ fn main() -> ! { let mut rootkeys_modal = Modal::new( gam::ROOTKEY_MODAL_NAME, ActionType::TextEntry(password_action.clone()), - Some(t!("rootkeys.bootpass", xous::LANG)), + Some(t!("rootkeys.updatefirstpass", xous::LANG)), None, GlyphStyle::Regular, 8 @@ -624,29 +624,29 @@ fn main() -> ! { } // setup_key_init() prepares the salt and other items necessary to receive a password safely keys.setup_key_init(); - // request the boot password first - keys.set_ux_password_type(Some(PasswordType::Boot)); + // request the update password first + keys.set_ux_password_type(Some(PasswordType::Update)); // pop up our private password dialog box - password_action.set_action_opcode(Opcode::UxInitBootPasswordReturn.to_u32().unwrap()); + password_action.set_action_opcode(Opcode::UxInitUpdateFirstPasswordReturn.to_u32().unwrap()); rootkeys_modal.modify( Some(ActionType::TextEntry(password_action.clone())), - Some(t!("rootkeys.bootpass", xous::LANG)), false, + Some(t!("rootkeys.updatefirstpass", xous::LANG)), false, None, true, None ); #[cfg(feature="tts")] - tts.tts_blocking(t!("rootkeys.bootpass", xous::LANG)).unwrap(); - log::info!("{}ROOTKEY.BOOTPW,{}", xous::BOOKEND_START, xous::BOOKEND_END); + tts.tts_blocking(t!("rootkeys.updatefirstpass", xous::LANG)).unwrap(); + log::info!("{}ROOTKEY.UPDPW,{}", xous::BOOKEND_START, xous::BOOKEND_END); rootkeys_modal.activate(); } }, - Some(Opcode::UxInitBootPasswordReturn) => { + Some(Opcode::UxInitUpdateFirstPasswordReturn) => { // assume: // - setup_key_init has also been called (exactly once, before anything happens) // - set_ux_password_type has been called already let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); @@ -667,7 +667,56 @@ fn main() -> ! { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + if !keys.hash_and_save_password(plaintext_pw.first().as_str(), true) { + // password did not verify + modals.add_list_item(t!("rootkeys.gwup.yes", xous::LANG)).expect("modals error"); + modals.add_list_item(t!("rootkeys.gwup.no", xous::LANG)).expect("modals error"); + match modals.get_radiobutton(t!("rootkeys.updatepass_fail", xous::LANG)) { + Ok(response) => { + if response == t!("rootkeys.gwup.yes", xous::LANG) { + keys.purge_password(PasswordType::Update); + // request the update password first + keys.set_ux_password_type(Some(PasswordType::Update)); + // pop up our private password dialog box + password_action.set_action_opcode(Opcode::UxInitUpdateFirstPasswordReturn.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::TextEntry(password_action.clone())), + Some(t!("rootkeys.updatefirstpass", xous::LANG)), false, + None, true, None + ); + #[cfg(feature="tts")] + tts.tts_blocking(t!("rootkeys.updatefirstpass", xous::LANG)).unwrap(); + log::info!("{}ROOTKEY.UPDPW,{}", xous::BOOKEND_START, xous::BOOKEND_END); + rootkeys_modal.activate(); + continue; + } else { + // abort + plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave + buf.volatile_clear(); + keys.purge_password(PasswordType::Update); + keys.purge_sensitive_data(); + susres.set_suspendable(true).expect("couldn't unblock suspend/resume"); + if let Some(dr) = deferred_response.take() { + xous::return_scalar(dr, 0).unwrap(); + } + continue; + } + } + _ => { + log::error!("get_radiobutton failed"); + plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave + buf.volatile_clear(); + keys.purge_password(PasswordType::Update); + keys.purge_sensitive_data(); + susres.set_suspendable(true).expect("couldn't unblock suspend/resume"); + if let Some(dr) = deferred_response.take() { + xous::return_scalar(dr, 0).unwrap(); + } + continue; + }, + } + } + plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); @@ -946,7 +995,7 @@ fn main() -> ! { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); // indicate that there should be no change to the policy @@ -1034,7 +1083,7 @@ fn main() -> ! { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); @@ -1130,7 +1179,7 @@ fn main() -> ! { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); @@ -1170,7 +1219,7 @@ fn main() -> ! { { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); @@ -1259,7 +1308,7 @@ fn main() -> ! { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); send_message(main_cid, @@ -1373,7 +1422,7 @@ fn main() -> ! { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); keys.set_ux_password_type(None); @@ -1554,7 +1603,7 @@ fn main() -> ! { let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; let plaintext_pw = buf.to_original::().unwrap(); - keys.hash_and_save_password(plaintext_pw.first().as_str()); + keys.hash_and_save_password(plaintext_pw.first().as_str(), false); plaintext_pw.first().volatile_clear(); // ensure the data is destroyed after sending to the keys enclave buf.volatile_clear(); keys.set_ux_password_type(None); From 7aca2d64b3f5fef681629c4513ca70fad35c88e7 Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 12 Aug 2022 23:09:06 +0800 Subject: [PATCH 3/6] lower debug level --- services/root-keys/src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/root-keys/src/main.rs b/services/root-keys/src/main.rs index 2c085c84b..f81194151 100644 --- a/services/root-keys/src/main.rs +++ b/services/root-keys/src/main.rs @@ -405,7 +405,7 @@ fn main() -> ! { use crate::implementation::RootKeys; log_server::init_wait().unwrap(); - log::set_max_level(log::LevelFilter::Debug); + log::set_max_level(log::LevelFilter::Info); log::info!("my PID is {}", xous::process::id()); let xns = xous_names::XousNames::new().unwrap(); From 4ae3308fbe9e6003f41651607ddb223e2b712271 Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 12 Aug 2022 23:10:18 +0800 Subject: [PATCH 4/6] add PIN change to the PDDB --- services/pddb/locales/i18n.json | 46 ++++++++++++++--- services/pddb/src/api.rs | 3 ++ services/pddb/src/backend/hw.rs | 91 ++++++++++++++++++++++++--------- services/pddb/src/main.rs | 16 ++++++ services/pddb/src/menu.rs | 9 ++++ 5 files changed, 132 insertions(+), 33 deletions(-) diff --git a/services/pddb/locales/i18n.json b/services/pddb/locales/i18n.json index ae8f9f5da..a6e6d3764 100644 --- a/services/pddb/locales/i18n.json +++ b/services/pddb/locales/i18n.json @@ -108,28 +108,28 @@ "en-tts": "No" }, "pddb.badpass": { - "en": "Incorrect password.\n\nTry again?\n", + "en": "Incorrect PIN.\n\nTry again?\n", "ja": "パスワードを認証失敗でした。\n\nもう一度実行しませんか。\n", "zh": "密码错误。 再试一次?", - "en-tts": "Incorrect password. Try again?" + "en-tts": "Incorrect PIN. Try again?" }, "pddb.checkpass": { - "en": "Press any key, then re-enter your password to confirm.", + "en": "Press any key, then re-enter your PIN to confirm.", "ja": "任意キーを押して、パスワードを再入力してセットアップを確認してください。", "zh": "第一次使用,再次输入密码", - "en-tts": "First-time setup: Enter password again." + "en-tts": "First-time setup: Enter PIN again." }, "pddb.checkpass_fail": { - "en": "Password mismatch!\n\nPlease try again.", + "en": "PIN mismatch!\n\nPlease try again.", "ja": "パスワード一致していません!\n\nもう一度実行しください。", "zh": "密码不匹配,请重试.", - "en-tts": "Password mismatch! Please try again." + "en-tts": "PIN mismatch! Please try again." }, "pddb.badpass_infallible": { - "en": "Incorrect password.\n\nPlease try again.", + "en": "Incorrect PIN.\n\nPlease try again.", "ja": "パスワードを認証失敗でした。\n\nもう一度実行しください。", "zh": "密码错误。", - "en-tts": "Incorrect password. Please try again." + "en-tts": "Incorrect PIN. Please try again." }, "pddb.requestformat": { "en": "The PDDB needs to be cryptographically formatted. This takes about 15 minutes and can't be interrupted.\n\nProceed?", @@ -203,6 +203,36 @@ "zh": "基础姓名: ", "en-tts": "For basis: " }, + "pddb.changepin.mountfirst": { + "en": "Unlock the device before changing the PIN", + "ja": "PIN を変更する前にデバイスのロックを解除してください", + "zh": "在更改 PIN 之前解锁设备", + "en-tts": "Unlock the device before changing the PIN" + }, + "pddb.changepin.enter_new_pin": { + "en": "Enter your new PIN in the next dialog box.", + "ja": "次のダイアログ ボックスに新しい PIN を入力します。", + "zh": "在下一个对话框中输入您的新 PIN。", + "en-tts": "Enter your new PIN in the next dialog box." + }, + "pddb.changepin.success": { + "en": "PIN updated!", + "ja": "PIN が更新されました。", + "zh": "PIN 已更新!", + "en-tts": "PIN updated!" + }, + "pddb.changepin.nochange": { + "en": "PIN unchanged.", + "ja": "PIN は変更されていません", + "zh": "PIN 未更改", + "en-tts": "PIN unchanged." + }, + "pddb.menu.change_unlock_pin": { + "en": "Change unlock PIN", + "ja": "ロック解除暗証番号の変更", + "zh": "更改解锁密码", + "en-tts": "Change unlock PIN" + }, "pddb.menu.listbasis": { "en": "List unlocked bases", "ja": "ロック解除されたベースをー覧表します", diff --git a/services/pddb/src/api.rs b/services/pddb/src/api.rs index fbb211581..a3bf10cd0 100644 --- a/services/pddb/src/api.rs +++ b/services/pddb/src/api.rs @@ -210,6 +210,9 @@ pub(crate) enum Opcode { /// Optimized key listing ListKeyV2 = 45, + /// change unlock PIN + MenuChangePin = 46, + /// This key type could not be decoded InvalidOpcode = u32::MAX as _, } diff --git a/services/pddb/src/backend/hw.rs b/services/pddb/src/backend/hw.rs index 07e8688ba..851da4dcc 100644 --- a/services/pddb/src/backend/hw.rs +++ b/services/pddb/src/backend/hw.rs @@ -82,6 +82,14 @@ impl Deref for StaticCryptoData { } } } +impl DerefMut for StaticCryptoData { + fn deref_mut(&mut self) -> &mut [u8] { + unsafe { + core::slice::from_raw_parts_mut(self as *mut StaticCryptoData as *mut u8, size_of::()) + as &mut [u8] + } + } +} #[derive(Eq, PartialEq)] enum DnaMode { Normal, @@ -1562,6 +1570,63 @@ impl PddbOs { } } + fn pw_check(&self, modals: &modals::Modals) -> Result<()> { + 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)); + + log::info!("{}PDDB.CHECKPASS,{}", xous::BOOKEND_START, xous::BOOKEND_END); + #[cfg(any(target_os = "none", target_os = "xous"))] // skip this dialog in hosted mode + modals.show_notification(t!("pddb.checkpass", xous::LANG), None).expect("notification failed"); + + self.clear_password(); + let mut checkblock_b = [0u8; BLOCK_SIZE]; + self.rootkeys.decrypt_block(GenericArray::from_mut_slice(&mut checkblock_b)); + + if checkblock_a == checkblock_b { + success = true; + } else { + log::info!("{}PDDB.PWFAIL,{}", xous::BOOKEND_START, xous::BOOKEND_END); + modals.show_notification(t!("pddb.checkpass_fail", xous::LANG), None).expect("notification failed"); + self.clear_password(); + } + } + if success { + Ok(()) + } else { + Err(Error::new(ErrorKind::PermissionDenied, "Password entry failed")) + } + } + + /// this function attempts to change the PIN. returns Ok() if changed, error if not. + pub(crate) fn pddb_change_pin(&mut self, modals: &modals::Modals) -> Result<()> { + if let Some(system_keys) = &self.system_basis_key { + // get the new password + self.clear_password(); + modals.show_notification(t!("pddb.changepin.enter_new_pin", xous::LANG), None) + .map_err(|_| Error::new(ErrorKind::Other, "Internal error"))?; + self.pw_check(modals)?; + + // wrap keys in the new password, and store them to disk + let wrapped_key = self.rootkeys.wrap_key(&system_keys.data).expect("Internal error wrapping our encryption key"); + let wrapped_key_pt = self.rootkeys.wrap_key(&system_keys.pt).expect("Internal error wrapping our encryption key"); + let mut crypto_keys = StaticCryptoData::default(); + crypto_keys.deref_mut().copy_from_slice(&self.static_crypto_data_get().deref()); + assert!(wrapped_key_pt.len() == 40); + assert!(wrapped_key.len() == 40); + crypto_keys.system_key_pt.copy_from_slice(&wrapped_key_pt); + crypto_keys.system_key.copy_from_slice(&wrapped_key); + self.patch_keys(crypto_keys.deref(), 0); + Ok(()) + } else { + Err(Error::new(ErrorKind::PermissionDenied, "System basis keys not unlocked")) + } + } /// this function is dangerous in that calling it will completely erase all of the previous data /// in the PDDB an replace it with a brand-spanking new, blank PDDB. /// The number of servers that can connect to the Spinor crate is strictly tracked, so we borrow a reference @@ -1572,31 +1637,7 @@ impl PddbOs { } // step 0. If we have a modal, confirm that the password entered was correct with a double-entry. 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)); - - log::info!("{}PDDB.CHECKPASS,{}", xous::BOOKEND_START, xous::BOOKEND_END); - #[cfg(any(target_os = "none", target_os = "xous"))] // skip this dialog in hosted mode - modals.show_notification(t!("pddb.checkpass", xous::LANG), None).expect("notification failed"); - - self.clear_password(); - let mut checkblock_b = [0u8; BLOCK_SIZE]; - self.rootkeys.decrypt_block(GenericArray::from_mut_slice(&mut checkblock_b)); - - if checkblock_a == checkblock_b { - success = true; - } else { - log::info!("{}PDDB.PWFAIL,{}", xous::BOOKEND_START, xous::BOOKEND_END); - modals.show_notification(t!("pddb.checkpass_fail", xous::LANG), None).expect("notification failed"); - self.clear_password(); - } - } + self.pw_check(modals)?; } // step 1. Erase the entire PDDB region - leaves the state in all 1's diff --git a/services/pddb/src/main.rs b/services/pddb/src/main.rs index 80412fdb0..0a0c1d48b 100644 --- a/services/pddb/src/main.rs +++ b/services/pddb/src/main.rs @@ -1419,6 +1419,22 @@ fn wrapped_main() -> ! { } modals.show_notification(¬e, None).expect("couldn't show basis list"); }, + Opcode::MenuChangePin => { + if basis_cache.basis_count() == 0 { + modals.show_notification(t!("pddb.changepin.mountfirst", xous::LANG), None) + .expect("couldn't show notification"); + continue; + } + match pddb_os.pddb_change_pin(&modals) { + Ok(_) => modals.show_notification(t!("pddb.changepin.success", xous::LANG), None) + .expect("couldn't show notification"), + Err(e) => { + log::error!("Error changing PIN: {:?}", e); + modals.show_notification(t!("pddb.changepin.nochange", xous::LANG), None) + .expect("couldn't show notification"); + } + } + }, Opcode::RekeyPddb => { let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) }; let rekey_op = buffer.to_original::().unwrap(); diff --git a/services/pddb/src/menu.rs b/services/pddb/src/menu.rs index 0b0d4eab3..b7644ff49 100644 --- a/services/pddb/src/menu.rs +++ b/services/pddb/src/menu.rs @@ -16,6 +16,15 @@ pub(crate) fn pddb_menu(conn: xous::CID) { close_on_select: true, } ); + menu_items.push( + MenuItem { + name: String::from_str(t!("pddb.menu.change_unlock_pin", xous::LANG)), + action_conn: Some(conn), + action_opcode: Opcode::MenuChangePin.to_u32().unwrap(), + action_payload: MenuPayload::Scalar([0, 0, 0, 0]), + close_on_select: true, + } + ); menu_items.push(MenuItem { name: String::from_str(t!("mainmenu.closemenu", xous::LANG)), action_conn: None, From ef62dbf3079c43cc7e50a827df1551b025e06544 Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 12 Aug 2022 23:22:48 +0800 Subject: [PATCH 5/6] update release notes --- RELEASE-v0.9.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/RELEASE-v0.9.md b/RELEASE-v0.9.md index 7de0fe6ab..5ed062e65 100644 --- a/RELEASE-v0.9.md +++ b/RELEASE-v0.9.md @@ -240,6 +240,9 @@ perform the Xous firmware upgrade. This requires running manual update commands, - iterator form for PNG decoding (thanks to nworbnhoj for a ton of work to get that together) - memory usage is well-constrained now, and suitable for everyday use - primary limit to PNG decode speed is read speed over e.g. TCP +- Feature #211 (change unlock PIN) implemented + - The menu item is in the PDDB Submenu->Change unlock PIN + - The redundant boot PIN setting during first power on setup is also removed. Only the one you set when you init the PDDB matters. ## Roadmap to 1.0 From f70dc246b8fb27356bd4b68631a1a3be2e043734 Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 12 Aug 2022 23:26:43 +0800 Subject: [PATCH 6/6] fix hosted mode --- services/root-keys/src/main.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/services/root-keys/src/main.rs b/services/root-keys/src/main.rs index f81194151..5b606dbd3 100644 --- a/services/root-keys/src/main.rs +++ b/services/root-keys/src/main.rs @@ -147,8 +147,9 @@ mod implementation { pub fn update_policy(&mut self, policy: Option) { log::info!("policy updated: {:?}", policy); } - pub fn hash_and_save_password(&mut self, pw: &str, _verify: bool) { + pub fn hash_and_save_password(&mut self, pw: &str, _verify: bool) -> bool { log::info!("got password plaintext: {}", pw); + true } pub fn set_ux_password_type(&mut self, cur_type: Option) { self.password_type = cur_type; @@ -197,6 +198,7 @@ mod implementation { } pub fn purge_password(&mut self, _ptype: PasswordType) {} pub fn purge_user_password(&mut self, _ptype: AesRootkeyType) {} + pub fn purge_sensitive_data(&mut self) {} pub fn get_ux_password_type(&self) -> Option {self.password_type} pub fn finish_key_init(&mut self) {}