mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
the base layer of the AES oracle is in place for the rootkeys
This commit is contained in:
parent
a1967a2128
commit
498f530165
6 changed files with 211 additions and 35 deletions
|
|
@ -189,6 +189,16 @@
|
|||
"zh": "更新完成重启应用",
|
||||
"en-audio": "Xous signing finished. Reboot at your earliest convenience."
|
||||
},
|
||||
"rootkeys.get_login_password": {
|
||||
"en": "Password request\nDevice unlock\nSecurity: Low\nWhy: User login",
|
||||
"zh": "输入密码\n解锁\n安全含义:低",
|
||||
"en-audio": "Enter device unlock password to access basic service."
|
||||
},
|
||||
"rootkeys.bad_password_request": {
|
||||
"en": "Someone issued a request\nfor a non-existent\npassword.",
|
||||
"zh": "**improve**无效的密码请求",
|
||||
"en-audio": "Someone issued a request for a non-existent password."
|
||||
},
|
||||
"rootkeys.policy_request": {
|
||||
"en": "Please pick a password\nretention policy:",
|
||||
"zh": "请选择密码保留策略:",
|
||||
|
|
|
|||
|
|
@ -44,7 +44,9 @@ pub(crate) enum Opcode {
|
|||
UxSignXousRun,
|
||||
|
||||
/// Ux AES calls
|
||||
//UxAesEnsurePassword,
|
||||
UxAesEnsurePassword,
|
||||
UxAesPasswordPolicy,
|
||||
UxAesEnsureReturn,
|
||||
|
||||
// General Ux calls
|
||||
UxGutter, // NOP for UX calls that require a destination
|
||||
|
|
@ -97,11 +99,18 @@ pub enum RootkeyResult {
|
|||
pub use cipher::{BlockCipher, consts::U16};
|
||||
use zeroize::Zeroize;
|
||||
|
||||
/// 128-bit AES block
|
||||
#[allow(dead_code)]
|
||||
pub type Block = cipher::generic_array::GenericArray<u8, cipher::consts::U16>;
|
||||
/// 16 x 128-bit AES blocks to be processed in bulk
|
||||
#[allow(dead_code)]
|
||||
pub type ParBlocks = cipher::generic_array::GenericArray<Block, cipher::consts::U16>;
|
||||
|
||||
pub const PAR_BLOCKS: usize = 16;
|
||||
/// Selects which key to use for the decryption/encryption oracle.
|
||||
/// currently only one type is available, the User key, but dozens more
|
||||
/// could be accommodated.
|
||||
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive, PartialEq, Eq)]
|
||||
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive, PartialEq, Eq, Copy, Clone)]
|
||||
pub enum AesRootkeyType {
|
||||
User0 = 0x28,
|
||||
NoneSpecified = 0xff,
|
||||
|
|
|
|||
|
|
@ -683,12 +683,16 @@ impl<'a> RootKeys {
|
|||
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
|
||||
},
|
||||
_ => {
|
||||
|
|
@ -711,12 +715,16 @@ impl<'a> RootKeys {
|
|||
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
|
||||
},
|
||||
_ => {
|
||||
|
|
@ -980,6 +988,14 @@ impl<'a> RootKeys {
|
|||
true
|
||||
}
|
||||
}
|
||||
pub fn is_pcache_boot_password_valid(&self) -> bool {
|
||||
let pcache: &mut PasswordCache = unsafe{&mut *(self.pass_cache.as_mut_ptr() as *mut PasswordCache)};
|
||||
if pcache.hashed_boot_pw_valid == 0 {
|
||||
false
|
||||
} else {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// Called by the UX layer to set up a key init run. It disables suspend/resume for the duration
|
||||
/// of the run, and also sets up some missing fields of KEYROM necessary to encrypt passwords.
|
||||
|
|
|
|||
|
|
@ -146,11 +146,28 @@ impl RootKeys {
|
|||
}
|
||||
}
|
||||
|
||||
fn ensure_aes_password(&self) -> bool {
|
||||
let response = send_message(self.conn,
|
||||
Message::new_blocking_scalar(Opcode::UxAesEnsurePassword.to_usize().unwrap(), self.key_index as usize, 0, 0, 0,)
|
||||
).expect("failed to ensure password is current");
|
||||
if let xous::Result::Scalar1(result) = response {
|
||||
if result != 1 {
|
||||
log::error!("there was a problem ensuring our password was unlocked, aborting!");
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
log::error!("there was a problem ensuring our password was unlocked, aborting!");
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
pub fn test_ux(&mut self, arg: usize) {
|
||||
send_message(self.conn,
|
||||
Message::new_scalar(Opcode::TestUx.to_usize().unwrap(),
|
||||
let response = send_message(self.conn,
|
||||
Message::new_blocking_scalar(Opcode::TestUx.to_usize().unwrap(),
|
||||
arg, 0, 0, 0)
|
||||
).expect("couldn't send test message");
|
||||
log::info!("test_ux response: {:?}", response);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -168,11 +185,6 @@ impl Drop for RootKeys {
|
|||
}
|
||||
}
|
||||
|
||||
/// 128-bit AES block
|
||||
pub type Block = cipher::generic_array::GenericArray<u8, cipher::consts::U16>;
|
||||
/// 16 x 128-bit AES blocks to be processed in bulk
|
||||
pub type ParBlocks = cipher::generic_array::GenericArray<Block, cipher::consts::U16>;
|
||||
|
||||
impl BlockCipher for RootKeys {
|
||||
type BlockSize = U16; // 128-bit cipher
|
||||
// we have to manually match this to PAR_BLOCKS!!
|
||||
|
|
@ -181,6 +193,9 @@ impl BlockCipher for RootKeys {
|
|||
|
||||
impl BlockEncrypt for RootKeys {
|
||||
fn encrypt_block(&self, block: &mut Block) {
|
||||
if !self.ensure_aes_password() {
|
||||
return;
|
||||
}
|
||||
let op = AesOp {
|
||||
key_index: self.key_index.to_u8().unwrap(),
|
||||
block: AesBlockType::SingleBlock(block.as_slice().try_into().unwrap()),
|
||||
|
|
@ -196,6 +211,9 @@ impl BlockEncrypt for RootKeys {
|
|||
}
|
||||
}
|
||||
fn encrypt_par_blocks(&self, blocks: &mut ParBlocks) {
|
||||
if !self.ensure_aes_password() {
|
||||
return;
|
||||
}
|
||||
let mut pb_buf: [[u8; 16]; PAR_BLOCKS] = [[0; 16]; PAR_BLOCKS];
|
||||
for (dst_block, src_block) in pb_buf.iter_mut().zip(blocks.as_slice().iter()) {
|
||||
for (dst, &src) in dst_block.iter_mut().zip(src_block.as_slice().iter()) {
|
||||
|
|
@ -222,6 +240,9 @@ impl BlockEncrypt for RootKeys {
|
|||
|
||||
impl BlockDecrypt for RootKeys {
|
||||
fn decrypt_block(&self, block: &mut Block) {
|
||||
if !self.ensure_aes_password() {
|
||||
return;
|
||||
}
|
||||
let op = AesOp {
|
||||
key_index: self.key_index.to_u8().unwrap(),
|
||||
block: AesBlockType::SingleBlock(block.as_slice().try_into().unwrap()),
|
||||
|
|
@ -237,6 +258,9 @@ impl BlockDecrypt for RootKeys {
|
|||
}
|
||||
}
|
||||
fn decrypt_par_blocks(&self, blocks: &mut ParBlocks) {
|
||||
if !self.ensure_aes_password() {
|
||||
return;
|
||||
}
|
||||
let mut pb_buf: [[u8; 16]; 16] = [[0; 16]; 16];
|
||||
for (dst_block, src_block) in pb_buf.iter_mut().zip(blocks.as_slice().iter()) {
|
||||
for (dst, &src) in dst_block.iter_mut().zip(src_block.as_slice().iter()) {
|
||||
|
|
|
|||
|
|
@ -174,6 +174,9 @@ mod implementation {
|
|||
pub fn is_pcache_update_password_valid(&self) -> bool {
|
||||
false
|
||||
}
|
||||
pub fn is_pcache_boot_password_valid(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
pub fn fetch_gw_metadata(&self, _region_enum: GatewareRegion) -> MetadataInFlash {
|
||||
MetadataInFlash {
|
||||
|
|
@ -293,8 +296,9 @@ fn xmain() -> ! {
|
|||
);
|
||||
|
||||
let mut reboot_initiated = false;
|
||||
let mut aes_sender: Option<xous::MessageSender> = None;
|
||||
loop {
|
||||
let msg = xous::receive_message(keys_sid).unwrap();
|
||||
let mut msg = xous::receive_message(keys_sid).unwrap();
|
||||
log::debug!("message: {:?}", msg);
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(Opcode::SuspendResume) => msg_scalar_unpack!(msg, token, _, _, _, {
|
||||
|
|
@ -327,28 +331,6 @@ fn xmain() -> ! {
|
|||
xous::return_scalar(msg.sender, 0).unwrap();
|
||||
}
|
||||
}),
|
||||
Some(Opcode::AesOperation) => {
|
||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||
// as_flat saves a copy step, but we have to deserialize some enums manually
|
||||
let aes_op = buffer.as_flat::<AesOp, _>().unwrap();
|
||||
// deserialize the specifier
|
||||
let optype = match aes_op.aes_op {
|
||||
ArchivedAesOpType::Decrypt => {
|
||||
AesOpType::Decrypt
|
||||
},
|
||||
ArchivedAesOpType::Encrypt => {
|
||||
AesOpType::Encrypt
|
||||
}
|
||||
};
|
||||
match aes_op.block {
|
||||
ArchivedAesBlockType::SingleBlock(mut b) => {
|
||||
keys.aes_op(aes_op.key_index, optype, &mut b);
|
||||
}
|
||||
ArchivedAesBlockType::ParBlock(mut pb) => {
|
||||
keys.aes_par_op(aes_op.key_index, optype, &mut pb);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
// UX flow opcodes
|
||||
Some(Opcode::UxTryInitKeys) => msg_scalar_unpack!(msg, _, _, _, _, {
|
||||
|
|
@ -938,6 +920,113 @@ fn xmain() -> ! {
|
|||
}
|
||||
}
|
||||
}
|
||||
Some(Opcode::UxAesEnsurePassword) => msg_blocking_scalar_unpack!(msg, key_index, _, _, _, {
|
||||
if key_index as u8 == AesRootkeyType::User0.to_u8().unwrap() {
|
||||
if keys.is_pcache_boot_password_valid() {
|
||||
// short circuit the process if the cache is hot
|
||||
xous::return_scalar(msg.sender, 1).unwrap();
|
||||
continue;
|
||||
}
|
||||
if aes_sender.is_some() {
|
||||
log::error!("multiple concurrent requests to UxAesEnsurePasword, not allowed!");
|
||||
xous::return_scalar(msg.sender, 0).unwrap();
|
||||
} else {
|
||||
aes_sender = Some(msg.sender);
|
||||
}
|
||||
keys.set_ux_password_type(Some(PasswordType::Boot));
|
||||
password_action.set_action_opcode(Opcode::UxAesPasswordPolicy.to_u32().unwrap());
|
||||
rootkeys_modal.modify(
|
||||
Some(ActionType::TextEntry(password_action)),
|
||||
Some(t!("rootkeys.get_login_password", xous::LANG)), false,
|
||||
None, true, None
|
||||
);
|
||||
rootkeys_modal.activate();
|
||||
// note that the scalar is *not* yet returned, it will be returned by the opcode called by the password assurance
|
||||
} else {
|
||||
// insert other indices, as we come to have them in else-ifs
|
||||
// note that there needs to be a way to keep the ensured password in sync with the
|
||||
// actual key index (if multiple passwords are used/required). For now, because there is only
|
||||
// one password, we can use is_pcache_boot_password_valid() to sync that up; but as we add
|
||||
// more keys with more passwords, this policy may need to become markedly more complicated!
|
||||
|
||||
// otherwise, an invalid password request
|
||||
dismiss_modal_action.set_action_opcode(Opcode::UxGutter.to_u32().unwrap());
|
||||
rootkeys_modal.modify(
|
||||
Some(ActionType::Notification(dismiss_modal_action)),
|
||||
Some(t!("rootkeys.bad_password_request", xous::LANG)), false,
|
||||
None, false, None);
|
||||
rootkeys_modal.activate();
|
||||
|
||||
xous::return_scalar(msg.sender, 0).unwrap();
|
||||
}
|
||||
}),
|
||||
Some(Opcode::UxAesPasswordPolicy) => {
|
||||
let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||
let mut plaintext_pw = buf.to_original::<gam::modal::TextEntryPayload, _>().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::UxAesEnsureReturn.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::UxAesEnsureReturn) => {
|
||||
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
|
||||
let payload = buffer.to_original::<RadioButtonPayload, _>().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);
|
||||
if let Some(sender) = aes_sender.take() {
|
||||
xous::return_scalar(sender, 1).unwrap();
|
||||
} else {
|
||||
log::error!("entered a UxAesEnsureReturn but the flow was not set up correctly!");
|
||||
panic!("entered a UxAesEnsureReturn but the flow was not set up correctly!")
|
||||
}
|
||||
}
|
||||
Some(Opcode::AesOperation) => {
|
||||
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
|
||||
// as_flat saves a copy step, but we have to deserialize some enums manually
|
||||
let mut aes_op = buffer.to_original::<AesOp, _>().unwrap();
|
||||
let op = match aes_op.aes_op { // seems stupid, but we have to do this because we want to have zeroize on the AesOp record, and it means we can't have Copy on this.
|
||||
AesOpType::Decrypt => AesOpType::Decrypt,
|
||||
AesOpType::Encrypt => AesOpType::Encrypt,
|
||||
};
|
||||
// deserialize the specifier
|
||||
match aes_op.block {
|
||||
AesBlockType::SingleBlock(mut b) => {
|
||||
log::info!("b: {:x?}", b);
|
||||
keys.aes_op(aes_op.key_index, op, &mut b);
|
||||
log::info!("b: {:x?}", b);
|
||||
aes_op.block = AesBlockType::SingleBlock(b);
|
||||
log::info!("after b: {:x?}", aes_op);
|
||||
}
|
||||
AesBlockType::ParBlock(mut pb) => {
|
||||
keys.aes_par_op(aes_op.key_index, op, &mut pb);
|
||||
aes_op.block = AesBlockType::ParBlock(pb);
|
||||
}
|
||||
};
|
||||
buffer.replace(aes_op).unwrap();
|
||||
},
|
||||
|
||||
Some(Opcode::CheckGatewareSignature) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||
if keys.is_initialized() {
|
||||
if keys.verify_gateware_self_signature() {
|
||||
|
|
@ -949,8 +1038,9 @@ fn xmain() -> ! {
|
|||
xous::return_scalar(msg.sender, 2).expect("couldn't send return value");
|
||||
}
|
||||
}),
|
||||
Some(Opcode::TestUx) => msg_scalar_unpack!(msg, _arg, _, _, _, {
|
||||
// empty test routine for now
|
||||
Some(Opcode::TestUx) => msg_blocking_scalar_unpack!(msg, _arg, _, _, _, {
|
||||
// dummy test for now
|
||||
xous::return_scalar(msg.sender, 1234).unwrap();
|
||||
}),
|
||||
Some(Opcode::UxGetPolicy) => {
|
||||
policy_menu.activate();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
use crate::{ShellCmdApi, CommonEnv};
|
||||
use root_keys::api::AesRootkeyType;
|
||||
use root_keys::api::{AesRootkeyType, Block};
|
||||
use xous_ipc::String;
|
||||
|
||||
#[derive(Debug)]
|
||||
|
|
@ -56,6 +56,33 @@ impl<'a> ShellCmdApi<'a> for Keys {
|
|||
//debug_here::debug_here!();
|
||||
write!(ret, "show UX").unwrap();
|
||||
}
|
||||
"aes" => {
|
||||
use aes_xous::{BlockEncrypt, BlockDecrypt};
|
||||
let mut pass = true;
|
||||
let mut block = Block::clone_from_slice(&[0; 16]);
|
||||
self.rootkeys.encrypt_block(&mut block);
|
||||
log::info!("encrypted block: {:?}", block);
|
||||
let mut sum = 0;
|
||||
for &b in block.as_slice().iter() {
|
||||
sum += b as u32; // we don't use .sum() because we need more bits than a u8
|
||||
}
|
||||
if sum == 0 {
|
||||
pass = false;
|
||||
}
|
||||
// this will cause a second password box to pop up if you told it to use-once.
|
||||
self.rootkeys.decrypt_block(&mut block);
|
||||
log::info!("decrypted block: {:?}", block);
|
||||
for &b in block.as_slice().iter() {
|
||||
if b != 0 {
|
||||
pass = false;
|
||||
}
|
||||
}
|
||||
if pass {
|
||||
write!(ret, "aes test passed").unwrap();
|
||||
} else {
|
||||
write!(ret, "aes test failed").unwrap();
|
||||
}
|
||||
}
|
||||
"usblock" => {
|
||||
env.llio.debug_usb(Some(true)).unwrap();
|
||||
write!(ret, "USB debug port locked out; one word at 0x80000000 is disclosable via USB.").unwrap();
|
||||
|
|
|
|||
Loading…
Reference in a new issue