add hash protection on the metadata header

stage is set for hash protection on the PDDB data itself.
that comes next.
This commit is contained in:
bunnie 2022-10-08 01:22:14 +08:00
parent c1eed3e7ad
commit a416069002
6 changed files with 168 additions and 16 deletions

View file

@ -256,7 +256,7 @@ impl Default for BackupHeaderIpc {
} }
} }
pub const BACKUP_VERSION: u32 = 0x00_01_00_00; pub const BACKUP_VERSION: u32 = 0x00_01_00_01;
#[repr(u32)] #[repr(u32)]
#[derive(Copy, Clone, PartialEq, Eq, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@ -359,6 +359,21 @@ impl From::<[u8; 4]> for BackupKeyboardLayout {
} }
} }
pub const HEADER_TOTAL_SIZE: u32 = 4096;
/// Size of a checksummed block in pages. 0x100 = 256 pages,
/// or 1 MiB for a checksummed block. This is specified in 4kiB pages
/// because it really doesn't make sense to checksum anything smaller
/// than that, and it allows us to grow the size of a single checksummed
/// block to well over 4GiB.
pub const CHECKSUM_BLOCKLEN_PAGE: u32 = 0x100;
/// The total number of checksums required to cover the length of the PDDB
/// divided by the length of a checksummed page. This number does not count
/// the single additional checksum that is included to check the integrity of the
/// plaintext + ciphertext header itself.
///
/// Total number of checksums has to divide evenly into the size of the PDDB region
pub const TOTAL_CHECKSUMS: u32 = xous::PDDB_LEN / CHECKSUM_BLOCKLEN_PAGE;
#[repr(C, align(8))] #[repr(C, align(8))]
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
pub struct BackupHeader { pub struct BackupHeader {
@ -372,11 +387,26 @@ pub struct BackupHeader {
pub language: [u8; 4], pub language: [u8; 4],
pub kbd_layout: [u8; 4], pub kbd_layout: [u8; 4],
pub dna: [u8; 8], pub dna: [u8; 8],
pub _reserved: [u8; 48], /// Length of a checksummed region, in 4kiB pages
pub checksum_len_page: [u8; 4],
/// Number of checksummed pages
///
/// The location of the first header is computed as follows:
/// `header_start_address + header_total_size - (total_checksums) * 16`
/// The backup data starts at `header_start_address + header_total_size`
///
/// In other words, checksums are aligned to the highest address in the header
/// while the header plaintext+ciphertext data is aligned to the lowest address
/// in the header region.
pub total_checksums: [u8; 4],
/// Total size of the header in bytes, including unused space
pub header_total_size: [u8; 4],
pub _reserved: [u8; 36],
pub op: BackupOp, pub op: BackupOp,
} }
impl Default for BackupHeader { impl Default for BackupHeader {
fn default() -> Self { fn default() -> Self {
assert!(xous::PDDB_LEN & ((CHECKSUM_BLOCKLEN_PAGE * 0x1000) - 1) == 0, "PDDB_LEN is not an integer multiple of CHECKSUM_LEN_PAGE");
BackupHeader { BackupHeader {
version: BACKUP_VERSION, version: BACKUP_VERSION,
xous_ver: [0u8; 16], xous_ver: [0u8; 16],
@ -387,7 +417,10 @@ impl Default for BackupHeader {
language: BackupLanguage::default().into(), // this is "correct by default" language: BackupLanguage::default().into(), // this is "correct by default"
kbd_layout: BackupKeyboardLayout::default().into(), // this has to be adjusted kbd_layout: BackupKeyboardLayout::default().into(), // this has to be adjusted
dna: [0u8; 8], dna: [0u8; 8],
_reserved: [0u8; 48], checksum_len_page: CHECKSUM_BLOCKLEN_PAGE.to_le_bytes(),
total_checksums: TOTAL_CHECKSUMS.to_le_bytes(),
header_total_size: HEADER_TOTAL_SIZE.to_le_bytes(),
_reserved: [0u8; 36],
op: BackupOp::Archive, op: BackupOp::Archive,
} }
} }

View file

@ -23,6 +23,7 @@ impl Default for KeyRomExport {
} }
} }
/// This is the plaintext portion of the backup header
#[derive(Zeroize)] #[derive(Zeroize)]
#[zeroize(drop)] #[zeroize(drop)]
#[repr(C, align(8))] #[repr(C, align(8))]
@ -62,6 +63,9 @@ impl DerefMut for BackupDataPt {
} }
} }
/// This is the ciphertext portion of the backup header. Note that there is an additional
/// 32-byte section that is a SHA512/256 hash of the pt+ct region, appended directly to
/// the end of the ct region.
#[repr(C, align(8))] #[repr(C, align(8))]
pub(crate) struct BackupDataCt { pub(crate) struct BackupDataCt {
pub nonce: [u8; 12], pub nonce: [u8; 12],
@ -97,6 +101,52 @@ impl DerefMut for BackupDataCt {
} }
} }
/// The Checksums structure is an array of 16-byte (128-bit) checksums that
/// are applied to backed up data. There is one checksum per block region
/// (currently set to 1MiB).
///
/// The actual checksum is a SHA512 of the region, but with only the first
/// 128 bits stored. The goal of the checksum isn't a cryptographic tamper
/// proofing -- this is already handled by the underlying AEAD's that are
/// applied to the PDDB. The utility of the checksum is to detect media
/// or transmission errors in storage, without having to fully decrypt
/// the entire PDDB to look for corruption. We use SHA512 and truncate it to
/// 128 bits not because it's the optimal hash, but because it's what we
/// have a hardware accelerator for. We don't truncate to 256 bits because
/// we're trying to pack as many checksums into a 4k header, and going to
/// 128 bits is still "strong" for a checksum and allows us to get the region
/// size down to 1MiB, which is a reasonably sized region for a retry-download
/// in case a checksum error is found.
#[repr(C, align(8))]
pub(crate) struct Checksums {
pub checksums: [[u8; 16]; crate::api::TOTAL_CHECKSUMS as usize],
}
impl Default for Checksums {
fn default() -> Self {
Checksums {
checksums: [[0u8; 16]; crate::api::TOTAL_CHECKSUMS as usize],
}
}
}
impl Deref for Checksums {
type Target = [u8];
fn deref(&self) -> &[u8] {
unsafe {
core::slice::from_raw_parts(self as *const Checksums as *const u8, size_of::<Checksums>())
as &[u8]
}
}
}
impl DerefMut for Checksums {
fn deref_mut(&mut self) -> &mut [u8] {
unsafe {
core::slice::from_raw_parts_mut(self as *mut Checksums as *mut u8, size_of::<Checksums>())
as &mut [u8]
}
}
}
/// Derive a key commitment. This takes in a base `key`, which is 256 bits; /// 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; /// 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. /// and `nonce_com` which is the commitment nonce, set at 256 bits.

