mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +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 aes_gcm_siv::{AeadInPlace, Aes256GcmSiv, KeyInit, Nonce, Tag};
|
||||||
use cramium_hal::ifram::IframRange;
|
use cramium_hal::ifram::IframRange;
|
||||||
use cramium_hal::iox::*;
|
use cramium_hal::iox::*;
|
||||||
|
use cramium_hal::sce;
|
||||||
use cramium_hal::udma::*;
|
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::bootconfig::BootConfig;
|
||||||
use crate::platform::{SPIM_FLASH_IFRAM_ADDR, SPIM_RAM_IFRAM_ADDR};
|
use crate::platform::{SPIM_FLASH_IFRAM_ADDR, SPIM_RAM_IFRAM_ADDR};
|
||||||
use crate::println;
|
use crate::println;
|
||||||
use crate::swap::*;
|
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.
|
/// 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;
|
const SWAP_IMG_START: usize = 0;
|
||||||
|
|
@ -20,11 +25,16 @@ pub struct SwapHal {
|
||||||
// overflow AAD with panic if it's longer than this!
|
// overflow AAD with panic if it's longer than this!
|
||||||
aad_storage: [u8; 64],
|
aad_storage: [u8; 64],
|
||||||
aad_len: usize,
|
aad_len: usize,
|
||||||
cipher: Aes256GcmSiv,
|
src_cipher: Aes256GcmSiv,
|
||||||
flash_spim: Spim,
|
flash_spim: Spim,
|
||||||
ram_spim: Spim,
|
ram_spim: Spim,
|
||||||
iox: Iox,
|
iox: Iox,
|
||||||
udma_global: GlobalConfig,
|
udma_global: GlobalConfig,
|
||||||
|
swap_start: usize,
|
||||||
|
swap_len: usize,
|
||||||
|
swap_mac_start: usize,
|
||||||
|
swap_mac_len: usize,
|
||||||
|
dst_cipher: Aes256GcmSiv,
|
||||||
buf: RawPage,
|
buf: RawPage,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -219,6 +229,33 @@ impl SwapHal {
|
||||||
// fetch the header
|
// fetch the header
|
||||||
flash_spim.mem_read(SWAP_IMG_START as u32, &mut buf.data);
|
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
|
// 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 ssh: &SwapSourceHeader = unsafe { &*(buf.data.as_ptr() as *const &SwapSourceHeader) };
|
||||||
let mut hal = SwapHal {
|
let mut hal = SwapHal {
|
||||||
|
|
@ -227,11 +264,16 @@ impl SwapHal {
|
||||||
partial_nonce: [0u8; 8],
|
partial_nonce: [0u8; 8],
|
||||||
aad_storage: [0u8; 64],
|
aad_storage: [0u8; 64],
|
||||||
aad_len: 0,
|
aad_len: 0,
|
||||||
cipher: Aes256GcmSiv::new((&swap.key).into()),
|
src_cipher: Aes256GcmSiv::new((&swap.key).into()),
|
||||||
flash_spim,
|
flash_spim,
|
||||||
ram_spim,
|
ram_spim,
|
||||||
iox,
|
iox,
|
||||||
udma_global,
|
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,
|
buf,
|
||||||
};
|
};
|
||||||
hal.aad_storage[..ssh.aad_len as usize].copy_from_slice(&ssh.aad[..ssh.aad_len as usize]);
|
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] }
|
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");
|
assert!((offset & 0xFFF) == 0, "offset is not page-aligned");
|
||||||
self.flash_spim.mem_read((self.image_start + offset) as u32, &mut self.buf.data);
|
self.flash_spim.mem_read((self.image_start + offset) as u32, &mut self.buf.data);
|
||||||
let mut nonce = [0u8; size_of::<Nonce>()];
|
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||||
|
|
@ -259,14 +301,70 @@ impl SwapHal {
|
||||||
aad[..self.aad_len].copy_from_slice(self.aad());
|
aad[..self.aad_len].copy_from_slice(self.aad());
|
||||||
self.flash_spim
|
self.flash_spim
|
||||||
.mem_read((self.image_mac_start + (offset / 4096) * size_of::<Tag>()) as u32, &mut tag);
|
.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),
|
Nonce::from_slice(&nonce),
|
||||||
&aad[..self.aad_len],
|
&aad[..self.aad_len],
|
||||||
&mut self.buf.data,
|
&mut self.buf.data,
|
||||||
(&tag).into(),
|
(&tag).into(),
|
||||||
) {
|
) {
|
||||||
Ok(_) => &self.buf.data,
|
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 core::mem::size_of;
|
||||||
|
|
||||||
use aes_gcm_siv::{AeadInPlace, Aes256GcmSiv, KeyInit, Nonce, Tag};
|
use aes_gcm_siv::{AeadInPlace, Aes256GcmSiv, KeyInit, Nonce, Tag};
|
||||||
|
use utralib::generated::*;
|
||||||
|
|
||||||
|
use super::RAM_BASE;
|
||||||
use crate::bootconfig::BootConfig;
|
use crate::bootconfig::BootConfig;
|
||||||
use crate::println;
|
use crate::println;
|
||||||
use crate::swap::*;
|
use crate::swap::*;
|
||||||
|
use crate::PAGE_SIZE;
|
||||||
|
|
||||||
pub struct SwapHal {
|
pub struct SwapHal {
|
||||||
data_area: &'static [u8],
|
src_data_area: &'static [u8],
|
||||||
mac_area: &'static [u8],
|
src_mac_area: &'static [u8],
|
||||||
partial_nonce: [u8; 8],
|
partial_nonce: [u8; 8],
|
||||||
aad: &'static [u8],
|
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,
|
buf: RawPage,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -23,13 +29,35 @@ impl SwapHal {
|
||||||
let ssh: &SwapSourceHeader =
|
let ssh: &SwapSourceHeader =
|
||||||
unsafe { (swap.flash_offset as *const SwapSourceHeader).as_ref().unwrap() };
|
unsafe { (swap.flash_offset as *const SwapSourceHeader).as_ref().unwrap() };
|
||||||
let swap_len = ssh.mac_offset as usize;
|
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 {
|
let mut hal = SwapHal {
|
||||||
// safety: the swap raw array is guaranteed to be correctly aligned by the image maker
|
// 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)
|
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
|
// 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(
|
core::slice::from_raw_parts(
|
||||||
(ssh.mac_offset + swap.flash_offset + 4096) as *const u8,
|
(ssh.mac_offset + swap.flash_offset + 4096) as *const u8,
|
||||||
(swap_len / 4096) * size_of::<Tag>(),
|
(swap_len / 4096) * size_of::<Tag>(),
|
||||||
|
|
@ -37,7 +65,21 @@ impl SwapHal {
|
||||||
},
|
},
|
||||||
partial_nonce: [0u8; 8],
|
partial_nonce: [0u8; 8],
|
||||||
aad: &ssh.aad[..ssh.aad_len as usize],
|
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] },
|
buf: RawPage { data: [0u8; 4096] },
|
||||||
};
|
};
|
||||||
hal.partial_nonce.copy_from_slice(&ssh.parital_nonce);
|
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");
|
assert!((offset & 0xFFF) == 0, "offset is not page-aligned");
|
||||||
// println!("data area: {:x?}", &self.data_area[..4]);
|
// println!("data area: {:x?}", &self.data_area[..4]);
|
||||||
// println!("offset: {:x}", offset);
|
// 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>()];
|
let mut nonce = [0u8; size_of::<Nonce>()];
|
||||||
nonce[..4].copy_from_slice(&(offset as u32).to_be_bytes());
|
nonce[..4].copy_from_slice(&(offset as u32).to_be_bytes());
|
||||||
nonce[4..].copy_from_slice(&self.partial_nonce);
|
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>()];
|
[(offset / 4096) * size_of::<Tag>()..(offset / 4096) * size_of::<Tag>() + size_of::<Tag>()];
|
||||||
// println!("nonce: {:x?}", nonce);
|
// println!("nonce: {:x?}", nonce);
|
||||||
// println!("tag: {:x?}", tag);
|
// println!("tag: {:x?}", tag);
|
||||||
// println!("aad: {:x?}", self.aad);
|
// println!("aad: {:x?}", self.aad);
|
||||||
// println!("data: {:x?}", &self.buf.data[0..32]);
|
// 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),
|
Nonce::from_slice(&nonce),
|
||||||
self.aad,
|
self.aad,
|
||||||
&mut self.buf.data,
|
&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
|
/// 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),
|
/// 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.
|
/// but extremely unsafe because we have to track the use of this buffer manually.
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue