From 09e1b99315ffde177f5879739aabe6077e19de88 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 12 Jul 2022 03:32:33 +0800 Subject: [PATCH] initial infrastructure for running backups code to serialize/deserialize and encrypt/decrypt the backup block. now filling in the UX flow around this. --- Cargo.lock | 2 + services/root-keys/Cargo.toml | 5 + services/root-keys/locales/i18n.json | 8 +- services/root-keys/src/api.rs | 23 +++ services/root-keys/src/backups.rs | 253 +++++++++++++++++++++++ services/root-keys/src/implementation.rs | 14 +- services/root-keys/src/lib.rs | 29 +++ services/root-keys/src/main.rs | 38 ++++ 8 files changed, 370 insertions(+), 2 deletions(-) create mode 100644 services/root-keys/src/backups.rs diff --git a/Cargo.lock b/Cargo.lock index 0387f53f1..0a93b564c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2863,6 +2863,7 @@ name = "root-keys" version = "0.1.0" dependencies = [ "aes", + "aes-gcm-siv", "blowfish 0.8.0", "byteorder", "cipher 0.4.3", @@ -2885,6 +2886,7 @@ dependencies = [ "rkyv", "sha2", "spinor", + "subtle", "susres", "ticktimer-server", "trng", diff --git a/services/root-keys/Cargo.toml b/services/root-keys/Cargo.toml index 98264650a..ad698fb48 100644 --- a/services/root-keys/Cargo.toml +++ b/services/root-keys/Cargo.toml @@ -44,6 +44,11 @@ jtag = {path = "../jtag"} # for text to speech support tts-frontend = {path="../tts"} +# backups +# aes-gcm-siv = {version = "0.11.0-pre", default-features = false, features = ["alloc"]} +aes-gcm-siv = {git="https://github.com/RustCrypto/AEADs.git", branch="master"} +subtle = {version = "2.4.1", default-features = false} + # private keys #sha2 = {version = "0.9.5", default-features = false, features = []} sha2 = {path = "../engine-sha512"} diff --git a/services/root-keys/locales/i18n.json b/services/root-keys/locales/i18n.json index efe3155d2..04d08de4f 100644 --- a/services/root-keys/locales/i18n.json +++ b/services/root-keys/locales/i18n.json @@ -206,9 +206,15 @@ "rootkeys.get_update_password": { "en": "⚠ Critical password request ⚠\nEnter the 'SYSTEM UPDATE' passphrase. This authorizes a system update.", "ja": "重要なパスワード要求\nSYSTEM UPDATEのパスフレーズを入力してください。これでシステムアップデートが許可されます。", - "zh": "输入密码 软件更新 安全含义:至关重要 ", + "zh": "⚠ 关键密码请求⚠\n输入“系统更新”密码。 这将授权系统更新。", "en-tts": "Enter update password, in order to authorize a gateware update." }, + "rootkeys.get_update_password_backup": { + "en": "⚠ Critical password request ⚠\nEnter the 'SYSTEM UPDATE' passphrase. This authorizes a backup to be created.", + "ja": "重要なパスワード要求\nSYSTEM UPDATEのパスフレーズを入力してください。これにより、バックアップの作成が許可されます。", + "zh": "⚠ 关键密码请求⚠\n输入“系统更新”密码。 这将授权创建备份。", + "en-tts": "Enter update password, in order to authorize a backup." + }, "rootkeys.gwup.finished": { "en": "Gateware update finished.\n\nReboot by inserting a paperclip into the small hole on the lower right at your earliest convenience.", "ja": "ゲートウェアアップデートが終了しました。ご都合の良い時に再起動してください。", diff --git a/services/root-keys/src/api.rs b/services/root-keys/src/api.rs index 14cf13cce..7b2e8eed3 100644 --- a/services/root-keys/src/api.rs +++ b/services/root-keys/src/api.rs @@ -82,6 +82,14 @@ pub(crate) enum Opcode { ShouldPromptForUpdate = 37, /// Set the "don't bother me again for an update" SetPromptForUpdate = 38, + /// Create a backup block (including UX flow that discloses our AES key!) + CreateBackup = 39, + UxCreateBackupPwReturn = 40, + /// Query if a backup exists to be restored + ShouldRestore = 41, + UxShouldRestorePwReturn = 42, + /// Perform the restore operation (including UX to acquire the AES key) + DoRestore = 43, } #[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive, PartialEq, Eq)] @@ -195,6 +203,8 @@ use std::error::Error; impl Error for KeywrapError {} use std::fmt; + +use crate::backups; impl fmt::Display for KeywrapError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { match self { @@ -219,4 +229,17 @@ pub (crate) struct KeyWrapper { pub result: Option, // used by the unwrap side pub expected_len: u32, +} + +// the BackupHeader type is serialized into u8 before going through rkyv. +// a bit inefficient but convenient, because we need an Option<> of the +// BackupHeader and not the header itself. +#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] +pub (crate) struct BackupHeaderIpc { + pub data: Option<[u8; core::mem::size_of::()]>, +} +impl Default for BackupHeaderIpc { + fn default() -> Self { + BackupHeaderIpc { data: None::<[u8; core::mem::size_of::()]> } + } } \ No newline at end of file diff --git a/services/root-keys/src/backups.rs b/services/root-keys/src/backups.rs new file mode 100644 index 000000000..c70d1d544 --- /dev/null +++ b/services/root-keys/src/backups.rs @@ -0,0 +1,253 @@ +use zeroize::Zeroize; +use core::mem::size_of; +use core::ops::{Deref, DerefMut}; +use aes_gcm_siv::{AesGcmSiv, Nonce, Key, Tag}; +use aes_gcm_siv::aead::{Aead, NewAead, Payload}; +use aes::Aes256; +use subtle::ConstantTimeEq; + +pub const BACKUP_VERSION: u32 = 0x00_01_00_00; +const BACKUP_AAD: &'static str = "PDDB backup v0.1.0"; + +#[derive(Zeroize, Default)] +#[zeroize(drop)] +pub(crate) struct BackupKey([u8;32]); + +#[derive(Zeroize)] +#[zeroize(drop)] +pub(crate) struct KeyRomExport([u32; 256]); + +#[repr(u32)] +pub enum BackupOp { + /// backup and restore can be manipulated by the OS without updating the ciphertext + Backup, + Restore, + /// This is the value that's kept inside the BackupDataPt + Archive, +} + +#[repr(C, align(8))] +pub struct BackupHeader { + pub version: u32, + // the `ver`s are all serialized SemVers. To be done by the caller. + pub xous_ver: [u8; 16], + pub soc_ver: [u8; 16], + pub ec_ver: [u8; 16], + pub wf200_ver: [u8; 16], + pub timestamp: u64, + pub _reserved: [u8; 64], + pub op: BackupOp, +} +impl Default for BackupHeader { + fn default() -> Self { + BackupHeader { + version: BACKUP_VERSION, + xous_ver: [0u8; 16], + soc_ver: [0u8; 16], + ec_ver: [0u8; 16], + wf200_ver: [0u8; 16], + timestamp: 0, + _reserved: [0u8; 64], + op: BackupOp::Archive, + } + } +} +impl Deref for BackupHeader { + type Target = [u8]; + fn deref(&self) -> &[u8] { + unsafe { + core::slice::from_raw_parts(self as *const BackupHeader as *const u8, size_of::()) + as &[u8] + } + } +} +impl DerefMut for BackupHeader { + fn deref_mut(&mut self) -> &mut [u8] { + unsafe { + core::slice::from_raw_parts_mut(self as *mut BackupHeader as *mut u8, size_of::()) + as &mut [u8] + } + } +} + +#[derive(Zeroize)] +#[zeroize(drop)] +#[repr(C, align(8))] +pub(crate) struct BackupDataPt { + /// A sealed copy of the plaintext header, for validation purposes (plaintext can be tampered with) + /// Note: the `op` field is allowed to be manipulated + pub header: BackupHeader, // 144 bytes => 9 aes blocks + /// exact copy of the KEYROM structure + pub keyrom: [u32; 256], // 1024 bytes + /// some reserved space for future things + pub _reserved: [u8; 64], +} +impl Default for BackupDataPt { + fn default() -> Self { + BackupDataPt { + header: BackupHeader::default(), + keyrom: [0u32; 256], + _reserved: [0u8; 64], + } + } +} +impl Deref for BackupDataPt { + type Target = [u8]; + fn deref(&self) -> &[u8] { + unsafe { + core::slice::from_raw_parts(self as *const BackupDataPt as *const u8, size_of::()) + as &[u8] + } + } +} +impl DerefMut for BackupDataPt { + fn deref_mut(&mut self) -> &mut [u8] { + unsafe { + core::slice::from_raw_parts_mut(self as *mut BackupDataPt as *mut u8, size_of::()) + as &mut [u8] + } + } +} + +#[repr(C, align(8))] +pub(crate) struct BackupDataCt { + pub nonce: [u8; 12], + pub ct_plus_mac: [u8; size_of::() + size_of::()], // should be 1232 + 16 + pub commit_nonce: [u8; 32], + pub commitment: [u8; 32], +} +impl Default for BackupDataCt { + fn default() -> Self { + BackupDataCt { + nonce: [0u8; 12], + ct_plus_mac: [0u8; size_of::() + size_of::()], + commit_nonce: [0u8; 32], + commitment: [0u8; 32], + } + } +} +impl Deref for BackupDataCt { + type Target = [u8]; + fn deref(&self) -> &[u8] { + unsafe { + core::slice::from_raw_parts(self as *const BackupDataCt as *const u8, size_of::()) + as &[u8] + } + } +} +impl DerefMut for BackupDataCt { + fn deref_mut(&mut self) -> &mut [u8] { + unsafe { + core::slice::from_raw_parts_mut(self as *mut BackupDataCt as *mut u8, size_of::()) + as &mut [u8] + } + } +} + +/// Derive a key commitment. This takes in a base `key`, which is 256 bits; +/// a `nonce` which is the 96-bit nonce used in the AES-GCM-SIV for a given block; +/// and `nonce_com` which is the commitment nonce, set at 256 bits. +/// The result is two tuples, (kenc, kcom). +fn kcom_func( + key: &[u8; 32], + nonce_com: &[u8; 32] +) -> (BackupKey, BackupKey) { + use sha2::{FallbackStrategy, Sha512Trunc256}; + use digest::Digest; + + let mut h_enc = Sha512Trunc256::new_with_strategy(FallbackStrategy::SoftwareOnly); + h_enc.update(key); + // per https://eprint.iacr.org/2020/1456.pdf Table 4 on page 13 Type I Lenc + h_enc.update([0x43, 0x6f, 0x6, 0xd6, 0xd, 0x69, 0x74, 0x01, 0x01]); + h_enc.update(nonce_com); + let k_enc = h_enc.finalize(); + + let mut h_com = Sha512Trunc256::new_with_strategy(FallbackStrategy::SoftwareOnly); + h_com.update(key); + // per https://eprint.iacr.org/2020/1456.pdf Table 4 on page 13 Type I Lcom. Note one-bit difference in last byte. + h_com.update([0x43, 0x6f, 0x6, 0xd6, 0xd, 0x69, 0x74, 0x01, 0x02]); + h_com.update(nonce_com); + let k_com = h_com.finalize(); + let mut kenc = BackupKey::default(); + let mut kcom = BackupKey::default(); + kenc.0.copy_from_slice(k_enc.as_slice()); + kcom.0.copy_from_slice(k_com.as_slice()); + (kenc, kcom) +} + +pub(crate) fn create_backup( + key: BackupKey, + header: BackupHeader, + keyrom: KeyRomExport, +) -> BackupDataCt { + let xns = xous_names::XousNames::new().unwrap(); + let mut trng = trng::Trng::new(&xns).unwrap(); + + // AES-GCM-SIV nonce + let mut nonce: [u8; size_of::()] = [0; size_of::()]; + trng.fill_bytes(&mut nonce); + + // key commitment nonce + let mut kcom_nonce = [0u8; 32]; + trng.fill_bytes(&mut kcom_nonce); + + let (kenc, kcom) = kcom_func(&key.0, &kcom_nonce); + let cipher = AesGcmSiv::::new(Key::from_slice(&kenc.0)); + + // the backup data + let mut backup_data_pt = BackupDataPt::default(); + backup_data_pt.header.deref_mut().copy_from_slice(header.deref()); + backup_data_pt.header.op = BackupOp::Archive; + + backup_data_pt.keyrom.copy_from_slice(&keyrom.0); + + // encrypt the backup data + let ciphertext = cipher.encrypt( + &nonce.into(), + Payload { + aad: BACKUP_AAD.as_bytes(), + msg: backup_data_pt.deref(), + } + ).expect("couldn't encrypt data"); + + // copy to a ciphertext record + let mut backup_ct = BackupDataCt::default(); + backup_ct.nonce.copy_from_slice(&nonce); + backup_ct.ct_plus_mac.copy_from_slice(&ciphertext); // this will panic if we have the wrong CT size, and that's exactly what we want. + backup_ct.commit_nonce.copy_from_slice(&kcom_nonce); + backup_ct.commitment.copy_from_slice(&kcom.0); + + backup_ct +} + +/// Returns `None` if the MAC or key commitment fail. +/// It is up to the caller to validate if the plaintext header matches the decrypted +/// version embedded in the return data. +pub(crate) fn restore_backup( + key: BackupKey, + backup: BackupDataCt +) -> Option { + let (kenc, kcom) = kcom_func(&key.0, &backup.commit_nonce); + let cipher = AesGcmSiv::::new(Key::from_slice(&kenc.0)); + + // Attempt decryption. This is None on failure + let plaintext = cipher.decrypt( + Nonce::from_slice(&backup.nonce), + Payload { + aad: BACKUP_AAD.as_bytes(), + msg: &backup.ct_plus_mac, + } + ).ok(); + + if kcom.0.ct_eq(&backup.commitment).into() { + if let Some(p) = plaintext { + let mut pt = BackupDataPt::default(); + pt.deref_mut().copy_from_slice(&p); // panics if pt is the wrong length. we want that. + Some(pt) + } else { + None + } + } else { + None + } +} \ No newline at end of file diff --git a/services/root-keys/src/implementation.rs b/services/root-keys/src/implementation.rs index 4612f5762..c9bbc93c2 100644 --- a/services/root-keys/src/implementation.rs +++ b/services/root-keys/src/implementation.rs @@ -5,7 +5,8 @@ use keywrap::*; pub use oracle::FpgaKeySource; use utralib::generated::*; -use crate::api::*; +use xous::BACKUP_OFFSET; +use crate::{api::*, backups}; use core::num::NonZeroUsize; use num_traits::*; @@ -2332,4 +2333,15 @@ impl<'a> RootKeys { self.gateware().len() as u32 - 4 ).expect("couldn't patch update prompt"); } + pub fn read_backup_header(&mut self) -> Option { + let kernel = self.kernel(); + let backup = &kernel[BACKUP_OFFSET as usize..BACKUP_OFFSET as usize + size_of::()]; + let mut header = backups::BackupHeader::default(); + header.as_mut().copy_from_slice(backup); + if header.version == backups::BACKUP_VERSION { + Some(header) + } else { + None + } + } } diff --git a/services/root-keys/src/lib.rs b/services/root-keys/src/lib.rs index 712cd150b..8b11dd52f 100644 --- a/services/root-keys/src/lib.rs +++ b/services/root-keys/src/lib.rs @@ -3,6 +3,7 @@ pub mod api; use api::*; +pub mod backups; pub mod key2bits; @@ -101,6 +102,34 @@ impl RootKeys { ).expect("couldn't send message to root keys"); } + pub fn do_create_backup_ux_flow(&self) { + send_message(self.conn, + Message::new_scalar(Opcode::CreateBackup.to_usize().unwrap(), + 0, 0, 0, 0) + ).expect("couldn't send message to root keys"); + } + pub fn do_restore_backup_ux_flow(&self) { + send_message(self.conn, + Message::new_scalar(Opcode::DoRestore.to_usize().unwrap(), + 0, 0, 0, 0) + ).expect("couldn't send message to root keys"); + } + /// Returns the raw, unchecked restore header. Further checking may be done at the restore point, + /// but the purpose of this is to just decide if we should even try to initiate a restore. + pub fn get_restore_header(&self) -> Result, xous::Error> { + let alloc = BackupHeaderIpc::default(); + let mut buf = Buffer::into_buf(alloc).or(Err(xous::Error::InternalError))?; + buf.lend_mut(self.conn, Opcode::ShouldRestore.to_u32().unwrap()).or(Err(xous::Error::InternalError))?; + let ret = buf.to_original::().unwrap(); + if let Some(d) = ret.data { + let mut header = backups::BackupHeader::default(); + header.copy_from_slice(&d); + Ok(Some(header)) + } else { + Ok(None) + } + } + /// this will return the version number, but always report the commit as None. /// The 32-bit commit ref isn't useful in version comparisons, it's more to assist /// maintainer debug. Including this would convert this from a scalar message to diff --git a/services/root-keys/src/main.rs b/services/root-keys/src/main.rs index 95f3dc891..9a5474a9e 100644 --- a/services/root-keys/src/main.rs +++ b/services/root-keys/src/main.rs @@ -3,6 +3,8 @@ mod api; use api::*; +mod backups; + use xous::{msg_scalar_unpack, send_message, msg_blocking_scalar_unpack}; #[cfg(feature = "policy-menu")] use xous_ipc::String; @@ -1198,6 +1200,42 @@ fn main() -> ! { Some(Opcode::SetPromptForUpdate) => msg_scalar_unpack!(msg, state, _, _, _, { keys.set_prompt_for_update(if state == 1 {true} else {false}); }), + Some(Opcode::ShouldRestore) => { + let mut buf = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) }; + let maybe_header = keys.read_backup_header(); + let mut ret = BackupHeaderIpc::default(); + if let Some(header) = maybe_header { + let mut data = [0u8; core::mem::size_of::()]; + data.copy_from_slice(header.as_ref()); + ret.data = Some(data); + } + buf.replace(ret).unwrap(); + } + Some(Opcode::CreateBackup) => { + keys.set_ux_password_type(Some(PasswordType::Update)); + password_action.set_action_opcode(Opcode::UxCreateBackupPwReturn.to_u32().unwrap()); + rootkeys_modal.modify( + Some(ActionType::TextEntry(password_action.clone())), + Some(t!("rootkeys.get_update_password_backup", xous::LANG)), false, + None, true, None + ); + #[cfg(feature="tts")] + tts.tts_blocking(t!("rootkeys.get_update_password_backup", xous::LANG)).unwrap(); + log::info!("{}ROOTKEY.UPDPW,{}", xous::BOOKEND_START, xous::BOOKEND_END); + rootkeys_modal.activate(); + } + Some(Opcode::UxUpdateGwPasswordReturn) => { + 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()); + 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); + + // check if the entered password is valid. + + } Some(Opcode::TestUx) => msg_blocking_scalar_unpack!(msg, _arg, _, _, _, { // dummy test for now xous::return_scalar(msg.sender, 1234).unwrap();