mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
add routines for shuttling encrypted data to/from swap RAM region
RAM is assumed to be off-chip, and thus the data is encrypted in the region. We also encrypt it in the Precursor case, even though it's on-chip, because we want to capture this as a test case in a known working environment. Also incorporate some routines to generate the per-boot random key for swap encryption.
This commit is contained in:
parent
c07f33a169
commit
bd54417e44
2 changed files with 209 additions and 15 deletions
|
|
@ -3,12 +3,17 @@ use core::mem::size_of;
|
|||
use aes_gcm_siv::{AeadInPlace, Aes256GcmSiv, KeyInit, Nonce, Tag};
|
||||
use cramium_hal::ifram::IframRange;
|
||||
use cramium_hal::iox::*;
|
||||
use cramium_hal::sce;
|
||||
use cramium_hal::udma::*;
|
||||
use rand_chacha::rand_core::RngCore;
|
||||
use rand_chacha::rand_core::SeedableRng;
|
||||
use rand_chacha::ChaCha8Rng;
|
||||
|
||||
use crate::bootconfig::BootConfig;
|
||||
use crate::platform::{SPIM_FLASH_IFRAM_ADDR, SPIM_RAM_IFRAM_ADDR};
|
||||
use crate::println;
|
||||
use crate::swap::*;
|
||||
use crate::PAGE_SIZE;
|
||||
|
||||
/// hard coded at offset 0 of SPI FLASH for now, until we figure out if and how to move this around.
|
||||
const SWAP_IMG_START: usize = 0;
|
||||
|
|
@ -20,11 +25,16 @@ pub struct SwapHal {
|
|||
// overflow AAD with panic if it's longer than this!
|
||||
aad_storage: [u8; 64],
|
||||
aad_len: usize,
|
||||
cipher: Aes256GcmSiv,
|
||||
src_cipher: Aes256GcmSiv,
|
||||
flash_spim: Spim,
|
||||
ram_spim: Spim,
|
||||
iox: Iox,
|
||||
udma_global: GlobalConfig,
|
||||
swap_start: usize,
|
||||
swap_len: usize,
|
||||
swap_mac_start: usize,
|
||||
swap_mac_len: usize,
|
||||
dst_cipher: Aes256GcmSiv,
|
||||
buf: RawPage,
|
||||
}
|
||||
|
||||
|
|
@ -219,6 +229,33 @@ impl SwapHal {
|
|||
// fetch the header
|
||||
flash_spim.mem_read(SWAP_IMG_START as u32, &mut buf.data);
|
||||
|
||||
// compute offsets for swap
|
||||
let mac_size = (swap.ram_size as usize / 4096) * size_of::<Tag>();
|
||||
let mac_size_to_page = (mac_size + (PAGE_SIZE - 1)) / PAGE_SIZE;
|
||||
let ram_size_actual = (swap.ram_size as usize & !(PAGE_SIZE - 1)) - mac_size_to_page;
|
||||
|
||||
// generate a random key for swap
|
||||
let mut trng = sce::trng::Trng::new(utralib::generated::HW_TRNG_BASE as usize);
|
||||
trng.setup_raw_generation(256);
|
||||
let mut seed = 0u64;
|
||||
seed |= trng.get_u32().expect("TRNG error") as u64;
|
||||
seed |= (trng.get_u32().expect("TRNG error") as u64) << 32;
|
||||
let mut cstrng = ChaCha8Rng::seed_from_u64(seed);
|
||||
// accumulate more TRNG data, because I don't trust it.
|
||||
// 1. whiten the existing TRNG data with ChaCha8
|
||||
// 2. XOR in another 32 bits of TRNG data
|
||||
// 3. create a new ChaCha8 from the resulting data
|
||||
for _ in 0..16 {
|
||||
seed = cstrng.next_u64();
|
||||
seed ^= trng.get_u32().expect("TRNG error") as u64;
|
||||
cstrng = ChaCha8Rng::seed_from_u64(seed);
|
||||
}
|
||||
// now we might have a properly seeded cryptographically secure TRNG...
|
||||
let mut dest_key = [0u8; 32];
|
||||
for word in dest_key.chunks_mut(core::mem::size_of::<u32>()) {
|
||||
word.copy_from_slice(&cstrng.next_u32().to_be_bytes());
|
||||
}
|
||||
|
||||
// safety: buf.data is aligned to 4096-byte boundary and filled with initialized data
|
||||
let ssh: &SwapSourceHeader = unsafe { &*(buf.data.as_ptr() as *const &SwapSourceHeader) };
|
||||
let mut hal = SwapHal {
|
||||
|
|
@ -227,11 +264,16 @@ impl SwapHal {
|
|||
partial_nonce: [0u8; 8],
|
||||
aad_storage: [0u8; 64],
|
||||
aad_len: 0,
|
||||
cipher: Aes256GcmSiv::new((&swap.key).into()),
|
||||
src_cipher: Aes256GcmSiv::new((&swap.key).into()),
|
||||
flash_spim,
|
||||
ram_spim,
|
||||
iox,
|
||||
udma_global,
|
||||
swap_start: 0,
|
||||
swap_len: ram_size_actual,
|
||||
swap_mac_start: ram_size_actual,
|
||||
swap_mac_len: mac_size,
|
||||
dst_cipher: Aes256GcmSiv::new((&dest_key).into()),
|
||||
buf,
|
||||
};
|
||||
hal.aad_storage[..ssh.aad_len as usize].copy_from_slice(&ssh.aad[..ssh.aad_len as usize]);
|
||||
|
|
@ -245,7 +287,7 @@ impl SwapHal {
|
|||
|
||||
fn aad(&self) -> &[u8] { &self.aad_storage[..self.aad_len] }
|
||||
|
||||
pub fn decrypt_page_at(&mut self, offset: usize) -> &[u8] {
|
||||
pub fn decrypt_src_page_at(&mut self, offset: usize) -> &[u8] {
|
||||
assert!((offset & 0xFFF) == 0, "offset is not page-aligned");
|
||||
self.flash_spim.mem_read((self.image_start + offset) as u32, &mut self.buf.data);
|
||||
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||
|
|
@ -259,14 +301,70 @@ impl SwapHal {
|
|||
aad[..self.aad_len].copy_from_slice(self.aad());
|
||||
self.flash_spim
|
||||
.mem_read((self.image_mac_start + (offset / 4096) * size_of::<Tag>()) as u32, &mut tag);
|
||||
match self.cipher.decrypt_in_place_detached(
|
||||
match self.src_cipher.decrypt_in_place_detached(
|
||||
Nonce::from_slice(&nonce),
|
||||
&aad[..self.aad_len],
|
||||
&mut self.buf.data,
|
||||
(&tag).into(),
|
||||
) {
|
||||
Ok(_) => &self.buf.data,
|
||||
Err(e) => panic!("Decryption error in swap: {:?}", e),
|
||||
Err(e) => panic!("Decryption error from swap image: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn buf_as_mut(&mut self) -> &mut [u8] { &mut self.buf.data }
|
||||
|
||||
pub fn buf_as_ref(&self) -> &[u8] { &self.buf.data }
|
||||
|
||||
/// Swap count is fixed at 0 by this routine. The data to be encrypted is
|
||||
/// assumed to already be in `self.buf`
|
||||
pub fn encrypt_swap_to(&mut self, buf: &mut [u8], dest_offset: usize, src_vaddr: usize, src_pid: u8) {
|
||||
assert!(buf.len() == PAGE_SIZE);
|
||||
assert!(dest_offset & (PAGE_SIZE - 1) == 0);
|
||||
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||
nonce[0..4].copy_from_slice(&[0u8; 4]); // this is the `swap_count` field
|
||||
nonce[5] = src_pid;
|
||||
let ppage_masked = dest_offset & !(PAGE_SIZE - 1);
|
||||
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
|
||||
let vpage_masked = src_vaddr & !(PAGE_SIZE - 1);
|
||||
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
|
||||
let aad: &[u8] = &[];
|
||||
match self.src_cipher.encrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf) {
|
||||
Ok(tag) => {
|
||||
self.ram_spim.mem_ram_write(dest_offset as u32, buf);
|
||||
self.ram_spim.mem_ram_write(
|
||||
(self.swap_mac_start + (dest_offset / PAGE_SIZE) * size_of::<Tag>()) as u32,
|
||||
tag.as_slice(),
|
||||
);
|
||||
}
|
||||
Err(e) => panic!("Encryption error to swap ram: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
/// Swap count is fixed at 0 by this routine. The data to be encrypted is
|
||||
/// assumed to already be in `self.buf`
|
||||
pub fn decrypt_swap_from(&mut self, src_offset: usize, dst_vaddr: usize, dst_pid: u8) -> &[u8] {
|
||||
assert!(src_offset & (PAGE_SIZE - 1) == 0);
|
||||
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||
nonce[0..4].copy_from_slice(&[0u8; 4]); // this is the `swap_count` field
|
||||
nonce[5] = dst_pid;
|
||||
let ppage_masked = src_offset & !(PAGE_SIZE - 1);
|
||||
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
|
||||
let vpage_masked = dst_vaddr & !(PAGE_SIZE - 1);
|
||||
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
|
||||
let aad: &[u8] = &[];
|
||||
let mut tag = [0u8; size_of::<Tag>()];
|
||||
self.ram_spim
|
||||
.mem_read((self.swap_mac_start + (src_offset / PAGE_SIZE) * size_of::<Tag>()) as u32, &mut tag);
|
||||
self.ram_spim.mem_read(src_offset as u32, &mut self.buf.data);
|
||||
match self.src_cipher.decrypt_in_place_detached(
|
||||
Nonce::from_slice(&nonce),
|
||||
aad,
|
||||
&mut self.buf.data,
|
||||
(&tag).into(),
|
||||
) {
|
||||
Ok(_) => &self.buf.data,
|
||||
Err(e) => panic!("Decryption error from swap ram: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,17 +1,23 @@
|
|||
use core::mem::size_of;
|
||||
|
||||
use aes_gcm_siv::{AeadInPlace, Aes256GcmSiv, KeyInit, Nonce, Tag};
|
||||
use utralib::generated::*;
|
||||
|
||||
use super::RAM_BASE;
|
||||
use crate::bootconfig::BootConfig;
|
||||
use crate::println;
|
||||
use crate::swap::*;
|
||||
use crate::PAGE_SIZE;
|
||||
|
||||
pub struct SwapHal {
|
||||
data_area: &'static [u8],
|
||||
mac_area: &'static [u8],
|
||||
src_data_area: &'static [u8],
|
||||
src_mac_area: &'static [u8],
|
||||
partial_nonce: [u8; 8],
|
||||
aad: &'static [u8],
|
||||
cipher: Aes256GcmSiv,
|
||||
src_cipher: Aes256GcmSiv,
|
||||
dst_data_area: &'static mut [u8],
|
||||
dst_mac_area: &'static mut [u8],
|
||||
dst_cipher: Aes256GcmSiv,
|
||||
buf: RawPage,
|
||||
}
|
||||
|
||||
|
|
@ -23,13 +29,35 @@ impl SwapHal {
|
|||
let ssh: &SwapSourceHeader =
|
||||
unsafe { (swap.flash_offset as *const SwapSourceHeader).as_ref().unwrap() };
|
||||
let swap_len = ssh.mac_offset as usize;
|
||||
|
||||
// compute the MAC area needed for the total RAM size. This is a slight over-estimate
|
||||
// because once we remove the MAC area, we need even less storage, but it's a small error.
|
||||
let mac_size = (swap.ram_size as usize / 4096) * size_of::<Tag>();
|
||||
let mac_size_to_page = (mac_size + (PAGE_SIZE - 1)) / PAGE_SIZE;
|
||||
let ram_size_actual = (swap.ram_size as usize & !(PAGE_SIZE - 1)) - mac_size_to_page;
|
||||
|
||||
// access the hardware TRNG manually to generate a per-boot random key for RAM swap
|
||||
let trng = CSR::new(utra::trng_kernel::HW_TRNG_KERNEL_BASE as *mut u32);
|
||||
for _ in 0..4 {
|
||||
// wait until the urandom port is initialized
|
||||
while trng.rf(utra::trng_kernel::URANDOM_VALID_URANDOM_VALID) == 0 {}
|
||||
// pull a dummy piece of data
|
||||
trng.rf(utra::trng_kernel::URANDOM_URANDOM);
|
||||
}
|
||||
let mut ram_swap_key = [0u8; 32];
|
||||
for word in ram_swap_key.chunks_exact_mut(core::mem::size_of::<u32>()) {
|
||||
while trng.rf(utra::trng_kernel::URANDOM_VALID_URANDOM_VALID) == 0 {}
|
||||
let r = trng.rf(utra::trng_kernel::URANDOM_URANDOM);
|
||||
word.copy_from_slice(&r.to_be_bytes())
|
||||
}
|
||||
|
||||
let mut hal = SwapHal {
|
||||
// safety: the swap raw array is guaranteed to be correctly aligned by the image maker
|
||||
data_area: unsafe {
|
||||
src_data_area: unsafe {
|
||||
core::slice::from_raw_parts((swap.flash_offset as usize + 4096) as *const u8, swap_len)
|
||||
},
|
||||
// safety: the mac raw array is guaranteed to be correctly aligned by the image maker
|
||||
mac_area: unsafe {
|
||||
src_mac_area: unsafe {
|
||||
core::slice::from_raw_parts(
|
||||
(ssh.mac_offset + swap.flash_offset + 4096) as *const u8,
|
||||
(swap_len / 4096) * size_of::<Tag>(),
|
||||
|
|
@ -37,7 +65,21 @@ impl SwapHal {
|
|||
},
|
||||
partial_nonce: [0u8; 8],
|
||||
aad: &ssh.aad[..ssh.aad_len as usize],
|
||||
cipher: Aes256GcmSiv::new((&swap.key).into()),
|
||||
src_cipher: Aes256GcmSiv::new((&swap.key).into()),
|
||||
// safety: the ram swap area is guaranteed aligned by the ram_offset specifier, and our
|
||||
// calculations on lengths ensure area alignment
|
||||
dst_data_area: unsafe {
|
||||
core::slice::from_raw_parts_mut(swap.ram_offset as *mut u8, ram_size_actual)
|
||||
},
|
||||
// safety: the ram swap area is guaranteed aligned by the ram_offset specifier, and our
|
||||
// calculations on lengths ensure area alignment
|
||||
dst_mac_area: unsafe {
|
||||
core::slice::from_raw_parts_mut(
|
||||
(swap.ram_offset as usize + ram_size_actual) as *mut u8,
|
||||
mac_size,
|
||||
)
|
||||
},
|
||||
dst_cipher: Aes256GcmSiv::new(&ram_swap_key.into()),
|
||||
buf: RawPage { data: [0u8; 4096] },
|
||||
};
|
||||
hal.partial_nonce.copy_from_slice(&ssh.parital_nonce);
|
||||
|
|
@ -47,21 +89,21 @@ impl SwapHal {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn decrypt_page_at(&mut self, offset: usize) -> &[u8] {
|
||||
pub fn decrypt_src_page_at(&mut self, offset: usize) -> &[u8] {
|
||||
assert!((offset & 0xFFF) == 0, "offset is not page-aligned");
|
||||
// println!("data area: {:x?}", &self.data_area[..4]);
|
||||
// println!("offset: {:x}", offset);
|
||||
self.buf.data.copy_from_slice(&self.data_area[offset..offset + 4096]);
|
||||
self.buf.data.copy_from_slice(&self.src_data_area[offset..offset + 4096]);
|
||||
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||
nonce[..4].copy_from_slice(&(offset as u32).to_be_bytes());
|
||||
nonce[4..].copy_from_slice(&self.partial_nonce);
|
||||
let tag = &self.mac_area
|
||||
let tag = &self.src_mac_area
|
||||
[(offset / 4096) * size_of::<Tag>()..(offset / 4096) * size_of::<Tag>() + size_of::<Tag>()];
|
||||
// println!("nonce: {:x?}", nonce);
|
||||
// println!("tag: {:x?}", tag);
|
||||
// println!("aad: {:x?}", self.aad);
|
||||
// println!("data: {:x?}", &self.buf.data[0..32]);
|
||||
match self.cipher.decrypt_in_place_detached(
|
||||
match self.src_cipher.decrypt_in_place_detached(
|
||||
Nonce::from_slice(&nonce),
|
||||
self.aad,
|
||||
&mut self.buf.data,
|
||||
|
|
@ -72,6 +114,60 @@ impl SwapHal {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn buf_as_mut(&mut self) -> &mut [u8] { &mut self.buf.data }
|
||||
|
||||
pub fn buf_as_ref(&self) -> &[u8] { &self.buf.data }
|
||||
|
||||
/// Swap count is fixed at 0 by this routine. The data to be encrypted is provided in
|
||||
/// `buf`, and is replaced with part of the encrypted data upon completion of the routine.
|
||||
pub fn encrypt_swap_to(&mut self, buf: &mut [u8], dest_offset: usize, src_vaddr: usize, src_pid: u8) {
|
||||
assert!(buf.len() == PAGE_SIZE);
|
||||
assert!(dest_offset & (PAGE_SIZE - 1) == 0);
|
||||
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||
nonce[0..4].copy_from_slice(&[0u8; 4]); // this is the `swap_count` field
|
||||
nonce[5] = src_pid;
|
||||
let ppage_masked = dest_offset & !(PAGE_SIZE - 1);
|
||||
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
|
||||
let vpage_masked = src_vaddr & !(PAGE_SIZE - 1);
|
||||
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
|
||||
let aad: &[u8] = &[];
|
||||
match self.src_cipher.encrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf) {
|
||||
Ok(tag) => {
|
||||
self.dst_data_area[dest_offset..dest_offset + PAGE_SIZE].copy_from_slice(buf);
|
||||
let mac_offset = (dest_offset / PAGE_SIZE) * size_of::<Tag>();
|
||||
self.dst_mac_area[mac_offset..mac_offset + size_of::<Tag>()].copy_from_slice(tag.as_slice());
|
||||
}
|
||||
Err(e) => panic!("Encryption error to swap ram: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
/// Swap count is fixed at 0 by this routine. The data to be encrypted is
|
||||
/// assumed to already be in `self.buf`
|
||||
pub fn decrypt_swap_from(&mut self, src_offset: usize, dst_vaddr: usize, dst_pid: u8) -> &[u8] {
|
||||
assert!(src_offset & (PAGE_SIZE - 1) == 0);
|
||||
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||
nonce[0..4].copy_from_slice(&[0u8; 4]); // this is the `swap_count` field
|
||||
nonce[5] = dst_pid;
|
||||
let ppage_masked = src_offset & !(PAGE_SIZE - 1);
|
||||
nonce[6..9].copy_from_slice(&(ppage_masked as u32).to_be_bytes()[..3]);
|
||||
let vpage_masked = dst_vaddr & !(PAGE_SIZE - 1);
|
||||
nonce[9..12].copy_from_slice(&(vpage_masked as u32).to_be_bytes()[..3]);
|
||||
let aad: &[u8] = &[];
|
||||
let mut tag = [0u8; size_of::<Tag>()];
|
||||
let mac_offset = (src_offset / PAGE_SIZE) * size_of::<Tag>();
|
||||
tag.copy_from_slice(&self.dst_mac_area[mac_offset..mac_offset + size_of::<Tag>()]);
|
||||
self.buf.data.copy_from_slice(&self.dst_data_area[src_offset..src_offset + PAGE_SIZE]);
|
||||
match self.src_cipher.decrypt_in_place_detached(
|
||||
Nonce::from_slice(&nonce),
|
||||
aad,
|
||||
&mut self.buf.data,
|
||||
(&tag).into(),
|
||||
) {
|
||||
Ok(_) => &self.buf.data,
|
||||
Err(e) => panic!("Decryption error from swap ram: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
/// Grabs a slice of the internal buffer. Useful for re-using the decrypted page
|
||||
/// between elements of the bootloader (saving us from redundant decrypt ops),
|
||||
/// but extremely unsafe because we have to track the use of this buffer manually.
|
||||
|
|
|
|||
Loading…
Reference in a new issue