View file

@ -2729,9 +2729,19 @@ impl<'a> RootKeys {
header.op = BackupOp::Backup; // set the "we're backing up" flag header.op = BackupOp::Backup; // set the "we're backing up" flag
// condense the data into a single block, to reduce read/write cycles on the block // condense the data into a single block, to reduce read/write cycles on the block
let mut block = [0u8; size_of::<BackupHeader>() + size_of::<backups::BackupDataCt>()]; const HASH_LEN: usize = 32;
let mut block = [0u8; size_of::<BackupHeader>() + size_of::<backups::BackupDataCt>() + HASH_LEN];
block[..size_of::<BackupHeader>()].copy_from_slice(header.as_ref()); block[..size_of::<BackupHeader>()].copy_from_slice(header.as_ref());
block[size_of::<BackupHeader>()..].copy_from_slice(backup_ct.as_ref()); block[size_of::<BackupHeader>()..size_of::<BackupHeader>() + size_of::<backups::BackupDataCt>()].copy_from_slice(backup_ct.as_ref());
// compute a hash of the data, for fast verification of the backup header integrity to detect media errors, etc.
let mut hasher = Sha512Trunc256::new_with_strategy(FallbackStrategy::HardwareThenSoftware);
hasher.update(&block[..size_of::<BackupHeader>() + size_of::<backups::BackupDataCt>()]);
let digest = hasher.finalize();
assert!(digest.len() == HASH_LEN, "Wrong length hash selected! Check your code.");
block[size_of::<BackupHeader>() + size_of::<backups::BackupDataCt>()..]
.copy_from_slice(digest.as_slice());
self.spinor.patch( self.spinor.patch(
self.kernel(), self.kernel(),
self.kernel_base(), self.kernel_base(),

View file

@ -1061,6 +1061,13 @@ fn wrapped_main() -> ! {
// sync the PDDB to disk prior to making backups // sync the PDDB to disk prior to making backups
let pddb = pddb::Pddb::new(); let pddb = pddb::Pddb::new();
pddb.sync().expect("couldn't synchronize PDDB to disk"); pddb.sync().expect("couldn't synchronize PDDB to disk");
// TODO: add PDDB hash map computations here + UX flow to indicate pause
// TODO: add a call to PDDB that blocks the PDDB forever. The system is rebooted
// after the backup is done. However, this call ensures that the PDDB does not
// get updated mid-way through a backup
let mut metadata = root_keys::api::BackupHeader::default(); let mut metadata = root_keys::api::BackupHeader::default();
// note: default() should set the language correctly by default since it's a systemwide constant // note: default() should set the language correctly by default since it's a systemwide constant
metadata.timestamp = localtime.get_local_time_ms().unwrap_or(0); metadata.timestamp = localtime.get_local_time_ms().unwrap_or(0);

View file

@ -112,6 +112,7 @@ def main():
TAG_LEN = 16 TAG_LEN = 16
COMMIT_NONCE_LEN = 32 COMMIT_NONCE_LEN = 32
COMMIT_LEN = 32 COMMIT_LEN = 32
CHECKSUM_LEN = 32
offset = PT_HEADER_LEN offset = PT_HEADER_LEN
nonce = backup[offset:offset+NONCE_LEN] nonce = backup[offset:offset+NONCE_LEN]
offset += NONCE_LEN offset += NONCE_LEN
@ -122,6 +123,9 @@ def main():
commit_nonce = backup[offset:offset+COMMIT_NONCE_LEN] commit_nonce = backup[offset:offset+COMMIT_NONCE_LEN]
offset += COMMIT_NONCE_LEN offset += COMMIT_NONCE_LEN
commit = backup[offset:offset+COMMIT_LEN] commit = backup[offset:offset+COMMIT_LEN]
offset += COMMIT_LEN
check_region = backup[:offset]
checksum = backup[offset:offset+CHECKSUM_LEN]
h_enc = SHA512.new(truncate="256") h_enc = SHA512.new(truncate="256")
h_enc.update(key) h_enc.update(key)
@ -149,7 +153,8 @@ def main():
exit(1) exit(1)
i = 0 i = 0
logging.info("Backup version: 0x{:08x}".format(int.from_bytes(pt_data[i:i+4], 'little'))) backup_version = int.from_bytes(pt_data[i:i+4], 'little')
logging.info("Backup version: 0x{:08x}".format(backup_version))
i += 4 i += 4
logging.info("Xous version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) logging.info("Xous version: {}".format(bytes_to_semverstr(pt_data[i:i+16])))
i += 16 i += 16
@ -171,11 +176,29 @@ def main():
dna = pt_data[i:i+8] dna = pt_data[i:i+8]
dna_int = int.from_bytes(dna, 'little') dna_int = int.from_bytes(dna, 'little')
i += 8 i += 8
i += 48 # reserved checksum_region_len = int.from_bytes(pt_data[i:i+4], 'little') * 4096
logging.info("Checksum region length: 0x{:x}".format(checksum_region_len))
i += 4
total_checksums = int.from_bytes(pt_data[i:i+4], 'little')
logging.info("Number of checksums, including the header checksum itself: {}".format(total_checksums))
i += 4
header_total_size = int.from_bytes(pt_data[i:i+4], 'little')
logging.info("Header total length in bytes: {}".format(header_total_size))
i += 36 # reserved
op = int.from_bytes(pt_data[i:i+4], 'little') op = int.from_bytes(pt_data[i:i+4], 'little')
logging.info("Stored Backup Opcode: {}".format(op)) logging.info("Stored Backup Opcode: {}".format(op))
i += 8 # padding because align=8 i += 8 # padding because align=8
if backup_version == 0x10001:
logging.info("Doing hash verification of pt+ct metadata")
hasher = SHA512.new(truncate="256")
hasher.update(check_region)
computed_checksum = hasher.digest()
if computed_checksum != checksum:
print("Header failed hash integrity check!")
# TODO: sector checks
keyrom = pt_data[i:i+1024] keyrom = pt_data[i:i+1024]
user_key_enc = get_key(40, keyrom, 32) user_key_enc = get_key(40, keyrom, 32)
pepper = get_key(248, keyrom, 16) pepper = get_key(248, keyrom, 16)

View file

@ -11,6 +11,7 @@ import csv
import urllib.request import urllib.request
from datetime import datetime from datetime import datetime
from datetime import date from datetime import date
from Crypto.Hash import SHA512
from progressbar.bar import ProgressBar from progressbar.bar import ProgressBar
@ -457,8 +458,9 @@ class SemVer:
def check_header(backup): def check_header(backup):
i = 0 i = 0
print("Backup protocol version: 0x{:08x}".format(int.from_bytes(backup[i:i+4], 'little'))) backup_version = int.from_bytes(backup[i:i+4], 'little')
if int.from_bytes(backup[i:i+4], 'little') != 0x00010000: print("Backup protocol version: 0x{:08x}".format(backup_version))
if backup_version != 0x00010000 and backup_version != 0x00010001:
print("Backup protocol version is not correct.") print("Backup protocol version is not correct.")
return False return False
i += 4 i += 4
@ -475,12 +477,11 @@ def check_header(backup):
ts = int.from_bytes(backup[i:i+8], 'little') / 1000 ts = int.from_bytes(backup[i:i+8], 'little') / 1000
print("Timestamp: {} / {}".format(ts, datetime.utcfromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S'))) print("Timestamp: {} / {}".format(ts, datetime.utcfromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')))
if (datetime.utcfromtimestamp(ts) - datetime.now()).total_seconds() > 600: if (datetime.utcfromtimestamp(ts) - datetime.now()).total_seconds() > 600:
print("Backup timestamp is in the future. Is the RTC and timezone set correctly on the device?") print("WARNING: Backup timestamp is in the future. Is the RTC and timezone set correctly on the device?")
print("Note: UTC time of the host must not be more than 10 minutes ahead of the device") # return False # non-fatal, because we have hash checks now
return False
if datetime.utcfromtimestamp(ts).year < 2021: if datetime.utcfromtimestamp(ts).year < 2021:
print("Backup timestamp is from before 2021. Is the RTC and timezone set correctly on the device?") print("WARNING: Backup timestamp is from before 2021. Is the RTC and timezone set correctly on the device?")
return False # return False
i += 8 i += 8
lcode = int.from_bytes(backup[i:i+4], 'little') lcode = int.from_bytes(backup[i:i+4], 'little')
print("Language code: {}".format(lcode)) print("Language code: {}".format(lcode))
@ -494,8 +495,15 @@ def check_header(backup):
i += 4 i += 4
print("DNA: 0x{:x}".format(int.from_bytes(backup[i:i+8], 'little'))) print("DNA: 0x{:x}".format(int.from_bytes(backup[i:i+8], 'little')))
i += 8 i += 8
i += 48 # reserved checksum_region_len = int.from_bytes(backup[i:i+4], 'little') * 4096
print("Checksum region length: 0x{:x}".format(checksum_region_len))
i += 4
total_checksums = int.from_bytes(backup[i:i+4], 'little') + 1
print("Number of checksums, including the header checksum itself: {}".format(total_checksums))
i += 4
header_total_size = int.from_bytes(backup[i:i+4], 'little')
print("Header total length in bytes: {}".format(header_total_size))
i += 36 # reserved
backup[i:i+4] = (2).to_bytes(4, 'little') backup[i:i+4] = (2).to_bytes(4, 'little')
op = int.from_bytes(backup[i:i+4], 'little') op = int.from_bytes(backup[i:i+4], 'little')
print("Opcode (should be 2, to trigger the next phase of restore): {}".format(op)) print("Opcode (should be 2, to trigger the next phase of restore): {}".format(op))
@ -503,6 +511,27 @@ def check_header(backup):
print("Opcode is incorrect.") print("Opcode is incorrect.")
return False return False
if backup_version == 0x10001:
print("Checksums found in backup image, checking...")
PT_HEADER_LEN = 4 + 16 * 4 + 4 + 8 + 64 + 4 + 4
NONCE_LEN = 12
CT_LEN = PT_HEADER_LEN + 1024 + 64
TAG_LEN = 16
COMMIT_NONCE_LEN = 32
COMMIT_LEN = 32
CHECKSUM_LEN = 32
checksum_loc = PT_HEADER_LEN + NONCE_LEN + CT_LEN + TAG_LEN + COMMIT_NONCE_LEN + COMMIT_LEN
check_region = backup[:checksum_loc]
checksum = backup[checksum_loc:checksum_loc + CHECKSUM_LEN]
hasher = SHA512.new(truncate="256")
hasher.update(check_region)
computed_checksum = hasher.digest()
if computed_checksum != checksum:
print("Header failed hash integrity check!")
return False
# TODO: checksums on data region
print("Backup header passes sanity check!") print("Backup header passes sanity check!")
return True return True