mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
first block retrieval from swap in userspace now decrypting
that's a good, solid step forward. now need to figure out why renode crashes after this starts working (o_O);;
This commit is contained in:
parent
57bbc4b2e5
commit
100e27db42
3 changed files with 41 additions and 80 deletions
|
|
@ -1,14 +1,12 @@
|
|||
mod debug;
|
||||
mod platform;
|
||||
use core::fmt::Write;
|
||||
use std::fmt::Debug;
|
||||
|
||||
use core::fmt::{Error, Write};
|
||||
use core::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use debug::*;
|
||||
use loader::swap::{SwapSpec, SWAP_CFG_VADDR, SWAP_PT_VADDR, SWAP_RPT_VADDR};
|
||||
use num_traits::FromPrimitive;
|
||||
use platform::SwapHal;
|
||||
use utralib::*;
|
||||
|
||||
static DUART_CSR_PA: AtomicUsize = AtomicUsize::new(0);
|
||||
use platform::{SwapHal, PAGE_SIZE};
|
||||
|
||||
pub struct PtPage {
|
||||
pub entries: [u32; 1024],
|
||||
|
|
@ -36,43 +34,6 @@ pub enum Opcode {
|
|||
EvalTrim = 256,
|
||||
}
|
||||
|
||||
pub struct DebugUart {}
|
||||
impl DebugUart {
|
||||
#[cfg(feature = "debug-print")]
|
||||
pub fn putc(&mut self, c: u8) {
|
||||
let mut csr_ptr = DUART_CSR_PA.load(Ordering::SeqCst);
|
||||
// map it if it doesn't exist
|
||||
if csr_ptr == 0 {
|
||||
let debug_uart_mem = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(utra::app_uart::HW_APP_UART_BASE),
|
||||
None,
|
||||
4096,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.expect("couldn't claim the debug UART");
|
||||
DUART_CSR_PA.store(csr_ptr, Ordering::SeqCst);
|
||||
csr_ptr = debug_uart_mem.as_ptr() as usize;
|
||||
}
|
||||
let mut csr = CSR::new(csr_ptr as *mut u32);
|
||||
|
||||
// Wait until TXFULL is `0`
|
||||
while csr.r(utra::app_uart::TXFULL) != 0 {}
|
||||
csr.wfo(utra::app_uart::RXTX_RXTX, c as u32);
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "debug-print"))]
|
||||
pub fn putc(&self, _c: u8) {}
|
||||
}
|
||||
|
||||
impl Write for DebugUart {
|
||||
fn write_str(&mut self, s: &str) -> Result<(), Error> {
|
||||
for c in s.bytes() {
|
||||
self.putc(c);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// This structure contains shared state accessible between the userspace code and the blocking swap call
|
||||
/// handler.
|
||||
struct SwapperSharedState {
|
||||
|
|
@ -187,7 +148,9 @@ fn swap_handler(
|
|||
)
|
||||
.ok();
|
||||
// walk the PT to find the swap data
|
||||
let paddr_in_swap = ss.pt_walk(pid as u8, vaddr_in_pid);
|
||||
let paddr_in_swap = ss
|
||||
.pt_walk(pid as u8, vaddr_in_pid)
|
||||
.expect("Couldn't resolve swapped data. Was the page actually swapped?");
|
||||
writeln!(
|
||||
DebugUart {},
|
||||
"resolved address in swap for 0x{:x}:{} -> 0x{:x?}",
|
||||
|
|
@ -196,6 +159,14 @@ fn swap_handler(
|
|||
paddr_in_swap
|
||||
)
|
||||
.ok();
|
||||
// safety: this is only safe because the pointer we're passed from the kernel is guaranteed to be
|
||||
// a valid u8-page in memory
|
||||
let buf = unsafe { core::slice::from_raw_parts_mut(vaddr_in_swap as *mut u8, PAGE_SIZE) };
|
||||
// TODO: manage swap_count
|
||||
ss.hal
|
||||
.decrypt_swap_from(buf, 0, paddr_in_swap, vaddr_in_pid, pid)
|
||||
.expect("Decryption error: swap image corrupted, the tag does not match the data!");
|
||||
// at this point, the `buf` has our desired data, we're done, modulo updating the count.
|
||||
}
|
||||
Some(Opcode::AllocateAdvisory) => {
|
||||
let advisories = [
|
||||
|
|
|
|||
|
|
@ -1,32 +1,26 @@
|
|||
use core::fmt::Write;
|
||||
use core::mem::size_of;
|
||||
|
||||
use aes_gcm_siv::{aead::Aead, AeadInPlace, Aes256GcmSiv, Error, KeyInit, Nonce, Tag};
|
||||
use cramium_hal::udma::*;
|
||||
use loader::swap::{SwapSpec, SPIM_RAM_IFRAM_ADDR};
|
||||
use loader::swap::{SwapSpec, SPIM_RAM_IFRAM_ADDR, SWAP_HAL_VADDR};
|
||||
use num_traits::ToBytes;
|
||||
use xous::MemoryRange;
|
||||
|
||||
use crate::debug::*;
|
||||
|
||||
pub const PAGE_SIZE: usize = 4096;
|
||||
|
||||
/// This is an implementation for SMTs that are accessible only through a SPI
|
||||
/// register interface. The base and bounds must be translated to SPI accesses
|
||||
/// in a hardware-specific manner.
|
||||
pub struct SwapHal {
|
||||
ifram_range: MemoryRange,
|
||||
swap_mac_start: usize,
|
||||
cipher: Aes256GcmSiv,
|
||||
ram_spim: Spim,
|
||||
}
|
||||
impl SwapHal {
|
||||
pub fn new(spec: &SwapSpec) -> Self {
|
||||
let ifram_range = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(SPIM_RAM_IFRAM_ADDR),
|
||||
None,
|
||||
PAGE_SIZE,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.expect("Couldn't map IFRAM area into swapper");
|
||||
|
||||
// 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 = (spec.swap_len as usize / 4096) * size_of::<Tag>();
|
||||
|
|
@ -38,11 +32,11 @@ impl SwapHal {
|
|||
#[cfg(not(feature = "spi-alt-channel"))]
|
||||
let channel = SpimChannel::Channel1;
|
||||
SwapMac {
|
||||
ifram_range,
|
||||
swap_mac_start: ram_size_actual,
|
||||
cipher: Aes256GcmSiv::new((spec.key).into()),
|
||||
// safety: this is safe because the global clocks were gated on by the bootloader
|
||||
// note that also the IFRAM0 range is pre-allocated by the bootloader
|
||||
// note that also the IFRAM0 range is pre-allocated by the bootloader, and pre-mapped
|
||||
// into the correct virtual address as well.
|
||||
ram_spim: unsafe {
|
||||
Spim::new_with_ifram(
|
||||
channel,
|
||||
|
|
@ -57,7 +51,7 @@ impl SwapHal {
|
|||
1024, // this is limited by the page length
|
||||
1024,
|
||||
Some(6),
|
||||
IframRange::from_raw_parts(SPIM_RAM_IFRAM_ADDR, ifram_range.as_ptr() as usize, PAGE_SIZE),
|
||||
IframRange::from_raw_parts(SPIM_RAM_IFRAM_ADDR, SWAP_HAL_VADDR, PAGE_SIZE),
|
||||
)
|
||||
},
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,45 +1,35 @@
|
|||
use core::mem::size_of;
|
||||
|
||||
use aes_gcm_siv::{AeadInPlace, Aes256GcmSiv, Error, KeyInit, Nonce, Tag};
|
||||
use loader::swap::SwapSpec;
|
||||
use xous::MemoryRange;
|
||||
use loader::swap::{SwapSpec, SWAP_HAL_VADDR};
|
||||
|
||||
pub const PAGE_SIZE: usize = 4096;
|
||||
|
||||
/// This defines a set of functions to get and receive MACs (message
|
||||
/// authentication codes, also referred to as the tag in AES-GCM-SIV.
|
||||
pub struct SwapHal {
|
||||
swap_mem: MemoryRange,
|
||||
dst_data_area: &'static mut [u8],
|
||||
dst_mac_area: &'static mut [u8],
|
||||
cipher: Aes256GcmSiv,
|
||||
}
|
||||
impl SwapHal {
|
||||
pub fn new(spec: &SwapSpec) -> Self {
|
||||
let swap_mem = xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(spec.swap_base as usize),
|
||||
None,
|
||||
spec.swap_len as usize,
|
||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.expect("Couldn't map swap area into swapper");
|
||||
// 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 = (spec.swap_len as usize / 4096) * size_of::<Tag>();
|
||||
let mac_size_to_page = (mac_size + (PAGE_SIZE - 1)) & !(PAGE_SIZE - 1);
|
||||
let ram_size_actual = (spec.swap_len as usize & !(PAGE_SIZE - 1)) - mac_size_to_page;
|
||||
|
||||
// safety: this is safe because all values within the memory region can be represented in `u8`
|
||||
let swap_slice = swap_mem.as_mut_ptr();
|
||||
Self {
|
||||
swap_mem,
|
||||
// safety: the ram swap area is guaranteed aligned by the ram_offset specifier, and our
|
||||
// safety: the ram swap area is pre-mapped into our virtual address by the loader, and our
|
||||
// calculations on lengths ensure area alignment
|
||||
dst_data_area: unsafe { core::slice::from_raw_parts_mut(swap_slice as *mut u8, ram_size_actual) },
|
||||
// safety: the ram swap area is guaranteed aligned by the ram_offset specifier, and our
|
||||
dst_data_area: unsafe {
|
||||
core::slice::from_raw_parts_mut(SWAP_HAL_VADDR as *mut u8, ram_size_actual)
|
||||
},
|
||||
// safety: the ram swap area is pre-mapped into our virtual address by the loader, and our
|
||||
// calculations on lengths ensure area alignment
|
||||
dst_mac_area: unsafe {
|
||||
core::slice::from_raw_parts_mut((swap_slice as *mut u8).add(ram_size_actual), mac_size)
|
||||
core::slice::from_raw_parts_mut((SWAP_HAL_VADDR as *mut u8).add(ram_size_actual), mac_size)
|
||||
},
|
||||
cipher: Aes256GcmSiv::new((&spec.key).into()),
|
||||
}
|
||||
|
|
@ -87,8 +77,11 @@ impl SwapHal {
|
|||
dst_vaddr: usize,
|
||||
dst_pid: u8,
|
||||
) -> Result<(), Error> {
|
||||
// println!("Decrypt swap:");
|
||||
// println!(" offset: {:x}, vaddr: {:x}, pid: {}", src_offset, dst_vaddr, dst_pid);
|
||||
// use core::fmt::Write;
|
||||
// use crate::debug::*;
|
||||
// writeln!(DebugUart {}, "Decrypt swap:").ok();
|
||||
// writeln!(DebugUart {}, " offset: {:x}, vaddr: {:x}, pid: {}", src_offset, dst_vaddr,
|
||||
// dst_pid).ok();
|
||||
assert!(src_offset & (PAGE_SIZE - 1) == 0);
|
||||
assert!(buf.len() == PAGE_SIZE);
|
||||
|
||||
|
|
@ -103,9 +96,12 @@ impl SwapHal {
|
|||
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>()]);
|
||||
// println!("dst_mac_area: {:x?}", &self.dst_mac_area[..32]);
|
||||
// writeln!(DebugUart {}, "dst_mac_area: {:x?}", &self.dst_mac_area[..32]).ok();
|
||||
buf.copy_from_slice(&self.dst_data_area[src_offset..src_offset + PAGE_SIZE]);
|
||||
// println!("Nonce: {:x?}, tag: {:x?}", &nonce, &tag);
|
||||
self.cipher.decrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf, (&tag).into())
|
||||
// writeln!(DebugUart {}, "Nonce: {:x?}, tag: {:x?}", &nonce, &tag).ok();
|
||||
let result =
|
||||
self.cipher.decrypt_in_place_detached(Nonce::from_slice(&nonce), aad, buf, (&tag).into());
|
||||
// writeln!(DebugUart {}, "result: {:?}, buf: {:x?}", result, &buf[..16]).ok();
|
||||
result
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue