repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rmi/rec/run.rs | rmm/src/rmi/rec/run.rs | use armv9a::{define_bitfield, define_bits, define_mask};
use crate::const_assert_eq;
use crate::granule::GRANULE_SIZE;
use crate::rmi::error::Error;
use crate::rmi::{PMU_OVERFLOW_ACTIVE, PMU_OVERFLOW_NOT_ACTIVE};
use autopadding::*;
/// The structure holds data passsed between the Host and the RMM
/// on Realm Execution Context (REC) entry and exit.
#[repr(C)]
#[derive(Default, Copy, Clone)]
pub struct Run {
entry: Entry,
exit: Exit,
}
const_assert_eq!(core::mem::size_of::<Run>(), GRANULE_SIZE);
pad_struct_and_impl_default!(
struct Entry {
0x0 flags: u64,
0x200 gprs: [u64; NR_GPRS],
0x300 gicv3_hcr: u64,
0x308 gicv3_lrs: [u64; NR_GIC_LRS],
0x800 => @END,
}
);
pad_struct_and_impl_default!(
struct Exit {
0x0 exit_reason: u8,
0x100 esr: u64,
0x108 far: u64,
0x110 hpfar: u64,
0x200 gprs: [u64; NR_GPRS],
0x300 gicv3_hcr: u64,
0x308 gicv3_lrs: [u64; NR_GIC_LRS],
0x388 gicv3_misr: u64,
0x390 gicv3_vmcr: u64,
0x400 cntp_ctl: u64,
0x408 cntp_cval: u64,
0x410 cntv_ctl: u64,
0x418 cntv_cval: u64,
0x500 ripas_base: u64,
0x508 ripas_top: u64,
0x510 ripas_value: u8,
0x600 imm: u16,
0x700 pmu_ovf: u8,
0x800 => @END,
}
);
impl Run {
pub fn entry_flags(&self) -> EntryFlag {
EntryFlag::new(self.entry.flags)
}
pub fn entry_gpr(&self, idx: usize) -> Result<u64, Error> {
if idx >= NR_GPRS {
error!("out of index: {}", idx);
return Err(Error::RmiErrorInput);
}
Ok(self.entry.gprs[idx])
}
pub fn entry_gic_lrs(&self) -> &[u64; 16] {
&self.entry.gicv3_lrs
}
pub fn entry_gic_hcr(&self) -> u64 {
self.entry.gicv3_hcr
}
pub fn exit_gic_lrs_mut(&mut self) -> &mut [u64; 16] {
&mut self.exit.gicv3_lrs
}
pub fn set_imm(&mut self, imm: u16) {
self.exit.imm = imm;
}
pub fn set_exit_reason(&mut self, exit_reason: u8) {
self.exit.exit_reason = exit_reason;
}
pub fn set_esr(&mut self, esr: u64) {
self.exit.esr = esr;
}
pub fn set_far(&mut self, far: u64) {
self.exit.far = far;
}
pub fn set_hpfar(&mut self, hpfar: u64) {
self.exit.hpfar = hpfar;
}
pub fn set_gpr(&mut self, idx: usize, val: u64) -> Result<(), Error> {
if idx >= NR_GPRS {
error!("out of index: {}", idx);
return Err(Error::RmiErrorInput);
}
self.exit.gprs[idx] = val;
Ok(())
}
pub fn set_ripas(&mut self, base: u64, top: u64, state: u8) {
self.exit.ripas_base = base;
self.exit.ripas_top = top;
self.exit.ripas_value = state;
}
pub fn set_gic_lrs(&mut self, src: &[u64], len: usize) {
self.exit.gicv3_lrs.copy_from_slice(&src[..len])
}
pub fn set_gic_misr(&mut self, val: u64) {
self.exit.gicv3_misr = val;
}
pub fn set_gic_vmcr(&mut self, val: u64) {
self.exit.gicv3_vmcr = val;
}
pub fn set_gic_hcr(&mut self, val: u64) {
self.exit.gicv3_hcr = val;
}
pub fn set_cntv_ctl(&mut self, val: u64) {
self.exit.cntv_ctl = val;
}
pub fn set_cntv_cval(&mut self, val: u64) {
self.exit.cntv_cval = val;
}
pub fn set_cntp_ctl(&mut self, val: u64) {
self.exit.cntp_ctl = val;
}
pub fn set_cntp_cval(&mut self, val: u64) {
self.exit.cntp_cval = val;
}
pub fn set_pmu_overflow(&mut self, val: bool) {
if val {
self.exit.pmu_ovf = PMU_OVERFLOW_ACTIVE;
} else {
self.exit.pmu_ovf = PMU_OVERFLOW_NOT_ACTIVE;
}
}
pub fn exit_reason(&self) -> u8 {
self.exit.exit_reason
}
pub fn gpr(&self, idx: usize) -> Result<u64, Error> {
if idx >= NR_GPRS {
error!("out of index: {}", idx);
return Err(Error::RmiErrorInput);
}
Ok(self.exit.gprs[idx])
}
pub fn ripas(&self) -> (u64, u64) {
(self.exit.ripas_base, self.exit.ripas_top)
}
}
#[cfg(fuzzing)]
impl Run {
pub fn set_entry_flags(&mut self, flags: u64) {
self.entry.flags = flags;
}
pub fn set_entry_gpr(&mut self, idx: usize, val: u64) -> Result<(), Error> {
if idx >= NR_GPRS {
error!("out of index: {}", idx);
return Err(Error::RmiErrorInput);
}
self.entry.gprs[idx] = val;
Ok(())
}
pub fn set_entry_gic_hcr(&mut self, val: u64) {
self.entry.gicv3_hcr = val;
}
pub fn set_entry_gic_lrs(&mut self, src: &[u64], len: usize) {
self.entry.gicv3_lrs.copy_from_slice(&src[..len])
}
}
impl core::fmt::Debug for Run {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("rec::Run")
.field("entry::flags", &format_args!("{:#X}", &self.entry.flags))
.field("entry::gprs", &self.entry.gprs)
.field(
"entry::gicv3_hcr",
&format_args!("{:#X}", &self.entry.gicv3_hcr),
)
.field("entry::gicv3_lrs", &self.entry.gicv3_lrs)
.field("exit::exit_reason", &self.exit.exit_reason)
.field("exit::imm", &self.exit.imm)
.field("exit::cntp_ctl", &self.exit.cntp_ctl)
.field("exit::cntp_cval", &self.exit.cntp_cval)
.field("exit::cntv_ctl", &self.exit.cntv_ctl)
.field("exit::cntv_cval", &self.exit.cntv_cval)
.field("exit::gpr0", &self.exit.gprs[0])
.finish()
}
}
// EntryFlag corresponds to the RmiRecEnterFlags fieldset in the spec document,
// containing flags provided by the Host during REC entry.
define_bits!(
EntryFlag,
// RIPAS_RESPONSE: Host response to RIPAS change request.
// val 0: Host accepted the Realm request.
// val 1: Host rejected the Realm request.
RIPAS_RESPONSE[4 - 4],
// TRAP_WFE: Whether to trap WFE execution by the Realm.
// val 0: Trap is disabled.
// val 1: Trap is enabled.
TRAP_WFE[3 - 3],
// TRAP_WFI: Whether to trap WFI execution by the Realm.
// val 0: Trap is disabled.
// val 1: Trap is enabled.
TRAP_WFI[2 - 2],
// INJECT_SEA: Whether to inject a Synchronous External Abort (SEA) into the Realm.
// val 0: Do not inject an SEA into the Realm.
// val 1: Inject an SEA into the Realm.
INJECT_SEA[1 - 1],
// EMUL_MMIO: Whether the host has completed emulation for an Emulatable Data Abort.
// val 0: Host has not completed emulation for an Emulatable Abort.
// val 1: Host has completed emulation for an Emulatable Abort.
EMUL_MMIO[0 - 0]
);
pub const NR_GPRS: usize = 31;
pub const NR_GIC_LRS: usize = 16;
impl Run {
pub fn verify_compliance(&self) -> Result<(), Error> {
const ICH_LR_HW_OFFSET: usize = 61;
// A6.1 Realm interrupts, HW == '0'
for lr in &self.entry.gicv3_lrs {
if lr & (1 << ICH_LR_HW_OFFSET) != 0 {
return Err(Error::RmiErrorRec);
}
}
Ok(())
}
}
impl safe_abstraction::raw_ptr::RawPtr for Run {}
impl safe_abstraction::raw_ptr::SafetyChecked for Run {}
impl safe_abstraction::raw_ptr::SafetyAssured for Run {
fn is_initialized(&self) -> bool {
// Returns `true` to maintain safety at the level preserved by the existing approach.
// TODO: It is crucial to re-evaluate whether this aspect could potentially
// lead to malfunctions related to RMM's memory safety.
true
}
fn verify_ownership(&self) -> bool {
// Returns `true` to maintain safety at the level preserved by the existing approach.
// TODO: It is crucial to re-evaluate whether this aspect could potentially
// lead to malfunctions related to RMM's memory safety.
true
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rmi/rec/exit.rs | rmm/src/rmi/rec/exit.rs | use crate::event::realmexit::*;
use crate::event::RsiHandle;
use crate::get_granule;
use crate::get_granule_if;
use crate::granule::GranuleState;
use crate::granule::GRANULE_MASK;
use crate::realm::mm::rtt::RTT_PAGE_LEVEL;
use crate::realm::mm::stage2_tte::S2TTE;
use crate::realm::rd::Rd;
use crate::rec::context::get_reg;
use crate::rec::sea::inject_sea;
use crate::rec::{
Rec, RmmRecEmulatableAbort::EmulatableAbort, RmmRecEmulatableAbort::NotEmulatableAbort,
};
use crate::rmi::error::Error;
use crate::rmi::rec::run::Run;
use crate::Monitor;
use crate::{rmi, rsi};
use armv9a::{
EsrEl2, DFSC_PERM_FAULTS, DFSC_PERM_FAULT_MASK, EMULATABLE_ABORT_MASK, INST_ABORT_MASK, ISS,
NON_EMULATABLE_ABORT_MASK, SERROR_MASK, WFX_MASK,
};
use aarch64_cpu::registers::HPFAR_EL2;
#[derive(Debug)]
enum AbortHandleType {
SeaInject,
AddrSizeFaultInject,
NonEmulatableExit,
EmulatableExit,
DataAbortExit,
}
pub fn handle_realm_exit(
realm_exit_res: [usize; 4],
rmm: &Monitor,
rec: &mut Rec<'_>,
run: &mut Run,
) -> Result<(bool, usize), Error> {
let mut return_to_ns = true;
let ret = match RecExitReason::from(realm_exit_res[0]) {
#[cfg(not(kani))]
// `rsi` is currently not reachable in model checking harnesses
RecExitReason::Sync(ExitSyncType::RSI) => {
trace!("REC_ENTER ret: {:#X?}", realm_exit_res);
let cmd = realm_exit_res[1];
let mut ret = rmi::SUCCESS;
let mut rsi_ctx = rsi::constraint::validate(cmd);
// set default value
if rmm.handle_rsi(&mut rsi_ctx, rec, run) == RsiHandle::RET_SUCCESS {
if rsi_ctx.ret_slice()[0] == rmi::SUCCESS_REC_ENTER {
return_to_ns = false;
}
ret = rsi_ctx.ret_slice()[0];
} else {
return_to_ns = false;
}
ret
}
RecExitReason::Sync(ExitSyncType::DataAbort) => {
match handle_data_abort(realm_exit_res, rec, run)? {
rmi::SUCCESS => {
run.set_exit_reason(rmi::EXIT_SYNC);
run.set_hpfar(realm_exit_res[2] as u64);
rmi::SUCCESS
}
rmi::SUCCESS_REC_ENTER => {
return_to_ns = false;
rmi::SUCCESS
}
_ => panic!("shouldn't be reached here"),
}
}
RecExitReason::IRQ => {
run.set_exit_reason(rmi::EXIT_IRQ);
run.set_esr(0);
run.set_hpfar(0);
run.set_far(0);
rmi::SUCCESS
}
RecExitReason::SError => {
run.set_exit_reason(rmi::EXIT_SERROR);
run.set_esr(realm_exit_res[1] as u64 & SERROR_MASK);
run.set_hpfar(0);
run.set_far(0);
rmi::SUCCESS
}
RecExitReason::Sync(ExitSyncType::InstAbort) => {
match handle_inst_abort(realm_exit_res, rec, run)? {
rmi::SUCCESS => {
run.set_exit_reason(rmi::EXIT_SYNC);
run.set_hpfar(realm_exit_res[2] as u64);
rmi::SUCCESS
}
rmi::SUCCESS_REC_ENTER => {
return_to_ns = false;
rmi::SUCCESS
}
_ => panic!("shouldn't be reached here"),
}
}
RecExitReason::Sync(ExitSyncType::WFx) => {
let esr_el2 = realm_exit_res[1] as u64;
run.set_exit_reason(rmi::EXIT_SYNC);
run.set_esr(esr_el2 & WFX_MASK);
run.set_hpfar(0);
run.set_far(0);
rmi::SUCCESS
}
RecExitReason::Sync(ExitSyncType::Undefined) => {
run.set_exit_reason(rmi::EXIT_SYNC);
run.set_esr(realm_exit_res[1] as u64);
run.set_hpfar(realm_exit_res[2] as u64);
let _ = match get_sys_write_val(rec, realm_exit_res[1] as u64)? {
Some(val) => run.set_gpr(0, val),
None => unimplemented!(),
};
rmi::SUCCESS
}
_ => rmi::SUCCESS,
};
Ok((return_to_ns, ret))
}
fn get_sys_write_val(rec: &Rec<'_>, esr_el2: u64) -> Result<Option<u64>, Error> {
let esr = ISS::new(esr_el2);
// direction: 0b0 - write, 0b1 - read
let direction = esr.get_masked_value(ISS::Direction);
let rt = esr.get_masked_value(ISS::Rt) as usize;
// We know that ExitSyncType::Undefined is from sys regs access trap.
// Thus, omit checking the EC again.
// MSR (read) case
if direction != 0 {
return Ok(None);
}
// MRS (write) case
let write_val = match rt == 31 {
true => 0, // xzr
false => get_reg(rec, rt)? as u64,
//rec.context.gp_regs[rt]);
};
Ok(Some(write_val))
}
fn get_write_val(rec: &Rec<'_>, esr_el2: u64) -> Result<u64, Error> {
let esr_el2 = EsrEl2::new(esr_el2);
let rt = esr_el2.get_masked_value(EsrEl2::SRT) as usize;
let write_val = match rt == 31 {
true => 0, // xzr
false => get_reg(rec, rt)? as u64 & esr_el2.get_access_size_mask(),
};
Ok(write_val)
}
fn abort_handle_type(
rd: &Rd,
exit: ExitSyncType,
esr_el2: u64,
fault_ipa: usize,
) -> Result<AbortHandleType, Error> {
let is_protected_ipa = rd.addr_in_par(fault_ipa);
let (s2tte, last_level) =
S2TTE::get_s2tte(rd, fault_ipa, RTT_PAGE_LEVEL, Error::RmiErrorRtt(0))?;
let esr = EsrEl2::new(esr_el2);
if is_protected_ipa {
if s2tte.is_assigned_empty() || s2tte.is_unassigned_empty() {
return Ok(AbortHandleType::SeaInject);
}
if s2tte.is_unassigned_ram() || s2tte.is_destroyed() {
return Ok(AbortHandleType::NonEmulatableExit);
}
} else if fault_ipa > rd.ipa_size() {
return Ok(AbortHandleType::AddrSizeFaultInject);
} else {
// for unprotected IPA
if exit == ExitSyncType::InstAbort {
return Ok(AbortHandleType::SeaInject);
}
let dfsc = esr.get_masked_value(EsrEl2::DFSC) & DFSC_PERM_FAULT_MASK;
let mut check_isv = false;
if s2tte.is_unassigned_ns()
|| (s2tte.is_assigned_ns(last_level) && dfsc == DFSC_PERM_FAULTS)
{
check_isv = true;
}
if check_isv {
if esr.get_masked_value(EsrEl2::ISV) == 1 {
return Ok(AbortHandleType::EmulatableExit);
} else {
return Ok(AbortHandleType::NonEmulatableExit);
}
}
}
Ok(AbortHandleType::DataAbortExit)
}
fn handle_data_abort(
realm_exit_res: [usize; 4],
rec: &mut Rec<'_>,
run: &mut Run,
) -> Result<usize, Error> {
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
let esr_el2 = realm_exit_res[1] as u64;
let hpfar_el2 = realm_exit_res[2] as u64;
let far_el2 = realm_exit_res[3] as u64;
let fault_ipa = hpfar_el2 & (HPFAR_EL2::FIPA.mask << HPFAR_EL2::FIPA.shift);
let fault_ipa = (fault_ipa << 8) as usize;
let ret = match abort_handle_type(&rd, ExitSyncType::DataAbort, esr_el2, fault_ipa)? {
AbortHandleType::SeaInject | AbortHandleType::AddrSizeFaultInject => {
inject_sea(rec, esr_el2, far_el2);
rmi::SUCCESS_REC_ENTER
}
AbortHandleType::NonEmulatableExit => {
rec.set_emulatable_abort(NotEmulatableAbort);
if rd.addr_in_par(fault_ipa) {
run.set_esr(esr_el2 & NON_EMULATABLE_ABORT_MASK);
} else {
run.set_esr(esr_el2 & NON_EMULATABLE_ABORT_MASK);
// FIXME: According to the RMM Spec, Non emulatable abort at unprotected ipa
// should carry ELR_EL2's IL bit. However, ACS test checks the opposite.
//run.set_esr(esr_el2 & (NON_EMULATABLE_ABORT_MASK | EsrEl2::IL));
}
run.set_far(0);
rmi::SUCCESS
}
AbortHandleType::EmulatableExit => {
if esr_el2 & EsrEl2::WNR != 0 {
let write_val = get_write_val(rec, esr_el2)?;
run.set_gpr(0, write_val)?;
}
rec.set_emulatable_abort(EmulatableAbort);
run.set_esr(esr_el2 & EMULATABLE_ABORT_MASK);
run.set_far(far_el2 & !(GRANULE_MASK as u64));
rmi::SUCCESS
}
AbortHandleType::DataAbortExit => {
rec.set_emulatable_abort(NotEmulatableAbort);
run.set_esr(esr_el2 & NON_EMULATABLE_ABORT_MASK);
run.set_far(0);
rmi::SUCCESS
}
};
Ok(ret)
}
fn handle_inst_abort(
realm_exit_res: [usize; 4],
rec: &mut Rec<'_>,
run: &mut Run,
) -> Result<usize, Error> {
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
let esr_el2 = realm_exit_res[1] as u64;
let hpfar_el2 = realm_exit_res[2] as u64;
let far_el2 = realm_exit_res[3] as u64;
let fault_ipa = hpfar_el2 & (HPFAR_EL2::FIPA.mask << HPFAR_EL2::FIPA.shift);
let fault_ipa = (fault_ipa << 8) as usize;
let ret = match abort_handle_type(&rd, ExitSyncType::InstAbort, esr_el2, fault_ipa)? {
AbortHandleType::SeaInject | AbortHandleType::AddrSizeFaultInject => {
inject_sea(rec, esr_el2, far_el2);
rmi::SUCCESS_REC_ENTER
}
AbortHandleType::NonEmulatableExit => {
run.set_esr(esr_el2 & INST_ABORT_MASK);
run.set_far(0);
rmi::SUCCESS
}
_ => panic!("Shoudn't be reaching here"),
};
Ok(ret)
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/config.rs | rmm/src/realm/config.rs | use crate::realm::mm::address::GuestPhysAddr;
use crate::realm::mm::rtt::RTT_PAGE_LEVEL;
use crate::realm::rd::{Rd, RPV_SIZE};
use crate::rmi::error::Error;
use autopadding::*;
use safe_abstraction::raw_ptr::assume_safe;
pad_struct_and_impl_default!(
pub struct RealmConfig {
0x0 ipa_width: usize, // Offset 0x0
0x8 hash_algo: u8, // Offset 0x8
0x200 rpv: [u8; RPV_SIZE], // Offset 0x200
0x1000 => @END, // The width of the RealmConfig structure is 4096 (0x1000) bytes.
}
);
impl RealmConfig {
// The below `init()` fills the object allocated in the Realm kernel with the proper
// value (ipa_width), which helps to redirect the accesses to decrypted pages.
//
// For some reason, using 33 for ipa_width causes a problem (format string bug?)
// in parsing the following kernel cmdline argument:
// `console=ttyS0 root=/dev/vda rw console=pl011,mmio,0x1c0a0000 console=ttyAMA0 printk.devkmsg=on`.
// So, we get back to use the same kernel argument with TF-RMM's one (uart0 & uart3).
pub fn init(
config_addr: usize,
ipa_width: usize,
hash_algo: u8,
rpv: &[u8],
) -> Result<(), Error> {
Ok(assume_safe::<RealmConfig>(config_addr)
.map(|mut realm_config| realm_config.init_inner(ipa_width, hash_algo, rpv))?)
}
fn init_inner(&mut self, ipa_width: usize, hash_algo: u8, rpv: &[u8]) {
self.ipa_width = ipa_width;
self.hash_algo = hash_algo;
self.rpv.copy_from_slice(rpv);
}
}
pub fn realm_config(rd: &Rd, config_ipa: usize, ipa_bits: usize) -> Result<(), Error> {
let res = rd
.s2_table()
.lock()
.ipa_to_pa(GuestPhysAddr::from(config_ipa), RTT_PAGE_LEVEL);
let hash_algo = rd.hash_algo();
let rpv = rd.personalization_value();
if let Some(pa) = res {
RealmConfig::init(pa.into(), ipa_bits, hash_algo, rpv)
} else {
Err(Error::RmiErrorInput)
}
}
impl safe_abstraction::raw_ptr::RawPtr for RealmConfig {}
impl safe_abstraction::raw_ptr::SafetyChecked for RealmConfig {}
impl safe_abstraction::raw_ptr::SafetyAssured for RealmConfig {
fn is_initialized(&self) -> bool {
// The initialization of this memory is guaranteed
// according to the RMM Specification A2.2.4 Granule Wiping.
// This instance belongs to a Data Granule and has been initialized.
true
}
fn verify_ownership(&self) -> bool {
// The instance's ownership is guaranteed while being processed by the RMM.
// While the Realm holds RW permissions for the instance,
// it cannot exercise these permissions from the moment an SMC request is made
// until the request is completed. Even in multi-core environments,
// the designated areas are protected by Stage 2 Table,
// ensuring that there are no adverse effects on RMM's memory safety.
true
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/rd.rs | rmm/src/realm/rd.rs | use vmsa::guard::Content;
use crate::measurement::{Measurement, MEASUREMENTS_SLOT_NR};
use crate::realm::mm::IPATranslation;
use crate::simd::SimdConfig;
use alloc::boxed::Box;
use alloc::collections::btree_map::BTreeMap;
use alloc::sync::Arc;
use spin::mutex::Mutex;
pub const RPV_SIZE: usize = 64;
lazy_static! {
static ref RTT_TABLES: Mutex<BTreeMap<usize, Arc<Mutex<Box<dyn IPATranslation>>>>> = {
let m = BTreeMap::new();
Mutex::new(m)
};
}
pub fn insert_rtt(id: usize, table: Arc<Mutex<Box<dyn IPATranslation>>>) {
RTT_TABLES.lock().insert(id, table);
}
#[derive(Debug)]
pub struct Rd {
vmid: u16,
state: State,
rtt_base: usize,
rtt_num_start: usize,
ipa_bits: usize,
rec_index: usize,
s2_starting_level: isize,
hash_algo: u8,
rpv: [u8; RPV_SIZE],
num_recs: usize,
pub measurements: [Measurement; MEASUREMENTS_SLOT_NR],
pub vcpu_index: usize,
metadata: Option<usize>,
simd_cfg: SimdConfig,
pmu_en: bool,
pmu_num_ctrs: usize,
}
impl Rd {
#[allow(clippy::too_many_arguments)]
pub fn init(
&mut self,
vmid: u16,
rtt_base: usize,
rtt_num_start: usize,
ipa_bits: usize,
s2_starting_level: isize,
rpv: [u8; 64],
sve_en: bool,
sve_vl: u64,
pmu_en: bool,
pmu_num_ctrs: usize,
) {
self.vmid = vmid;
self.state = State::New;
self.rtt_base = rtt_base;
self.rtt_num_start = rtt_num_start;
self.ipa_bits = ipa_bits;
self.rec_index = 0;
self.s2_starting_level = s2_starting_level;
self.measurements = [Measurement::empty(); MEASUREMENTS_SLOT_NR];
self.vcpu_index = 0;
self.rpv.copy_from_slice(rpv.as_slice());
self.metadata = None;
self.simd_cfg.sve_en = sve_en;
self.pmu_en = pmu_en;
if sve_en {
self.simd_cfg.sve_vq = sve_vl;
}
if pmu_en {
self.pmu_num_ctrs = pmu_num_ctrs;
}
self.num_recs = 0;
}
pub fn id(&self) -> usize {
self.vmid as usize
}
pub fn num_recs(&self) -> usize {
self.num_recs
}
pub fn s2_table(&self) -> Arc<Mutex<Box<dyn IPATranslation>>> {
Arc::clone(RTT_TABLES.lock().get_mut(&self.id()).unwrap())
}
pub fn state(&self) -> State {
self.state
}
pub fn set_state(&mut self, state: State) {
self.state = state;
}
pub fn at_state(&self, compared: State) -> bool {
self.state == compared
}
pub fn rtt_base(&self) -> usize {
self.rtt_base
}
pub fn rtt_num_start(&self) -> usize {
self.rtt_num_start
}
pub fn ipa_bits(&self) -> usize {
self.ipa_bits
}
pub fn pmu_config(&self) -> (bool, usize) {
(self.pmu_en, self.pmu_num_ctrs)
}
pub fn rec_index(&self) -> usize {
self.rec_index
}
pub fn s2_starting_level(&self) -> isize {
self.s2_starting_level
}
pub fn inc_recs(&mut self) {
self.num_recs += 1;
self.rec_index += 1;
}
pub fn dec_recs(&mut self) {
self.num_recs -= 1;
}
pub fn ipa_size(&self) -> usize {
1 << self.ipa_bits
}
pub fn par_size(&self) -> usize {
self.ipa_size() / 2
}
pub fn addr_in_par(&self, ipa: usize) -> bool {
ipa < self.par_size()
}
pub fn hash_algo(&self) -> u8 {
self.hash_algo
}
pub fn set_hash_algo(&mut self, alg: u8) {
self.hash_algo = alg;
}
pub fn personalization_value(&self) -> &[u8] {
self.rpv.as_slice()
}
pub fn metadata(&self) -> Option<usize> {
self.metadata
}
pub fn set_metadata(&mut self, metadata: Option<usize>) {
self.metadata = metadata
}
pub fn simd_config(&self) -> &SimdConfig {
&self.simd_cfg
}
}
impl Content for Rd {}
impl safe_abstraction::raw_ptr::RawPtr for Rd {}
impl safe_abstraction::raw_ptr::SafetyChecked for Rd {}
impl safe_abstraction::raw_ptr::SafetyAssured for Rd {
fn is_initialized(&self) -> bool {
// The initialization of this memory is guaranteed
// according to the RMM Specification A2.2.4 Granule Wiping.
// This instance belongs to a RD Granule and has been initialized.
true
}
fn verify_ownership(&self) -> bool {
// The ownership of this instance is exclusively ensured by the RMM.
// under the following conditions:
//
// 1. A lock on the given address is obtained using the `get_granule*` macros.
// 2. The instance is converted from a raw pointer through the `content*` functions.
// 3. The instance is accessed only within the lock scope.
//
// Ownership verification is guaranteed because these criteria are satisfied
// in all cases where this object is accessed.
true
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum State {
Null,
New,
Active,
SystemOff,
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/registry.rs | rmm/src/realm/registry.rs | use crate::rmi::error::Error;
use alloc::collections::BTreeSet;
use spinning_top::Spinlock;
pub static VMID_SET: Spinlock<BTreeSet<usize>> = Spinlock::new(BTreeSet::new());
pub fn remove(id: usize) -> Result<(), Error> {
VMID_SET
.lock()
.remove(&id)
.then_some(())
.ok_or(Error::RmiErrorInput)
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mod.rs | rmm/src/realm/mod.rs | pub mod config;
pub mod mm;
pub mod rd;
pub mod registry;
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/attribute.rs | rmm/src/realm/mm/attribute.rs | pub mod shareable {
pub const NON_SHAREABLE: u64 = 0b00;
pub const RESERVED: u64 = 0b01;
pub const OUTER: u64 = 0b10;
pub const INNER: u64 = 0b11;
}
pub mod permission {
pub const RW: u64 = 0b11;
pub const WO: u64 = 0b10;
pub const RO: u64 = 0b01;
pub const NONE: u64 = 0b00;
}
// MemAttr[3:2]:
// 0b01 - Normal, Outer Non-cacheable
// 0b10 - Normal, Outer Write-Through Cacheable
// 0b10 - Normal, Outer Write-Back Cacheable
// MemAttr[1:0]: if MemAttr[3:2] != 0b00
// 0b01 - Inner Non-cacheable
// 0b10 - Inner Write-Through Cacheable
// 0b11 - Inner Write-Back Cacheable
// MemAttr[1:0]: if MemAttr[3:2] == 0b00
// 0b00 - Device-nGnRnE
// 0b01 - Device-nGnRE
// 0b10 - Device-nGRE
// 0b11 - Device-GRE
pub mod memattr {
pub const NORMAL_FWB: u64 = 0b0110;
pub const NORMAL: u64 = 0b0111;
pub const NORMAL_NC: u64 = 0b0101;
pub const FWB_RESERVED: u64 = 0b0100;
pub const DEVICE_NGNRE: u64 = 0b0001;
}
pub mod page_type {
pub const BLOCK: u64 = 0b0;
pub const TABLE_OR_PAGE: u64 = 0b1;
}
pub mod desc_type {
pub const L012_TABLE: u64 = 0x3;
pub const L012_BLOCK: u64 = 0x1;
pub const L3_PAGE: u64 = 0x3;
pub const LX_INVALID: u64 = 0x0;
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/page.rs | rmm/src/realm/mm/page.rs | use super::attribute::page_type;
use super::stage2_tte::S2TTE;
use super::table_level::{L1Table, L2Table, L3Table};
use crate::config::{HUGE_PAGE_SIZE, LARGE_PAGE_SIZE, PAGE_SIZE};
use vmsa::page::PageSize;
use vmsa::page_table::Level;
use armv9a::bits_in_reg;
#[derive(Clone, Copy)]
/// A 4 KiB page mapped in the L3Table.
pub enum BasePageSize {}
impl PageSize for BasePageSize {
const SIZE: usize = PAGE_SIZE;
const MAP_TABLE_LEVEL: usize = L3Table::THIS_LEVEL;
const MAP_EXTRA_FLAG: u64 = bits_in_reg(S2TTE::TYPE, page_type::TABLE_OR_PAGE);
}
#[derive(Clone, Copy)]
/// A 2 MiB page mapped in the L2Table.
pub enum LargePageSize {}
impl PageSize for LargePageSize {
const SIZE: usize = LARGE_PAGE_SIZE;
const MAP_TABLE_LEVEL: usize = L2Table::THIS_LEVEL;
const MAP_EXTRA_FLAG: u64 = bits_in_reg(S2TTE::TYPE, page_type::BLOCK);
}
#[derive(Clone, Copy)]
/// A 1 GiB page mapped in the L1Table.
pub enum HugePageSize {}
impl PageSize for HugePageSize {
const SIZE: usize = HUGE_PAGE_SIZE;
const MAP_TABLE_LEVEL: usize = L1Table::THIS_LEVEL;
const MAP_EXTRA_FLAG: u64 = bits_in_reg(S2TTE::TYPE, page_type::BLOCK);
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/rtt.rs | rmm/src/realm/mm/rtt.rs | use crate::granule::GRANULE_SHIFT;
use crate::granule::{set_granule, GranuleState};
use crate::measurement::HashContext;
use crate::realm::mm::address::GuestPhysAddr;
use crate::realm::mm::attribute::desc_type;
use crate::realm::mm::entry;
use crate::realm::mm::stage2_translation::{RttAllocator, Tlbi};
use crate::realm::mm::stage2_tte::{hipas, mapping_size, ripas, S2TTE};
use crate::realm::mm::stage2_tte::{
level_mask, INVALID_UNPROTECTED, TABLE_TTE, TTE_ATTR_MASK, VALID_NS_TTE, VALID_TTE,
};
use crate::realm::mm::table_level;
use crate::realm::rd::Rd;
use crate::rmi::error::Error;
use crate::rmi::rtt_entry_state;
use crate::{get_granule, get_granule_if};
use armv9a::bits_in_reg;
use vmsa::address::PhysAddr;
use vmsa::page_table::{Entry, Level, PageTable};
pub const RTT_MIN_BLOCK_LEVEL: usize = table_level::L1Table::THIS_LEVEL;
pub const RTT_PAGE_LEVEL: usize = table_level::L3Table::THIS_LEVEL;
pub const RTT_STRIDE: usize = GRANULE_SHIFT - 3;
const CHANGE_DESTROYED: u64 = 0x1;
fn level_space_size(rd: &Rd, level: usize) -> usize {
rd.s2_table().lock().space_size(level)
}
fn create_pgtbl_at(
rtt_addr: usize,
flags: u64,
mut pa: usize,
map_size: usize,
) -> Result<(), Error> {
let alloc = RttAllocator { base: rtt_addr };
let mut new_s2tte = pa as u64 | flags;
let ret = PageTable::<
GuestPhysAddr,
table_level::L3Table, //Table Level is not meaninful here
entry::Entry,
{ table_level::L3Table::NUM_ENTRIES },
>::new_init_in(&alloc, |entries| {
for e in entries.iter_mut() {
let _ = (*e).set(PhysAddr::from(pa), new_s2tte);
pa += map_size;
new_s2tte = pa as u64 | flags;
}
});
if ret.is_err() {
return Err(Error::RmiErrorRtt(0));
}
Ok(())
}
pub fn create(rd: &Rd, rtt_addr: usize, ipa: usize, level: usize) -> Result<(), Error> {
let mut invalidate = Tlbi::NONE;
let (parent_s2tte, last_level) = S2TTE::get_s2tte(rd, ipa, level - 1, Error::RmiErrorInput)?;
if last_level != level - 1 || parent_s2tte.is_table(last_level) {
return Err(Error::RmiErrorRtt(last_level));
}
let map_size = mapping_size(level);
let mut flags = parent_s2tte.get_masked(S2TTE::HIPAS);
if rd.addr_in_par(ipa) {
flags |= parent_s2tte.get_masked(S2TTE::RIPAS);
} else {
flags |= parent_s2tte.get_masked(S2TTE::NS);
}
if parent_s2tte.is_unassigned() || parent_s2tte.is_unassigned_ns() {
create_pgtbl_at(rtt_addr, flags, 0, 0)?;
} else {
// for assigned_ram or assinged_ns, set desc_type
if !parent_s2tte.is_assigned_invalid() {
if level == RTT_PAGE_LEVEL {
flags |= bits_in_reg(S2TTE::DESC_TYPE, desc_type::L3_PAGE);
} else {
flags |= bits_in_reg(S2TTE::DESC_TYPE, desc_type::L012_BLOCK);
}
invalidate = Tlbi::LEAF(rd.id());
}
let pa: usize = parent_s2tte.addr_as_block(level - 1).into(); //XXX: check this again
flags |= parent_s2tte.get_masked(TTE_ATTR_MASK);
create_pgtbl_at(rtt_addr, flags, pa, map_size)?;
}
let parent_s2tte = rtt_addr as u64 | TABLE_TTE;
rd.s2_table().lock().ipa_to_pte_set(
GuestPhysAddr::from(ipa),
level - 1,
parent_s2tte,
invalidate,
)?;
Ok(())
}
pub fn destroy<F: FnMut(usize)>(
rd: &Rd,
ipa: usize,
level: usize,
mut f: F,
) -> Result<(usize, usize), Error> {
let invalidate;
let (parent_s2tte, last_level) = S2TTE::get_s2tte(rd, ipa, level - 1, Error::RmiErrorRtt(0))?;
if (last_level != level - 1) || !parent_s2tte.is_table(last_level) {
let top_ipa = skip_non_live_entries(rd, ipa, last_level)?;
f(top_ipa);
return Err(Error::RmiErrorRtt(last_level));
}
let rtt_addr = parent_s2tte.addr_as_block(RTT_PAGE_LEVEL).into();
let mut g_rtt = get_granule_if!(rtt_addr, GranuleState::RTT)?;
// TODO: granule needs to contain its refcount info.
// Unless its ref count is 0, RTT DESTROY should fail
if is_live_rtt(rd, ipa, level).unwrap_or(false) {
f(ipa);
return Err(Error::RmiErrorRtt(level));
}
let parent_s2tte = if rd.addr_in_par(ipa) {
invalidate = Tlbi::LEAF(rd.id());
bits_in_reg(S2TTE::HIPAS, hipas::UNASSIGNED)
| bits_in_reg(S2TTE::RIPAS, ripas::DESTROYED)
| bits_in_reg(S2TTE::DESC_TYPE, desc_type::LX_INVALID)
} else {
invalidate = Tlbi::BREAKDOWN(rd.id());
bits_in_reg(S2TTE::NS, 1)
| bits_in_reg(S2TTE::HIPAS, hipas::UNASSIGNED)
| INVALID_UNPROTECTED
};
rd.s2_table().lock().ipa_to_pte_set(
GuestPhysAddr::from(ipa),
level - 1,
parent_s2tte,
invalidate,
)?;
set_granule(&mut g_rtt, GranuleState::Delegated)?;
let top_ipa = skip_non_live_entries(rd, ipa, last_level)?;
Ok((rtt_addr, top_ipa))
}
pub fn init_ripas(rd: &mut Rd, base: usize, top: usize) -> Result<usize, Error> {
// TODO: get s2tte without the level input
let level = RTT_PAGE_LEVEL;
let (s2tte, last_level) = S2TTE::get_s2tte(rd, base, level, Error::RmiErrorRtt(0))?;
let map_size = mapping_size(last_level);
let mut addr = base & !(map_size - 1);
if addr != base {
warn!("base is not aligned");
return Err(Error::RmiErrorRtt(last_level));
}
if top != (top & !(map_size - 1)) {
warn!("top is not aligned");
return Err(Error::RmiErrorRtt(last_level));
}
if s2tte.get_masked_value(S2TTE::HIPAS) != hipas::UNASSIGNED {
warn!("base is assigned already");
return Err(Error::RmiErrorRtt(last_level));
}
let space_size = level_space_size(rd, last_level);
let top_addr = (addr & !(space_size - 1)) + space_size;
while addr < top_addr {
let next = addr + map_size;
if next > top {
break;
}
let (s2tte, last_level) = S2TTE::get_s2tte(rd, addr, level, Error::RmiErrorRtt(0))?;
if s2tte.is_table(last_level) || s2tte.get_masked_value(S2TTE::HIPAS) == hipas::ASSIGNED {
break;
}
let new_s2tte =
bits_in_reg(S2TTE::HIPAS, hipas::UNASSIGNED) | bits_in_reg(S2TTE::RIPAS, ripas::RAM);
rd.s2_table().lock().ipa_to_pte_set(
GuestPhysAddr::from(addr),
last_level,
new_s2tte,
Tlbi::NONE,
)?;
#[cfg(not(kani))]
// `rsi` is currently not reachable in model checking harnesses
HashContext::new(rd)?.measure_ripas_granule(addr as u64, next as u64)?;
addr += map_size;
}
if addr > base {
Ok(addr)
} else {
Err(Error::RmiErrorRtt(last_level))
}
}
// return (out_top, ripas)
pub fn get_ripas(rd: &Rd, start: usize, end: usize) -> Result<(usize, u64), Error> {
let level = RTT_PAGE_LEVEL;
let mut addr = start;
let mut common_ripas = 0; // initialized in the below if condition (addr == start)
let mut map_size = 0; // initialized in the below if condition (addr == start)
while addr < end {
let (s2tte, last_level) = S2TTE::get_s2tte(rd, addr, level, Error::RmiErrorRtt(0))?;
if !s2tte.has_ripas(level) {
break;
}
let ripas = s2tte.get_ripas();
if addr == start {
common_ripas = ripas;
map_size = mapping_size(last_level);
} else if common_ripas != ripas {
break;
}
addr += map_size;
}
if addr == start {
return Err(Error::RmiErrorInput);
}
Ok((addr, common_ripas))
}
pub fn read_entry(rd: &Rd, ipa: usize, level: usize) -> Result<[usize; 4], Error> {
let (s2tte, last_level) = S2TTE::get_s2tte(rd, ipa, level, Error::RmiErrorRtt(0))?;
let r1 = last_level;
let (mut r2, mut r3, mut r4) = (0, 0, 0);
if s2tte.is_unassigned() {
r2 = rtt_entry_state::RMI_UNASSIGNED;
r4 = s2tte.get_masked_value(S2TTE::RIPAS) as usize;
} else if s2tte.is_assigned() {
r2 = rtt_entry_state::RMI_ASSIGNED;
r3 = s2tte.addr_as_block(last_level).into(); //XXX: check this again
r4 = s2tte.get_masked_value(S2TTE::RIPAS) as usize;
} else if s2tte.is_table(last_level) {
r2 = rtt_entry_state::RMI_TABLE;
r3 = s2tte.get_masked(S2TTE::ADDR_TBL_OR_PAGE); //XXX: check this again
} else if s2tte.is_unassigned_ns() {
r2 = rtt_entry_state::RMI_UNASSIGNED;
} else if s2tte.is_assigned_ns(last_level) {
r2 = rtt_entry_state::RMI_ASSIGNED;
let addr_mask: u64 = level_mask(last_level).ok_or(Error::RmiErrorRtt(0))?;
let mask = addr_mask | S2TTE::MEMATTR | S2TTE::S2AP;
r3 = s2tte.get_masked(mask);
} else {
error!("Unexpected S2TTE value retrieved!");
}
Ok([r1, r2, r3 as usize, r4])
}
pub fn map_unprotected(rd: &Rd, ipa: usize, level: usize, host_s2tte: usize) -> Result<(), Error> {
if rd.addr_in_par(ipa) {
return Err(Error::RmiErrorInput);
}
// TODO: should return actual last level, not level 0
let (s2tte, last_level) = S2TTE::get_s2tte(rd, ipa, level, Error::RmiErrorRtt(0))?;
if level != last_level {
return Err(Error::RmiErrorRtt(last_level));
}
if !s2tte.is_unassigned_ns() {
return Err(Error::RmiErrorRtt(level));
}
let host_s2tte = S2TTE::new(host_s2tte as u64);
let mut new_s2tte = host_s2tte.get_masked(S2TTE::ADDR_TBL_OR_PAGE)
| host_s2tte.get_masked(S2TTE::MEMATTR)
| host_s2tte.get_masked(S2TTE::S2AP)
| bits_in_reg(S2TTE::HIPAS, hipas::ASSIGNED);
if level == RTT_PAGE_LEVEL {
new_s2tte |= VALID_NS_TTE | bits_in_reg(S2TTE::DESC_TYPE, desc_type::L3_PAGE);
} else {
new_s2tte |= VALID_NS_TTE | bits_in_reg(S2TTE::DESC_TYPE, desc_type::L012_BLOCK);
}
rd.s2_table().lock().ipa_to_pte_set(
GuestPhysAddr::from(ipa),
level,
new_s2tte,
Tlbi::LEAF(rd.id()),
)?;
Ok(())
}
pub fn unmap_unprotected<F: FnMut(usize)>(
rd: &Rd,
ipa: usize,
level: usize,
mut f: F,
) -> Result<usize, Error> {
if rd.addr_in_par(ipa) {
return Err(Error::RmiErrorInput);
}
let (s2tte, last_level) = S2TTE::get_s2tte(rd, ipa, level, Error::RmiErrorRtt(0))?;
if level != last_level || !s2tte.is_assigned_ns(last_level) {
let top_ipa = skip_non_live_entries(rd, ipa, last_level)?;
f(top_ipa);
return Err(Error::RmiErrorRtt(last_level));
}
let new_s2tte: u64 = bits_in_reg(S2TTE::NS, 1)
| bits_in_reg(S2TTE::HIPAS, hipas::UNASSIGNED)
| INVALID_UNPROTECTED;
rd.s2_table().lock().ipa_to_pte_set(
GuestPhysAddr::from(ipa),
level,
new_s2tte,
Tlbi::LEAF(rd.id()),
)?;
let top_ipa = skip_non_live_entries(rd, ipa, level)?;
Ok(top_ipa)
}
pub fn set_ripas(rd: &Rd, base: usize, top: usize, ripas: u8, flags: u64) -> Result<usize, Error> {
// TODO: get it from s2table with the start address
let level = RTT_PAGE_LEVEL;
let (_s2tte, level) = S2TTE::get_s2tte(rd, base, RTT_PAGE_LEVEL, Error::RmiErrorRtt(level))?;
let map_size = mapping_size(level);
let mut addr = base & !(map_size - 1);
if addr != base || top & !(map_size - 1) != top {
return Err(Error::RmiErrorRtt(level));
}
let space_size = level_space_size(rd, level);
let table_top = (addr & !(space_size - 1)) + space_size;
if table_top < top {
debug!(
"table can address upto 0x{:X}, top {:X} overlimits the range",
table_top, top
);
}
while addr < table_top && addr < top {
let mut invalidate = Tlbi::NONE;
let (s2tte, last_level) = S2TTE::get_s2tte(rd, addr, level, Error::RmiErrorRtt(level))?;
let mut new_s2tte = 0;
let mut add_pa = false;
if s2tte.is_table(last_level) || s2tte.is_destroyed() && flags & CHANGE_DESTROYED == 0 {
break;
}
let pa: usize = s2tte.addr_as_block(last_level).into(); //XXX: check this again
new_s2tte |= s2tte.get_masked(S2TTE::HIPAS);
new_s2tte |= bits_in_reg(S2TTE::RIPAS, ripas as u64);
// If requested riaps == current ripas, skip it.
if ripas == s2tte.get_masked_value(S2TTE::RIPAS) as u8 {
addr += map_size;
continue;
}
if ripas as u64 == ripas::EMPTY {
if s2tte.is_assigned_ram(last_level) {
add_pa = true;
invalidate = Tlbi::LEAF(rd.id());
} else if s2tte.is_assigned_destroyed() {
add_pa = true;
}
new_s2tte |= bits_in_reg(S2TTE::DESC_TYPE, desc_type::LX_INVALID);
} else if ripas as u64 == ripas::RAM {
if s2tte.is_assigned_invalid() {
new_s2tte |= VALID_TTE;
if last_level == RTT_PAGE_LEVEL {
new_s2tte |= bits_in_reg(S2TTE::DESC_TYPE, desc_type::L3_PAGE);
} else {
new_s2tte |= bits_in_reg(S2TTE::DESC_TYPE, desc_type::L012_BLOCK);
}
add_pa = true;
}
} else {
unreachable!();
}
if add_pa {
new_s2tte |= pa as u64;
}
rd.s2_table().lock().ipa_to_pte_set(
GuestPhysAddr::from(addr),
last_level,
new_s2tte,
invalidate,
)?;
addr += map_size;
}
if addr > base {
Ok(addr)
} else {
Err(Error::RmiErrorRtt(level))
}
}
pub fn data_create(rd: &Rd, ipa: usize, target_pa: usize, unknown: bool) -> Result<(), Error> {
let level = RTT_PAGE_LEVEL;
let (s2tte, last_level) = S2TTE::get_s2tte(rd, ipa, level, Error::RmiErrorRtt(0))?;
if level != last_level {
return Err(Error::RmiErrorRtt(last_level));
}
if !s2tte.is_unassigned() {
return Err(Error::RmiErrorRtt(RTT_PAGE_LEVEL));
}
let mut new_s2tte = target_pa as u64;
if s2tte.is_ripas() {
panic!("invalid ripas");
}
let ripas = s2tte.get_ripas();
// New HIPAS: ASSIGNED
new_s2tte |= bits_in_reg(S2TTE::HIPAS, hipas::ASSIGNED);
if unknown && ripas != ripas::RAM {
// New RIPAS: Unchanged
new_s2tte |= bits_in_reg(S2TTE::RIPAS, ripas);
} else {
// New RIPAS: RAM
new_s2tte |= bits_in_reg(S2TTE::RIPAS, ripas::RAM);
new_s2tte |= bits_in_reg(S2TTE::DESC_TYPE, desc_type::L3_PAGE);
new_s2tte |= VALID_TTE;
}
rd.s2_table()
.lock()
.ipa_to_pte_set(GuestPhysAddr::from(ipa), level, new_s2tte, Tlbi::NONE)?;
Ok(())
}
pub fn data_destroy<F: FnMut(usize)>(
rd: &Rd,
ipa: usize,
mut f: F,
) -> Result<(usize, usize), Error> {
let mut invalidate = Tlbi::NONE;
let level = RTT_PAGE_LEVEL;
let (s2tte, last_level) = S2TTE::get_s2tte(rd, ipa, level, Error::RmiErrorRtt(level))?;
if last_level < level || !s2tte.is_assigned() {
let top_ipa = skip_non_live_entries(rd, ipa, last_level)?;
f(top_ipa);
return Err(Error::RmiErrorRtt(last_level));
}
let pa = s2tte.addr_as_block(last_level).into(); //XXX: check this again
let mut new_s2tte = bits_in_reg(S2TTE::HIPAS, hipas::UNASSIGNED)
| bits_in_reg(S2TTE::DESC_TYPE, desc_type::LX_INVALID);
if s2tte.get_masked(S2TTE::RIPAS) == ripas::EMPTY {
new_s2tte |= bits_in_reg(S2TTE::RIPAS, ripas::EMPTY);
} else {
new_s2tte |= bits_in_reg(S2TTE::RIPAS, ripas::DESTROYED);
}
if s2tte.is_assigned_ram(RTT_PAGE_LEVEL) {
invalidate = Tlbi::LEAF(rd.id());
}
rd.s2_table()
.lock()
.ipa_to_pte_set(GuestPhysAddr::from(ipa), level, new_s2tte, invalidate)?;
let top_ipa = skip_non_live_entries(rd, ipa, level)?;
Ok((pa, top_ipa))
}
fn is_live_rtt(rd: &Rd, base: usize, level: usize) -> Result<bool, Error> {
let binding = rd.s2_table();
let binding = binding.lock();
let (entries_iter, last_level) = binding.entries(GuestPhysAddr::from(base), level)?;
if level != last_level {
error!(
"level doesn't match! level:{:?} last_level:{:?}",
level, last_level
);
}
for entry in entries_iter {
let s2tte = S2TTE::new(entry.pte());
if s2tte.is_live(level) {
return Ok(true);
}
}
Err(Error::RmiErrorRtt(level))
}
fn skip_non_live_entries(rd: &Rd, base: usize, level: usize) -> Result<usize, Error> {
let map_size = mapping_size(level);
let mut addr = base & !(map_size - 1);
let space_size = level_space_size(rd, level);
let mut entry0_ipa = addr & !(space_size - 1);
let binding = rd.s2_table();
let binding = binding.lock();
let (entries_iter, last_level) = binding.entries(GuestPhysAddr::from(base), level)?;
if level != last_level {
warn!(
"level doesn't match! level:{:?} last_level:{:?}",
level, last_level
);
}
for entry in entries_iter {
// skip entries less than the base ipa
if entry0_ipa < base {
entry0_ipa += map_size;
continue;
}
let s2tte = S2TTE::new(entry.pte());
if s2tte.is_live(level) {
return Ok(addr);
}
addr += map_size;
}
Ok(addr)
}
pub fn fold(rd: &Rd, ipa: usize, level: usize) -> Result<usize, Error> {
let is_protected_ipa = rd.addr_in_par(ipa);
let (fold_s2tte, _last_level) = S2TTE::get_s2tte(rd, ipa, level, Error::RmiErrorRtt(level))?;
let (parent_s2tte, parent_level) = S2TTE::get_s2tte(rd, ipa, level - 1, Error::RmiErrorInput)?;
if parent_level < (level - 1) || !parent_s2tte.is_table(level - 1) {
return Err(Error::RmiErrorRtt(parent_level));
}
// TODO: spec doesn't reject the fold with its state in TABLE.
if fold_s2tte.is_table(level) {
warn!("Trying to fold which points another RTT");
return Err(Error::RmiErrorRtt(level));
}
let rtt_addr = parent_s2tte.get_masked(S2TTE::ADDR_TBL_OR_PAGE);
let mut g_rtt = get_granule_if!(rtt_addr as usize, GranuleState::RTT)?;
// TODO: ref count check
let binding = rd.s2_table();
let mut binding = binding.lock();
let (mut entries_iter, _) = binding.entries(GuestPhysAddr::from(ipa), level)?;
if !S2TTE::is_homogeneous(&mut entries_iter, level) {
return Err(Error::RmiErrorRtt(level));
}
let mut pa: u64 = 0;
let mut attr = fold_s2tte.get_masked(S2TTE::NS);
let hipas = fold_s2tte.get_masked(S2TTE::HIPAS);
let mut ripas = 0;
let mut desc_type = 0;
if fold_s2tte.get_masked_value(S2TTE::HIPAS) == hipas::ASSIGNED {
pa = fold_s2tte.addr_as_block(level).into();
attr |= fold_s2tte.get_masked(TTE_ATTR_MASK);
}
if is_protected_ipa {
ripas = fold_s2tte.get_masked(S2TTE::RIPAS);
}
if fold_s2tte.is_assigned_ram(level) || fold_s2tte.is_assigned_ns(level) {
desc_type = desc_type::L012_BLOCK;
}
let parent_s2tte = pa | attr | hipas | ripas | desc_type;
binding.ipa_to_pte_set(
GuestPhysAddr::from(ipa),
level - 1,
parent_s2tte,
Tlbi::BREAKDOWN(rd.id()),
)?;
//Change state of child table (pa)
set_granule(&mut g_rtt, GranuleState::Delegated)?;
Ok(rtt_addr as usize)
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/address.rs | rmm/src/realm/mm/address.rs | use core::fmt;
use core::ops::{Add, AddAssign, BitAnd, BitOr, Sub, SubAssign};
use vmsa::address::Address;
use vmsa::impl_addr;
pub use vmsa::address::PhysAddr;
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct GuestPhysAddr(usize);
impl_addr!(GuestPhysAddr);
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/mod.rs | rmm/src/realm/mm/mod.rs | pub mod address;
pub mod attribute;
pub mod entry;
pub mod page;
pub mod rtt;
pub mod stage2_translation;
pub mod stage2_tte;
pub mod table_level;
use crate::rmi::error::Error;
use core::ffi::c_void;
use core::fmt::Debug;
use core::slice::Iter;
use address::{GuestPhysAddr, PhysAddr};
use stage2_translation::Tlbi;
pub trait IPATranslation: Debug + Send + Sync {
fn get_base_address(&self) -> *const c_void;
// TODO: remove mut
fn ipa_to_pa(&mut self, guest: GuestPhysAddr, level: usize) -> Option<PhysAddr>;
fn ipa_to_pte(&mut self, guest: GuestPhysAddr, level: usize) -> Option<(u64, usize)>;
fn ipa_to_pte_set(
&mut self,
guest: GuestPhysAddr,
level: usize,
val: u64,
invalidate: Tlbi,
) -> Result<(), Error>;
fn clean(&mut self, vmid: usize);
fn space_size(&self, level: usize) -> usize;
fn entries(
&self,
guest: GuestPhysAddr,
level: usize,
) -> Result<(Iter<'_, entry::Entry>, usize), Error>;
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/table_level.rs | rmm/src/realm/mm/table_level.rs | use crate::const_assert_size;
use crate::realm::mm::address::GuestPhysAddr;
use crate::realm::mm::entry::Entry;
use vmsa::page_table::{HasSubtable, Level, PageTable};
use crate::config::PAGE_SIZE;
/// Root Table
pub enum RootTable<const L: usize, const N: usize> {}
impl<const L: usize, const N: usize> Level for RootTable<L, N> {
const THIS_LEVEL: usize = L;
const TABLE_SIZE: usize = (PAGE_SIZE * N);
const TABLE_ALIGN: usize = PAGE_SIZE;
const NUM_ENTRIES: usize = (Self::TABLE_SIZE / core::mem::size_of::<Entry>());
}
impl<const N: usize> HasSubtable for RootTable<0, N> {
type NextLevel = L1Table;
}
impl<const N: usize> HasSubtable for RootTable<1, N> {
type NextLevel = L2Table;
}
impl<const N: usize> HasSubtable for RootTable<2, N> {
type NextLevel = L3Table;
}
/// The Level 0 Table
pub enum L0Table {}
impl Level for L0Table {
const THIS_LEVEL: usize = 0;
const TABLE_SIZE: usize = PAGE_SIZE;
const TABLE_ALIGN: usize = PAGE_SIZE;
const NUM_ENTRIES: usize = (Self::TABLE_SIZE / core::mem::size_of::<Entry>());
}
impl HasSubtable for L0Table {
type NextLevel = L1Table;
}
/// The Level 1 Table
pub enum L1Table {}
impl Level for L1Table {
const THIS_LEVEL: usize = 1;
const TABLE_SIZE: usize = PAGE_SIZE;
const TABLE_ALIGN: usize = PAGE_SIZE;
const NUM_ENTRIES: usize = (Self::TABLE_SIZE / core::mem::size_of::<Entry>());
}
impl HasSubtable for L1Table {
type NextLevel = L2Table;
}
/// The Level 2 Table
pub enum L2Table {}
impl Level for L2Table {
const THIS_LEVEL: usize = 2;
const TABLE_SIZE: usize = PAGE_SIZE;
const TABLE_ALIGN: usize = PAGE_SIZE;
const NUM_ENTRIES: usize = (Self::TABLE_SIZE / core::mem::size_of::<Entry>());
}
impl HasSubtable for L2Table {
type NextLevel = L3Table;
}
/// The Level 3 Table (Doesn't have Subtable!)
pub enum L3Table {}
impl Level for L3Table {
const THIS_LEVEL: usize = 3;
const TABLE_SIZE: usize = PAGE_SIZE;
const TABLE_ALIGN: usize = PAGE_SIZE;
const NUM_ENTRIES: usize = (Self::TABLE_SIZE / core::mem::size_of::<Entry>());
}
const_assert_size!(PageTable<GuestPhysAddr, L0Table, Entry, { L0Table::NUM_ENTRIES }>, PAGE_SIZE);
const_assert_size!(PageTable<GuestPhysAddr, L1Table, Entry, { L1Table::NUM_ENTRIES }>, PAGE_SIZE);
const_assert_size!(PageTable<GuestPhysAddr, L2Table, Entry, { L2Table::NUM_ENTRIES }>, PAGE_SIZE);
const_assert_size!(PageTable<GuestPhysAddr, L3Table, Entry, { L3Table::NUM_ENTRIES }>, PAGE_SIZE);
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/stage2_tte.rs | rmm/src/realm/mm/stage2_tte.rs | use core::slice::Iter;
use armv9a::{bits_in_reg, define_bitfield, define_bits, define_mask};
use vmsa::address::PhysAddr;
use vmsa::page_table::Entry;
use crate::realm::mm::address::GuestPhysAddr;
use crate::realm::mm::attribute::{desc_type, memattr, permission, shareable};
use crate::realm::mm::entry;
use crate::realm::mm::rtt::{RTT_MIN_BLOCK_LEVEL, RTT_PAGE_LEVEL};
use crate::realm::rd::Rd;
use crate::rmi::error::Error;
pub const INVALID_UNPROTECTED: u64 = 0x0;
pub const VALID_TTE: u64 = bits_in_reg(S2TTE::MEMATTR, memattr::NORMAL_FWB)
| bits_in_reg(S2TTE::S2AP, permission::RW)
| bits_in_reg(S2TTE::SH, shareable::INNER)
| bits_in_reg(S2TTE::AF, 1);
pub const VALID_NS_TTE: u64 =
bits_in_reg(S2TTE::NS, 1) | bits_in_reg(S2TTE::XN, 1) | bits_in_reg(S2TTE::AF, 1);
pub const TABLE_TTE: u64 = bits_in_reg(S2TTE::DESC_TYPE, desc_type::L012_TABLE)
| bits_in_reg(S2TTE::MEMATTR, memattr::NORMAL_FWB)
| bits_in_reg(S2TTE::SH, shareable::INNER);
pub const TTE_ATTR_MASK: u64 = S2TTE::MEMATTR | S2TTE::S2AP | S2TTE::SH | S2TTE::AF;
pub mod hipas {
pub const UNASSIGNED: u64 = 0b0;
pub const ASSIGNED: u64 = 0b1;
}
pub mod ripas {
pub const EMPTY: u64 = 0b0;
pub const RAM: u64 = 0b1;
pub const DESTROYED: u64 = 0b10;
pub const DEV: u64 = 0b11;
}
pub fn mapping_size(level: usize) -> usize {
match level {
3 => 1 << S2TTE::ADDR_BLK_L3.trailing_zeros(), // 4096
2 => 1 << S2TTE::ADDR_BLK_L2.trailing_zeros(),
1 => 1 << S2TTE::ADDR_BLK_L1.trailing_zeros(),
0 => 1 << S2TTE::ADDR_BLK_L0.trailing_zeros(),
_ => unreachable!(),
}
}
pub fn level_mask(level: usize) -> Option<u64> {
match level {
3 => Some(S2TTE::ADDR_BLK_L3),
2 => Some(S2TTE::ADDR_BLK_L2),
1 => Some(S2TTE::ADDR_BLK_L1),
0 => Some(S2TTE::ADDR_BLK_L0),
_ => None,
}
}
fn is_block_level(level: usize) -> bool {
level >= RTT_MIN_BLOCK_LEVEL && level < RTT_PAGE_LEVEL
}
define_bits!(
S2TTE,
HIPAS[58 - 58], // Host IPA State (HIPAS)
RIPAS[57 - 56], // Realm IPA State (RIPAS)
NS[55 - 55], // DDI0615A: For a Block or Page descriptor fetched for stage 2 in the Realm Security state, bit 55 is the NS field. if set, it means output address is in NS PAS.
XN[54 - 54],
CONT[52 - 52],
// https://armv8-ref.codingbelief.com/en/chapter_d4/d43_1_vmsav8-64_translation_table_descriptor_formats.html
ADDR_BLK_L0[47 - 39], // block descriptor; level 0 w/o concatenation
ADDR_BLK_L1[47 - 30], // block descriptor; level 1
ADDR_BLK_L2[47 - 21], // block descriptor; level 2
ADDR_BLK_L3[47 - 12], // page descriptor; level 3
ADDR_TBL_OR_PAGE[47 - 12], // table descriptor(level 0-2) || page descriptor(level3)
AF[10 - 10],
SH[9 - 8], // pte_shareable
S2AP[7 - 6], // pte_access_perm
MEMATTR[5 - 2], // pte_mem_attr
DESC_TYPE[1 - 0],
TYPE[1 - 1], // pte_type ; block(0) or table(1)
VALID[0 - 0]
);
impl S2TTE {
pub fn get_s2tte(
rd: &Rd,
ipa: usize,
level: usize,
error_code: Error,
) -> Result<(S2TTE, usize), Error> {
let (mut s2tte, last_level) = rd
.s2_table()
.lock()
.ipa_to_pte(GuestPhysAddr::from(ipa), level)
.ok_or(error_code)?;
if ipa < rd.ipa_size() && !rd.addr_in_par(ipa) && s2tte == 0 {
s2tte |= S2TTE::NS;
}
Ok((S2TTE::from(s2tte as usize), last_level))
}
pub fn is_host_ns_valid(&self, level: usize) -> bool {
let tmp = S2TTE::new(!0);
let addr_mask = match level {
1 => tmp.get_masked(S2TTE::ADDR_BLK_L1),
2 => tmp.get_masked(S2TTE::ADDR_BLK_L2),
3 => tmp.get_masked(S2TTE::ADDR_BLK_L3),
_ => return false,
};
let mask = addr_mask
| tmp.get_masked(S2TTE::MEMATTR)
| tmp.get_masked(S2TTE::S2AP)
| tmp.get_masked(S2TTE::SH);
if (self.get() & !mask) != 0 {
return false;
}
if self.get_masked_value(S2TTE::MEMATTR) == memattr::FWB_RESERVED {
return false;
}
if self.get_masked_value(S2TTE::SH) == shareable::RESERVED {
return false;
}
true
}
pub fn is_unassigned(&self) -> bool {
self.get_masked_value(S2TTE::DESC_TYPE) == desc_type::LX_INVALID
&& self.get_masked_value(S2TTE::HIPAS) == hipas::UNASSIGNED
&& self.get_masked_value(S2TTE::NS) == 0
}
pub fn is_unassigned_empty(&self) -> bool {
self.is_unassigned() && self.get_masked_value(S2TTE::RIPAS) == ripas::EMPTY
}
pub fn is_unassigned_destroyed(&self) -> bool {
self.is_unassigned() && self.get_masked_value(S2TTE::RIPAS) == ripas::DESTROYED
}
pub fn is_unassigned_ram(&self) -> bool {
self.is_unassigned() && self.get_masked_value(S2TTE::RIPAS) == ripas::RAM
}
pub fn is_unassigned_ns(&self) -> bool {
self.get_masked_value(S2TTE::DESC_TYPE) == desc_type::LX_INVALID
&& self.get_masked_value(S2TTE::HIPAS) == hipas::UNASSIGNED
&& self.get_masked_value(S2TTE::NS) != 0
}
pub fn is_destroyed(&self) -> bool {
self.get_masked_value(S2TTE::DESC_TYPE) == desc_type::LX_INVALID
&& self.get_masked_value(S2TTE::RIPAS) == ripas::DESTROYED
&& self.get_masked_value(S2TTE::NS) == 0
}
pub fn is_assigned(&self) -> bool {
self.get_masked_value(S2TTE::NS) == 0
&& self.get_masked_value(S2TTE::HIPAS) == hipas::ASSIGNED
}
pub fn is_assigned_invalid(&self) -> bool {
self.get_masked_value(S2TTE::NS) == 0
&& self.get_masked_value(S2TTE::DESC_TYPE) == desc_type::LX_INVALID
&& self.get_masked_value(S2TTE::HIPAS) == hipas::ASSIGNED
}
pub fn is_assigned_empty(&self) -> bool {
self.is_assigned_invalid() && self.get_masked_value(S2TTE::RIPAS) == ripas::EMPTY
}
pub fn is_assigned_destroyed(&self) -> bool {
self.is_assigned_invalid() && self.get_masked_value(S2TTE::RIPAS) == ripas::DESTROYED
}
pub fn is_assigned_ram(&self, level: usize) -> bool {
if self.get_masked_value(S2TTE::NS) != 0
|| self.get_masked_value(S2TTE::RIPAS) != ripas::RAM
{
return false;
}
let desc_type = self.get_masked_value(S2TTE::DESC_TYPE);
if (level == RTT_PAGE_LEVEL && desc_type == desc_type::L3_PAGE)
|| (is_block_level(level) && desc_type == desc_type::L012_BLOCK)
{
return true;
}
false
}
pub fn is_assigned_ns(&self, level: usize) -> bool {
if self.get_masked_value(S2TTE::NS) == 0
|| self.get_masked_value(S2TTE::HIPAS) != hipas::ASSIGNED
{
return false;
}
let desc_type = self.get_masked_value(S2TTE::DESC_TYPE);
if (level == RTT_PAGE_LEVEL && desc_type == desc_type::L3_PAGE)
|| (is_block_level(level) && desc_type == desc_type::L012_BLOCK)
{
return true;
}
false
}
pub fn has_ripas(&self, level: usize) -> bool {
self.get_masked_value(S2TTE::NS) == 0 && !self.is_table(level)
}
// level should be the value returned in page table walking
// (== the last level that has been reached)
pub fn is_table(&self, level: usize) -> bool {
(level < RTT_PAGE_LEVEL)
&& self.get_masked_value(S2TTE::DESC_TYPE) == desc_type::L012_TABLE
&& self.get_masked_value(S2TTE::NS | S2TTE::HIPAS | S2TTE::RIPAS) == 0x0
}
pub fn is_ripas(&self) -> bool {
(self.get_masked_value(S2TTE::DESC_TYPE) != desc_type::LX_INVALID)
&& (self.get_ripas() != ripas::RAM)
}
pub fn addr_as_block(&self, level: usize) -> PhysAddr {
match level {
1 => PhysAddr::from(self.get_masked(S2TTE::ADDR_BLK_L1)),
2 => PhysAddr::from(self.get_masked(S2TTE::ADDR_BLK_L2)),
3 => PhysAddr::from(self.get_masked(S2TTE::ADDR_BLK_L3)),
_ => unreachable!(),
}
}
pub fn get_ripas(&self) -> u64 {
self.get_masked_value(S2TTE::RIPAS)
}
pub fn is_live(&self, _level: usize) -> bool {
// live tte: ASSIGNED, ASSIGNED_NS, TABLE
self.get_masked_value(S2TTE::DESC_TYPE) != desc_type::LX_INVALID
|| self.get_masked_value(S2TTE::HIPAS) == hipas::ASSIGNED
}
// TODO: remvoe mut
pub fn is_homogeneous(entries: &mut Iter<'_, entry::Entry>, level: usize) -> bool {
let mut hipas = 0;
let mut ripas = 0;
let mut desc_type = 0;
let mut pa = 0;
let mut attr: u64 = 0;
let mut ns = 0;
let mut first = true;
let map_size = mapping_size(level) as u64;
for entry in entries {
let s2tte = S2TTE::new(entry.pte());
if first {
desc_type = s2tte.get_masked_value(S2TTE::DESC_TYPE);
hipas = s2tte.get_masked_value(S2TTE::HIPAS);
ripas = s2tte.get_masked_value(S2TTE::RIPAS);
ns = s2tte.get_masked_value(S2TTE::NS);
first = false;
if s2tte.is_assigned_ns(level) | s2tte.is_assigned() {
// level is 2 or 3
if level != 2 && level != 3 {
return false;
}
pa = s2tte.addr_as_block(level).into(); //XXX: check this again
attr = entry.pte() & !level_mask(level).unwrap_or(0);
// output of first entry is algned to parent's mapping size
if (pa & !level_mask(level - 1).unwrap_or(0)) != 0 {
return false;
}
}
continue;
}
if desc_type != s2tte.get_masked_value(S2TTE::DESC_TYPE) {
return false;
} else if s2tte.is_assigned_ns(level) {
// addr is contiguous
pa += map_size;
if pa != s2tte.addr_as_block(level).into() {
return false;
}
// attributes are identical
if attr != s2tte.get() & !level_mask(level).unwrap_or(0) {
return false;
}
} else if s2tte.is_assigned() {
// addr is contiguous
pa += map_size;
if pa != s2tte.addr_as_block(level).into() {
return false;
}
// ripas is identical
if ripas != s2tte.get_masked_value(S2TTE::RIPAS) {
return false;
}
} else if s2tte.is_unassigned_ns() {
// ns is always 1
if ns != s2tte.get_masked_value(S2TTE::NS) {
return false;
}
// hipas is always UNASSIGNED
if hipas != s2tte.get_masked_value(S2TTE::HIPAS) {
return false;
}
} else if s2tte.is_unassigned() {
// hipas is always UNASSIGNED
if hipas != s2tte.get_masked_value(S2TTE::HIPAS) {
return false;
}
// ripas is identical
if ripas != s2tte.get_masked_value(S2TTE::RIPAS) {
return false;
}
}
}
true
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/stage2_translation.rs | rmm/src/realm/mm/stage2_translation.rs | use core::arch::asm;
use core::ffi::c_void;
use core::fmt;
use core::slice::Iter;
use crate::granule::GRANULE_SHIFT;
use crate::realm::mm::address::GuestPhysAddr;
use crate::realm::mm::entry;
use crate::realm::mm::page::BasePageSize;
use crate::realm::mm::page::{HugePageSize, LargePageSize};
use crate::realm::mm::stage2_tte::mapping_size;
use crate::realm::mm::table_level::RootTable;
use crate::realm::mm::table_level::{L0Table, L1Table, L2Table};
use crate::realm::mm::IPATranslation;
use crate::rmi::error::Error;
use alloc::alloc::Layout;
use vmsa::address::PhysAddr;
use vmsa::page::{Page, PageIter, PageSize};
use vmsa::page_table::Entry;
use vmsa::page_table::{Level, MemAlloc, PageTable, PageTableMethods};
use aarch64_cpu::registers::*;
use armv9a::{bits_in_reg, define_bitfield, define_bits, define_mask};
pub mod tlbi_ns {
pub const IPAS_S: u64 = 0b0;
pub const IPAS_NS: u64 = 0b1;
}
pub enum Tlbi {
NONE,
LEAF(usize), // vmid : usize
BREAKDOWN(usize), // vmid: usize
}
define_bits!(TLBI_OP, NS[63 - 63], TTL[47 - 44], IPA[35 - 0]);
define_bits!(
TLBI_RANGE_OP,
NS[63 - 63],
TG[47 - 46],
SCALE[45 - 44],
NUM[43 - 39],
TTL[38 - 37],
IPA[36 - 0]
);
const ENTR1: usize = <RootTable<0, 1> as Level>::NUM_ENTRIES;
const ENTR2: usize = ENTR1 * 2;
const ENTR4: usize = ENTR1 * 4;
const ENTR8: usize = ENTR1 * 8;
const ENTR16: usize = ENTR1 * 16;
type RootTBL<'a, const L: usize, const N: usize, const E: usize> =
&'a mut PageTable<GuestPhysAddr, RootTable<{ L }, { N }>, entry::Entry, { E }>;
pub enum Root<'a> {
L0N1(RootTBL<'a, 0, 1, ENTR1>),
L0N16(RootTBL<'a, 0, 16, ENTR16>),
L1N1(RootTBL<'a, 1, 1, ENTR1>),
L1N2(RootTBL<'a, 1, 2, ENTR2>),
L1N8(RootTBL<'a, 1, 8, ENTR8>),
L2N4(RootTBL<'a, 2, 4, ENTR4>),
L2N8(RootTBL<'a, 2, 8, ENTR8>),
L2N16(RootTBL<'a, 2, 16, ENTR16>),
}
#[macro_export]
macro_rules! init_table {
($level:expr, $pages:expr, $base:expr) => {
&mut *PageTable::<
GuestPhysAddr,
RootTable<$level, $pages>,
entry::Entry,
{ <RootTable<$level, $pages> as Level>::NUM_ENTRIES },
>::new_init_in(&RttAllocator { base: $base }, |entries| {
for e in entries.iter_mut() {
*e = Entry::new();
}
})
.unwrap()
};
}
pub struct Stage2Translation<'a> {
// We will set the translation granule with 4KB.
root_pgtbl: Root<'a>,
root_level: usize,
root_pages: usize,
dirty: bool,
}
impl Stage2Translation<'_> {
pub fn new(rtt_base: usize, root_level: usize, root_pages: usize) -> Self {
// Concatenated translation tables
// For stage 2 address translations, for the initial lookup,
// up to 16 translation tables can be concatenated.
let root_pgtbl = match root_level {
0 => unsafe {
match root_pages {
1 => Root::L0N1(init_table!(0, 1, rtt_base)),
16 => Root::L0N16(init_table!(0, 16, rtt_base)),
_ => todo!(),
}
},
1 => unsafe {
match root_pages {
1 => Root::L1N1(init_table!(1, 1, rtt_base)),
2 => Root::L1N2(init_table!(1, 2, rtt_base)),
8 => Root::L1N8(init_table!(1, 8, rtt_base)),
_ => todo!(),
}
},
2 => unsafe {
match root_pages {
4 => Root::L2N4(init_table!(2, 4, rtt_base)),
8 => Root::L2N8(init_table!(2, 8, rtt_base)),
16 => Root::L2N16(init_table!(2, 16, rtt_base)),
_ => todo!(),
}
},
_ => todo!(),
};
Self {
root_pgtbl,
root_level,
root_pages,
dirty: false,
}
}
fn tlbi_iter<S: PageSize>(level: usize, guest_iter: PageIter<S, GuestPhysAddr>, vmid: usize) {
let vmid_saved = VTTBR_EL2.read(VTTBR_EL2::VMID);
VTTBR_EL2.write(VTTBR_EL2::VMID.val(vmid as u64));
unsafe {
asm!("isb");
}
for guest in guest_iter {
let mut ipa: u64 = guest.address().as_u64() >> GRANULE_SHIFT;
unsafe {
ipa = bits_in_reg(TLBI_OP::TTL, 0b0100 | level as u64)
| bits_in_reg(TLBI_OP::IPA, ipa);
asm!(
"tlbi IPAS2E1IS, {}",
in(reg) ipa,
);
}
}
unsafe {
asm!("dsb ish");
}
VTTBR_EL2.write(VTTBR_EL2::VMID.val(vmid_saved));
}
// According to DDI0608A E1.2.1.11 Cache and TLB operations
// 'TLBI IPAS2E1, Xt; DSB; TLBI VMALLE1'
// or TLBI ALL or TLBI VMALLS1S2
fn tlbi_by_vmid_ipa(level: usize, guest: GuestPhysAddr, vmid: usize) {
let guest_iter =
Page::<BasePageSize, GuestPhysAddr>::range_with_size(guest, BasePageSize::SIZE);
Self::tlbi_iter(level, guest_iter, vmid);
// TODO: Do it at once when switchng the context to the realm
Self::tlbi_vmalle1is(vmid);
}
#[allow(unused)]
// Saved in case tlb-rmi arch extension is not provided
fn tlbi_by_vmid_ipa_range_v2(level: usize, guest: GuestPhysAddr, vmid: usize) {
match level {
L2Table::THIS_LEVEL => {
let guest_iter = Page::<BasePageSize, GuestPhysAddr>::range_with_size(
guest,
mapping_size(level),
);
Self::tlbi_iter(level + 1, guest_iter, vmid);
}
L1Table::THIS_LEVEL => {
let guest_iter = Page::<LargePageSize, GuestPhysAddr>::range_with_size(
guest,
mapping_size(level),
);
Self::tlbi_iter(level + 1, guest_iter, vmid);
}
L0Table::THIS_LEVEL => {
let guest_iter = Page::<HugePageSize, GuestPhysAddr>::range_with_size(
guest,
mapping_size(level),
);
Self::tlbi_iter(level + 1, guest_iter, vmid);
}
_ => {
panic!("wrong invalidation level")
}
};
// TODO: Do it at once when switchng the context to the realm
Self::tlbi_vmalle1is(vmid);
}
fn tlbi_by_vmid_ipa_range(level: usize, guest: GuestPhysAddr, vmid: usize) {
let vmid_saved = VTTBR_EL2.read(VTTBR_EL2::VMID);
VTTBR_EL2.write(VTTBR_EL2::VMID.val(vmid as u64));
unsafe {
asm!("isb");
}
// The entry is within the address range determined by the formula
// [BaseADDR <= VA < BaseADDR + ((NUM +1)*2(5*SCALE +1) * Translation_Granule_Size)].
let scale = 3 - level as u64;
let num = 8 + 4 * scale;
unsafe {
let xt = bits_in_reg(TLBI_RANGE_OP::TG, 0b01) // 4K tranlsation granule
| bits_in_reg(TLBI_RANGE_OP::SCALE, scale)
| bits_in_reg(TLBI_RANGE_OP::NUM, num)
| bits_in_reg(TLBI_RANGE_OP::TTL, (level + 1) as u64)
| bits_in_reg(TLBI_RANGE_OP::IPA, guest.as_u64());
asm!(
"tlbi RIPAS2LE1, {}",
in(reg) xt,
);
}
unsafe {
asm!("dsb ish");
}
VTTBR_EL2.write(VTTBR_EL2::VMID.val(vmid_saved));
// TODO: Do it at once when switchng the context to the realm
Self::tlbi_vmalle1is(vmid);
}
fn tlbi_vmalle1is(vmid: usize) {
unsafe {
let vmid_saved = VTTBR_EL2.read(VTTBR_EL2::VMID);
VTTBR_EL2.write(VTTBR_EL2::VMID.val(vmid as u64));
// According to DDI0608A E1.2.1.11 Cache and TLB operations
// second half part
asm! {
"
dsb ishst
tlbi VMALLE1IS
dsb ish
isb
"
}
VTTBR_EL2.write(VTTBR_EL2::VMID.val(vmid_saved));
}
}
}
pub struct RttAllocator {
pub base: usize,
}
impl MemAlloc for RttAllocator {
unsafe fn allocate(&self, _layout: Layout) -> *mut u8 {
//TODO: check alignment
self.base as *mut u8
}
unsafe fn deallocate(&self, ptr: *mut u8, layout: Layout) {
error!(
"dealloc for RttAllocator will do nothing. {:?}, {:?}",
ptr, layout
);
}
}
#[macro_export]
// ipa_to_pa closure
macro_rules! to_pa {
($root:expr, $guest:expr, $level:expr, $pa:expr) => {
$root.entry($guest, $level, false, |entry| {
$pa = entry.address(0);
Ok(None)
})
};
}
// ipa_to_pte closure
macro_rules! to_pte {
($root:expr, $guest:expr, $level:expr, $pte:expr) => {
$root.entry($guest, $level, true, |entry| {
$pte = entry.pte();
Ok(None)
})
};
}
// ipa_to_pte_set clousre
macro_rules! set_pte {
($root:expr, $guest:expr, $level:expr, $val:expr) => {
$root.entry($guest, $level, true, |entry| {
let _ = entry.set(PhysAddr::from(0 as u64), $val); //FIXME: get pa
Ok(None)
})
};
}
impl IPATranslation for Stage2Translation<'_> {
fn get_base_address(&self) -> *const c_void {
match &self.root_pgtbl {
Root::L2N8(c) => *c as *const _ as *const c_void, // most likely first, for linux-realm
Root::L0N1(a) => *a as *const _ as *const c_void,
Root::L0N16(a) => *a as *const _ as *const c_void,
Root::L1N1(b) => *b as *const _ as *const c_void,
Root::L1N2(b) => *b as *const _ as *const c_void,
Root::L1N8(b) => *b as *const _ as *const c_void,
Root::L2N4(c) => *c as *const _ as *const c_void,
Root::L2N16(c) => *c as *const _ as *const c_void,
}
}
/// Retrieves Page Table Entry (PA) from Intermediate Physical Address (IPA)
///
/// (input)
/// guest: a target guest physical address to translate
/// level: the intended page-table level to reach
///
/// (output)
/// if exists,
/// physical address
/// else,
/// None
fn ipa_to_pa(&mut self, guest: GuestPhysAddr, level: usize) -> Option<PhysAddr> {
let guest = Page::<BasePageSize, GuestPhysAddr>::including_address(guest);
let mut pa = None;
let res = match &mut self.root_pgtbl {
Root::L2N8(root) => to_pa!(root, guest, level, pa), // most likely first, for linux-realm
Root::L0N1(root) => to_pa!(root, guest, level, pa),
Root::L0N16(root) => to_pa!(root, guest, level, pa),
Root::L1N1(root) => to_pa!(root, guest, level, pa),
Root::L1N2(root) => to_pa!(root, guest, level, pa),
Root::L1N8(root) => to_pa!(root, guest, level, pa),
Root::L2N4(root) => to_pa!(root, guest, level, pa),
Root::L2N16(root) => to_pa!(root, guest, level, pa),
};
if res.is_ok() {
pa
} else {
None
}
}
/// Retrieves Page Table Entry (PTE) from Intermediate Physical Address (IPA)
///
/// (input)
/// guest: a target guest physical address to translate
/// level: the intended page-table level to reach
///
/// (output)
/// if exists,
/// A tuple of (pte value (u64), lastly reached page table level (usize))
/// else,
/// None
fn ipa_to_pte(&mut self, guest: GuestPhysAddr, level: usize) -> Option<(u64, usize)> {
let guest = Page::<BasePageSize, GuestPhysAddr>::including_address(guest);
let mut pte = 0;
let res = match &mut self.root_pgtbl {
Root::L2N8(root) => to_pte!(root, guest, level, pte), // most likely first, for linux-realm
Root::L0N1(root) => to_pte!(root, guest, level, pte),
Root::L0N16(root) => to_pte!(root, guest, level, pte),
Root::L1N1(root) => to_pte!(root, guest, level, pte),
Root::L1N2(root) => to_pte!(root, guest, level, pte),
Root::L1N8(root) => to_pte!(root, guest, level, pte),
Root::L2N4(root) => to_pte!(root, guest, level, pte),
Root::L2N16(root) => to_pte!(root, guest, level, pte),
};
if let Ok(x) = res {
Some((pte, x.1))
} else {
None
}
}
fn ipa_to_pte_set(
&mut self,
guest: GuestPhysAddr,
level: usize,
val: u64,
invalidate: Tlbi,
) -> Result<(), Error> {
let map_addr = guest;
let guest = Page::<BasePageSize, GuestPhysAddr>::including_address(guest);
let res = match &mut self.root_pgtbl {
Root::L2N8(root) => set_pte!(root, guest, level, val),
Root::L0N1(root) => set_pte!(root, guest, level, val),
Root::L0N16(root) => set_pte!(root, guest, level, val),
Root::L1N1(root) => set_pte!(root, guest, level, val),
Root::L1N2(root) => set_pte!(root, guest, level, val),
Root::L1N8(root) => set_pte!(root, guest, level, val),
Root::L2N4(root) => set_pte!(root, guest, level, val),
Root::L2N16(root) => set_pte!(root, guest, level, val),
};
if let Ok(_x) = res {
match invalidate {
Tlbi::LEAF(vmid) => {
#[cfg(not(any(miri, test, fuzzing)))]
Self::tlbi_by_vmid_ipa(level, map_addr, vmid);
self.dirty = true;
}
Tlbi::BREAKDOWN(vmid) => {
#[cfg(not(any(miri, test, fuzzing)))]
Self::tlbi_by_vmid_ipa_range(level, map_addr, vmid);
self.dirty = true;
}
_ => {}
}
Ok(())
} else {
Err(Error::RmiErrorInput)
}
}
fn clean(&mut self, vmid: usize) {
if self.dirty {
Self::tlbi_vmalle1is(vmid);
self.dirty = false;
}
}
fn space_size(&self, level: usize) -> usize {
let count = if level == self.root_level {
self.root_pages
} else {
1
};
if level == 0 {
mapping_size(0) * L0Table::NUM_ENTRIES * count
} else {
mapping_size(level - 1) * count
}
}
fn entries(
&self,
guest: GuestPhysAddr,
level: usize,
) -> Result<(Iter<'_, entry::Entry>, usize), Error> {
let guest = Page::<BasePageSize, GuestPhysAddr>::including_address(guest);
let res = match &self.root_pgtbl {
Root::L2N8(root) => root.table_entries(guest, level),
Root::L0N1(root) => root.table_entries(guest, level),
Root::L0N16(root) => root.table_entries(guest, level),
Root::L1N1(root) => root.table_entries(guest, level),
Root::L1N2(root) => root.table_entries(guest, level),
Root::L1N8(root) => root.table_entries(guest, level),
Root::L2N4(root) => root.table_entries(guest, level),
Root::L2N16(root) => root.table_entries(guest, level),
};
if let Ok(ref _x) = res {
Ok(res?)
} else {
Err(Error::RmiErrorInput)
}
}
}
impl fmt::Debug for Stage2Translation<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct(stringify!(Self)).finish()
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/realm/mm/entry.rs | rmm/src/realm/mm/entry.rs | use crate::config::PAGE_SIZE;
use crate::realm::mm::attribute::{desc_type, memattr, page_type, shareable};
use crate::realm::mm::stage2_tte::S2TTE;
use crate::realm::mm::table_level::L3Table;
use vmsa::address::PhysAddr;
use vmsa::error::Error;
use vmsa::page_table::{self, Level};
use vmsa::RawGPA;
#[derive(Clone, Copy)]
pub struct Entry(S2TTE);
impl From<usize> for S2TTE {
fn from(val: usize) -> Self {
Self(val as u64)
}
}
impl page_table::Entry for Entry {
type Inner = S2TTE;
fn new() -> Self {
Self(S2TTE::new(0))
}
fn is_valid(&self) -> bool {
self.0.get_masked_value(S2TTE::VALID) != 0
}
fn clear(&mut self) {
self.0 = S2TTE::new(0);
}
fn pte(&self) -> u64 {
self.0.get()
}
fn mut_pte(&mut self) -> &mut Self::Inner {
self.0.get_mut()
}
fn address(&self, level: usize) -> Option<PhysAddr> {
match self.is_valid() {
true => match self.0.get_masked_value(S2TTE::TYPE) {
page_type::TABLE_OR_PAGE => {
Some(PhysAddr::from(self.0.get_masked(S2TTE::ADDR_TBL_OR_PAGE)))
}
page_type::BLOCK => match level {
1 => Some(PhysAddr::from(self.0.get_masked(S2TTE::ADDR_BLK_L1))),
2 => Some(PhysAddr::from(self.0.get_masked(S2TTE::ADDR_BLK_L2))),
_ => None,
},
_ => None,
},
false => None,
}
}
fn set(&mut self, addr: PhysAddr, flags: u64) -> Result<(), Error> {
self.0.set(addr.as_u64() | flags);
#[cfg(not(any(miri, test, fuzzing)))]
unsafe {
core::arch::asm!(
"dsb ishst",
"dc civac, {}",
"dsb ish",
"isb",
in(reg) &self.0 as *const _ as usize,
);
}
Ok(())
}
fn point_to_subtable(&mut self, _index: usize, addr: PhysAddr) -> Result<(), Error> {
let mut flags = S2TTE::new(0);
flags
.set_masked_value(S2TTE::DESC_TYPE, desc_type::L012_TABLE)
.set_masked_value(S2TTE::MEMATTR, memattr::NORMAL_FWB)
.set_masked_value(S2TTE::SH, shareable::INNER);
self.set(addr, flags.get())
}
fn index<L: Level>(addr: usize) -> usize {
match L::THIS_LEVEL {
0 => RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize,
1 => {
if L::TABLE_SIZE > PAGE_SIZE {
// We know that refering one direct parent table is enough
// because concatenation of the initial lookup table is upto 16.
let l0 = RawGPA::from(addr).get_masked_value(RawGPA::L0Index) as usize;
let l1 = RawGPA::from(addr).get_masked_value(RawGPA::L1Index) as usize;
// assuming L3Table is a single page-sized
l0 * L3Table::NUM_ENTRIES + l1
} else {
RawGPA::from(addr).get_masked_value(RawGPA::L1Index) as usize
}
}
2 => {
if L::TABLE_SIZE > PAGE_SIZE {
let l1 = RawGPA::from(addr).get_masked_value(RawGPA::L1Index) as usize;
let l2 = RawGPA::from(addr).get_masked_value(RawGPA::L2Index) as usize;
l1 * L3Table::NUM_ENTRIES + l2
} else {
RawGPA::from(addr).get_masked_value(RawGPA::L2Index) as usize
}
}
3 => RawGPA::from(addr).get_masked_value(RawGPA::L3Index) as usize,
_ => panic!(),
}
}
fn points_to_table_or_page(&self) -> bool {
match self.is_valid() {
true => match self.0.get_masked_value(S2TTE::TYPE) {
page_type::TABLE_OR_PAGE => true,
page_type::BLOCK => false,
_ => false,
},
false => false,
}
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/hostcall.rs | rmm/src/rsi/hostcall.rs | use crate::const_assert_eq;
use crate::rmi::error::Error;
use autopadding::*;
pub const HOST_CALL_NR_GPRS: usize = 31;
pad_struct_and_impl_default!(
pub struct HostCall {
0x0 imm: u16,
0x8 gprs: [u64; HOST_CALL_NR_GPRS],
0x100 => @END,
}
);
const_assert_eq!(core::mem::size_of::<HostCall>(), 0x100);
impl HostCall {
pub fn set_gpr(&mut self, idx: usize, val: u64) -> Result<(), Error> {
if idx >= HOST_CALL_NR_GPRS {
error!("out of index: {}", idx);
return Err(Error::RmiErrorInput);
}
self.gprs[idx] = val;
Ok(())
}
pub fn gpr(&self, idx: usize) -> Result<u64, Error> {
if idx >= HOST_CALL_NR_GPRS {
error!("out of index: {}", idx);
return Err(Error::RmiErrorInput);
}
Ok(self.gprs[idx])
}
pub fn imm(&self) -> u16 {
self.imm
}
}
impl core::fmt::Debug for HostCall {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("rsi::HostCall")
.field("imm", &format_args!("{:#X}", &self.imm))
.field("gprs", &self.gprs)
.finish()
}
}
impl safe_abstraction::raw_ptr::RawPtr for HostCall {}
impl safe_abstraction::raw_ptr::SafetyChecked for HostCall {}
impl safe_abstraction::raw_ptr::SafetyAssured for HostCall {
fn is_initialized(&self) -> bool {
// The initialization of this memory is guaranteed
// according to the RMM Specification A2.2.4 Granule Wiping.
// This instance belongs to a Data Granule and has been initialized.
true
}
fn verify_ownership(&self) -> bool {
// The instance's ownership is guaranteed while being processed by the RMM.
// While the Realm holds RW permissions for the instance,
// it cannot exercise these permissions from the moment an SMC request is made
// until the request is completed. Even in multi-core environments,
// the designated areas are protected by Stage 2 Table,
// ensuring that there are no adverse effects on RMM's memory safety.
true
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/psci.rs | rmm/src/rsi/psci.rs | use crate::event::RsiHandle;
use crate::granule::GranuleState;
use crate::listen;
use crate::realm::rd::{Rd, State};
use crate::rec::context::{get_reg, set_reg, RegOffset};
use crate::rec::Rec;
use crate::rmi;
use crate::rmi::error::Error;
use crate::rmi::rec::mpidr::MPIDR;
use crate::rsi;
use crate::{get_granule, get_granule_if};
struct PsciReturn;
impl PsciReturn {
const SUCCESS: usize = 0;
const AFFINITY_INFO_ON: usize = 0;
const AFFINITY_INFO_OFF: usize = 1;
const NOT_SUPPORTED: usize = !0;
const INVALID_PARAMS: usize = !1;
const DENIED: usize = !2;
const ALREADY_ON: usize = !3;
//const ON_PENDING: usize = !4;
//const INTERNAL_FAILURE: usize = !5;
//const NOT_PRESENT: usize = !6; // UL(-7)
//const DISABLED: usize = !7; // UL(-8);
const INVALID_ADDRESS: usize = !8; //UL(-9);
}
const SMCCC_MAJOR_VERSION: usize = 1;
const SMCCC_MINOR_VERSION: usize = 2;
const PSCI_MAJOR_VERSION: usize = 1;
const PSCI_MINOR_VERSION: usize = 1;
extern crate alloc;
pub fn set_event_handler(rsi: &mut RsiHandle) {
listen!(rsi, rsi::PSCI_VERSION, |_arg, ret, _rmm, rec, _run| {
if set_reg(rec, 0, psci_version()).is_err() {
warn!("Unable to set register 0. rec: {:?}", rec);
}
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, rsi::PSCI_CPU_ON, |_arg, ret, _rmm, rec, run| {
let rd = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd.content::<Rd>()?;
let target_mpidr = get_reg(rec, 1)? as u64;
let entry_addr = get_reg(rec, 2)?;
if !rd.addr_in_par(entry_addr) {
set_reg(rec, 0, PsciReturn::INVALID_ADDRESS)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
let target_index = MPIDR::from(target_mpidr).index();
if target_index >= rd.rec_index() {
set_reg(rec, 0, PsciReturn::INVALID_PARAMS)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
if target_index == rec.vcpuid() {
set_reg(rec, 0, PsciReturn::ALREADY_ON)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
rec.set_psci_pending(true);
run.set_exit_reason(rmi::EXIT_PSCI);
run.set_gpr(0, rsi::PSCI_CPU_ON as u64)?;
run.set_gpr(1, target_mpidr)?;
// set 0 for the rest of gprs
ret[0] = rmi::SUCCESS;
Ok(())
});
listen!(rsi, rsi::PSCI_CPU_OFF, |_arg, ret, _rmm, rec, run| {
rec.set_runnable(0);
run.set_exit_reason(rmi::EXIT_PSCI);
run.set_gpr(0, rsi::PSCI_CPU_OFF as u64)?;
ret[0] = rmi::SUCCESS;
Ok(())
});
listen!(rsi, rsi::PSCI_SYSTEM_OFF, |_arg, ret, _rmm, rec, run| {
let mut rd = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let mut rd = rd.content_mut::<Rd>()?;
rd.set_state(State::SystemOff);
run.set_exit_reason(rmi::EXIT_PSCI);
run.set_gpr(0, rsi::PSCI_SYSTEM_OFF as u64)?;
ret[0] = rmi::SUCCESS;
Ok(())
});
listen!(rsi, rsi::PSCI_CPU_SUSPEND, |_arg, ret, _rmm, rec, run| {
let _power_state = get_reg(rec, 1)? as u64;
let _entry_addr = get_reg(rec, 2)?;
let _context_id = get_reg(rec, 3)?;
run.set_exit_reason(rmi::EXIT_PSCI);
run.set_gpr(0, rsi::PSCI_CPU_SUSPEND as u64)?;
// set 0 for the rest of gprs
ret[0] = rmi::SUCCESS;
Ok(())
});
listen!(rsi, rsi::PSCI_SYSTEM_RESET, |_arg, ret, _rmm, rec, run| {
let mut rd = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let mut rd = rd.content_mut::<Rd>()?;
rd.set_state(State::SystemOff);
run.set_exit_reason(rmi::EXIT_PSCI);
run.set_gpr(0, rsi::PSCI_SYSTEM_RESET as u64)?;
ret[0] = rmi::SUCCESS;
Ok(())
});
listen!(rsi, rsi::PSCI_AFFINITY_INFO, |_arg, ret, _rmm, rec, run| {
#[cfg(feature = "gst_page_table")]
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let affinity = get_reg(rec, 1)? as u64;
let lowest_level = get_reg(rec, 2)?;
if lowest_level != 0 {
set_reg(rec, 0, PsciReturn::INVALID_PARAMS)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
let target_index = MPIDR::from(affinity).index();
// check if target_index is in the range
#[cfg(feature = "gst_page_table")]
if target_index >= rd_granule.num_children() {
set_reg(rec, 0, PsciReturn::INVALID_PARAMS)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
if target_index == rec.vcpuid() {
set_reg(rec, 0, PsciReturn::SUCCESS)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
rec.set_psci_pending(true);
run.set_exit_reason(rmi::EXIT_PSCI);
run.set_gpr(0, rsi::PSCI_AFFINITY_INFO as u64)?;
run.set_gpr(1, affinity)?;
// set 0 for the rest of gprs
ret[0] = rmi::SUCCESS;
Ok(())
});
listen!(rsi, rsi::PSCI_FEATURES, |_arg, ret, _rmm, rec, _run| {
let feature_id = get_reg(rec, 1)?;
let retval = match feature_id {
rsi::SMCCC_VERSION //XXX: this should be added for realm-linux booting
| rsi::PSCI_CPU_SUSPEND
| rsi::PSCI_CPU_OFF
| rsi::PSCI_CPU_ON
| rsi::PSCI_AFFINITY_INFO
| rsi::PSCI_SYSTEM_OFF
| rsi::PSCI_SYSTEM_RESET
| rsi::PSCI_FEATURES
| rsi::PSCI_VERSION => PsciReturn::SUCCESS,
_ => PsciReturn::NOT_SUPPORTED,
};
if set_reg(rec, 0, retval).is_err() {
warn!("Unable to set register 0. rec: {:?}", rec);
}
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, rsi::SMCCC_VERSION, |_arg, ret, _rmm, rec, _run| {
if set_reg(rec, 0, smccc_version()).is_err() {
warn!("Unable to set register 0. rec: {:?}", rec);
}
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
}
fn psci_version() -> usize {
(PSCI_MAJOR_VERSION << 16) | PSCI_MINOR_VERSION
}
fn smccc_version() -> usize {
(SMCCC_MAJOR_VERSION << 16) | SMCCC_MINOR_VERSION
}
fn return_code_permitted(
caller: &mut Rec<'_>,
target: &mut Rec<'_>,
status: usize,
) -> Result<(), Error> {
if status == PsciReturn::SUCCESS {
return Ok(());
}
let command = get_reg(caller, 0)?;
if command == rsi::PSCI_CPU_ON && !target.runnable() && status == PsciReturn::DENIED {
return Ok(());
}
Err(Error::RmiErrorInput)
}
pub fn complete_psci(
caller: &mut Rec<'_>,
target: &mut Rec<'_>,
status: usize,
) -> Result<(), Error> {
let target_vcpuid = target.vcpuid();
let target_mpidr = get_reg(caller, 1)? as u64;
// TODO: check the below again
if MPIDR::from(target_mpidr).index() != target_vcpuid {
return Err(Error::RmiErrorInput);
}
return_code_permitted(caller, target, status)?;
let command = get_reg(caller, 0)?;
let psci_ret = match command {
rsi::PSCI_CPU_ON if target.runnable() => PsciReturn::ALREADY_ON,
rsi::PSCI_CPU_ON if status == PsciReturn::DENIED => PsciReturn::DENIED,
rsi::PSCI_CPU_ON => {
let entry_point = get_reg(caller, 2)?;
let context_id = get_reg(caller, 3)?;
target.reset_ctx();
set_reg(target, 0, context_id)?;
set_reg(target, RegOffset::PC, entry_point)?;
target.set_runnable(1);
PsciReturn::SUCCESS
}
rsi::PSCI_AFFINITY_INFO if target.runnable() => PsciReturn::AFFINITY_INFO_ON,
rsi::PSCI_AFFINITY_INFO => PsciReturn::AFFINITY_INFO_OFF,
_ => PsciReturn::NOT_SUPPORTED,
};
set_reg(caller, 0, psci_ret)?;
set_reg(caller, 1, 0)?;
set_reg(caller, 2, 0)?;
set_reg(caller, 3, 0)?;
caller.set_psci_pending(false);
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/version.rs | rmm/src/rsi/version.rs | use crate::rsi;
pub fn decode_version(version: usize) -> (usize, usize) {
let major = (version & 0x7fff0000) >> 16;
let minor = version & 0xffff;
(major, minor)
}
pub fn encode_version() -> usize {
(rsi::ABI_VERSION_MAJOR << 16) | rsi::ABI_VERSION_MINOR
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/error.rs | rmm/src/rsi/error.rs | use crate::measurement::MeasurementError;
#[derive(Debug)]
pub enum Error {
RealmDoesNotExists,
InvalidMeasurementIndex,
MeasurementError(MeasurementError),
}
impl From<MeasurementError> for Error {
fn from(value: MeasurementError) -> Self {
Self::MeasurementError(value)
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/measurement.rs | rmm/src/rsi/measurement.rs | use crate::measurement::MeasurementError;
use crate::rsi::error::Error;
use crate::rsi::Rd;
pub fn read(
rd: &Rd,
index: usize,
out: &mut crate::measurement::Measurement,
) -> Result<(), crate::rsi::error::Error> {
let measurement = rd
.measurements
.get(index)
.ok_or(Error::InvalidMeasurementIndex)?;
out.as_mut_slice().copy_from_slice(measurement.as_slice());
Ok(())
}
pub fn extend(
rd: &mut Rd,
index: usize,
f: impl Fn(&mut crate::measurement::Measurement) -> Result<(), MeasurementError>,
) -> Result<(), crate::rsi::error::Error> {
let measurement = rd
.measurements
.get_mut(index)
.ok_or(Error::InvalidMeasurementIndex)?;
f(measurement)?;
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/ripas.rs | rmm/src/rsi/ripas.rs | use crate::granule::is_granule_aligned;
use crate::granule::GranuleState;
use crate::realm::mm::stage2_tte::ripas;
use crate::realm::rd::Rd;
use crate::rec::context::{get_reg, set_reg};
use crate::rec::Rec;
use crate::rmi;
use crate::rmi::error::Error;
use crate::rmi::rec::run::{EntryFlag, Run};
use crate::rsi;
use crate::Monitor;
use crate::{get_granule, get_granule_if};
pub fn get_ripas_state(
_arg: &[usize],
ret: &mut [usize],
_rmm: &Monitor,
rec: &mut Rec<'_>,
_run: &mut Run,
) -> core::result::Result<(), Error> {
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
let base = get_reg(rec, 1)?;
let top = get_reg(rec, 2)?;
// To prevent underflow when top is 0,
// check top <= base prior to addr_in_par() check
if !is_granule_aligned(base)
|| !is_granule_aligned(top)
|| !rd.addr_in_par(base)
|| top <= base
|| !rd.addr_in_par(top - 1)
{
if set_reg(rec, 0, rsi::ERROR_INPUT).is_err() {
warn!("Unable to set register 0. rec: {:?}", rec);
}
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
let res = crate::realm::mm::rtt::get_ripas(&rd, base, top);
let (out_top, ripas) = if let Ok((out_top, ripas)) = res {
if out_top > top {
(top, ripas)
} else {
(out_top, ripas)
}
} else {
if set_reg(rec, 0, rsi::ERROR_INPUT).is_err() {
warn!("Unable to set register 0. rec: {:?}", rec);
}
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
};
debug!(
"RSI_IPA_STATE_GET: base: {:X} top: {:X} out_top: {:X} ripas: {:X}",
base, top, out_top, ripas
);
if set_reg(rec, 0, rsi::SUCCESS).is_err() {
warn!("Unable to set register 0. rec: {:?}", rec);
}
if set_reg(rec, 1, out_top).is_err() {
warn!("Unable to set register 1. rec: {:?}", rec);
}
if set_reg(rec, 2, ripas as usize).is_err() {
warn!("Unable to set register 2. rec: {:?}", rec);
}
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
}
pub fn set_ripas_state(
_arg: &[usize],
ret: &mut [usize],
_rmm: &Monitor,
rec: &mut Rec<'_>,
run: &mut Run,
) -> core::result::Result<(), Error> {
let ipa_start = get_reg(rec, 1)?;
let ipa_end = get_reg(rec, 2)?;
let ipa_state = get_reg(rec, 3)? as u8;
let flags = get_reg(rec, 4)? as u64;
if ipa_end <= ipa_start {
set_reg(rec, 0, rsi::ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
//return Err(Error::RmiErrorInput); // integer overflows or size is zero
}
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
if !is_granule_aligned(ipa_start)
|| !is_granule_aligned(ipa_end)
|| !is_ripas_valid(ipa_state)
|| ipa_end <= ipa_start
|| !rd.addr_in_par(ipa_start)
|| !rd.addr_in_par(ipa_end - 1)
{
set_reg(rec, 0, rsi::ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
// TODO: check ipa_state value, ipa address granularity
run.set_exit_reason(rmi::EXIT_RIPAS_CHANGE);
run.set_ripas(ipa_start as u64, ipa_end as u64, ipa_state);
rec.set_ripas(ipa_start as u64, ipa_end as u64, ipa_state, flags);
ret[0] = rmi::SUCCESS;
debug!(
"RSI_IPA_STATE_SET: {:X} ~ {:X} {:X} {:X}",
ipa_start, ipa_end, ipa_state, flags
);
Ok(())
}
fn is_ripas_valid(ripas: u8) -> bool {
match ripas as u64 {
ripas::EMPTY | ripas::RAM => true,
_ => false,
}
}
pub fn complete_ripas(rec: &mut Rec<'_>, run: &Run) -> Result<(), Error> {
let ripas_addr = rec.ripas_addr() as usize;
if rec.ripas_end() as usize > 0 {
set_reg(rec, 0, rsi::SUCCESS)?; // RSI_SUCCESS
set_reg(rec, 1, ripas_addr)?;
let flags = run.entry_flags();
if flags.get_masked(EntryFlag::RIPAS_RESPONSE) != 0 {
set_reg(rec, 2, 1)?; // REJECT
} else {
set_reg(rec, 2, 0)?; // ACCEPT
}
rec.set_ripas(0, 0, 0, 0);
}
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/mod.rs | rmm/src/rsi/mod.rs | pub mod attestation;
pub mod constraint;
pub mod error;
pub mod hostcall;
pub mod measurement;
pub mod psci;
pub mod ripas;
pub mod sealing;
pub mod version;
use alloc::vec::Vec;
use crate::define_interface;
use crate::event::RsiHandle;
use crate::granule::{GranuleState, GRANULE_SIZE};
use crate::listen;
use crate::measurement::{HashContext, Measurement, MEASUREMENTS_SLOT_NR, MEASUREMENTS_SLOT_RIM};
use crate::realm::config::realm_config;
use crate::realm::mm::address::GuestPhysAddr;
use crate::realm::mm::rtt::RTT_PAGE_LEVEL;
use crate::realm::rd::Rd;
use crate::rec::context::{get_reg, set_reg};
use crate::rec::{Rec, RmmRecAttestState};
use crate::rmi;
use crate::rmi::error::Error;
use crate::rmi::rec::run::Run;
use crate::rmi::rtt::validate_ipa;
use crate::rsi::hostcall::{HostCall, HOST_CALL_NR_GPRS};
use crate::rsi::ripas::{get_ripas_state, set_ripas_state};
use crate::rsi::sealing::{realm_sealing_key, SEALING_KEY_SIZE};
use crate::Monitor;
use crate::{get_granule, get_granule_if};
use safe_abstraction::raw_ptr::assume_safe;
define_interface! {
command {
ABI_VERSION = 0xc400_0190,
FEATURES = 0xc400_0191,
MEASUREMENT_READ = 0xc400_0192,
MEASUREMENT_EXTEND = 0xc400_0193,
ATTEST_TOKEN_INIT = 0xc400_0194,
ATTEST_TOKEN_CONTINUE = 0xc400_0195,
REALM_CONFIG = 0xc400_0196,
IPA_STATE_SET = 0xc400_0197,
IPA_STATE_GET = 0xc400_0198,
HOST_CALL = 0xc400_0199,
// PSCI smcs
// XXX: SMCCC_VERSION is not defined in the spec, so remove it if it is not used now
SMCCC_VERSION = 0x8000_0000,
PSCI_VERSION = 0x8400_0000,
PSCI_CPU_SUSPEND = 0xC400_0001,
PSCI_CPU_OFF = 0x8400_0002,
PSCI_CPU_ON = 0xC400_0003,
PSCI_AFFINITY_INFO = 0xC400_0004,
PSCI_SYSTEM_OFF = 0x8400_0008,
PSCI_SYSTEM_RESET = 0x8400_0009,
PSCI_FEATURES = 0x8400_000A,
// vendor calls
ISLET_REALM_SEALING_KEY = 0xC700_0191,
}
}
pub const SUCCESS: usize = 0;
pub const ERROR_INPUT: usize = 1;
pub const ERROR_STATE: usize = 2;
pub const INCOMPLETE: usize = 3;
pub const ABI_VERSION_MAJOR: usize = 1;
pub const ABI_VERSION_MINOR: usize = 0;
extern crate alloc;
pub fn do_host_call(
_arg: &[usize],
ret: &mut [usize],
_rmm: &Monitor,
rec: &mut Rec<'_>,
run: &mut Run,
) -> core::result::Result<(), Error> {
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
let ipa = get_reg(rec, 1).unwrap_or(0x0);
let struct_size = core::mem::size_of::<HostCall>();
if ipa % struct_size != 0
|| !rd.addr_in_par(ipa)
|| ipa / GRANULE_SIZE != (ipa + struct_size - 1) / GRANULE_SIZE
{
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
let pa = rd
.s2_table()
.lock()
.ipa_to_pa(
crate::realm::mm::address::GuestPhysAddr::from(ipa),
RTT_PAGE_LEVEL,
)
.ok_or(Error::RmiErrorInput)?;
// page mapping result 'pa' is PAGE_SIZE aligned. Get hsot_call_ptr.
let host_call_ptr: usize = pa.as_usize() + ipa % crate::config::PAGE_SIZE;
let mut host_call = assume_safe::<HostCall>(host_call_ptr)?;
let imm = host_call.imm();
if rec.host_call_pending() {
for i in 0..HOST_CALL_NR_GPRS {
let val = run.entry_gpr(i)?;
host_call.set_gpr(i, val)?
}
set_reg(rec, 0, SUCCESS)?;
rec.set_host_call_pending(false);
} else {
for i in 0..HOST_CALL_NR_GPRS {
let val = host_call.gpr(i)?;
run.set_gpr(i, val)?
}
run.set_imm(imm);
run.set_exit_reason(rmi::EXIT_HOST_CALL);
rec.set_host_call_pending(true);
}
trace!("HOST_CALL param: {:#X?}", *host_call);
ret[0] = rmi::SUCCESS;
Ok(())
}
fn get_token_part(
rd: &Rd,
context: &mut Rec<'_>,
size: usize,
) -> core::result::Result<(Vec<u8>, usize), Error> {
let hash_algo = rd.hash_algo();
let measurements = rd.measurements;
// FIXME: This should be stored instead of generating it for every call.
let token = crate::rsi::attestation::get_token(
context.attest_challenge(),
&measurements,
rd.personalization_value(),
hash_algo,
);
let offset = context.attest_token_offset();
let part_size = core::cmp::min(size, token.len() - offset);
let part_end = offset + part_size;
context.set_attest_offset(part_end);
Ok((token[offset..part_end].to_vec(), token.len() - part_end))
}
pub fn set_event_handler(rsi: &mut RsiHandle) {
listen!(rsi, ATTEST_TOKEN_INIT, |_arg, ret, _rmm, rec, _| {
let mut challenge: [u8; 64] = [0; 64];
for i in 0..8 {
let challenge_part = get_reg(rec, i + 1)?;
let start_idx = i * 8;
let end_idx = start_idx + 8;
challenge[start_idx..end_idx].copy_from_slice(&challenge_part.to_le_bytes());
}
rec.set_attest_challenge(&challenge);
rec.set_attest_state(RmmRecAttestState::AttestInProgress);
rec.set_attest_offset(0);
set_reg(rec, 0, SUCCESS)?;
set_reg(rec, 1, attestation::MAX_CCA_TOKEN_SIZE)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, ATTEST_TOKEN_CONTINUE, |_arg, ret, _rmm, rec, _| {
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
if rec.attest_state() != RmmRecAttestState::AttestInProgress {
warn!("Calling attest token continue without init");
set_reg(rec, 0, ERROR_STATE)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
let attest_ipa = get_reg(rec, 1)?;
if validate_ipa(&rd, attest_ipa).is_err() {
warn!("Wrong ipa passed {}", attest_ipa);
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
let attest_pa: usize = rd
.s2_table()
.lock()
.ipa_to_pa(GuestPhysAddr::from(attest_ipa), RTT_PAGE_LEVEL)
.ok_or(Error::RmiErrorInput)?
.into();
let pa_offset = get_reg(rec, 2)?;
let buffer_size = get_reg(rec, 3)?;
let (_, overflowed) = pa_offset.overflowing_add(buffer_size);
if overflowed || pa_offset + buffer_size > GRANULE_SIZE {
warn!("Buffer addres region invalid");
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
#[cfg(not(kani))]
// `rsi` is currently not reachable in model checking harnesses
{
let (token_part, token_left) = get_token_part(&rd, rec, buffer_size)?;
unsafe {
let pa_ptr = attest_pa as *mut u8;
core::ptr::copy(token_part.as_ptr(), pa_ptr.add(pa_offset), token_part.len());
}
if token_left == 0 {
set_reg(rec, 0, SUCCESS)?;
rec.set_attest_state(RmmRecAttestState::NoAttestInProgress);
} else {
set_reg(rec, 0, INCOMPLETE)?;
}
set_reg(rec, 1, token_part.len())?;
}
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, FEATURES, |_arg, ret, _rmm, rec, _| {
let _index = get_reg(rec, 1);
set_reg(rec, 0, SUCCESS)?;
// B5.3.3 In the current version of the interface, this commands returns
// zero regardless of the index provided.
set_reg(rec, 1, 0)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, HOST_CALL, do_host_call);
listen!(rsi, ABI_VERSION, |_arg, ret, _rmm, rec, _| {
let req = get_reg(rec, 1)?;
let (req_major, req_minor) = version::decode_version(req);
if req_major != ABI_VERSION_MAJOR || req_minor != ABI_VERSION_MINOR {
warn!(
"Wrong unsupported version requested ({}, {})",
req_major, req_minor
);
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
let lower = version::encode_version();
let higher = lower;
set_reg(rec, 0, SUCCESS)?;
set_reg(rec, 1, lower)?;
set_reg(rec, 2, higher)?;
trace!("RSI_ABI_VERSION: {:#X?} {:#X?}", lower, higher);
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, MEASUREMENT_READ, |_arg, ret, _rmm, rec, _| {
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
let mut measurement = Measurement::empty();
let index = get_reg(rec, 1)?;
if index >= MEASUREMENTS_SLOT_NR {
warn!("Wrong index passed: {}", index);
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
#[cfg(not(kani))]
// `rsi` is currently not reachable in model checking harnesses
crate::rsi::measurement::read(&rd, index, &mut measurement)?;
set_reg(rec, 0, SUCCESS)?;
for (ind, chunk) in measurement
.as_slice()
.chunks_exact(core::mem::size_of::<usize>())
.enumerate()
{
let reg_value = usize::from_le_bytes(chunk.try_into().unwrap());
set_reg(rec, ind + 1, reg_value)?;
}
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, MEASUREMENT_EXTEND, |_arg, ret, _rmm, rec, _| {
let mut rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let mut rd = rd_granule.content_mut::<Rd>()?;
let index = get_reg(rec, 1)?;
let size = get_reg(rec, 2)?;
let mut buffer = [0u8; 64];
for i in 0..8 {
buffer[i * 8..i * 8 + 8].copy_from_slice(get_reg(rec, i + 3)?.to_le_bytes().as_slice());
}
if size > buffer.len() || index == MEASUREMENTS_SLOT_RIM || index >= MEASUREMENTS_SLOT_NR {
warn!(
"Wrong index or buffer size passed: idx: {}, size: {}",
index, size
);
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
#[cfg(not(kani))]
// `rsi` is currently not reachable in model checking harnesses
HashContext::new(&mut rd)?.extend_measurement(&buffer[0..size], index)?;
set_reg(rec, 0, SUCCESS)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, REALM_CONFIG, |_arg, ret, _rmm, rec, _| {
let ipa_bits = rec.ipa_bits()?;
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
let config_ipa = get_reg(rec, 1)?;
if validate_ipa(&rd, config_ipa).is_err() {
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
realm_config(&rd, config_ipa, ipa_bits)?;
if set_reg(rec, 0, SUCCESS).is_err() {
warn!("Unable to set register 0. rec: {:?}", rec);
}
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
listen!(rsi, IPA_STATE_GET, get_ripas_state);
listen!(rsi, IPA_STATE_SET, set_ripas_state);
// ISLET_REALM_SEALING_KEY is a vendor specific RSI for derivation and retrieval of Sealing Keys
// Input registers:
// x0: function id (0xC7000191)
// x1: flags - a bit field, where:
// bit 0: if not set, VHUK_A i used (default), otherwise VHUK_M is used as an input key material
// bit 1: if set, RIM is used as a key metarial
// bit 2: if set, the realm_id is used as a key material
// bit 3: if set, provided SVN is used as a key material
// x2: svn - Security Version Number
// The resulting key is returned 256 bit long key is returned
// in x1, x2, x3, x4 registers
listen!(rsi, ISLET_REALM_SEALING_KEY, |_arg, ret, _rmm, rec, _| {
let flags = get_reg(rec, 1)?;
let svn = get_reg(rec, 2)?;
let mut buf = [0u8; SEALING_KEY_SIZE];
let rd_granule = get_granule_if!(rec.owner()?, GranuleState::RD)?;
let rd = rd_granule.content::<Rd>()?;
if realm_sealing_key(&rd, flags, svn, &mut buf).is_err() {
set_reg(rec, 0, ERROR_INPUT)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
return Ok(());
}
for (ind, chunk) in buf.chunks_exact(core::mem::size_of::<usize>()).enumerate() {
let reg_value = usize::from_ne_bytes(chunk.try_into().unwrap());
set_reg(rec, ind + 1, reg_value)?;
}
// Clear the sealing key
// TODO: use zeroize?
unsafe {
core::ptr::write_bytes(buf.as_mut_ptr(), 0x0, SEALING_KEY_SIZE);
}
set_reg(rec, 0, SUCCESS)?;
ret[0] = rmi::SUCCESS_REC_ENTER;
Ok(())
});
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/sealing.rs | rmm/src/rsi/sealing.rs | use core::ffi::CStr;
use crate::granule::GranuleState;
use crate::measurement::{Measurement, MEASUREMENTS_SLOT_MAX_SIZE, MEASUREMENTS_SLOT_RIM};
use crate::realm::rd::{Rd, RPV_SIZE};
use crate::rmi::error::Error;
use crate::rmi::metadata::{IsletRealmMetadata, P384_PUBLIC_KEY_SIZE, REALM_ID_SIZE};
use crate::rmm_el3::{vhuk_a, vhuk_m};
use crate::{get_granule, get_granule_if};
const RSI_ISLET_USE_VHUK_M: usize = 0x1 << 0;
const RSI_ISLET_SLK_RIM: usize = 0x1 << 1;
const RSI_ISLET_SLK_REALM_ID: usize = 0x1 << 2;
const RSI_ISLET_SLK_SVN: usize = 0x1 << 3;
pub const SEALING_KEY_SIZE: usize = 32;
const SALT: [u8; 32] = [
0xd5, 0x77, 0x5f, 0x52, 0x4a, 0xce, 0x32, 0x21, 0xce, 0x77, 0x1e, 0xd2, 0x74, 0xbb, 0x74, 0xa4,
0x60, 0xce, 0x3f, 0xb9, 0x74, 0x9c, 0xe3, 0x7d, 0x0a, 0xe6, 0xd2, 0xe9, 0x07, 0xf8, 0xb5, 0x4b,
];
#[repr(C, packed)]
struct KdfInfo {
public_key: [u8; P384_PUBLIC_KEY_SIZE],
realm_id: [u8; REALM_ID_SIZE],
rpv: [u8; RPV_SIZE],
flags: usize,
rim: [u8; MEASUREMENTS_SLOT_MAX_SIZE],
hash_algo: u8,
svn: usize,
}
impl KdfInfo {
fn new() -> Self {
Self {
public_key: [0; P384_PUBLIC_KEY_SIZE],
realm_id: [0; REALM_ID_SIZE],
rpv: [0; RPV_SIZE],
flags: 0,
rim: [0; MEASUREMENTS_SLOT_MAX_SIZE],
hash_algo: 0,
svn: 0,
}
}
// TODO: use zeroize?
fn zeroize(&mut self) {
let addr = self as *mut Self;
unsafe {
core::ptr::write_bytes(addr as *mut u8, 0x0, core::mem::size_of::<Self>());
}
}
fn realm_id_as_str(&self) -> Option<&str> {
let Ok(cstr) = CStr::from_bytes_until_nul(&self.realm_id) else {
return None;
};
let Ok(s) = cstr.to_str() else {
return None;
};
Some(s)
}
fn dump(&self) {
debug!("KDF info");
debug!("public_key: {}", hex::encode(self.public_key));
debug!(
"realm_id: {}",
self.realm_id_as_str().unwrap_or("INVALID REALM ID")
);
debug!("rpv: {}", hex::encode(self.rpv));
let flags = self.flags; // not aligned
debug!("flags: {:#010x}", flags);
debug!("rim: {}", hex::encode(self.rim));
debug!("hash_algo: {:#04x}", self.hash_algo);
let svn = self.svn; // not aligned
debug!("svn: {:#010x}", svn);
}
fn as_u8_slice(&self) -> &[u8] {
unsafe {
core::slice::from_raw_parts(
(self as *const Self) as *const u8,
core::mem::size_of::<Self>(),
)
}
}
fn derive_sealing_key(
&self,
use_vhuk_m: bool,
okm: &mut [u8; SEALING_KEY_SIZE],
) -> core::result::Result<(), Error> {
let ikm = if use_vhuk_m { vhuk_m() } else { vhuk_a() };
let info = self.as_u8_slice();
let hkdf = hkdf::Hkdf::<sha2::Sha256>::new(Some(&SALT), &ikm);
hkdf.expand(info, okm).or(Err(Error::RmiErrorInput))?;
Ok(())
}
}
pub fn realm_sealing_key(
rd: &Rd,
flags: usize,
svn: usize,
buf: &mut [u8; SEALING_KEY_SIZE],
) -> core::result::Result<(), Error> {
debug!("flags: {:#010x}, svn: {:#010x}", flags, svn);
let mut info = KdfInfo::new();
info.rpv.copy_from_slice(rd.personalization_value());
info.flags = flags;
if let Some(meta_addr) = rd.metadata() {
let metadata_granule = get_granule_if!(meta_addr, GranuleState::Metadata)?;
let metadata_obj = metadata_granule.content::<IsletRealmMetadata>()?;
if flags & RSI_ISLET_SLK_SVN != 0 && metadata_obj.svn() < svn {
warn!("The SVN parameter is invalid!");
Err(Error::RmiErrorInput)?
}
info.public_key = *metadata_obj.public_key();
if flags & RSI_ISLET_SLK_REALM_ID != 0 {
info.realm_id = *metadata_obj.realm_id();
}
if flags & RSI_ISLET_SLK_SVN != 0 {
info.svn = svn;
}
}
// We allow realms not having a metadata block assigned
// to derive sealing keys. In that case, the RIM of the realm
// is always used as the key material.
if flags & RSI_ISLET_SLK_RIM != 0 || rd.metadata().is_none() {
let mut rim = Measurement::empty();
crate::rsi::measurement::read(rd, MEASUREMENTS_SLOT_RIM, &mut rim)?;
info.rim.copy_from_slice(rim.as_slice());
}
info.dump();
debug!(
"ikm type: {}",
if flags & RSI_ISLET_USE_VHUK_M != 0 {
"VHUK_M"
} else {
"VHUK_A"
}
);
info.derive_sealing_key(flags & RSI_ISLET_USE_VHUK_M != 0, buf)?;
// Clear the input key material
info.zeroize();
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/constraint.rs | rmm/src/rsi/constraint.rs | use crate::config::SMCCC_1_3_SVE_HINT;
use crate::event::{Command, Context};
use crate::rmi::constraint::Constraint; // TODO: we might need rsi's own constraint struct in the future
use crate::rsi;
fn pick(cmd: Command) -> Option<Constraint> {
let constraint = match cmd {
// XXX: Constraints for RSI and PSCI are not correctly enforced now.
// Note that arg and ret values in Context are not used in RSI where
// set_reg and get_reg are instead used.
rsi::ABI_VERSION => Constraint::new(rsi::ABI_VERSION, 2, 3),
rsi::FEATURES => Constraint::new(rsi::FEATURES, 2, 2),
rsi::MEASUREMENT_READ => Constraint::new(rsi::MEASUREMENT_READ, 2, 9),
rsi::MEASUREMENT_EXTEND => Constraint::new(rsi::MEASUREMENT_EXTEND, 11, 1),
rsi::ATTEST_TOKEN_INIT => Constraint::new(rsi::ATTEST_TOKEN_INIT, 9, 2),
rsi::ATTEST_TOKEN_CONTINUE => Constraint::new(rsi::ATTEST_TOKEN_CONTINUE, 4, 2),
rsi::REALM_CONFIG => Constraint::new(rsi::REALM_CONFIG, 2, 1),
rsi::IPA_STATE_SET => Constraint::new(rsi::IPA_STATE_SET, 5, 3),
rsi::IPA_STATE_GET => Constraint::new(rsi::IPA_STATE_GET, 3, 3),
rsi::HOST_CALL => Constraint::new(rsi::HOST_CALL, 2, 1),
// PSCI
// XXX: Setting 0 in ret_num currently causes a problem, while PSCI_CPU_SUSPEND,
// PSCI_CPU_OFF, PSCI_SYSTEM_OFF, and PSCI_SYSTEM_RESET have no output values.
rsi::PSCI_VERSION => Constraint::new(rsi::PSCI_VERSION, 1, 1),
rsi::PSCI_CPU_SUSPEND => Constraint::new(rsi::PSCI_CPU_SUSPEND, 4, 1),
rsi::PSCI_CPU_OFF => Constraint::new(rsi::PSCI_CPU_OFF, 1, 1),
rsi::PSCI_CPU_ON => Constraint::new(rsi::PSCI_CPU_ON, 4, 1),
rsi::PSCI_AFFINITY_INFO => Constraint::new(rsi::PSCI_AFFINITY_INFO, 3, 1),
rsi::PSCI_SYSTEM_OFF => Constraint::new(rsi::PSCI_SYSTEM_OFF, 1, 1),
rsi::PSCI_SYSTEM_RESET => Constraint::new(rsi::PSCI_SYSTEM_RESET, 1, 1),
rsi::PSCI_FEATURES => Constraint::new(rsi::PSCI_FEATURES, 2, 1),
// XXX: SMCCC_VERSION is not defined in the spec, so remove it if it is not used now
rsi::SMCCC_VERSION => Constraint::new(rsi::SMCCC_VERSION, 2, 1),
// XXX: REALM_SEALING_KEY do not exist in the spec
rsi::ISLET_REALM_SEALING_KEY => Constraint::new(rsi::ISLET_REALM_SEALING_KEY, 2, 5),
_ => return None,
};
Some(constraint)
}
pub fn validate(cmd: Command) -> Context {
let fid = cmd & !SMCCC_1_3_SVE_HINT;
let mut ctx = Context::new(fid);
if cmd & SMCCC_1_3_SVE_HINT != 0 {
ctx.sve_hint = true;
}
if let Some(c) = pick(fid) {
ctx.resize_ret(c.ret_num);
} else {
// rmm.handle_rsi takes care of unregistered command.
// Just limit the array size here.
ctx.resize_ret(1);
}
ctx
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/attestation/mod.rs | rmm/src/rsi/attestation/mod.rs | pub mod claims;
use alloc::{boxed::Box, string::String, vec, vec::Vec};
use ciborium::{ser, Value};
use coset::{CoseSign1Builder, HeaderBuilder, TaggedCborSerializable};
use ecdsa::signature::Signer;
use tinyvec::ArrayVec;
use crate::{
measurement::Measurement,
rmi::{HASH_ALGO_SHA256, HASH_ALGO_SHA512},
};
use self::claims::RealmClaims;
use crate::rmm_el3::{plat_token, realm_attest_key};
// Arbitrary number.
pub const MAX_CCA_TOKEN_SIZE: usize = 4096;
// This mostly depends on amount of measurement slots used.
// In the maximum it could take around 6kB.
// Currently platform token size is a little over 1kB.
pub const MAX_PLATFORM_TOKEN_SIZE: usize = 2048;
pub const MAX_CHALLENGE_SIZE: usize = 64;
const CCA_TOKEN_COLLECTION: u64 = 399;
const CCA_PLATFORM_TOKEN: u64 = 44234;
const CCA_REALM_DELEGATED_TOKEN: u64 = 44241;
// Hardcoded RAK private key for use in fuzzing, where HES is absent.
#[cfg(fuzzing)]
const RAK_PRIV_KEY: [u8; 48] = [
60, 140, 180, 183, 23, 21, 46, 76, 243, 33, 155, 38, 242, 82, 86, 0, 57, 97, 140, 67, 71, 234,
13, 22, 87, 140, 136, 172, 120, 226, 162, 115, 202, 242, 116, 10, 141, 245, 16, 119, 255, 31,
1, 3, 10, 113, 218, 134,
];
type PlatformToken = ArrayVec<[u8; MAX_PLATFORM_TOKEN_SIZE]>;
// 48B - the length of EC-P384 private key
type RAKPriv = ArrayVec<[u8; 48]>;
#[derive(Debug, Default)]
pub struct Attestation {
platform_token: PlatformToken,
rak_priv: RAKPriv,
}
// TODO: Can we keep this context anywhere?
impl Attestation {
pub fn new(platform_token: &[u8], rak_priv: &[u8]) -> Self {
let mut at = Self::default();
at.set_platform_token(platform_token);
at.set_rak_priv(rak_priv);
at
}
fn set_platform_token(&mut self, token: &[u8]) {
self.platform_token = token.iter().cloned().collect();
}
fn set_rak_priv(&mut self, key_priv: &[u8]) {
self.rak_priv = key_priv.iter().cloned().collect();
}
// TODO: Consider returning errors.
// Though all errors in here are programmer errors
// or a result of incorrect data passed from HES.
pub fn create_attestation_token(
&self,
challenge: &[u8],
measurements: &[Measurement],
personalization_value: &[u8],
hash_algo: u8,
) -> Vec<u8> {
let mut cca_token = Vec::new();
let realm_token =
self.create_realm_token(challenge, measurements, personalization_value, hash_algo);
let realm_token_entry = (
Value::Integer(CCA_REALM_DELEGATED_TOKEN.into()),
Value::Bytes(realm_token),
);
let platform_token_entry = (
Value::Integer(CCA_PLATFORM_TOKEN.into()),
Value::Bytes(self.platform_token.to_vec()),
);
let token_map: Vec<(Value, Value)> = vec![platform_token_entry, realm_token_entry];
ser::into_writer(
&Value::Tag(CCA_TOKEN_COLLECTION, Box::new(Value::Map(token_map))),
&mut cca_token,
)
.expect("Failed to serialize CCA token");
cca_token
}
fn create_realm_token(
&self,
challenge: &[u8],
measurements: &[Measurement],
personalization_value: &[u8],
hash_algo: u8,
) -> Vec<u8> {
let hash_algo_id = match hash_algo {
HASH_ALGO_SHA256 => String::from("sha-256"),
HASH_ALGO_SHA512 => String::from("sha-512"),
_ => panic!("Unrecognized hash algorithm {}", hash_algo),
};
let secret_key =
p384::SecretKey::from_slice(&self.rak_priv).expect("Failed to import private RAK.");
let public_key = secret_key.public_key().to_sec1_bytes().to_vec();
let claims = RealmClaims::init(
challenge,
personalization_value,
measurements,
hash_algo_id,
&public_key,
// TODO: should this value be stored somewhere else?
String::from("sha-256"),
);
let claims_map: Vec<(Value, Value)> = vec![
claims.challenge.into(),
claims.profile.into(),
claims.personalization_value.into(),
claims.rim.into(),
claims.rems.into(),
claims.measurement_hash_algo.into(),
claims.rak_pub.into(),
claims.rak_pub_hash_algo.into(),
];
let mut realm_token = Vec::new();
ser::into_writer(&Value::Map(claims_map), &mut realm_token)
.expect("Failed to serialize realm token");
let protected = HeaderBuilder::new()
.algorithm(coset::iana::Algorithm::ES384)
.build();
let sign1 = CoseSign1Builder::new()
.protected(protected)
.payload(realm_token)
.create_signature(b"", |payload| Self::sign(secret_key, payload))
.build();
sign1
.to_tagged_vec()
.expect("Failed to create tagged signed token")
}
fn sign(secret_key: p384::SecretKey, data: &[u8]) -> Vec<u8> {
let signing_key = p384::ecdsa::SigningKey::from_bytes(&secret_key.to_bytes())
.expect("Failed to generate signing key");
let signature: p384::ecdsa::Signature = signing_key
.try_sign(data)
.expect("Failed to create P384 signature");
signature.to_vec()
}
}
pub fn get_token(
challenge: &[u8],
measurements: &[Measurement],
personalization_value: &[u8],
hash_algo: u8,
) -> Vec<u8> {
// TODO: consider storing attestation object somewhere,
// as RAK and token do not change during rmm lifetime.
#[cfg(fuzzing)]
let realm_attest_key = &RAK_PRIV_KEY;
#[cfg(not(fuzzing))]
let realm_attest_key = &realm_attest_key();
Attestation::new(&plat_token(), realm_attest_key).create_attestation_token(
challenge,
measurements,
personalization_value,
hash_algo,
)
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rsi/attestation/claims.rs | rmm/src/rsi/attestation/claims.rs | use core::fmt::Debug;
use alloc::{
string::{String, ToString},
vec::Vec,
};
use ciborium::Value;
use tinyvec::ArrayVec;
use crate::cose;
use crate::measurement::{Measurement, MEASUREMENTS_SLOT_NR, MEASUREMENTS_SLOT_RIM};
pub const CHALLENGE_LABEL: u64 = 10;
pub const PROFILE_LABEL: u64 = 265;
pub const PERSONALIZATION_VALUE_LABEL: u64 = 44235;
pub const INITIAL_MEASUREMENT_LABEL: u64 = 44238;
pub const EXTENSIBLE_MEASUREMENTS_LABEL: u64 = 44239;
pub const HASH_ALGO_ID_LABEL: u64 = 44236;
pub const PUBLIC_KEY_LABEL: u64 = 44237;
pub const PUBLIC_KEY_HASH_ALOG_ID_LABEL: u64 = 44240;
pub const REALM_PROFILE: &str = "tag:arm.com,2023:realm#1.0.0";
#[derive(Clone, Copy, Debug, Default)]
pub struct MeasurementEntry(Measurement, usize);
#[derive(Clone, Debug)]
pub struct Data<T: Default, const N: usize>(ArrayVec<[T; N]>);
impl<T: Copy + Default, const N: usize> Data<T, N> {
pub fn from_slice(slice: &[T]) -> Self {
Data(slice.iter().cloned().collect())
}
}
pub const REM_SLOT_NR: usize = MEASUREMENTS_SLOT_NR - 1;
pub type Challenge = Data<u8, 64>;
pub type Profile = String;
pub type PersonalizationValue = Data<u8, 64>;
pub type REMs = Data<MeasurementEntry, REM_SLOT_NR>;
pub type RIM = MeasurementEntry;
pub type HashAlgo = String;
pub type RAKPubKey = Vec<u8>;
#[derive(Clone, Debug)]
pub struct Claim<T> {
value: T,
label: u64,
}
impl<T: Into<Value>> From<Claim<T>> for (Value, Value) {
fn from(value: Claim<T>) -> Self {
(Value::Integer(value.label.into()), value.value.into())
}
}
impl From<MeasurementEntry> for Value {
fn from(value: MeasurementEntry) -> Self {
Value::Bytes(value.0.as_ref()[..value.1].to_vec())
}
}
impl<const N: usize> From<Data<u8, N>> for Value {
fn from(value: Data<u8, N>) -> Self {
Value::Bytes(value.0.to_vec())
}
}
impl<T: Into<Value>, const N: usize> From<Data<T, N>> for Value
where
T: Default,
{
default fn from(value: Data<T, N>) -> Self {
let mut array = Vec::new();
for el in value.0.into_iter() {
array.push(el.into());
}
array.into()
}
}
#[derive(Clone, Debug)]
pub struct RealmClaims {
pub challenge: Claim<Challenge>,
pub profile: Claim<Profile>,
pub personalization_value: Claim<PersonalizationValue>,
pub rim: Claim<RIM>,
pub rems: Claim<REMs>,
pub measurement_hash_algo: Claim<HashAlgo>,
pub rak_pub: Claim<RAKPubKey>,
pub rak_pub_hash_algo: Claim<HashAlgo>,
}
impl RealmClaims {
pub fn init(
challenge: &[u8],
personalization_val: &[u8],
measurements: &[Measurement],
measurement_hash_algo: String,
key_pub: &[u8],
key_pub_hash_algo: String,
) -> RealmClaims {
let challenge_claim: Claim<Challenge> = Claim {
label: CHALLENGE_LABEL,
value: Data::from_slice(challenge),
};
let profile: Claim<Profile> = Claim {
label: PROFILE_LABEL,
value: REALM_PROFILE.to_string(),
};
let personalization_value: Claim<PersonalizationValue> = Claim {
label: PERSONALIZATION_VALUE_LABEL,
value: Data::from_slice(personalization_val),
};
let measurement_size = match measurement_hash_algo.as_str() {
"sha-256" => 32,
"sha-512" => 64,
_ => panic!("Unexpected hash algo id {}", measurement_hash_algo),
};
let rim: Claim<RIM> = Claim {
label: INITIAL_MEASUREMENT_LABEL,
value: MeasurementEntry(measurements[MEASUREMENTS_SLOT_RIM], measurement_size),
};
let mut rems_data = [MeasurementEntry::default(); REM_SLOT_NR];
for i in 0..REM_SLOT_NR {
rems_data[i] = MeasurementEntry(measurements[i + 1], measurement_size);
}
let rems: Claim<REMs> = Claim {
label: EXTENSIBLE_MEASUREMENTS_LABEL,
value: Data::from_slice(&rems_data),
};
let hash_algo_id: Claim<HashAlgo> = Claim {
label: HASH_ALGO_ID_LABEL,
value: measurement_hash_algo,
};
let key_pub_cose = cose::ec_public_key_sec1_to_cose(key_pub);
let rak_pub: Claim<RAKPubKey> = Claim {
label: PUBLIC_KEY_LABEL,
value: key_pub_cose,
};
let rak_pub_hash_algo: Claim<HashAlgo> = Claim {
label: PUBLIC_KEY_HASH_ALOG_ID_LABEL,
value: key_pub_hash_algo,
};
Self {
challenge: challenge_claim,
profile,
personalization_value,
rim,
rems,
measurement_hash_algo: hash_algo_id,
rak_pub,
rak_pub_hash_algo,
}
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/gic.rs | rmm/src/rec/gic.rs | use super::Rec;
use crate::gic::*;
use crate::rmi::error::Error;
use crate::rmi::rec::run::Run;
use aarch64_cpu::registers::*;
pub fn init_gic(rec: &mut Rec<'_>) {
let gic_state = &mut rec.context.gic_state;
gic_state.ich_hcr_el2 = ICH_HCR_EL2_INIT;
}
pub fn restore_state(rec: &Rec<'_>) {
let gic_state = &rec.context.gic_state;
let nr_lrs = nr_lrs();
let nr_aprs = nr_aprs();
for i in 0..=nr_lrs {
set_lr(i, gic_state.ich_lr_el2[i]);
}
for i in 0..=nr_aprs {
set_ap0r(i, gic_state.ich_ap0r_el2[i]);
set_ap1r(i, gic_state.ich_ap1r_el2[i]);
}
ICH_VMCR_EL2.set(gic_state.ich_vmcr_el2);
ICH_HCR_EL2.set(gic_state.ich_hcr_el2);
}
pub fn save_state(rec: &mut Rec<'_>) {
let gic_state = &mut rec.context.gic_state;
let nr_lrs = nr_lrs();
let nr_aprs = nr_aprs();
for i in 0..=nr_lrs {
gic_state.ich_lr_el2[i] = get_lr(i);
}
for i in 0..=nr_aprs {
gic_state.ich_ap0r_el2[i] = get_ap0r(i);
gic_state.ich_ap1r_el2[i] = get_ap1r(i);
}
gic_state.ich_vmcr_el2 = ICH_VMCR_EL2.get();
gic_state.ich_hcr_el2 = ICH_HCR_EL2.get();
gic_state.ich_misr_el2 = ICH_MISR_EL2.get();
ICH_HCR_EL2.set(gic_state.ich_hcr_el2 & !(ICH_HCR_EL2::En.mask << ICH_HCR_EL2::En.shift));
}
pub fn receive_state_from_host(rec: &mut Rec<'_>, run: &Run) -> Result<(), Error> {
let gic_state = &mut rec.context.gic_state;
let nr_lrs = nr_lrs();
gic_state.ich_lr_el2[..nr_lrs].copy_from_slice(&run.entry_gic_lrs()[..nr_lrs]);
gic_state.ich_hcr_el2 &= !ICH_HCR_EL2_NS_MASK;
gic_state.ich_hcr_el2 |= run.entry_gic_hcr() & ICH_HCR_EL2_NS_MASK;
Ok(())
}
pub fn send_state_to_host(rec: &Rec<'_>, run: &mut Run) -> Result<(), Error> {
let gic_state = &rec.context.gic_state;
let nr_lrs = nr_lrs();
run.exit_gic_lrs_mut()[..nr_lrs].copy_from_slice(&gic_state.ich_lr_el2[..nr_lrs]);
run.set_gic_misr(gic_state.ich_misr_el2);
run.set_gic_vmcr(gic_state.ich_vmcr_el2);
run.set_gic_hcr(gic_state.ich_hcr_el2 & (ICH_HCR_EL2_EOI_COUNT_MASK | ICH_HCR_EL2_NS_MASK));
Ok(())
}
pub fn validate_state(run: &Run) -> bool {
let hcr = run.entry_gic_hcr();
/* Validate rec_entry.gicv3_hcr MBZ bits */
if (hcr & !ICH_HCR_EL2_NS_MASK) != 0 {
return false;
}
for i in 0..nr_lrs() {
let lrs = run.entry_gic_lrs();
let lr = lrs[i];
let state = (lr >> ICH_LR0_EL2::State.shift) & ICH_LR0_EL2::State.mask;
let vintid = (lr >> ICH_LR0_EL2::vINTID.shift) & ICH_LR0_EL2::vINTID.mask;
let priority = (lr >> ICH_LR0_EL2::Priority.shift) & ICH_LR0_EL2::Priority.mask;
let pintid_mask = ICH_LR0_EL2::pINTID.mask << ICH_LR0_EL2::pINTID.shift;
let eoi_mask = ICH_LR0_EL2::EOI.mask << ICH_LR0_EL2::EOI.shift;
let only_eoi = pintid_mask & !eoi_mask;
let hw = (lr >> ICH_LR0_EL2::HW.shift) & ICH_LR0_EL2::HW.mask;
if state == ICH_LR0_EL2::State::Invalid.into() {
continue;
}
/* The RMM Specification imposes the constraint that HW == '0' */
if hw != 0
/* Check RES0 bits in the Priority field */
|| priority & pri_res0_mask() != 0
/* Only the EOI bit in the pINTID is allowed to be set */
|| lr & only_eoi != 0
/* Check if vINTID is in the valid range */
|| !valid_vintid(vintid)
{
return false;
}
/*
* Behavior is UNPREDICTABLE if two or more List Registers
* specify the same vINTID.
*/
for j in i + 1..=nr_lrs() {
let lrs = run.entry_gic_lrs();
let lr = lrs[j];
let vintid_2 = (lr >> ICH_LR0_EL2::vINTID.shift) & ICH_LR0_EL2::vINTID.mask;
let state = (lr >> ICH_LR0_EL2::State.shift) & ICH_LR0_EL2::State.mask;
if state == ICH_LR0_EL2::State::Invalid.into() {
continue;
}
if vintid == vintid_2 {
return false;
}
}
}
true
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/pmu.rs | rmm/src/rec/pmu.rs | use super::Rec;
use crate::pmu::*;
use core::array::from_fn;
use lazy_static::lazy_static;
use spin::mutex::Mutex;
use aarch64_cpu::registers::*;
use armv9a::regs::pmu::*;
use armv9a::{MDCR_EL2, PMCR_EL0};
use crate::config::NUM_OF_CPU;
use crate::cpu::get_cpu_id;
use crate::rmi::error::Error;
use crate::rmi::rec::run::Run;
#[repr(C)]
#[derive(Default, Debug)]
pub struct PmuRegister {
pub pmcr_el0: u64,
pub pmccfiltr_el0: u64,
pub pmccntr_el0: u64,
pub pmcntenset_el0: u64,
pub pmcntenclr_el0: u64,
pub pmintenset_el1: u64,
pub pmintenclr_el1: u64,
pub pmovsset_el0: u64,
pub pmovsclr_el0: u64,
pub pmselr_el0: u64,
pub pmuserenr_el0: u64,
pub pmxevcntr_el0: u64,
pub pmxevtyper_el0: u64,
pub pmevcntr_el0: [u64; MAX_EVCNT],
pub pmevtyper_el0: [u64; MAX_EVCNT],
}
lazy_static! {
static ref NS_PMU: [Mutex<PmuRegister>; NUM_OF_CPU] =
from_fn(|_| Mutex::new(PmuRegister::default()));
}
const CLEAR_MASK: u64 = 0x1_FFFF_FFFF;
pub fn init_pmu(rec: &mut Rec<'_>) {
let (pmu_enabled, pmu_num_ctrs) = rec.pmu_config().expect("REASON");
#[cfg(not(any(miri, test, fuzzing)))]
let mdcr_el2 = MDCR_EL2.get();
#[cfg(any(miri, test, fuzzing))]
let mdcr_el2 = 0;
let mask: u64 = MDCR_EL2::TPM::SET.value
| MDCR_EL2::TPMCR::SET.value
| (MDCR_EL2::HPMN.mask << MDCR_EL2::HPMN.shift);
rec.context.mdcr_el2 = if pmu_enabled {
(mdcr_el2 & !mask) | MDCR_EL2::HPMN.val(pmu_num_ctrs as u64).value
} else {
mdcr_el2 | (MDCR_EL2::TPM::SET + MDCR_EL2::TPMCR::SET).value
};
let rec_pmu = &mut rec.context.pmu;
rec_pmu.pmcr_el0 = if pmu_enabled {
(PMCR_EL0::LC::SET + PMCR_EL0::DP::SET + PMCR_EL0::C::SET + PMCR_EL0::P::SET).into()
} else {
(PMCR_EL0::LC::SET + PMCR_EL0::DP::SET).into()
};
}
fn restore_pmu(pmu: &PmuRegister, num_cntrs: usize) {
PMCR_EL0.set(pmu.pmcr_el0);
PMCCFILTR_EL0.set(pmu.pmccfiltr_el0);
PMCCNTR_EL0.set(pmu.pmccntr_el0);
PMCNTENSET_EL0.set(pmu.pmcntenset_el0);
PMCNTENCLR_EL0.set(pmu.pmcntenclr_el0 ^ CLEAR_MASK);
PMINTENSET_EL1.set(pmu.pmintenset_el1);
PMINTENCLR_EL1.set(pmu.pmintenclr_el1 ^ CLEAR_MASK);
PMOVSSET_EL0.set(pmu.pmovsset_el0);
PMOVSCLR_EL0.set(pmu.pmovsclr_el0 ^ CLEAR_MASK);
PMSELR_EL0.set(pmu.pmselr_el0);
PMUSERENR_EL0.set(pmu.pmuserenr_el0);
PMXEVCNTR_EL0.set(pmu.pmxevcntr_el0);
PMXEVTYPER_EL0.set(pmu.pmxevtyper_el0);
set_pmev_regs(num_cntrs, &pmu.pmevcntr_el0, &pmu.pmevtyper_el0);
}
pub fn restore_state(rec: &Rec<'_>) {
let (enabled, num_cntrs) = rec.pmu_config().expect("REASON");
if !enabled {
return;
}
MDCR_EL2.set(rec.context.mdcr_el2);
let rec_pmu = &rec.context.pmu;
restore_pmu(rec_pmu, num_cntrs);
}
fn save_pmu(pmu: &mut PmuRegister, num_cntrs: usize) {
pmu.pmcr_el0 = PMCR_EL0.get();
pmu.pmccfiltr_el0 = PMCCFILTR_EL0.get();
pmu.pmccntr_el0 = PMCCNTR_EL0.get();
pmu.pmcntenset_el0 = PMCNTENSET_EL0.get();
pmu.pmcntenclr_el0 = PMCNTENCLR_EL0.get();
pmu.pmintenset_el1 = PMINTENSET_EL1.get();
pmu.pmintenclr_el1 = PMINTENCLR_EL1.get();
pmu.pmovsset_el0 = PMOVSSET_EL0.get();
pmu.pmovsclr_el0 = PMOVSCLR_EL0.get();
pmu.pmselr_el0 = PMSELR_EL0.get();
pmu.pmuserenr_el0 = PMUSERENR_EL0.get();
pmu.pmxevcntr_el0 = PMXEVCNTR_EL0.get();
pmu.pmxevtyper_el0 = PMXEVTYPER_EL0.get();
get_pmev_regs(num_cntrs, &mut pmu.pmevcntr_el0, &mut pmu.pmevtyper_el0);
}
pub fn save_state(rec: &mut Rec<'_>) {
let (enabled, num_cntrs) = rec.pmu_config().expect("REASON");
if !enabled {
return;
}
let rec_pmu = &mut rec.context.pmu;
save_pmu(rec_pmu, num_cntrs);
}
pub fn save_host_state(rec: &Rec<'_>) {
let (enabled, _) = rec.pmu_config().expect("REASON");
if !enabled {
return;
}
let mut ns_pmu = NS_PMU[get_cpu_id()].lock();
// Event counter and cycle counter can be reset by P and C bits in PMCR_EL0
// thus save and restore all counters.
save_pmu(&mut ns_pmu, pmu_num_ctrs() as usize);
}
pub fn restore_host_state(rec: &Rec<'_>) {
let (enabled, _) = rec.pmu_config().expect("REASON");
if !enabled {
return;
}
let ns_pmu = NS_PMU[get_cpu_id()].lock();
// Event counter and cycle counter can be reset by P and C bits in PMCR_EL0
// thus save and restore all counters.
restore_pmu(&ns_pmu, pmu_num_ctrs() as usize);
}
pub fn pmu_overflow_active() -> bool {
(PMOVSSET_EL0.get() & PMINTENSET_EL1.get() & PMCNTENSET_EL0.get()) != 0
&& PMCR_EL0.read(PMCR_EL0::E) != 0
}
#[cfg(not(any(miri, test, fuzzing)))]
pub fn send_state_to_host(_rec: &Rec<'_>, run: &mut Run) -> Result<(), Error> {
run.set_pmu_overflow(pmu_overflow_active());
Ok(())
}
#[cfg(any(miri, test, fuzzing))]
pub fn send_state_to_host(_rec: &Rec<'_>, run: &mut Run) -> Result<(), Error> {
run.set_pmu_overflow(false);
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/sea.rs | rmm/src/rec/sea.rs | use crate::realm::rd::Rd;
use crate::rec::context::{set_reg, RegOffset};
use crate::rec::Rec;
use crate::rmi::error::Error;
use crate::rmi::rec::run::{EntryFlag, Run};
use aarch64_cpu::registers::Readable;
use aarch64_cpu::registers::{HPFAR_EL2, SPSR_EL2};
use armv9a::regs::*;
use armv9a::InMemoryRegister; // re-exported from tock_registers
pub fn host_sea_inject(rec: &mut Rec<'_>, run: &Run) -> Result<(), Error> {
let flags = run.entry_flags();
// Host has not completed emulation for an Emulatable Abort.
if flags.get_masked(EntryFlag::INJECT_SEA) == 0 {
return Ok(());
}
let esr_el2 = rec.context.sys_regs.esr_el2;
let esr = EsrEl2::new(esr_el2);
let ec = esr.get_masked_value(EsrEl2::EC);
if ec != ESR_EL2_EC_DATA_ABORT {
return Ok(());
}
// [Spec] If the most recent exit was due to Data Abort at an Unprotected IPA
// and enter.flags.inject_sea == RMI_INJECT_SEA,
// then a Synchronous External Abort is taken to the Realm.
let fault_ipa = rec.context.sys_regs.hpfar & (HPFAR_EL2::FIPA.mask << HPFAR_EL2::FIPA.shift);
let fault_ipa = (fault_ipa << 8) as usize;
let raw_ptr: *const Rd = rec.owner()? as *const Rd;
let rd: &Rd = unsafe { raw_ptr.as_ref().expect("REASON") }; // FIXME
if !rd.addr_in_par(fault_ipa) && fault_ipa < rd.ipa_size() {
inject_sea(rec, esr_el2, rec.context.sys_regs.far_el2);
}
Ok(())
}
pub fn inject_sea(rec: &mut Rec<'_>, esr_el2: u64, far_el2: u64) {
let mut esr_el1 = esr_el2 & !(EsrEl2::EC | EsrEl2::FNV | EsrEl2::S1PTW | EsrEl2::DFSC);
let mut ec = esr_el2 & EsrEl2::EC;
let context = &mut rec.context;
let spsr_el2: InMemoryRegister<u64, SPSR_EL2::Register> =
InMemoryRegister::new(context.spsr_el2);
let elr_el2 = context.elr_el2;
let spsr_m = spsr_el2.read(SPSR_EL2::M);
if spsr_m != SPSR_EL2::M::EL0t.into() {
ec |= 1 << EsrEl2::EC.trailing_zeros();
}
esr_el1 |= ec;
esr_el1 |= EsrEl2::EA;
esr_el1 |= 0b010000; // Synchronous External Abort (SEA)
const VBAR_CURRENT_SP0_OFFSET: u64 = 0x0;
const VBAR_CURRENT_SPX_OFFSET: u64 = 0x200;
const VBAR_LOWER_AARCH64_OFFSET: u64 = 0x400;
let mut vector_entry = {
match spsr_el2.read_as_enum(SPSR_EL2::M) {
Some(SPSR_EL2::M::Value::EL0t) => VBAR_LOWER_AARCH64_OFFSET,
Some(SPSR_EL2::M::Value::EL1t) => VBAR_CURRENT_SP0_OFFSET,
Some(SPSR_EL2::M::Value::EL1h) => VBAR_CURRENT_SPX_OFFSET,
_ => panic!("shouldn't be reached here"), // Realms run at aarch64 state only (i.e. no aarch32)
}
};
vector_entry += context.sys_regs.vbar;
let pstate: u64 = (SPSR_EL2::D::SET
+ SPSR_EL2::A::SET
+ SPSR_EL2::I::SET
+ SPSR_EL2::F::SET
+ SPSR_EL2::M::EL1h)
.into();
context.sys_regs.esr_el1 = esr_el1;
context.sys_regs.far = far_el2;
context.sys_regs.elr = elr_el2;
context.sys_regs.spsr = spsr_el2.get();
context.elr_el2 = vector_entry;
let _ = set_reg(rec, RegOffset::PSTATE, pstate as usize);
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/pauth.rs | rmm/src/rec/pauth.rs | use super::Rec;
use aarch64_cpu::registers::*;
#[repr(C)]
#[derive(Default, Debug)]
pub struct PauthRegister {
pub apiakeylo_el1: u64,
pub apiakeyhi_el1: u64,
pub apibkeylo_el1: u64,
pub apibkeyhi_el1: u64,
pub apdakeylo_el1: u64,
pub apdakeyhi_el1: u64,
pub apdbkeylo_el1: u64,
pub apdbkeyhi_el1: u64,
pub apgakeylo_el1: u64,
pub apgakeyhi_el1: u64,
}
pub fn init_pauth(_rec: &mut Rec<'_>) {
// Does nothing
}
pub fn restore_state(rec: &Rec<'_>) {
unsafe {
_restore_state(rec);
}
}
/// # Safety
///
/// Use pauth only for (re)storing Rec's context
#[target_feature(enable = "pacg", enable = "paca")]
unsafe fn _restore_state(rec: &Rec<'_>) {
let pauth = &rec.context.pauth;
APIAKEYLO_EL1.set(pauth.apiakeylo_el1);
APIAKEYHI_EL1.set(pauth.apiakeyhi_el1);
APIBKEYLO_EL1.set(pauth.apibkeylo_el1);
APIBKEYHI_EL1.set(pauth.apibkeyhi_el1);
APDAKEYLO_EL1.set(pauth.apdakeylo_el1);
APDAKEYHI_EL1.set(pauth.apdakeyhi_el1);
APDBKEYLO_EL1.set(pauth.apdbkeylo_el1);
APDBKEYHI_EL1.set(pauth.apdbkeyhi_el1);
APGAKEYLO_EL1.set(pauth.apgakeylo_el1);
APGAKEYHI_EL1.set(pauth.apgakeyhi_el1);
}
pub fn save_state(rec: &mut Rec<'_>) {
unsafe {
_save_state(rec);
}
}
/// # Safety
///
/// Use pauth only for (re)storing Rec's context
#[target_feature(enable = "pacg", enable = "paca")]
unsafe fn _save_state(rec: &mut Rec<'_>) {
let pauth = &mut rec.context.pauth;
pauth.apiakeylo_el1 = APIAKEYLO_EL1.get();
pauth.apiakeyhi_el1 = APIAKEYHI_EL1.get();
pauth.apibkeylo_el1 = APIBKEYLO_EL1.get();
pauth.apibkeyhi_el1 = APIBKEYHI_EL1.get();
pauth.apdakeylo_el1 = APDAKEYLO_EL1.get();
pauth.apdakeyhi_el1 = APDAKEYHI_EL1.get();
pauth.apdbkeylo_el1 = APDBKEYLO_EL1.get();
pauth.apdbkeyhi_el1 = APDBKEYHI_EL1.get();
pauth.apgakeylo_el1 = APGAKEYLO_EL1.get();
pauth.apgakeyhi_el1 = APGAKEYHI_EL1.get();
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/timer.rs | rmm/src/rec/timer.rs | use super::Rec;
use crate::asm::isb;
use crate::rmi::error::Error;
use crate::rmi::rec::run::Run;
use aarch64_cpu::registers::*;
#[cfg(feature = "ns_state_save")]
mod ns_timer {
use super::*;
use crate::config::NUM_OF_CPU;
use crate::cpu::get_cpu_id;
use crate::rec::context::TimerRegister;
use core::array::from_fn;
use lazy_static::lazy_static;
use spin::mutex::Mutex;
lazy_static! {
static ref NS_TIMER: [Mutex<TimerRegister>; NUM_OF_CPU] =
from_fn(|_| Mutex::new(TimerRegister::default()));
}
pub(super) fn restore() {
let ns_timer = NS_TIMER[get_cpu_id()].lock();
CNTVOFF_EL2.set(ns_timer.cntvoff_el2);
CNTPOFF_EL2.set(ns_timer.cntpoff_el2);
CNTV_CVAL_EL0.set(ns_timer.cntv_cval_el0);
CNTV_CTL_EL0.set(ns_timer.cntv_ctl_el0);
CNTP_CVAL_EL0.set(ns_timer.cntp_cval_el0);
CNTP_CTL_EL0.set(ns_timer.cntp_ctl_el0);
CNTHCTL_EL2.set(ns_timer.cnthctl_el2);
}
pub(super) fn save() {
let mut timer = NS_TIMER[get_cpu_id()].lock();
timer.cntvoff_el2 = CNTVOFF_EL2.get();
timer.cntv_cval_el0 = CNTV_CVAL_EL0.get();
timer.cntv_ctl_el0 = CNTV_CTL_EL0.get();
timer.cntpoff_el2 = CNTPOFF_EL2.get();
timer.cntp_cval_el0 = CNTP_CVAL_EL0.get();
timer.cntp_ctl_el0 = CNTP_CTL_EL0.get();
timer.cnthctl_el2 = CNTHCTL_EL2.get();
}
}
pub fn init_timer(rec: &mut Rec<'_>) {
let timer = &mut rec.context.timer;
timer.cnthctl_el2 = (CNTHCTL_EL2::EL1PCEN::SET + CNTHCTL_EL2::EL1PCTEN::SET).into();
}
pub fn set_cnthctl(rec: &mut Rec<'_>, val: u64) {
let timer = &mut rec.context.timer;
timer.cnthctl_el2 = val;
}
#[cfg(not(fuzzing))]
pub fn restore_state(rec: &Rec<'_>) {
let timer = &rec.context.timer;
CNTVOFF_EL2.set(timer.cntvoff_el2);
CNTPOFF_EL2.set(timer.cntpoff_el2);
CNTV_CVAL_EL0.set(timer.cntv_cval_el0);
CNTV_CTL_EL0.set(timer.cntv_ctl_el0);
CNTP_CVAL_EL0.set(timer.cntp_cval_el0);
CNTP_CTL_EL0.set(timer.cntp_ctl_el0);
CNTHCTL_EL2.set(timer.cnthctl_el2);
}
#[cfg(not(fuzzing))]
pub fn save_state(rec: &mut Rec<'_>) {
let timer = &mut rec.context.timer;
timer.cntvoff_el2 = CNTVOFF_EL2.get();
timer.cntv_cval_el0 = CNTV_CVAL_EL0.get();
timer.cntv_ctl_el0 = CNTV_CTL_EL0.get();
timer.cntpoff_el2 = CNTPOFF_EL2.get();
timer.cntp_cval_el0 = CNTP_CVAL_EL0.get();
timer.cntp_ctl_el0 = CNTP_CTL_EL0.get();
timer.cnthctl_el2 = CNTHCTL_EL2.get();
}
pub fn send_state_to_host(rec: &Rec<'_>, run: &mut Run) -> Result<(), Error> {
let timer = &rec.context.timer;
run.set_cntv_ctl(timer.cntv_ctl_el0);
run.set_cntv_cval(timer.cntv_cval_el0 - timer.cntvoff_el2);
run.set_cntp_ctl(timer.cntp_ctl_el0);
run.set_cntp_cval(timer.cntp_cval_el0 - timer.cntpoff_el2);
Ok(())
}
pub fn save_host_state(_rec: &Rec<'_>) {
#[cfg(feature = "ns_state_save")]
ns_timer::save();
}
pub fn restore_host_state(_rec: &Rec<'_>) {
#[cfg(feature = "ns_state_save")]
ns_timer::restore();
}
// RMM spec A6.2 Realm timers, I<VRWGS>
// On REC entry, for both the EL1 Virtual Timer and the EL1 Physical Timer,
// if the EL1 timer asserts its output in the state described in the REC exit
// structure from the previous REC exit then the RMM masks the hardware timer
// signal before returning to the Realm.
pub fn update_timer_assertion(rec: &mut Rec<'_>) {
const CNTHCTL_EL2_CNTVMASK: u64 = 0x1 << 18;
const CNTHCTL_EL2_CNTPMASK: u64 = 0x1 << 19;
let timer = &mut rec.context.timer;
// Get recently saved timer control registers
let cnthctl_old = timer.cnthctl_el2;
// Check if virtual timer is asserted
if CNTV_CTL_EL0.matches_all(
CNTV_CTL_EL0::ISTATUS::SET + CNTV_CTL_EL0::IMASK::CLEAR + CNTV_CTL_EL0::ENABLE::SET,
) {
timer.cnthctl_el2 |= CNTHCTL_EL2_CNTVMASK;
} else {
timer.cnthctl_el2 &= !CNTHCTL_EL2_CNTVMASK; // Clear MASK
}
// Check if physical timer is asserted
if CNTP_CTL_EL0.matches_all(
CNTP_CTL_EL0::ISTATUS::SET + CNTP_CTL_EL0::IMASK::CLEAR + CNTP_CTL_EL0::ENABLE::SET,
) {
timer.cnthctl_el2 |= CNTHCTL_EL2_CNTPMASK;
} else {
timer.cnthctl_el2 &= !CNTHCTL_EL2_CNTPMASK; // Clear MASK
}
// If cnthctl changed, write it back and ensure synchronization
if cnthctl_old != timer.cnthctl_el2 {
CNTHCTL_EL2.set(timer.cnthctl_el2);
isb();
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/mod.rs | rmm/src/rec/mod.rs | pub mod context;
pub mod gic;
pub mod mmio;
pub mod pauth;
pub mod pmu;
pub mod sea;
pub mod simd;
pub mod timer;
use crate::realm::rd::Rd;
use crate::rec::context::Context;
use crate::rmi::error::Error;
use crate::rmi::rec::params::NR_AUX;
use crate::rmm_exit;
use crate::rsi::attestation::MAX_CHALLENGE_SIZE;
use aarch64_cpu::registers::*;
use core::cell::OnceCell;
use vmsa::guard::Content;
const MAX_RECS_ORDER_VALUE: u64 = 4;
#[derive(Copy, Clone, Debug)]
pub enum RecAuxIndex {
SIMD = 0,
PMU = 1,
Undefined,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RmmRecAttestState {
AttestInProgress,
NoAttestInProgress,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RmmRecEmulatableAbort {
EmulatableAbort,
NotEmulatableAbort,
}
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum State {
Ready = 1,
Running = 2,
}
#[derive(Debug)]
struct Ripas {
start: u64,
end: u64,
addr: u64,
state: u8,
flags: u64,
}
#[repr(C)]
#[derive(Debug)]
pub struct Rec<'a> {
pub context: Context,
attest_state: RmmRecAttestState,
// TODO: Create consts for both numbers
attest_challenge: [u8; MAX_CHALLENGE_SIZE],
attest_token_offset: usize,
aux: [u64; NR_AUX], // Addresses of auxiliary Granules
emulatable_abort: RmmRecEmulatableAbort,
/// PA of RD of Realm which owns this REC
///
/// Safety:
/// Only immutable fields of Rd must be dereferenced by owner
/// by making getter method for the safety
owner: OnceCell<&'a Rd>,
vcpuid: usize,
runnable: bool,
psci_pending: bool,
state: State,
ripas: Ripas,
vtcr: u64,
host_call_pending: bool,
}
impl Rec<'_> {
pub fn new() -> Self {
Self {
context: Context::new(),
attest_state: RmmRecAttestState::NoAttestInProgress,
attest_challenge: [0; MAX_CHALLENGE_SIZE],
attest_token_offset: 0,
aux: [0; NR_AUX],
emulatable_abort: RmmRecEmulatableAbort::NotEmulatableAbort,
owner: OnceCell::new(),
vcpuid: 0,
runnable: false,
psci_pending: false,
state: State::Ready,
ripas: Ripas {
start: 0,
end: 0,
addr: 0,
state: 0,
flags: 0,
},
vtcr: 0,
host_call_pending: false,
}
}
pub fn init(
&mut self,
owner: usize,
vcpuid: usize,
flags: u64,
aux: [u64; NR_AUX],
vttbr: u64,
vmpidr: u64,
) -> Result<(), Error> {
if owner == 0 {
error!("owner should be non-zero");
return Err(Error::RmiErrorInput);
}
if let Err(input_owner) = self.owner.set(unsafe { &*(owner as *const Rd) }) {
error!(
"Rec::init() called twice. cur owner: {:x}, input owner: {:x}",
self.get_owner()? as *const Rd as usize,
input_owner as *const Rd as usize
);
return Err(Error::RmiErrorRec);
}
self.vcpuid = vcpuid;
self.set_runnable(flags);
self.context.sys_regs.vttbr = vttbr;
self.context.sys_regs.vmpidr = vmpidr;
self.aux.copy_from_slice(&aux);
pauth::init_pauth(self);
pmu::init_pmu(self);
timer::init_timer(self);
gic::init_gic(self);
simd::init_simd(self)?;
Ok(())
}
pub fn attest_state(&self) -> RmmRecAttestState {
self.attest_state
}
pub fn attest_challenge(&self) -> &[u8] {
&self.attest_challenge
}
pub fn attest_token_offset(&self) -> usize {
self.attest_token_offset
}
pub fn aux(&self, index: usize) -> u64 {
self.aux[index]
}
pub fn emulatable_abort(&self) -> RmmRecEmulatableAbort {
self.emulatable_abort
}
pub fn runnable(&self) -> bool {
self.runnable
}
pub fn vcpuid(&self) -> usize {
self.vcpuid
}
fn get_owner(&self) -> Result<&Rd, Error> {
match self.owner.get() {
Some(owner) => Ok(owner),
None => {
// XXX: the below is added not to be reached
// note that it can be assured by Rec's invariants
#[cfg(kani)]
kani::assume(false);
Err(Error::RmiErrorRec)
}
}
}
pub fn owner(&self) -> Result<usize, Error> {
let owner = self.get_owner()?;
Ok(owner as *const Rd as usize)
}
pub fn host_call_pending(&self) -> bool {
self.host_call_pending
}
pub fn psci_pending(&self) -> bool {
self.psci_pending
}
pub fn set_attest_state(&mut self, state: RmmRecAttestState) {
self.attest_state = state;
}
pub fn set_attest_challenge(&mut self, challenge: &[u8]) {
self.attest_challenge.copy_from_slice(challenge);
}
pub fn set_attest_offset(&mut self, offset: usize) {
self.attest_token_offset = offset;
}
pub fn set_emulatable_abort(&mut self, val: RmmRecEmulatableAbort) {
self.emulatable_abort = val;
}
pub fn set_host_call_pending(&mut self, val: bool) {
self.host_call_pending = val;
}
pub fn set_psci_pending(&mut self, val: bool) {
self.psci_pending = val;
}
pub fn set_ripas(&mut self, start: u64, end: u64, state: u8, flags: u64) {
self.ripas.start = start;
self.ripas.end = end;
self.ripas.state = state;
self.ripas.flags = flags;
self.ripas.addr = start; // reset addr to the start
}
pub fn set_vtcr(&mut self, vtcr: u64) {
self.vtcr = vtcr;
}
//TODO: change interface. A Rec state can be set by other Recs in the same Rd.
pub fn set_runnable(&mut self, flags: u64) {
const RUNNABLE_OFFSET: u64 = 1;
self.runnable = match flags & RUNNABLE_OFFSET {
0 => false,
_ => true,
}
}
pub fn set_state(&mut self, state: State) {
self.state = state;
}
pub fn get_state(&self) -> State {
self.state
}
pub fn set_ripas_addr(&mut self, addr: u64) {
self.ripas.addr = addr;
}
pub fn ripas_addr(&self) -> u64 {
self.ripas.addr
}
pub fn ripas_start(&self) -> u64 {
self.ripas.start
}
pub fn ripas_end(&self) -> u64 {
self.ripas.end
}
pub fn ripas_state(&self) -> u8 {
self.ripas.state
}
pub fn ripas_flags(&self) -> u64 {
self.ripas.flags
}
pub fn vtcr(&self) -> u64 {
self.vtcr
}
pub fn realmid(&self) -> Result<usize, Error> {
let owner = self.get_owner()?;
Ok(owner.id())
}
pub fn ipa_bits(&self) -> Result<usize, Error> {
let owner = self.get_owner()?;
Ok(owner.ipa_bits())
}
pub fn pmu_config(&self) -> Result<(bool, usize), Error> {
let owner = self.get_owner()?;
Ok(owner.pmu_config())
}
pub fn from_current(&mut self) {
unsafe {
Context::from_current(self);
}
}
pub fn into_current(&self) {
unsafe {
Context::into_current(self);
}
}
pub fn reset_ctx(&mut self) {
self.context.spsr_el2 = (SPSR_EL2::D.mask << SPSR_EL2::D.shift)
| (SPSR_EL2::A.mask << SPSR_EL2::A.shift)
| (SPSR_EL2::I.mask << SPSR_EL2::I.shift)
| (SPSR_EL2::F.mask << SPSR_EL2::F.shift)
| (SPSR_EL2::M.mask & u64::from(SPSR_EL2::M::EL1h)) << SPSR_EL2::M.shift;
self.context.sys_regs.sctlr = 0;
}
}
impl Content for Rec<'_> {}
impl safe_abstraction::raw_ptr::RawPtr for Rec<'_> {}
impl safe_abstraction::raw_ptr::SafetyChecked for Rec<'_> {}
impl safe_abstraction::raw_ptr::SafetyAssured for Rec<'_> {
fn is_initialized(&self) -> bool {
// The initialization of this memory is guaranteed
// according to the RMM Specification A2.2.4 Granule Wiping.
// This instance belongs to a REC Granule and has been initialized.
true
}
fn verify_ownership(&self) -> bool {
// The ownership of this instance is exclusively ensured by the RMM.
// under the following conditions:
//
// 1. A lock on the given address is obtained using the `get_granule*` macros.
// 2. The instance is converted from a raw pointer through the `content*` functions.
// 3. The instance is accessed only within the lock scope.
//
// Ownership verification is guaranteed because these criteria are satisfied
// in all cases where this object is accessed.
true
}
}
// XXX: is using 'static okay here?
unsafe fn current() -> Option<&'static mut Rec<'static>> {
match TPIDR_EL2.get() {
0 => None,
current => Some(&mut *(current as *mut Rec<'_>)),
}
}
fn enter() -> [usize; 4] {
unsafe {
if let Some(_rec) = current() {
// TODO: add code equivalent to the previous clean()
return rmm_exit([0; 4]);
}
[0, 0, 0, 0]
}
}
fn exit() {
unsafe {
if let Some(rec) = current() {
rec.from_current();
}
}
}
// TODO: check the below again
pub fn run_prepare(rd: &Rd, vcpu: usize, rec: &mut Rec<'_>, incr_pc: usize) -> Result<(), Error> {
if incr_pc == 1 {
rec.context.elr_el2 += 4;
}
timer::update_timer_assertion(rec);
debug!("resuming: {:#x}", rec.context.elr_el2);
rec.into_current();
trace!("Switched to VCPU {} on Realm {}", vcpu, rd.id());
Ok(())
}
pub fn run() -> Result<[usize; 4], Error> {
let ret = enter();
exit();
Ok(ret)
}
pub fn max_recs_order() -> usize {
MAX_RECS_ORDER_VALUE as usize
}
// Note: Islet intends to manage states only for the realm world.
// Handling the ns state here does not align Islet's desgin.
// Save the host state only if necessary.
pub fn save_host_state(rec: &Rec<'_>) {
pmu::save_host_state(rec);
// TODO: Apply 'ns_state_save' feature to the save_host_state func.
// For that, we need to move the code here from the corresponding patches
// in the nw-linux.
timer::save_host_state(rec);
}
pub fn restore_host_state(rec: &Rec<'_>) {
pmu::restore_host_state(rec);
timer::restore_host_state(rec);
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/simd.rs | rmm/src/rec/simd.rs | use aarch64_cpu::registers::{Readable, Writeable};
use armv9a::regs::{CPTR_EL2, SMCR_EL2, SVCR, ZCR_EL1, ZCR_EL2};
use armv9a::InMemoryRegister;
use core::arch::asm;
use core::array::from_fn;
use lazy_static::lazy_static;
use spin::mutex::Mutex;
use super::Rec;
use crate::config::NUM_OF_CPU;
use crate::cpu::get_cpu_id;
use crate::granule::GranuleState;
use crate::realm::rd::Rd;
use crate::rec::RecAuxIndex;
use crate::rmi::error::Error;
use crate::simd::{sme_en, SimdConfig, MAX_VQ};
use crate::{get_granule, get_granule_if};
// SIMD context structure
#[derive(Default, Debug)]
pub struct SimdContext {
pub is_used: bool,
pub is_saved: bool,
pub cfg: SimdConfig,
}
#[derive(Default, Debug)]
pub struct SimdRegister {
// EL2 trap register for this context
pub cptr_el2: u64,
// SME specific Streaming vector control register
pub svcr: u64,
// SIMD data registers
pub fpu: FpuRegs,
pub sve: SveRegs,
}
impl SimdRegister {
pub fn new() -> Self {
Default::default()
}
}
impl vmsa::guard::Content for SimdRegister {}
impl safe_abstraction::raw_ptr::RawPtr for SimdRegister {}
impl safe_abstraction::raw_ptr::SafetyChecked for SimdRegister {}
impl safe_abstraction::raw_ptr::SafetyAssured for SimdRegister {
fn is_initialized(&self) -> bool {
// It is wiped out with zero's on granule delegation.
// Then, SimdRegister gets initialized on Rec::init() call.
true
}
fn verify_ownership(&self) -> bool {
true
}
}
// FPU registers
const NUM_FPU_REGS: usize = 32;
#[derive(Default, Debug)]
pub struct FpuRegs {
pub q: [u128; NUM_FPU_REGS],
// SIMD related control and status sysregs
pub fpsr: u64,
pub fpcr: u64,
}
lazy_static! {
static ref NS_SIMD: [Mutex<SimdRegister>; NUM_OF_CPU] =
from_fn(|_| Mutex::new(SimdRegister::default()));
}
// SVE registers
const NUM_VECTOR_REGS: usize = 32;
const NUM_PREDICATE_REGS: usize = 16;
#[derive(Default, Debug)]
pub struct SveRegs {
// lower 128bits of each z register are shared with v
// implementation-defined lengh: 128bits~2048bits. get it from zcr_el2
pub z: [[u128; NUM_VECTOR_REGS]; MAX_VQ as usize],
// Each predicate register is 1/8 of the Zx length.
pub p: [[u16; NUM_PREDICATE_REGS]; MAX_VQ as usize],
pub ffr: [u16; MAX_VQ as usize],
pub zcr_el2: u64,
pub zcr_el12: u64,
}
// TODO: Save according to the hint in FID with SMCCCv1.3 or v1.4
// SIMD context initialization function
pub fn init_simd(rec: &mut Rec<'_>) -> Result<(), Error> {
let raw_ptr: *const Rd = rec.owner()? as *const Rd;
let rd: &Rd = unsafe { raw_ptr.as_ref().expect("REASON") }; // FIXME
let simd_cfg = rd.simd_config();
let mut zcr_el2: u64 = 0;
let mut svcr: u64 = 0;
rec.context.simd.is_used = false;
rec.context.simd.is_saved = false;
rec.context.simd.cfg.sve_en = simd_cfg.sve_en;
rec.context.simd.cfg.sve_vq = simd_cfg.sve_vq;
rec.context.simd.cfg.sme_en = simd_cfg.sme_en;
// Initialize SVE related fields and config registers
if simd_cfg.sve_en {
zcr_el2 = ZCR_EL2::LEN.val(simd_cfg.sve_vq).value;
}
if simd_cfg.sme_en {
svcr = 0;
}
let simd_aux = rec.aux(RecAuxIndex::SIMD as usize) as usize;
let mut simd_granule = get_granule_if!(simd_aux, GranuleState::RecAux)?;
debug!("RecAux granule for simd at 0x{:x}", simd_aux);
let mut simd_regs = simd_granule.new_uninit_with::<SimdRegister>(SimdRegister::new())?;
// Note: As islet-rmm doesn't enable VHE in the realm world as following,
// HCR_EL2.E2H=0, HCR_EL2.TGE=0
// the layout of CPTR_EL2 for non E2H is used.
simd_regs.cptr_el2 =
(CPTR_EL2::TAM::SET + CPTR_EL2::TSM::SET + CPTR_EL2::TFP::SET + CPTR_EL2::TZ::SET).value;
simd_regs.sve.zcr_el2 = zcr_el2;
simd_regs.svcr = svcr;
Ok(())
}
// Note: Put assembly instructions only in the functions below.
// Do not add log messages in functions with simd features.
// RMM doesn't maintain its own SIMD context. However, compiler
// tries to utilize simd registers in a function with the 'neon'
// or 'sve' feature and it may results state corruption.
/// # Safety
///
/// Use neon only for (re)storing Rec's simd context
#[target_feature(enable = "neon")]
unsafe fn save_fpu(fpu: &mut FpuRegs) {
let addr_q: u64 = fpu.q.as_ptr() as u64;
unsafe {
asm!(
"stp q0, q1, [{addr_q}]",
"stp q2, q3, [{addr_q}, #32]",
"stp q4, q5, [{addr_q}, #64]",
"stp q6, q7, [{addr_q}, #96]",
"stp q8, q9, [{addr_q}, #128]",
"stp q10, q11, [{addr_q}, #160]",
"stp q12, q13, [{addr_q}, #192]",
"stp q14, q15, [{addr_q}, #224]",
"stp q16, q17, [{addr_q}, #256]",
"stp q18, q19, [{addr_q}, #288]",
"stp q20, q21, [{addr_q}, #320]",
"stp q22, q23, [{addr_q}, #352]",
"stp q24, q25, [{addr_q}, #384]",
"stp q26, q27, [{addr_q}, #416]",
"stp q28, q29, [{addr_q}, #448]",
"stp q30, q31, [{addr_q}, #480]",
addr_q = in(reg) addr_q,
);
save_fpu_crsr(fpu);
}
}
/// # Safety
///
/// Use neon only for (re)storing Rec's simd context
#[target_feature(enable = "neon")]
unsafe fn save_fpu_crsr(fpu: &mut FpuRegs) {
let fpsr: u64;
let fpcr: u64;
unsafe {
asm!(
"mrs {fpsr}, fpsr",
"mrs {fpcr}, fpcr",
fpsr = out(reg) fpsr,
fpcr = out(reg) fpcr,
);
}
fpu.fpsr = fpsr;
fpu.fpcr = fpcr;
}
/// # Safety
///
/// Use neon only for (re)storing Rec's simd context
#[target_feature(enable = "neon")]
pub unsafe fn restore_fpu(fpu: &FpuRegs) {
let addr_q: u64 = fpu.q.as_ptr() as u64;
unsafe {
asm!(
"ldp q0, q1, [{addr_q}]",
"ldp q2, q3, [{addr_q}, #32]",
"ldp q4, q5, [{addr_q}, #64]",
"ldp q6, q7, [{addr_q}, #96]",
"ldp q8, q9, [{addr_q}, #128]",
"ldp q10, q11, [{addr_q}, #160]",
"ldp q12, q13, [{addr_q}, #192]",
"ldp q14, q15, [{addr_q}, #224]",
"ldp q16, q17, [{addr_q}, #256]",
"ldp q18, q19, [{addr_q}, #288]",
"ldp q20, q21, [{addr_q}, #320]",
"ldp q22, q23, [{addr_q}, #352]",
"ldp q24, q25, [{addr_q}, #384]",
"ldp q26, q27, [{addr_q}, #416]",
"ldp q28, q29, [{addr_q}, #448]",
"ldp q30, q31, [{addr_q}, #480]",
addr_q = in(reg) addr_q,
);
restore_fpu_crsr(fpu);
}
}
/// # Safety
///
/// Use neon only for (re)storing Rec's simd context
#[target_feature(enable = "neon")]
pub unsafe fn restore_fpu_crsr(fpu: &FpuRegs) {
unsafe {
asm!(
"msr fpsr, {fpsr}",
"msr fpcr, {fpcr}",
fpsr = in(reg) fpu.fpsr,
fpcr = in(reg) fpu.fpcr,
);
}
}
/// # Safety
///
/// Use neon only for (re)storing Rec's simd context
#[target_feature(enable = "sve")]
unsafe fn save_sve(sve: &mut SveRegs, save_ffr: bool) {
let addr_z: u64 = sve.z.as_ptr() as u64;
let addr_p: u64 = sve.p.as_ptr() as u64;
unsafe {
// Save the z regster bank
asm!(
"str z0, [{addr_z}, #0, MUL VL]",
"str z1, [{addr_z}, #1, MUL VL]",
"str z2, [{addr_z}, #2, MUL VL]",
"str z3, [{addr_z}, #3, MUL VL]",
"str z4, [{addr_z}, #4, MUL VL]",
"str z5, [{addr_z}, #5, MUL VL]",
"str z6, [{addr_z}, #6, MUL VL]",
"str z7, [{addr_z}, #7, MUL VL]",
"str z8, [{addr_z}, #8, MUL VL]",
"str z9, [{addr_z}, #9, MUL VL]",
"str z10, [{addr_z}, #10, MUL VL]",
"str z11, [{addr_z}, #11, MUL VL]",
"str z12, [{addr_z}, #12, MUL VL]",
"str z13, [{addr_z}, #13, MUL VL]",
"str z14, [{addr_z}, #14, MUL VL]",
"str z15, [{addr_z}, #15, MUL VL]",
"str z16, [{addr_z}, #16, MUL VL]",
"str z17, [{addr_z}, #17, MUL VL]",
"str z18, [{addr_z}, #18, MUL VL]",
"str z19, [{addr_z}, #19, MUL VL]",
"str z20, [{addr_z}, #20, MUL VL]",
"str z21, [{addr_z}, #21, MUL VL]",
"str z22, [{addr_z}, #22, MUL VL]",
"str z23, [{addr_z}, #23, MUL VL]",
"str z24, [{addr_z}, #24, MUL VL]",
"str z25, [{addr_z}, #25, MUL VL]",
"str z26, [{addr_z}, #26, MUL VL]",
"str z27, [{addr_z}, #27, MUL VL]",
"str z28, [{addr_z}, #28, MUL VL]",
"str z29, [{addr_z}, #29, MUL VL]",
"str z30, [{addr_z}, #30, MUL VL]",
"str z31, [{addr_z}, #31, MUL VL]",
addr_z = in(reg) addr_z,
);
// Save the p register bank
asm!(
"str p0, [{addr_p}, #0, MUL VL]",
"str p1, [{addr_p}, #1, MUL VL]",
"str p2, [{addr_p}, #2, MUL VL]",
"str p3, [{addr_p}, #3, MUL VL]",
"str p4, [{addr_p}, #4, MUL VL]",
"str p5, [{addr_p}, #5, MUL VL]",
"str p6, [{addr_p}, #6, MUL VL]",
"str p7, [{addr_p}, #7, MUL VL]",
"str p8, [{addr_p}, #8, MUL VL]",
"str p9, [{addr_p}, #9, MUL VL]",
"str p10, [{addr_p}, #10, MUL VL]",
"str p11, [{addr_p}, #11, MUL VL]",
"str p12, [{addr_p}, #12, MUL VL]",
"str p13, [{addr_p}, #13, MUL VL]",
"str p14, [{addr_p}, #14, MUL VL]",
"str p15, [{addr_p}, #15, MUL VL]",
addr_p = in(reg) addr_p,
);
if save_ffr {
let addr_ffr: u64 = core::ptr::addr_of!(sve.ffr) as u64;
asm!(
"rdffr p0.B",
"str p0, [{addr_ffr}]",
addr_ffr = in(reg) addr_ffr,
);
}
}
}
/// # Safety
///
/// Use neon only for (re)storing Rec's simd context
#[inline(never)]
#[target_feature(enable = "sve")]
pub unsafe fn restore_sve(sve: &SveRegs, restore_ffr: bool) {
let addr_z: u64 = sve.z.as_ptr() as u64;
let addr_p: u64 = sve.p.as_ptr() as u64;
unsafe {
// Restore the z regster bank
asm!(
"ldr z0, [{addr_z}, #0, MUL VL]",
"ldr z1, [{addr_z}, #1, MUL VL]",
"ldr z2, [{addr_z}, #2, MUL VL]",
"ldr z3, [{addr_z}, #3, MUL VL]",
"ldr z4, [{addr_z}, #4, MUL VL]",
"ldr z5, [{addr_z}, #5, MUL VL]",
"ldr z6, [{addr_z}, #6, MUL VL]",
"ldr z7, [{addr_z}, #7, MUL VL]",
"ldr z8, [{addr_z}, #8, MUL VL]",
"ldr z9, [{addr_z}, #9, MUL VL]",
"ldr z10, [{addr_z}, #10, MUL VL]",
"ldr z11, [{addr_z}, #11, MUL VL]",
"ldr z12, [{addr_z}, #12, MUL VL]",
"ldr z13, [{addr_z}, #13, MUL VL]",
"ldr z14, [{addr_z}, #14, MUL VL]",
"ldr z15, [{addr_z}, #15, MUL VL]",
"ldr z16, [{addr_z}, #16, MUL VL]",
"ldr z17, [{addr_z}, #17, MUL VL]",
"ldr z18, [{addr_z}, #18, MUL VL]",
"ldr z19, [{addr_z}, #19, MUL VL]",
"ldr z20, [{addr_z}, #20, MUL VL]",
"ldr z21, [{addr_z}, #21, MUL VL]",
"ldr z22, [{addr_z}, #22, MUL VL]",
"ldr z23, [{addr_z}, #23, MUL VL]",
"ldr z24, [{addr_z}, #24, MUL VL]",
"ldr z25, [{addr_z}, #25, MUL VL]",
"ldr z26, [{addr_z}, #26, MUL VL]",
"ldr z27, [{addr_z}, #27, MUL VL]",
"ldr z28, [{addr_z}, #28, MUL VL]",
"ldr z29, [{addr_z}, #29, MUL VL]",
"ldr z30, [{addr_z}, #30, MUL VL]",
"ldr z31, [{addr_z}, #31, MUL VL]",
addr_z = in(reg) addr_z,
);
if restore_ffr {
let addr_ffr: u64 = core::ptr::addr_of!(sve.ffr) as u64;
asm!(
"ldr p0, [{addr_ffr}]",
"wrffr p0.B",
addr_ffr = in(reg) addr_ffr,
);
}
// Restore the p register bank
asm!(
"ldr p0, [{addr_p}, #0, MUL VL]",
"ldr p1, [{addr_p}, #1, MUL VL]",
"ldr p2, [{addr_p}, #2, MUL VL]",
"ldr p3, [{addr_p}, #3, MUL VL]",
"ldr p4, [{addr_p}, #4, MUL VL]",
"ldr p5, [{addr_p}, #5, MUL VL]",
"ldr p6, [{addr_p}, #6, MUL VL]",
"ldr p7, [{addr_p}, #7, MUL VL]",
"ldr p8, [{addr_p}, #8, MUL VL]",
"ldr p9, [{addr_p}, #9, MUL VL]",
"ldr p10, [{addr_p}, #10, MUL VL]",
"ldr p11, [{addr_p}, #11, MUL VL]",
"ldr p12, [{addr_p}, #12, MUL VL]",
"ldr p13, [{addr_p}, #13, MUL VL]",
"ldr p14, [{addr_p}, #14, MUL VL]",
"ldr p15, [{addr_p}, #15, MUL VL]",
addr_p = in(reg) addr_p,
);
}
}
fn preserve_ffr(svcr: u64) -> bool {
let svcr: InMemoryRegister<u64, SVCR::Register> = InMemoryRegister::new(svcr);
let mut rtn = true;
let is_streaming = sme_en() && svcr.read(SVCR::SM) != 0;
if is_streaming {
rtn = SMCR_EL2.read(SMCR_EL2::FA64) != 0;
}
rtn
}
// This function is called when a SIMD access in Realm
// is made for the first time since REC_ENTER.
// See exception/trap.rs.
pub fn restore_state_lazy(rec: &Rec<'_>) {
let rec_simd_ctxt = &rec.context.simd;
let simd_aux = rec.aux(RecAuxIndex::SIMD as usize) as usize;
let simd_granule = match get_granule_if!(simd_aux, GranuleState::RecAux) {
Ok(guard) => guard,
Err(_e) => {
error!("Unable to get RecAux granule at 0x{:x}", simd_aux);
return;
}
};
let rec_simd = simd_granule.content::<SimdRegister>().unwrap();
let mut ns_simd = NS_SIMD[get_cpu_id()].lock();
// Disable simd traps during the context mgmt.
CPTR_EL2.write(CPTR_EL2::TAM::SET);
if rec_simd_ctxt.cfg.sve_en {
ns_simd.sve.zcr_el2 = ZCR_EL2.get();
ns_simd.sve.zcr_el12 = ZCR_EL1.get();
// To prevent cross-world leakage, set to rec's len
ZCR_EL2.set(rec_simd.sve.zcr_el2);
ZCR_EL1.set(rec_simd.sve.zcr_el12);
#[cfg(not(any(test, miri, fuzzing)))]
unsafe {
// ns_simd.svcr is save at restore_state() on REC_ENTER
let save_ffr = preserve_ffr(ns_simd.svcr);
save_sve(&mut ns_simd.sve, save_ffr);
save_fpu_crsr(&mut ns_simd.fpu);
if sme_en() {
SVCR.set(rec_simd.svcr);
}
if rec_simd_ctxt.is_saved {
let restore_ffr = true; // Sinde Realm is not supported with SME, it's always true.
restore_sve(&rec_simd.sve, restore_ffr);
restore_fpu_crsr(&rec_simd.fpu);
}
}
} else {
unsafe {
save_fpu(&mut ns_simd.fpu);
if rec_simd_ctxt.is_saved {
restore_fpu(&rec_simd.fpu);
}
}
}
}
pub fn restore_state(rec: &Rec<'_>) {
let simd_aux = rec.aux(RecAuxIndex::SIMD as usize) as usize;
let simd_granule = match get_granule_if!(simd_aux, GranuleState::RecAux) {
Ok(guard) => guard,
Err(_e) => {
error!("Unable to get RecAux granule at 0x{:x}", simd_aux);
return;
}
};
let rec_simd = simd_granule.content::<SimdRegister>().unwrap();
let mut ns_simd = NS_SIMD[get_cpu_id()].lock();
// Disable simd traps during the context mgmt.
CPTR_EL2.write(CPTR_EL2::TAM::SET);
// We don't save/restore any state
// until SIMD registers are actually accessed in Realms.
if sme_en() {
ns_simd.svcr = SVCR.get();
// Note: Don't call SVCR.set(rec_simd.svcr) here.
// Otherwise, we will loose unsaved NS context.
// SVCR's SM bit change between 0 and 1, one way or the other,
// results in setting the whole SIMD registers to zeros.
}
ns_simd.cptr_el2 = CPTR_EL2.get();
CPTR_EL2.set(rec_simd.cptr_el2);
}
pub fn save_state(rec: &mut Rec<'_>) {
let simd_aux = rec.aux(RecAuxIndex::SIMD as usize) as usize;
let rec_simd_ctxt = &mut rec.context.simd;
let mut simd_granule = match get_granule_if!(simd_aux, GranuleState::RecAux) {
Ok(guard) => guard,
Err(_e) => {
error!("Unable to get RecAux granule at 0x{:x}", simd_aux);
return;
}
};
let mut rec_simd = simd_granule.content_mut::<SimdRegister>().unwrap();
let ns_simd = NS_SIMD[get_cpu_id()].lock();
rec_simd.cptr_el2 =
(CPTR_EL2::TAM::SET + CPTR_EL2::TSM::SET + CPTR_EL2::TFP::SET + CPTR_EL2::TZ::SET).value;
if !rec_simd_ctxt.is_used {
CPTR_EL2.set(ns_simd.cptr_el2);
if sme_en() {
SVCR.set(ns_simd.svcr);
}
return;
}
// Disable simd traps during the context mgmt.
CPTR_EL2.write(CPTR_EL2::TAM::SET);
// Since FEAT_SME is not for Realms, no need to store SVCR which doesn't change.
if rec_simd_ctxt.cfg.sve_en {
rec_simd.sve.zcr_el2 = ZCR_EL2.get();
rec_simd.sve.zcr_el12 = ZCR_EL1.get();
unsafe {
let save_ffr = true; // Since FEAT_SME is not for Realms, it's always true.
save_sve(&mut rec_simd.sve, save_ffr);
save_fpu_crsr(&mut rec_simd.fpu);
// Set SVCR before loading context.
// Otherwise, when SVCR:SM is 0, all simd registers are set to zero.
if sme_en() {
SVCR.set(ns_simd.svcr);
}
// To prevent cross-world leakage, restore ns's context of rec's len.
let restore_ffr = preserve_ffr(ns_simd.svcr);
restore_sve(&ns_simd.sve, restore_ffr);
restore_fpu_crsr(&ns_simd.fpu);
}
ZCR_EL2.set(ns_simd.sve.zcr_el2);
ZCR_EL1.set(ns_simd.sve.zcr_el12);
} else {
// For SIMD and FPU
unsafe {
save_fpu(&mut rec_simd.fpu);
restore_fpu(&ns_simd.fpu);
}
}
// To maintain immutability of rec.context during its restoration,
// update the context here in advance.
rec_simd_ctxt.is_used = false;
rec_simd_ctxt.is_saved = true;
CPTR_EL2.set(ns_simd.cptr_el2);
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/context.rs | rmm/src/rec/context.rs | use super::gic;
use super::pauth;
use super::pauth::PauthRegister;
use super::pmu;
use super::pmu::PmuRegister;
use super::simd;
use super::simd::SimdContext;
use super::timer;
use super::Rec;
use crate::rmi::error::Error;
use aarch64_cpu::registers::*;
#[repr(C)]
#[derive(Default, Debug)]
pub struct Context {
pub gp_regs: [u64; 31],
pub elr_el2: u64,
pub spsr_el2: u64,
pub sys_regs: SystemRegister,
pub mdcr_el2: u64,
pub gic_state: GICRegister,
pub timer: TimerRegister,
pub simd: SimdContext,
pub pauth: PauthRegister,
pub pmu: PmuRegister,
}
pub struct RegOffset;
impl RegOffset {
pub const PC: usize = 31;
pub const PSTATE: usize = 32;
pub const SCTLR: usize = 40;
}
pub fn set_reg(rec: &mut Rec<'_>, register: usize, value: usize) -> Result<(), Error> {
match register {
0..=30 => {
rec.context.gp_regs[register] = value as u64;
Ok(())
}
RegOffset::PC => {
rec.context.elr_el2 = value as u64;
Ok(())
}
RegOffset::PSTATE => {
rec.context.spsr_el2 = value as u64;
Ok(())
}
_ => Err(Error::RmiErrorInput),
}?;
Ok(())
}
pub fn get_reg(rec: &Rec<'_>, register: usize) -> Result<usize, Error> {
match register {
0..=30 => {
let value = rec.context.gp_regs[register];
Ok(value as usize)
}
RegOffset::PC => {
let value = rec.context.elr_el2;
Ok(value as usize)
}
_ => Err(Error::RmiErrorInput),
}
}
impl Context {
pub fn new() -> Self {
// Set appropriate sys registers
// TODO: enable floating point
// CPTR_EL2, CPACR_EL1, update vectors.s, etc..
Self {
spsr_el2: (SPSR_EL2::D.mask << SPSR_EL2::D.shift)
| (SPSR_EL2::A.mask << SPSR_EL2::A.shift)
| (SPSR_EL2::I.mask << SPSR_EL2::I.shift)
| (SPSR_EL2::F.mask << SPSR_EL2::F.shift)
| (SPSR_EL2::M.mask & u64::from(SPSR_EL2::M::EL1h)) << SPSR_EL2::M.shift,
..Default::default()
}
}
/// Restores the current execution context from the given `Rec`.
///
/// # Safety
///
/// - This function modifies processor-specific registers and state;
/// ensure that this is safe in the current execution context.
pub unsafe fn into_current(rec: &Rec<'_>) {
TPIDR_EL2.set(rec as *const _ as u64);
gic::restore_state(rec);
pauth::restore_state(rec);
pmu::restore_state(rec);
#[cfg(not(fuzzing))]
timer::restore_state(rec);
#[cfg(not(any(test, miri, fuzzing)))]
simd::restore_state(rec);
}
/// Saves the current execution context into the given `Rec` record.
///
/// # Safety
///
/// - This function reads and modifies processor-specific registers and state;
/// ensure that this is appropriate in the current execution context.
pub unsafe fn from_current(rec: &mut Rec<'_>) {
gic::save_state(rec);
pauth::save_state(rec);
pmu::save_state(rec);
#[cfg(not(fuzzing))]
timer::save_state(rec);
#[cfg(not(any(test, miri, fuzzing)))]
simd::save_state(rec);
}
}
/// Generic Interrupt Controller Registers
#[repr(C)]
#[derive(Default, Debug)]
pub struct GICRegister {
// Interrupt Controller Hyp Active Priorities Group 0 Registers
pub ich_ap0r_el2: [u64; 4],
// Interrupt Controller Hyp Active Priorities Group 1 Registers
pub ich_ap1r_el2: [u64; 4],
// GICv3 Virtual Machine Control Register
pub ich_vmcr_el2: u64,
// Interrupt Controller Hyp Control Register
pub ich_hcr_el2: u64,
// GICv3 List Registers
pub ich_lr_el2: [u64; 16],
// GICv3 Maintenance Interrupt State Register
pub ich_misr_el2: u64,
}
#[repr(C)]
#[derive(Default, Debug)]
// System registers without explicit exception level are for EL1
// unless it is unique to EL2 (e.g., vmpidr_el2, hpfar_el2)
pub struct SystemRegister {
pub sp: u64,
pub sp_el0: u64,
pub esr_el1: u64,
pub vbar: u64,
pub ttbr0: u64,
pub ttbr1: u64,
pub mair: u64,
pub amair: u64,
pub tcr: u64,
pub tpidr: u64,
pub tpidr_el0: u64,
pub tpidrro: u64,
pub actlr: u64,
pub vmpidr: u64,
pub csselr: u64,
pub cpacr: u64,
pub afsr0: u64,
pub afsr1: u64,
pub far: u64,
pub contextidr: u64,
pub cntkctl: u64,
pub par: u64,
pub vttbr: u64,
pub elr: u64,
pub spsr: u64,
pub sctlr: u64,
pub esr_el2: u64,
pub hpfar: u64,
pub far_el2: u64,
}
#[repr(C)]
#[derive(Default, Debug)]
pub struct TimerRegister {
pub cntvoff_el2: u64,
pub cntv_cval_el0: u64,
pub cntv_ctl_el0: u64,
pub cntpoff_el2: u64,
pub cntp_cval_el0: u64,
pub cntp_ctl_el0: u64,
pub cnthctl_el2: u64,
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/src/rec/mmio.rs | rmm/src/rec/mmio.rs | use crate::rec::{Rec, RmmRecEmulatableAbort::EmulatableAbort};
use crate::rmi::error::Error;
use crate::rmi::rec::run::{EntryFlag, Run};
use armv9a::regs::*;
pub fn emulate_mmio(rec: &mut Rec<'_>, run: &Run) -> Result<(), Error> {
let flags = run.entry_flags();
// Host has not completed emulation for an Emulatable Abort.
// if INJECT_SEA is set then the value of EMUL_MMIO is ignored.
if flags.get_masked(EntryFlag::INJECT_SEA | EntryFlag::EMUL_MMIO) == 0 {
return Ok(());
}
let esr_el2 = rec.context.sys_regs.esr_el2;
let esr = EsrEl2::new(esr_el2);
let ec = esr.get_masked_value(EsrEl2::EC);
let wnr = esr.get_masked_value(EsrEl2::WNR);
let rt = esr.get_masked_value(EsrEl2::SRT) as usize;
if ec != ESR_EL2_EC_DATA_ABORT || rec.emulatable_abort() != EmulatableAbort {
return Err(Error::RmiErrorRec);
}
// MMIO read case
if wnr == 0 && rt != 31 {
let mask = esr.get_access_size_mask();
let val = run.entry_gpr(0)? & mask;
let sign_extended = esr.get_masked_value(EsrEl2::SSE);
if sign_extended != 0 {
// TODO
unimplemented!();
}
rec.context.gp_regs[rt] = val;
}
rec.context.elr_el2 += 4;
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_fold_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_fold_fuzz.rs | #![no_main]
use islet_rmm::granule::GRANULE_SIZE;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, RTT_CREATE, RTT_FOLD,
RTT_INIT_RIPAS, RTT_MAP_UNPROTECTED, RTT_READ_ENTRY, RTT_UNMAP_UNPROTECTED, SUCCESS,
};
use islet_rmm::test_utils::{mock, *};
use mock::host::alloc_granule_l2_aligned;
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
const L2_PAGE_COUNT: usize = L2_SIZE / L3_SIZE;
#[derive(Debug, Copy, Clone, arbitrary::Arbitrary)]
enum FoldType {
Unassigned,
Assigned,
NonHomogenous,
}
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTFoldFuzz {
base: u64,
fold_type: FoldType,
ram: bool,
}
/* In the cases of ASSIGNED_RAM and ASSIGNED_NS, before we can revert them
* to their UNASSIGNED STATES, we need to unfold them first.
*/
fn unfold(rd: usize, base: usize) {
let rtt_l3 = alloc_granule(IDX_RTT_LEVEL3);
let ret = rmi::<RTT_CREATE>(&[rd, rtt_l3, base, MAP_LEVEL]);
assert_eq!(ret[0], SUCCESS);
}
fn destroy_fold(rd: usize, base: usize, fold_type: FoldType, fold_success: bool) {
let ns: bool = (base & (1 << IPA_WIDTH - 1)) != 0;
match fold_type {
FoldType::Assigned => {
if fold_success {
unfold(rd, base);
}
for idx in 0..L2_PAGE_COUNT {
if ns {
let ret = rmi::<RTT_UNMAP_UNPROTECTED>(&[rd, base + idx * L3_SIZE, MAP_LEVEL]);
assert_eq!(ret[0], SUCCESS);
} else {
let ret = rmi::<DATA_DESTROY>(&[rd, base + idx * L3_SIZE]);
assert_eq!(ret[0], SUCCESS);
let data_granule = alloc_granule_l2_aligned(IDX_L2_ALIGNED_DATA + idx);
let ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
assert_eq!(ret[0], SUCCESS);
}
}
}
FoldType::Unassigned => {}
FoldType::NonHomogenous => {
if ns {
let ret = rmi::<RTT_UNMAP_UNPROTECTED>(&[rd, base, MAP_LEVEL]);
assert_eq!(ret[0], SUCCESS);
} else {
let ret = rmi::<DATA_DESTROY>(&[rd, base]);
assert_eq!(ret[0], SUCCESS);
let data_granule = alloc_granule_l2_aligned(IDX_L2_ALIGNED_DATA);
let ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
assert_eq!(ret[0], SUCCESS);
}
}
}
}
fn setup_fold(rd: usize, base: usize, fold_type: FoldType, ram: bool) {
let top = base + L2_SIZE;
let ns = (base & (1 << IPA_WIDTH - 1)) != 0;
if ram && !ns {
let ret = rmi::<RTT_INIT_RIPAS>(&[rd, base, top]);
assert_eq!(ret[0], SUCCESS);
}
match fold_type {
FoldType::Assigned => {
for idx in 0..L2_PAGE_COUNT {
if ns {
let ns_desc = alloc_granule_l2_aligned(IDX_L2_ALIGNED_DATA + idx);
let ret =
rmi::<RTT_MAP_UNPROTECTED>(&[rd, base + idx * L3_SIZE, MAP_LEVEL, ns_desc]);
assert_eq!(ret[0], SUCCESS);
} else {
let data_granule = alloc_granule_l2_aligned(IDX_L2_ALIGNED_DATA + idx);
let ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, base + idx * L3_SIZE]);
assert_eq!(ret[0], SUCCESS);
}
}
}
FoldType::Unassigned => {
if ns {
for idx in 0..L2_PAGE_COUNT {
let ns_desc = alloc_granule(IDX_NS_DESC);
let ret =
rmi::<RTT_MAP_UNPROTECTED>(&[rd, base + idx * L3_SIZE, MAP_LEVEL, ns_desc]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<RTT_UNMAP_UNPROTECTED>(&[rd, base + idx * L3_SIZE, MAP_LEVEL]);
assert_eq!(ret[0], SUCCESS);
}
}
}
FoldType::NonHomogenous => {
if ns {
let ns_desc = alloc_granule_l2_aligned(IDX_L2_ALIGNED_DATA);
let ret = rmi::<RTT_MAP_UNPROTECTED>(&[rd, base, MAP_LEVEL, ns_desc]);
assert_eq!(ret[0], SUCCESS);
} else {
let data_granule = alloc_granule_l2_aligned(IDX_L2_ALIGNED_DATA);
let ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, base]);
assert_eq!(ret[0], SUCCESS);
}
}
}
}
fuzz_target!(|data: RTTFoldFuzz| -> Corpus {
let base = (data.base as usize / L2_SIZE) * L2_SIZE;
let top = match (data.base as usize).checked_add(L2_SIZE) {
Some(x) => x,
None => {
return Corpus::Reject;
}
};
let fold_type = data.fold_type;
let ram = data.ram;
let rd = realm_create();
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, base, MAP_LEVEL]);
if ret[0] != SUCCESS {
realm_destroy(rd);
return Corpus::Reject;
}
mock::host::map(rd, base);
setup_fold(rd, base, fold_type, ram);
let ret = rmi::<RTT_FOLD>(&[rd, base, MAP_LEVEL]);
if ret[0] == SUCCESS {
destroy_fold(rd, base, fold_type, true);
match fold_type {
FoldType::Unassigned => mock::host::unmap(rd, base, true),
_ => mock::host::unmap(rd, base, false),
}
} else {
destroy_fold(rd, base, fold_type, false);
mock::host::unmap(rd, base, false);
}
realm_destroy(rd);
Corpus::Keep
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_data_create_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_data_create_fuzz.rs | #![no_main]
use islet_rmm::rmi::rtt_entry_state::{RMI_ASSIGNED, RMI_UNASSIGNED};
use islet_rmm::rmi::{
DATA_CREATE, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, RTT_INIT_RIPAS,
RTT_READ_ENTRY, SUCCESS,
};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct DataCreateFuzz {
ipa: u64,
flags: u64,
}
fuzz_target!(|data: DataCreateFuzz| -> Corpus {
let ipa = data.ipa as usize;
let flags = data.flags as usize;
let base = (ipa / L3_SIZE) * L3_SIZE;
let data_granule = alloc_granule(IDX_DATA1);
let src = alloc_granule(IDX_SRC1);
let top = match (base as usize).checked_add(L3_SIZE) {
Some(x) => x,
None => {
return Corpus::Reject;
}
};
let rd = realm_create();
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
if (ret[0] != SUCCESS) {
realm_destroy(rd);
return Corpus::Reject;
}
mock::host::map(rd, ipa);
let ret = rmi::<RTT_INIT_RIPAS>(&[rd, base, top]);
if ret[0] != SUCCESS {
mock::host::unmap(rd, ipa, false);
realm_destroy(rd);
return Corpus::Reject;
}
let _ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
let ret = rmi::<DATA_CREATE>(&[rd, data_granule, ipa, src, flags]);
if ret[0] == SUCCESS {
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
assert_eq!(ret[2], RMI_ASSIGNED);
let ret = rmi::<DATA_DESTROY>(&[rd, ipa]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
assert_eq!(ret[2], RMI_UNASSIGNED);
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::unmap(rd, ipa, false);
realm_destroy(rd);
Corpus::Keep
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_set_ripas_destroyed_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_set_ripas_destroyed_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE,
REC_ENTER, RTT_INIT_RIPAS, RTT_READ_ENTRY, RTT_SET_RIPAS, SUCCESS,
};
use islet_rmm::rsi::IPA_STATE_SET;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTSetRIPASFuzz {
base: u64,
ripas_state: u8,
ripas_flags: u64,
is_assigned: bool,
}
fuzz_target!(|data: RTTSetRIPASFuzz| -> Corpus {
let base = (data.base as usize) / L3_SIZE * L3_SIZE;
let top = match (base as usize).checked_add(L3_SIZE) {
Some(x) => x,
None => {
return Corpus::Reject;
}
};
let rd = mock::host::realm_unactivated_setup();
let ripas_state = data.ripas_state as usize;
let ripas_flags = data.ripas_flags as usize;
let is_assigned = data.is_assigned;
let mut fuzz_ret = Corpus::Keep;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, base, MAP_LEVEL]);
if (ret[0] != SUCCESS) {
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
mock::host::map(rd, base);
/* Only ASSIGNED_RAM entries can be converted to DESTROYED */
let ret = rmi::<RTT_INIT_RIPAS>(&[rd, base, top]);
if ret[0] != SUCCESS {
mock::host::unmap(rd, base, false);
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
let data_granule = alloc_granule(IDX_DATA1);
let _ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, base]);
if ret[0] == SUCCESS {
let _ret = rmi::<REALM_ACTIVATE>(&[rd]);
assert_eq!(ret[0], SUCCESS);
/* Create DESTROYED entries */
let ret = rmi::<DATA_DESTROY>(&[rd, base]);
assert_eq!(ret[0], SUCCESS);
/* Create ASSIGNED_DESTROYED entries, otherwise UNASSIGNED_DESTROYED */
if is_assigned {
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, base]);
assert_eq!(ret[0], SUCCESS);
}
let ret = rmi::<REC_ENTER>(&[
rec1,
run1,
IPA_STATE_SET,
base,
top,
ripas_state,
ripas_flags,
]);
if ret[0] == SUCCESS {
let ret = rmi::<RTT_SET_RIPAS>(&[rd, rec1, base, top]);
/* Complete RIPAS change */
let _ret = rmi::<REC_ENTER>(&[rec1, run1]);
}
if is_assigned {
let ret = rmi::<DATA_DESTROY>(&[rd, base]);
assert_eq!(ret[0], SUCCESS);
}
} else {
fuzz_ret = Corpus::Reject
}
mock::host::unmap(rd, base, false);
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::realm_teardown(rd);
fuzz_ret
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_abi_version_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_abi_version_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{REC_ENTER, SUCCESS};
use islet_rmm::rsi::ABI_VERSION;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: u64| {
let rd = mock::host::realm_setup();
let version = data as usize;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let _ret = rmi::<REC_ENTER>(&[rec1, run1, ABI_VERSION, version]);
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_invalid_ipa_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_invalid_ipa_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE,
REC_ENTER, RTT_INIT_RIPAS, RTT_READ_ENTRY, SUCCESS,
};
use islet_rmm::rsi::{ATTEST_TOKEN_CONTINUE, ATTEST_TOKEN_INIT, HOST_CALL, REALM_CONFIG};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
enum RSICommand {
HOST_CALL,
REALM_CONFIG,
ATTESTATION,
}
#[derive(Debug, arbitrary::Arbitrary)]
struct InvalidIPACmdFuzz {
ipa: u64,
cmd: RSICommand,
}
fuzz_target!(|data: InvalidIPACmdFuzz| {
let ipa = data.ipa as usize;
let rd = mock::host::realm_setup();
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
match data.cmd {
RSICommand::HOST_CALL => {
let _ret = rmi::<REC_ENTER>(&[rec1, run1, HOST_CALL, ipa]);
}
RSICommand::REALM_CONFIG => {
let _ret = rmi::<REC_ENTER>(&[rec1, run1, REALM_CONFIG, ipa]);
}
RSICommand::ATTESTATION => {
let _ret = rmi::<REC_ENTER>(&[rec1, run1, ATTEST_TOKEN_INIT, 0, 0, 0, 0, 0, 0, 0, 0]);
let _ret = rmi::<REC_ENTER>(&[rec1, run1, ATTEST_TOKEN_CONTINUE, ipa, 0, 0]);
}
}
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_ipa_state_get_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_ipa_state_get_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REC_ENTER,
RTT_INIT_RIPAS, RTT_READ_ENTRY, SUCCESS,
};
use islet_rmm::rsi::IPA_STATE_GET;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct GetRipasFuzz {
base: u64,
top: u64,
}
fuzz_target!(|data: GetRipasFuzz| -> Corpus {
let rd = mock::host::realm_setup();
let base = data.base as usize;
let top = data.top as usize;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let data_granule = alloc_granule(IDX_DATA1);
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, base, MAP_LEVEL]);
if ret[0] != SUCCESS {
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
mock::host::map(rd, base);
let _ret = rmi::<REC_ENTER>(&[rec1, run1, IPA_STATE_GET, base, top]);
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::unmap(rd, base, false);
mock::host::realm_teardown(rd);
Corpus::Keep
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_set_ripas_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_set_ripas_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE,
REC_ENTER, RTT_INIT_RIPAS, RTT_READ_ENTRY, RTT_SET_RIPAS, SUCCESS,
};
use islet_rmm::rsi::IPA_STATE_SET;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTSetRIPASFuzz {
base: u64,
top: u64,
ripas_state: u8,
ripas_flags: u64,
}
fuzz_target!(|data: RTTSetRIPASFuzz| -> Corpus {
let rd = mock::host::realm_setup();
let base = data.base as usize;
let top = data.top as usize;
let ripas_state = data.ripas_state as usize;
let ripas_flags = data.ripas_flags as usize;
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, base, MAP_LEVEL]);
if (ret[0] != SUCCESS) {
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let ret = rmi::<REC_ENTER>(&[
rec1,
run1,
IPA_STATE_SET,
base,
top,
ripas_state,
ripas_flags,
]);
if ret[0] == SUCCESS {
mock::host::map(rd, base);
let ret = rmi::<RTT_SET_RIPAS>(&[rd, rec1, base, top]);
mock::host::unmap(rd, base, false);
/* Complete RIPAS change */
let _ret = rmi::<REC_ENTER>(&[rec1, run1]);
}
mock::host::realm_teardown(rd);
Corpus::Keep
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_attestation_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_attestation_fuzz.rs | #![no_main]
use islet_rmm::granule::GRANULE_SIZE;
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE,
REC_ENTER, RTT_INIT_RIPAS, RTT_READ_ENTRY, SUCCESS,
};
use islet_rmm::rsi::{ATTEST_TOKEN_CONTINUE, ATTEST_TOKEN_INIT};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct TokenContinueFuzz {
offset: u64,
size: u64,
}
#[derive(Debug, arbitrary::Arbitrary)]
struct AttestFuzz {
ipa: u64,
challenge: [u64; 8],
/* Fuzz multiple ATTEST_TOKEN_CONTINUE calls */
tokens: Vec<TokenContinueFuzz>,
}
fuzz_target!(|data: AttestFuzz| -> Corpus {
let ipa = data.ipa as usize;
let challenge = &data.challenge;
let top = match ipa.checked_add(L3_SIZE) {
Some(x) => x,
None => {
return Corpus::Reject;
}
};
let rd = mock::host::realm_unactivated_setup();
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let data_granule = alloc_granule(IDX_DATA1);
let mut fuzz_ret = Corpus::Keep;
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
if ret[0] != SUCCESS {
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
mock::host::map(rd, ipa);
let ret = rmi::<RTT_INIT_RIPAS>(&[rd, ipa, top]);
if ret[0] != SUCCESS {
mock::host::unmap(rd, ipa, false);
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
let ret = rmi::<REALM_ACTIVATE>(&[rd]);
assert_eq!(ret[0], SUCCESS);
let _ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, ipa]);
if ret[0] == SUCCESS {
let _ret = rmi::<REC_ENTER>(&[
rec1,
run1,
ATTEST_TOKEN_INIT,
challenge[0] as usize,
challenge[1] as usize,
challenge[2] as usize,
challenge[3] as usize,
challenge[4] as usize,
challenge[5] as usize,
challenge[6] as usize,
challenge[7] as usize,
]);
for token in data.tokens {
let offset = token.offset as usize;
let size = token.size as usize;
let _ret = rmi::<REC_ENTER>(&[rec1, run1, ATTEST_TOKEN_CONTINUE, ipa, offset, size]);
}
let ret = rmi::<DATA_DESTROY>(&[rd, ipa]);
assert_eq!(ret[0], SUCCESS);
} else {
fuzz_ret = Corpus::Reject;
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::unmap(rd, ipa, false);
mock::host::realm_teardown(rd);
fuzz_ret
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_realm_create_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_realm_create_fuzz.rs | #![no_main]
use islet_rmm::granule::GRANULE_STATUS_TABLE_SIZE;
use islet_rmm::rmi::realm::params::Params as RealmParams;
use islet_rmm::rmi::{
GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE, REALM_CREATE, REALM_DESTROY, SUCCESS,
};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct RealmParamsFuzz {
flags: u64,
s2sz: u8,
sve_vl: u8,
num_bps: u8,
num_wps: u8,
pmu_num_ctrs: u8,
hash_algo: u8,
rpv: [u8; 64],
vmid: u16,
rtt_level_start: i64,
rtt_num_start: u32,
}
fuzz_target!(|data: RealmParamsFuzz| {
let (rd, rtt, params_ptr) = (
alloc_granule(IDX_RD),
alloc_granule(IDX_RTT_LEVEL0),
alloc_granule(IDX_REALM_PARAMS),
);
let _ret = rmi::<GRANULE_DELEGATE>(&[rd]);
let _ret = rmi::<GRANULE_DELEGATE>(&[rtt]);
unsafe {
let params = &mut *(params_ptr as *mut RealmParams);
params.flags = data.flags;
params.s2sz = data.s2sz;
params.sve_vl = data.sve_vl;
params.num_bps = data.num_bps;
params.num_wps = data.num_wps;
params.pmu_num_ctrs = data.pmu_num_ctrs;
params.hash_algo = data.hash_algo;
params.rpv = data.rpv;
params.vmid = data.vmid;
params.rtt_base = rtt as u64;
params.rtt_level_start = data.rtt_level_start;
params.rtt_num_start = data.rtt_num_start;
}
let ret = rmi::<REALM_CREATE>(&[rd, params_ptr]);
if ret[0] == SUCCESS {
let _ret = rmi::<REALM_ACTIVATE>(&[rd]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<REALM_DESTROY>(&[rd]);
assert_eq!(ret[0], SUCCESS);
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[rd]);
let _ret = rmi::<GRANULE_UNDELEGATE>(&[rtt]);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rec_enter_data_abort_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rec_enter_data_abort_fuzz.rs | #![no_main]
use armv9a::regs::*;
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::{Run, REC_ENTRY_FLAG_EMUL_MMIO};
use islet_rmm::rmi::{REC_ENTER, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
const DataAbort: usize = 2 << 4;
#[derive(Debug, arbitrary::Arbitrary)]
struct DataAbortFuzz {
esr: u64,
hpfar: u64,
far: u64,
}
fuzz_target!(|data: DataAbortFuzz| {
let rd = mock::host::realm_setup();
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let esr = EsrEl2::new(data.esr)
.set_masked_value(EsrEl2::SSE, 0) /* SSE triggers an unimplemented! */
.set_masked_value(EsrEl2::EC, ESR_EL2_EC_DATA_ABORT)
.get() as u64;
unsafe {
let rec = &mut *(rec1 as *mut Rec<'_>);
rec.context.sys_regs.esr_el2 = esr;
}
let _ret = rmi::<REC_ENTER>(&[
rec1,
run1,
REC_ENTER_EXIT_CMD,
DataAbort,
esr as usize,
data.hpfar as usize,
data.far as usize,
]);
unsafe {
let run = &mut *(run1 as *mut Run);
run.set_entry_flags(REC_ENTRY_FLAG_EMUL_MMIO);
}
/* Complete data abort handling */
let _ret = rmi::<REC_ENTER>(&[rec1, run1]);
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_measurement_extend_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_measurement_extend_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{REC_ENTER, SUCCESS};
use islet_rmm::rsi::MEASUREMENT_EXTEND;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct MeasurementExtendFuzz {
idx: u64,
size: u64,
values: [u64; 8],
}
fuzz_target!(|data: MeasurementExtendFuzz| {
let rd = mock::host::realm_setup();
let measurement_index = data.idx as usize;
let size = data.size as usize;
let values = &data.values;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let _ret = rmi::<REC_ENTER>(&[
rec1,
run1,
MEASUREMENT_EXTEND,
measurement_index,
size,
values[0] as usize,
values[1] as usize,
values[2] as usize,
values[3] as usize,
values[4] as usize,
values[5] as usize,
values[6] as usize,
values[7] as usize,
]);
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_measurement_read_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_measurement_read_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{REC_ENTER, SUCCESS};
use islet_rmm::rsi::MEASUREMENT_READ;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: u64| {
let rd = mock::host::realm_setup();
let measurement_index = data as usize;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let _ret = rmi::<REC_ENTER>(&[rec1, run1, MEASUREMENT_READ, measurement_index]);
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_granule_delegate_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_granule_delegate_fuzz.rs | #![no_main]
use islet_rmm::granule::GRANULE_STATUS_TABLE_SIZE;
use islet_rmm::rmi::{GRANULE_DELEGATE, GRANULE_UNDELEGATE, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
enum GranuleAddress {
GranuleRegion(u16),
RandomAddress(u64),
}
fuzz_target!(|data: GranuleAddress| {
let addr: usize = match data {
GranuleAddress::GranuleRegion(idx) => {
alloc_granule((idx as usize) % GRANULE_STATUS_TABLE_SIZE)
}
GranuleAddress::RandomAddress(addr) => addr as usize,
};
let ret = rmi::<GRANULE_DELEGATE>(&[addr]);
if ret[0] == SUCCESS {
let _ret = rmi::<GRANULE_UNDELEGATE>(&[addr]);
}
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rec_enter_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rec_enter_fuzz.rs | #![no_main]
use islet_rmm::rmi::rec::run::{Run, NR_GIC_LRS, NR_GPRS};
use islet_rmm::rmi::{REC_ENTER, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct RunEntryFuzz {
flags: u64,
gprs: [u64; NR_GPRS],
gicv3_hcr: u64,
gicv3_lrs: [u64; NR_GIC_LRS],
}
fuzz_target!(|data: RunEntryFuzz| {
let rd = mock::host::realm_setup();
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
unsafe {
let run = &mut *(run1 as *mut Run);
run.set_entry_flags(data.flags);
run.set_entry_gic_hcr(data.gicv3_hcr);
run.set_entry_gic_lrs(&data.gicv3_lrs, NR_GIC_LRS);
for idx in 0..NR_GPRS {
run.set_entry_gpr(idx, data.gprs[idx]).unwrap();
}
}
let _ret = rmi::<REC_ENTER>(&[rec1, run1]);
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_features_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_features_fuzz.rs | #![no_main]
use islet_rmm::rmi::FEATURES;
use islet_rmm::test_utils::*;
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: u64| {
let feature_reg_index = data as usize;
let _ret = rmi::<FEATURES>(&[feature_reg_index]);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_psci_cpu_on_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_psci_cpu_on_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{PSCI_COMPLETE, REC_ENTER, SUCCESS, SUCCESS_REC_ENTER};
use islet_rmm::rsi::PSCI_CPU_ON;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct PSCICpuOnFuzz {
target: u64,
entrypoint: u64,
context_id: u32,
status: usize,
target_runnable: bool,
}
fuzz_target!(|data: PSCICpuOnFuzz| {
let rd = mock::host::realm_setup();
let target = data.target as usize;
let entrypoint = data.entrypoint as usize;
let context_id = data.entrypoint as usize;
let status = data.status;
let target_runnable = data.target_runnable as u64;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let rec2 = alloc_granule(IDX_REC2);
let ret = rmi::<REC_ENTER>(&[rec1, run1, PSCI_CPU_ON, target, entrypoint, context_id]);
if ret[0] == SUCCESS {
unsafe {
let target_rec = &mut *(rec2 as *mut Rec<'_>);
target_rec.set_runnable(target_runnable);
}
let _ret = rmi::<PSCI_COMPLETE>(&[rec1, rec2, status]);
}
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_host_call_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_host_call_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE,
REC_ENTER, RTT_INIT_RIPAS, RTT_READ_ENTRY, SUCCESS,
};
use islet_rmm::rsi::HOST_CALL;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{fuzz_target, Corpus};
fuzz_target!(|data: u64| -> Corpus {
let ipa = (data as usize) / L3_SIZE * L3_SIZE;
let top = match (ipa as usize).checked_add(L3_SIZE) {
Some(x) => x,
None => {
return Corpus::Reject;
}
};
let rd = mock::host::realm_unactivated_setup();
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let data_granule = alloc_granule(IDX_DATA1);
let mut fuzz_ret = Corpus::Keep;
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
if ret[0] != SUCCESS {
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
mock::host::map(rd, ipa);
let ret = rmi::<RTT_INIT_RIPAS>(&[rd, ipa, top]);
if ret[0] != SUCCESS {
mock::host::unmap(rd, ipa, false);
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
let ret = rmi::<REALM_ACTIVATE>(&[rd]);
assert_eq!(ret[0], SUCCESS);
let _ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, ipa]);
if ret[0] == SUCCESS {
/* Enter first time to run HOST_CALL */
let _ret = rmi::<REC_ENTER>(&[rec1, run1, HOST_CALL, ipa]);
/* Enter again to finish host call */
let _ret = rmi::<REC_ENTER>(&[rec1, run1]);
let ret = rmi::<DATA_DESTROY>(&[rd, ipa]);
assert_eq!(ret[0], SUCCESS);
} else {
fuzz_ret = Corpus::Reject;
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::unmap(rd, ipa, false);
mock::host::realm_teardown(rd);
fuzz_ret
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_realm_config_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_realm_config_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE,
REC_ENTER, RTT_INIT_RIPAS, RTT_READ_ENTRY, SUCCESS,
};
use islet_rmm::rsi::REALM_CONFIG;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{fuzz_target, Corpus};
fuzz_target!(|data: u64| -> Corpus {
let ipa = (data as usize) / L3_SIZE * L3_SIZE;
let top = match (ipa as usize).checked_add(L3_SIZE) {
Some(x) => x,
None => {
return Corpus::Reject;
}
};
let rd = mock::host::realm_unactivated_setup();
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let data_granule = alloc_granule(IDX_DATA1);
let mut fuzz_ret = Corpus::Keep;
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
if ret[0] != SUCCESS {
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
mock::host::map(rd, ipa);
let ret = rmi::<RTT_INIT_RIPAS>(&[rd, ipa, top]);
if ret[0] != SUCCESS {
mock::host::unmap(rd, ipa, false);
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
let _ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
let ret = rmi::<REALM_ACTIVATE>(&[rd]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, ipa]);
if ret[0] == SUCCESS {
let _ret = rmi::<REC_ENTER>(&[rec1, run1, REALM_CONFIG, ipa]);
let ret = rmi::<DATA_DESTROY>(&[rd, ipa]);
assert_eq!(ret[0], SUCCESS);
} else {
fuzz_ret = Corpus::Reject;
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::unmap(rd, ipa, false);
mock::host::realm_teardown(rd);
fuzz_ret
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_psci_features_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_psci_features_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{REC_ENTER, SUCCESS};
use islet_rmm::rsi::PSCI_FEATURES;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: u32| {
let rd = mock::host::realm_setup();
let feature = data as usize;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let _ret = rmi::<REC_ENTER>(&[rec1, run1, PSCI_FEATURES, feature]);
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_granule_undelegate_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_granule_undelegate_fuzz.rs | #![no_main]
use islet_rmm::granule::GRANULE_STATUS_TABLE_SIZE;
use islet_rmm::rmi::{GRANULE_UNDELEGATE, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
enum GranuleAddress {
GranuleRegion(u16),
RandomAddress(u64),
}
fuzz_target!(|data: GranuleAddress| {
let addr: usize = match data {
GranuleAddress::GranuleRegion(idx) => {
alloc_granule((idx as usize) % GRANULE_STATUS_TABLE_SIZE)
}
GranuleAddress::RandomAddress(addr) => addr as usize,
};
let _ret = rmi::<GRANULE_UNDELEGATE>(&[addr]);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rec_create_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rec_create_fuzz.rs | #![no_main]
use islet_rmm::rmi::rec::params::Params as RecParams;
use islet_rmm::rmi::rec::params::NR_GPRS;
use islet_rmm::rmi::{
GRANULE_DELEGATE, GRANULE_UNDELEGATE, REC_AUX_COUNT, REC_CREATE, REC_DESTROY, SUCCESS,
};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct RecParamsFuzz {
flags: u64,
mpidr: u64,
pc: u64,
gprs: [u64; NR_GPRS],
}
fuzz_target!(|data: RecParamsFuzz| {
let rd = realm_create();
let ret = rmi::<REC_AUX_COUNT>(&[rd]);
let rec_aux_count = ret[1];
let (rec, params_ptr) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_PARAMS));
let _ret = rmi::<GRANULE_DELEGATE>(&[rec]);
unsafe {
let params = &mut *(params_ptr as *mut RecParams);
params.flags = data.flags;
params.mpidr = data.mpidr;
params.pc = data.pc;
params.gprs = data.gprs;
params.num_aux = rec_aux_count as u64;
for idx in 0..rec_aux_count {
let mocking_addr = alloc_granule(IDX_REC1_AUX + idx);
let ret = rmi::<GRANULE_DELEGATE>(&[mocking_addr]);
params.aux[idx] = mocking_addr as u64;
}
}
let ret = rmi::<REC_CREATE>(&[rd, rec, params_ptr]);
if ret[0] == SUCCESS {
let ret = rmi::<REC_DESTROY>(&[rec]);
assert_eq!(ret[0], SUCCESS);
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[rec]);
for idx in 0..rec_aux_count {
let mocking_addr = alloc_granule(IDX_REC1_AUX + idx);
let _ret = rmi::<GRANULE_UNDELEGATE>(&[rec]);
}
realm_destroy(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_data_create_unknown_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_data_create_unknown_fuzz.rs | #![no_main]
use islet_rmm::rmi::rtt_entry_state::{RMI_ASSIGNED, RMI_UNASSIGNED};
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, RTT_READ_ENTRY,
SUCCESS,
};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct DataCreateFuzz {
ipa: u64,
}
fuzz_target!(|data: DataCreateFuzz| -> Corpus {
let rd = realm_create();
let ipa = data.ipa as usize;
let data_granule = alloc_granule(IDX_DATA1);
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
if (ret[0] != SUCCESS) {
realm_destroy(rd);
return Corpus::Reject;
}
mock::host::map(rd, ipa);
let _ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, ipa]);
if ret[0] == SUCCESS {
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
assert_eq!(ret[2], RMI_ASSIGNED);
let ret = rmi::<DATA_DESTROY>(&[rd, ipa]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
assert_eq!(ret[2], RMI_UNASSIGNED);
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::unmap(rd, ipa, false);
realm_destroy(rd);
Corpus::Keep
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_create_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_create_fuzz.rs | #![no_main]
use islet_rmm::rmi::{GRANULE_DELEGATE, GRANULE_UNDELEGATE, RTT_CREATE, RTT_DESTROY, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTCreateFuzz {
ipa: u64,
level: i64,
}
fuzz_target!(|data: RTTCreateFuzz| {
let rd = realm_create();
let ipa = data.ipa as usize;
let level = data.level as usize;
let rtt = alloc_granule(IDX_RTT_LEVEL1);
let _ret = rmi::<GRANULE_DELEGATE>(&[rtt]);
let ret = rmi::<RTT_CREATE>(&[rd, rtt, ipa, level]);
if ret[0] == SUCCESS {
let ret = rmi::<RTT_DESTROY>(&[rd, ipa, level]);
assert_eq!(ret[0], SUCCESS);
}
let _ret = rmi::<GRANULE_UNDELEGATE>(&[rtt]);
realm_destroy(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rec_enter_exit_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rec_enter_exit_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{REC_ENTER, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
/* Fuzz exits outside of RSI and Data aborts */
#[derive(Debug, arbitrary::Arbitrary)]
enum ExitReason {
IRQ = 1,
FIQ = 2,
PSCI = 3,
SError = 4,
InstAbort = 3 << 4,
}
#[derive(Debug, arbitrary::Arbitrary)]
struct RecExitFuzz {
command: ExitReason,
esr: u64,
hpfar: u64,
far: u64,
}
fuzz_target!(|data: RecExitFuzz| {
let rd = mock::host::realm_setup();
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let _ret = rmi::<REC_ENTER>(&[
rec1,
run1,
REC_ENTER_EXIT_CMD,
data.command as usize,
data.esr as usize,
data.hpfar as usize,
data.far as usize,
]);
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rsi_psci_affinity_info_fuzz.rs | rmm/fuzz/fuzz_targets/rsi_psci_affinity_info_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{PSCI_COMPLETE, REC_ENTER, SUCCESS, SUCCESS_REC_ENTER};
use islet_rmm::rsi::PSCI_AFFINITY_INFO;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct PSCIAffinityFuzz {
target_affinity: u64,
lowest_affinity_level: u32,
status: usize,
target_runnable: bool,
}
fuzz_target!(|data: PSCIAffinityFuzz| {
let rd = mock::host::realm_setup();
let target_affinity = data.target_affinity as usize;
let lowest_affinity_level = data.lowest_affinity_level as usize;
let status = data.status;
let target_runnable = data.target_runnable as u64;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
let rec2 = alloc_granule(IDX_REC2);
let ret = rmi::<REC_ENTER>(&[
rec1,
run1,
PSCI_AFFINITY_INFO,
target_affinity,
lowest_affinity_level,
]);
if ret[0] == SUCCESS {
unsafe {
let target_rec = &mut *(rec2 as *mut Rec<'_>);
target_rec.set_runnable(target_runnable);
}
let _ret = rmi::<PSCI_COMPLETE>(&[rec1, rec2, status]);
}
mock::host::realm_teardown(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_init_ripas_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_init_ripas_fuzz.rs | #![no_main]
use islet_rmm::rmi::{RTT_INIT_RIPAS, RTT_READ_ENTRY, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTInitRipasFuzz {
base: u64,
top: u64,
}
fuzz_target!(|data: RTTInitRipasFuzz| -> Corpus {
let rd = realm_create();
let base = data.base as usize;
let top = data.top as usize;
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, base, MAP_LEVEL]);
if ret[0] != SUCCESS {
realm_destroy(rd);
return Corpus::Reject;
}
mock::host::map(rd, base);
let _ret = rmi::<RTT_INIT_RIPAS>(&[rd, base, top]);
mock::host::unmap(rd, base, false);
realm_destroy(rd);
Corpus::Keep
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_version_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_version_fuzz.rs | #![no_main]
use islet_rmm::rmi::VERSION;
use islet_rmm::test_utils::*;
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: u64| {
let req = data as usize;
let _ret = rmi::<VERSION>(&[req]);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_read_entry_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_read_entry_fuzz.rs | #![no_main]
use islet_rmm::rmi::{RTT_READ_ENTRY, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target};
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTEntryReadFuzz {
ipa: u64,
level: i64,
}
fuzz_target!(|data: RTTEntryReadFuzz| {
let rd = realm_create();
let ipa = data.ipa as usize;
let level = data.level as usize;
let _ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, level]);
realm_destroy(rd);
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_map_unprotected_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_map_unprotected_fuzz.rs | #![no_main]
use islet_rmm::rmi::rtt_entry_state::{RMI_ASSIGNED, RMI_UNASSIGNED};
use islet_rmm::rmi::{RTT_MAP_UNPROTECTED, RTT_READ_ENTRY, RTT_UNMAP_UNPROTECTED, SUCCESS};
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTUnprotected {
ipa: u64,
ATTR_NORMAL_WB_WA_RA: bool,
ATTR_STAGE2_AP_RW: bool,
ATTR_INNER_SHARED: bool,
}
fuzz_target!(|data: RTTUnprotected| -> Corpus {
let rd = realm_create();
let ipa = data.ipa as usize;
let mut ns = alloc_granule(IDX_NS_DESC);
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
if ret[0] != SUCCESS {
realm_destroy(rd);
return Corpus::Reject;
}
mock::host::map(rd, ipa);
if data.ATTR_NORMAL_WB_WA_RA {
ns = ns | ATTR_NORMAL_WB_WA_RA;
}
if data.ATTR_STAGE2_AP_RW {
ns = ns | ATTR_STAGE2_AP_RW;
}
if data.ATTR_INNER_SHARED {
ns = ns | ATTR_INNER_SHARED;
}
let ret = rmi::<RTT_MAP_UNPROTECTED>(&[rd, ipa, MAP_LEVEL, ns]);
if ret[0] == SUCCESS {
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
assert_eq!(ret[2], RMI_ASSIGNED);
let ret = rmi::<RTT_UNMAP_UNPROTECTED>(&[rd, ipa, MAP_LEVEL]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<RTT_READ_ENTRY>(&[rd, ipa, MAP_LEVEL]);
assert_eq!(ret[2], RMI_UNASSIGNED);
}
mock::host::unmap(rd, ipa, false);
realm_destroy(rd);
Corpus::Keep
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/rmm/fuzz/fuzz_targets/rmi_rtt_set_ripas_assigned_fuzz.rs | rmm/fuzz/fuzz_targets/rmi_rtt_set_ripas_assigned_fuzz.rs | #![no_main]
use islet_rmm::rec::Rec;
use islet_rmm::rmi::rec::run::Run;
use islet_rmm::rmi::{
DATA_CREATE_UNKNOWN, DATA_DESTROY, GRANULE_DELEGATE, GRANULE_UNDELEGATE, REALM_ACTIVATE,
REC_ENTER, RTT_INIT_RIPAS, RTT_READ_ENTRY, RTT_SET_RIPAS, SUCCESS,
};
use islet_rmm::rsi::IPA_STATE_SET;
use islet_rmm::test_utils::{mock, *};
use libfuzzer_sys::{arbitrary, fuzz_target, Corpus};
#[derive(Debug, arbitrary::Arbitrary)]
struct RTTSetRIPASFuzz {
base: u64,
ripas_state: u8,
ripas_flags: u64,
ram: bool,
}
fuzz_target!(|data: RTTSetRIPASFuzz| -> Corpus {
let base = (data.base as usize) / L3_SIZE * L3_SIZE;
let top = match (base as usize).checked_add(L3_SIZE) {
Some(x) => x,
None => {
return Corpus::Reject;
}
};
let rd = mock::host::realm_unactivated_setup();
let ripas_state = data.ripas_state as usize;
let ripas_flags = data.ripas_flags as usize;
let ram = data.ram;
let mut fuzz_ret = Corpus::Keep;
let (rec1, run1) = (alloc_granule(IDX_REC1), alloc_granule(IDX_REC1_RUN));
/* Reject IPAs which cannot be mapped */
let ret = rmi::<RTT_READ_ENTRY>(&[rd, base, MAP_LEVEL]);
if (ret[0] != SUCCESS) {
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
mock::host::map(rd, base);
if ram {
let ret = rmi::<RTT_INIT_RIPAS>(&[rd, base, top]);
if ret[0] != SUCCESS {
mock::host::unmap(rd, base, false);
mock::host::realm_teardown(rd);
return Corpus::Reject;
}
}
let data_granule = alloc_granule(IDX_DATA1);
let _ret = rmi::<GRANULE_DELEGATE>(&[data_granule]);
let ret = rmi::<DATA_CREATE_UNKNOWN>(&[rd, data_granule, base]);
if ret[0] == SUCCESS {
let _ret = rmi::<REALM_ACTIVATE>(&[rd]);
assert_eq!(ret[0], SUCCESS);
let ret = rmi::<REC_ENTER>(&[
rec1,
run1,
IPA_STATE_SET,
base,
top,
ripas_state,
ripas_flags,
]);
if ret[0] == SUCCESS {
let ret = rmi::<RTT_SET_RIPAS>(&[rd, rec1, base, top]);
/* Complete RIPAS change */
let _ret = rmi::<REC_ENTER>(&[rec1, run1]);
}
let ret = rmi::<DATA_DESTROY>(&[rd, base]);
assert_eq!(ret[0], SUCCESS);
} else {
fuzz_ret = Corpus::Reject
}
mock::host::unmap(rd, base, false);
let _ret = rmi::<GRANULE_UNDELEGATE>(&[data_granule]);
mock::host::realm_teardown(rd);
fuzz_ret
});
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/lib.rs | hes/islet-hes/src/lib.rs | #![no_std]
//! Islet HES library.
extern crate alloc;
// Submodule implementing the attestation functionality.
mod attestation;
// Submodule containing hardware data trait.
mod hw;
// Submodule implementing the measured boot functionality.
mod measured_boot;
// Common functionality.
pub(crate) mod utils;
use core::{fmt::Debug, str::from_utf8};
use alloc::{string::ToString, vec::Vec};
use ciborium::into_writer;
use coset::CoseSign1;
use key_derivation::generate_seed;
use tinyvec::ArrayVec;
pub use measured_boot::{
Measurement, MeasurementError, MeasurementMetaData, MeasurementMgr, MeasurementType, SWType,
SWVersion, SignerHash, MEASUREMENT_VALUE_MAX_SIZE, MEASUREMENT_VALUE_MIN_SIZE,
NUM_OF_MEASUREMENT_SLOTS, SIGNER_ID_MAX_SIZE, SIGNER_ID_MIN_SIZE, SW_TYPE_MAX_SIZE,
VERSION_MAX_SIZE,
};
pub use hw::{
BootMeasurement, BootMeasurementMetadata, HWAsymmetricKey, HWData, HWHash, HWSWType,
HWSWVersion, HWSymmetricKey,
};
pub use attestation::{
calculate_public_key_hash, AttestationError, AttestationMgr, ECCFamily, HWClaims, HashAlgo,
KeyBits, KeyMaterialData,
};
pub const MAX_HASH_VALUE_SIZE: usize = 64;
pub type ValueHash = ArrayVec<[u8; MAX_HASH_VALUE_SIZE]>;
/// Possible PSA lifecycle states (major):
pub mod security_lifecycle {
pub const UNKNOWN: u32 = 0x1000;
pub const PSA_ROT_PROVISIONNING: u32 = 0x2000;
pub const SECURED: u32 = 0x3000;
pub const NON_PSA_ROT_DEBUG: u32 = 0x4000;
pub const RECOVERABLE_PSA_ROT_DEBUG: u32 = 0x5000;
pub const DECOMISSIONED: u32 = 0x6000;
}
pub struct IsletHES {
measured_boot_mgr: MeasurementMgr,
attestation_mgr: AttestationMgr,
lcs: u32,
huk: Vec<u8>,
}
#[derive(Debug)]
pub enum IsletHESError {
/// Implementations may use this error code if none of the other is applicable.
GenericError,
/// The parameters passed to the function are invalid.
InvalidArgument,
/// Measurement signer_id doesn't match for extend operation
NotPermitted,
/// Slot_id of a Measurement is not populated
DoesNotExist,
/// Slot_id of a Measurement is lock for extend operation
BadState,
/// Requested key size of DAK is not supported
NotSupported,
}
impl From<MeasurementError> for IsletHESError {
fn from(value: MeasurementError) -> Self {
match value {
MeasurementError::BadState => Self::BadState,
MeasurementError::DoesNotExist => Self::DoesNotExist,
MeasurementError::InvalidArgument => Self::InvalidArgument,
MeasurementError::InvalidData(_) => Self::InvalidArgument,
MeasurementError::NotPermitted => Self::NotPermitted,
}
}
}
impl From<AttestationError> for IsletHESError {
fn from(value: AttestationError) -> Self {
match value {
AttestationError::InvalidArgument => Self::InvalidArgument,
AttestationError::GenericError => Self::GenericError,
AttestationError::NotSupported => Self::NotSupported,
}
}
}
impl IsletHES {
/// Initializes IsletHes with data for [`HWData`] interface
pub fn init<H: HWData>(hw_data: H) -> Result<Self, IsletHESError>
where
<H as HWData>::Error: Debug,
{
let measured_boot_mgr = MeasurementMgr::init(
hw_data
.boot_measurements()
.map_err(|_| IsletHESError::InvalidArgument)?,
)?;
let profile_definition = match hw_data
.profile_definition()
.map_err(|_| IsletHESError::InvalidArgument)?
{
Some(p) => Some(
from_utf8(&p)
.map_err(|_| IsletHESError::InvalidArgument)?
.to_string(),
),
None => None,
};
let verification_service_url = match hw_data
.verification_service_url()
.map_err(|_| IsletHESError::InvalidArgument)?
{
Some(p) => Some(
from_utf8(&p)
.map_err(|_| IsletHESError::InvalidArgument)?
.to_string(),
),
None => None,
};
let security_lifecycle = hw_data
.security_lifecycle()
.map_err(|_| IsletHESError::InvalidArgument)?;
let attestation_mgr = AttestationMgr::init(
KeyMaterialData {
hash: hw_data
.bl_hash()
.map_err(|_| IsletHESError::InvalidArgument)?,
guk: hw_data.guk().map_err(|_| IsletHESError::InvalidArgument)?,
},
HWClaims {
implementation_id: hw_data
.implementation_id()
.map_err(|_| IsletHESError::InvalidArgument)?,
security_lifecycle,
profile_definition,
verification_service_url,
platform_config: hw_data
.platform_config()
.map_err(|_| IsletHESError::InvalidArgument)?,
},
);
Ok(IsletHES {
measured_boot_mgr,
attestation_mgr,
lcs: security_lifecycle,
huk: hw_data
.huk()
.map_err(|_| IsletHESError::InvalidArgument)?
.to_vec(),
})
}
/// Resets the measurements database and unmarks DAK key as generated
pub fn reset<H: HWData>(&mut self, hw_data: H) -> Result<(), IsletHESError> {
self.measured_boot_mgr = MeasurementMgr::init(
hw_data
.boot_measurements()
.map_err(|_| IsletHESError::InvalidArgument)?,
)?;
self.attestation_mgr.reset();
Ok(())
}
/// Returns measurement metadata, value and locked attribute from given slot_id.
/// Returns [`IsletHESError::InvalidArgument`], when slot_id is out of bounds.
/// Returns [`IsletHESError::DoesNotExist`], when is not populated.
pub fn read_measurement(&self, slot_id: usize) -> Result<(&Measurement, bool), IsletHESError> {
Ok(self.measured_boot_mgr.read_measurement(slot_id)?)
}
/// Extends measurement with updated metadata, value and locked attribute in given slot_id.
/// Returns [`IsletHESError::InvalidArgument`], when slot_id is out of bounds.
/// Returns [`IsletHESError::BadState`], when measurement is locked.
/// Returns [`IsletHESError::NotPermitted`], when measurements signer id's
/// and algorithm do not match.
pub fn extend_measurement(
&mut self,
slot_id: usize,
measurement: Measurement,
lock: bool,
) -> Result<(), IsletHESError> {
Ok(self
.measured_boot_mgr
.extend_measurement(slot_id, measurement, lock)?)
}
fn fetch_current_measurements(&self) -> Result<Vec<Measurement>, IsletHESError> {
let mut measurements = Vec::new();
for i in 0..measured_boot::NUM_OF_MEASUREMENT_SLOTS {
match self.measured_boot_mgr.read_measurement(i) {
Ok((measurement, _)) => measurements.push(measurement.clone()),
Err(MeasurementError::DoesNotExist) => continue,
Err(e) => return Err(e.into()),
}
}
Ok(measurements)
}
/// Generates DAK with [`ECCFamily`] and uses `measurements` ([`Measurement`])
/// as salt in the process.
/// Returns bytes of a scalar primitive, which can be used to recreate DAK Private Key.
/// [`HashAlgo`] is used for verification process, when `get_platform_token` is called.
/// Returns [`IsletHESError::GenericError`], when CBOR or crypto operation fails.
pub fn get_delegated_key(
&mut self,
ecc_family: ECCFamily,
key_bits: KeyBits,
hash_algo: HashAlgo,
) -> Result<Vec<u8>, IsletHESError> {
let measurements = self.fetch_current_measurements()?;
Ok(self.attestation_mgr.get_delegated_key(
ecc_family,
key_bits,
hash_algo,
&measurements,
)?)
}
/// Creates a tagged [`CoseSign1`] of the platform token.
/// `dak_pub_hash` must be a valid hash of DAK Public Key using [`HashAlgo`] passed
/// in [`IsletHES::get_delegated_key`].
/// Returns [`IsletHESError::GenericError`], when CBOR or crypto operation fails.
/// Returns [`IsletHESError::InvalidArgument`], when DAK was not requsted before
/// this operation, or `dak_pub_hash` is not a valid hash of DAK Public Key.
pub fn get_platform_token(&mut self, dak_pub_hash: &[u8]) -> Result<CoseSign1, IsletHESError> {
let measurements = self.fetch_current_measurements()?;
Ok(self
.attestation_mgr
.get_platform_token(dak_pub_hash, &measurements)?)
}
/// Creates an authority based Virtual HUK (VHUK_A).
/// This key is bound to the authority data, the type of firmware components
/// and HUK. This makes it immune to firmware updates.
/// This function should not return an error.
pub fn get_authority_vhuk(&mut self) -> Result<Vec<u8>, IsletHESError> {
let measurements = self.fetch_current_measurements()?;
let mut authority_info = Vec::new();
for Measurement { metadata, .. } in measurements {
let MeasurementMetaData {
signer_id, sw_type, ..
} = metadata;
authority_info.extend_from_slice(signer_id.as_slice());
authority_info.extend_from_slice(sw_type.as_bytes());
}
let mut context = Vec::new();
context.extend(&authority_info);
context.extend(self.lcs.to_ne_bytes());
Ok(generate_seed(&context, &self.huk, b"VHUK_A"))
}
/// Creates a measurement based Virtual HUK (VHUK_M).
/// This key is bound to the boot measurements of firmware components and HUK.
/// It is bound to a specific version of CCA Platform firmware.
pub fn get_measurement_vhuk(&mut self) -> Result<Vec<u8>, IsletHESError> {
let measurements = self.fetch_current_measurements()?;
let encoded_measurements = utils::encode_measurements(&measurements);
let mut context = Vec::new();
into_writer(&encoded_measurements, &mut context)
.map_err(|_| IsletHESError::GenericError)?;
context.extend(self.lcs.to_ne_bytes());
Ok(generate_seed(&context, &self.huk, b"VHUK_M"))
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/utils.rs | hes/islet-hes/src/utils.rs | use alloc::vec::Vec;
use ciborium::Value;
use crate::Measurement;
/// Keeps all platform token tag values based on RSS
pub mod token_tag {
/* Claims */
pub const CCA_PLAT_CHALLENGE: u32 = 10;
pub const CCA_PLAT_INSTANCE_ID: u32 = 256;
pub const CCA_PLAT_PROFILE: u32 = 265;
pub const CCA_PLAT_SECURITY_LIFECYCLE: u32 = 2395;
pub const CCA_PLAT_IMPLEMENTATION_ID: u32 = 2396;
pub const CCA_PLAT_SW_COMPONENTS: u32 = 2399;
pub const CCA_PLAT_VERIFICATION_SERVICE: u32 = 2400;
pub const CCA_PLAT_CONFIGURATION: u32 = 2401;
pub const CCA_PLAT_HASH_ALGO_DESC: u32 = 2402;
/* Software components */
pub const CCA_SW_COMP_TITLE: u32 = 1;
pub const CCA_SW_COMP_MEASUREMENT_VALUE: u32 = 2;
pub const CCA_SW_COMP_VERSION: u32 = 4;
pub const CCA_SW_COMP_SIGNER_ID: u32 = 5;
pub const CCA_SW_COMP_HASH_ALGORITHM: u32 = 6;
}
fn encode_measurement(measurement: &Measurement) -> Value {
let mut map: Vec<(Value, Value)> = Vec::with_capacity(5);
map.push((
Value::Integer(token_tag::CCA_SW_COMP_TITLE.into()),
Value::Text(measurement.metadata.sw_type.clone()),
));
map.push((
Value::Integer(token_tag::CCA_SW_COMP_HASH_ALGORITHM.into()),
Value::Text(measurement.metadata.algorithm.into()),
));
map.push((
Value::Integer(token_tag::CCA_SW_COMP_MEASUREMENT_VALUE.into()),
Value::Bytes(measurement.value.to_vec()),
));
map.push((
Value::Integer(token_tag::CCA_SW_COMP_VERSION.into()),
Value::Text(measurement.metadata.sw_version.clone()),
));
map.push((
Value::Integer(token_tag::CCA_SW_COMP_SIGNER_ID.into()),
Value::Bytes(measurement.metadata.signer_id.to_vec()),
));
Value::Map(map)
}
pub fn encode_measurements(measurements: &[Measurement]) -> Value {
let mut array: Vec<Value> = Vec::with_capacity(measurements.len());
for measurement in measurements {
array.push(encode_measurement(measurement));
}
Value::Array(array)
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/main.rs | hes/islet-hes/src/main.rs | use coset::TaggedCborSerializable;
use islet_hes::{
self, calculate_public_key_hash, AttestationMgr, BootMeasurement, BootMeasurementMetadata,
HWAsymmetricKey, HWClaims, HWData, HWHash, HWSymmetricKey, HashAlgo, KeyMaterialData,
MeasurementMgr, NUM_OF_MEASUREMENT_SLOTS,
};
use tinyvec::ArrayVec;
use std::fs::{self, create_dir_all, File};
use std::io::{Read, Result as IOResult, Write};
struct DummyHW();
type DummyError = ();
impl HWData for DummyHW {
type Error = DummyError;
fn boot_measurements(&self) -> Result<Vec<BootMeasurement>, DummyError> {
Ok(Vec::from([
BootMeasurement {
measurement_value: [
0x61, 0x97, 0x3b, 0x4f, 0x62, 0x0c, 0x2a, 0xe6, 0xc7, 0x63, 0x51, 0x18, 0xa0,
0xb4, 0x37, 0x6d, 0x15, 0x34, 0x4c, 0x1c, 0x53, 0xa2, 0x17, 0x89, 0xb1, 0xaa,
0x95, 0xd2, 0x0f, 0x3c, 0x45, 0x06,
]
.iter()
.cloned()
.collect(),
metadata: BootMeasurementMetadata {
signer_id: [
0xc6, 0xc3, 0x2a, 0x95, 0x7d, 0xf4, 0xc6, 0x69, 0x8c, 0x55, 0x0b, 0x69,
0x5d, 0x02, 0x2e, 0xd5, 0x18, 0x0c, 0xae, 0x71, 0xf8, 0xb4, 0x9c, 0xbb,
0x75, 0xe6, 0x06, 0x1c, 0x2e, 0xf4, 0x97, 0xe1,
]
.iter()
.cloned()
.collect(),
measurement_type: 0,
sw_type: b"Dummy BL1".iter().cloned().collect(),
sw_version: b"0.1.0".iter().cloned().collect(),
},
},
BootMeasurement {
measurement_value: [
0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2, 0x33, 0xff, 0x5d, 0x75, 0xd7,
0xea, 0x89, 0xa8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x05,
0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6,
0xFF, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x56, 0x46, 0x58, 0x49,
0x99, 0x31, 0xcf, 0x59, 0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c,
]
.into(),
metadata: BootMeasurementMetadata {
signer_id: [
0xa0, 0x64, 0xb1, 0xad, 0x60, 0xfa, 0x18, 0x33, 0x94, 0xdd, 0xa5, 0x78,
0x91, 0x35, 0x7f, 0x97, 0x2e, 0x4f, 0xe7, 0x22, 0x78, 0x2a, 0xdf, 0xf1,
0x85, 0x4c, 0x8b, 0x2a, 0x14, 0x2c, 0x04, 0x10,
]
.iter()
.cloned()
.collect(),
measurement_type: 2,
sw_type: b"Dummy BL2".iter().cloned().collect(),
sw_version: b"1.9.0+0".iter().cloned().collect(),
},
},
]))
}
fn huk(&self) -> Result<HWSymmetricKey, DummyError> {
Ok([
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
]
.into())
}
// Equivalent to res/dummy_guk.bin
fn guk(&self) -> Result<HWSymmetricKey, DummyError> {
Ok([
0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67,
0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45,
0x67, 0x89, 0x01, 0x23,
]
.into())
}
// Equivalent to res/bl2_signed_hash.bin
fn bl_hash(&self) -> Result<HWHash, Self::Error> {
Ok([
0xf1, 0x5f, 0x95, 0x3b, 0xe5, 0x0d, 0xad, 0x92, 0xc3, 0xb2, 0xaa, 0x32, 0x97, 0xe6,
0xa4, 0xa8, 0xd6, 0x6d, 0x33, 0x63, 0x84, 0x49, 0xec, 0x19, 0x22, 0xb4, 0xa7, 0x92,
0x4a, 0x7b, 0x30, 0x22,
]
.iter()
.cloned()
.collect())
}
fn cpak(&self) -> Result<Option<HWAsymmetricKey>, DummyError> {
Ok(None)
}
fn implementation_id(&self) -> Result<[u8; 32], DummyError> {
Ok([
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
0xBB, 0xBB, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xDD, 0xDD, 0xDD, 0xDD,
0xDD, 0xDD, 0xDD, 0xDD,
])
}
fn profile_definition(&self) -> Result<Option<ArrayVec<[u8; 35]>>, DummyError> {
Ok(Some(
b"tag:arm.com,2023:cca_platform#1.0.0"
.iter()
.cloned()
.collect(),
))
}
fn security_lifecycle(&self) -> Result<u32, DummyError> {
Ok(0x3000)
}
fn verification_service_url(&self) -> Result<Option<ArrayVec<[u8; 32]>>, DummyError> {
Ok(Some(b"http://whatever.com".iter().cloned().collect()))
}
fn platform_config(&self) -> Result<ArrayVec<[u8; 32]>, DummyError> {
Ok(0xDEADBEEFu32.to_ne_bytes().iter().cloned().collect())
}
}
// Can be used instead of hardcoded guk and bl hash.
fn _load_binary_file(filename: &str) -> IOResult<Vec<u8>> {
let mut f = File::open(filename)?;
let metadata = fs::metadata(filename)?;
let mut buffer = vec![0; metadata.len() as usize];
f.read(&mut buffer)?;
Ok(buffer)
}
fn save_binary_file(filename: &str, data: &[u8]) -> IOResult<()> {
println!("Saving file {filename}");
let mut f = File::create(filename)?;
f.write_all(data)
}
fn main() {
let hw_data = DummyHW();
// let guk = load_binary_file("res/dummy_guk.bin").unwrap();
// let hash = load_binary_file("res/bl2_signed_hash.bin").unwrap();
let key_material = KeyMaterialData {
guk: hw_data.guk().unwrap(),
hash: hw_data.bl_hash().unwrap(),
};
let hw_claims = HWClaims {
implementation_id: hw_data.implementation_id().unwrap().into(),
platform_config: hw_data.platform_config().unwrap(),
profile_definition: Some(
String::from_utf8(
hw_data
.profile_definition()
.unwrap()
.unwrap()
.as_slice()
.to_vec(),
)
.unwrap(),
),
security_lifecycle: hw_data.security_lifecycle().unwrap().try_into().unwrap(),
verification_service_url: Some(
String::from_utf8(
hw_data
.verification_service_url()
.unwrap()
.unwrap()
.as_slice()
.to_vec(),
)
.unwrap(),
),
};
let measurement_mgr = MeasurementMgr::init(hw_data.boot_measurements().unwrap()).unwrap();
let mut measurements = Vec::new();
for i in 0..NUM_OF_MEASUREMENT_SLOTS {
if let Ok((measurement, _)) = measurement_mgr.read_measurement(i) {
measurements.push(measurement.clone());
}
}
let mut attestation_mgr = AttestationMgr::init(key_material, hw_claims);
let dak_scalar_bytes = attestation_mgr
.get_delegated_key(
islet_hes::ECCFamily::SecpR1,
islet_hes::KeyBits::Bits384,
islet_hes::HashAlgo::Sha256,
&measurements,
)
.unwrap();
let priv_dak = p384::SecretKey::from_slice(&dak_scalar_bytes).unwrap();
// let scalar = dak.as_scalar_primitive().to_bytes().to_vec();
let dak_pub_hash =
calculate_public_key_hash(&priv_dak.public_key().to_sec1_bytes(), HashAlgo::Sha256);
let token = attestation_mgr
.get_platform_token(&dak_pub_hash, &measurements)
.unwrap()
.to_tagged_vec()
.expect("Couldn't export CoseSign1 to tagged cbor");
let out_dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../out/");
println!("{out_dir}");
create_dir_all(&out_dir).unwrap();
save_binary_file(&format!("{}/{}", out_dir, "platform_token.bin"), &token).unwrap();
save_binary_file(
&format!("{}/{}", out_dir, "dak_priv.bin"),
&dak_scalar_bytes,
)
.unwrap();
save_binary_file(
&format!("{}/{}", out_dir, "dak_pub.bin"),
&priv_dak.public_key().to_sec1_bytes(),
)
.unwrap();
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/measured_boot/manager.rs | hes/islet-hes/src/measured_boot/manager.rs | use super::*;
use crate::{BootMeasurement, ValueHash};
use alloc::vec::Vec;
use measurement::*;
use sha2::{Digest, Sha256, Sha384, Sha512};
#[derive(Debug)]
/// Keeps measurement in a slot.
struct MeasurementSlot {
/// Measurement metadata and value.
measurement: Measurement,
/// Indicates whether the slot is locked and cannot be further extended.
is_locked: bool,
/// Indicates whether the slot is populated with an actual measurement.
is_populated: bool,
}
impl Default for MeasurementSlot {
/// Create an instance of `MeasurementSlot` with default values.
fn default() -> Self {
Self {
is_locked: false,
is_populated: false,
measurement: Measurement::default(),
}
}
}
impl MeasurementSlot {
/// Extends slot metadata and value.
pub fn extend(&mut self, measurement: Measurement, lock: bool) {
self.extend_metadata(measurement.metadata);
self.extend_value(measurement.value, lock);
}
/// Extends slot metadata. Updates only sw type and version, as signer_id
/// and algorithm never change.
fn extend_metadata(&mut self, metadata: MeasurementMetaData) {
// RSS does something strange here - it zero'es metadatas version and sw type
// see https://git.trustedfirmware.org/TF-M/tf-m-extras.git/tree/partitions/measured_boot/measured_boot.c#n221
// I think it was supposed to clear and then update the version and sw type.
self.measurement.metadata.sw_type = metadata.sw_type;
self.measurement.metadata.sw_version = metadata.sw_version;
}
/// Extends slot value only. Recalculates value hash based on current slot value
/// and new measurement value.
fn extend_value(&mut self, value: ValueHash, lock: bool) {
let measurement_value_len = self.measurement.metadata.algorithm.hash_len();
let total_len = measurement_value_len + value.len();
let mut temp = Vec::with_capacity(total_len);
temp.resize(total_len, 0);
temp[..measurement_value_len]
.copy_from_slice(&self.measurement.value[..measurement_value_len]);
temp[measurement_value_len..].copy_from_slice(&value);
match self.measurement.metadata.algorithm {
MeasurementType::Sha256 => {
let mut hasher = Sha256::new();
hasher.update(&temp);
let result = hasher.finalize();
self.measurement.value[..result.len()].copy_from_slice(&result);
}
MeasurementType::Sha384 => {
let mut hasher = Sha384::new();
hasher.update(&temp);
let result = hasher.finalize();
self.measurement.value[..result.len()].copy_from_slice(&result);
}
MeasurementType::Sha512 => {
let mut hasher = Sha512::new();
hasher.update(&temp);
let result = hasher.finalize();
self.measurement.value[..result.len()].copy_from_slice(&result);
}
};
self.is_populated = true;
self.is_locked = lock;
}
/// Overwrites measurement metadata and value. Should be used only when
/// upopulated slot is extended for the first time.
pub fn initialize(&mut self, measurement: Measurement, lock: bool) {
assert!(!self.is_populated, "Do not initialize a populated slot!");
self.set_metadata(measurement.metadata);
self.measurement
.value
.resize(self.measurement.metadata.algorithm.hash_len(), 0);
self.extend_value(measurement.value, lock);
}
/// Overwrites measurement metadata. Should be used only when unpopulated
/// slot is extended for the first time.
fn set_metadata(&mut self, metadata: MeasurementMetaData) {
self.measurement.metadata = metadata;
}
pub fn is_locked(&self) -> bool {
self.is_locked
}
pub fn is_populated(&self) -> bool {
self.is_populated
}
pub fn mark_as_populated(&mut self) {
self.is_populated = true;
}
/// Checks if slot extending is prohibited. The singer_id and algorithm
/// cannot change.
pub fn is_prohibited(&self, metadata: &MeasurementMetaData) -> bool {
metadata.signer_id != self.measurement.metadata.signer_id
|| metadata.algorithm != self.measurement.metadata.algorithm
}
}
#[derive(Debug)]
/// Responsible for storing all software components measurements and performing
/// the `read_measurement` and `extend_measurement` functions.
pub struct MeasurementMgr {
measurements: [MeasurementSlot; NUM_OF_MEASUREMENT_SLOTS],
}
/// Maximum number of slots - based on the RSS implementation.
pub const NUM_OF_MEASUREMENT_SLOTS: usize = 32;
impl MeasurementMgr {
/// Initializes with `BootMeasurement`s repacked and stores as `Measurement` slots.
pub fn init(
boot_measurements: Vec<BootMeasurement>,
) -> Result<MeasurementMgr, MeasurementError> {
assert!(
boot_measurements.len() <= NUM_OF_MEASUREMENT_SLOTS,
"MeasurementMgr cannot contain HW measurements"
);
let mut measurements = core::array::from_fn(|_| MeasurementSlot::default());
boot_measurements
.into_iter()
.enumerate()
.try_for_each(|(index, boot_measurement)| {
let measurement = boot_measurement.try_into()?;
measurements[index].initialize(measurement, false);
Ok::<(), MeasurementError>(())
})
.unwrap();
Ok(MeasurementMgr { measurements })
}
/// Returns measurement metadata, value and locked attribute from given slot_id.
/// Returns [`MeasurementError::InvalidArgument`], when slot_id is out of bounds.
/// Returns [`MeasurementError::DoesNotExist`], when is not populated.
pub fn read_measurement(
&self,
slot_id: usize,
) -> Result<(&Measurement, bool), MeasurementError> {
if slot_id >= NUM_OF_MEASUREMENT_SLOTS {
return Err(MeasurementError::InvalidArgument);
}
let slot = &self.measurements[slot_id];
if !slot.is_populated() {
return Err(MeasurementError::DoesNotExist);
}
Ok((&slot.measurement, slot.is_locked))
}
/// Extends measurement with updated metadata, value and locked attribute in given slot_id.
/// Returns [`MeasurementError::InvalidArgument`], when slot_id is out of bounds.
/// Returns [`MeasurementError::BadState`], when measurement is locked.
/// Returns [`MeasurementError::NotPermitted`], when measurements signer id's
/// and algorithm do not match.
pub fn extend_measurement(
&mut self,
slot_id: usize,
measurement: Measurement,
lock: bool,
) -> Result<(), MeasurementError> {
if slot_id >= NUM_OF_MEASUREMENT_SLOTS {
return Err(MeasurementError::InvalidArgument);
}
let slot = &mut self.measurements[slot_id];
if slot.is_locked() {
return Err(MeasurementError::BadState);
}
if slot.is_populated() {
if slot.is_prohibited(&measurement.metadata) {
return Err(MeasurementError::NotPermitted);
}
slot.extend(measurement, lock);
} else {
slot.initialize(measurement, lock);
slot.mark_as_populated();
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use crate::hw::BootMeasurementMetadata;
use alloc::{string::ToString, vec::Vec};
use core::{iter, str::from_utf8};
use super::*;
use tinyvec::ArrayVec;
fn metadata(algorithm: MeasurementType) -> MeasurementMetaData {
let signer_id: SignerHash = ArrayVec::from([
0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06, 0x54, 0xAB, 0x09, 0x01,
0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01, 0x83, 0x09, 0x22, 0xCD,
0x09, 0x61, 0xB6, 0xFF, 0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06,
0x54, 0xAB, 0x09, 0x01, 0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01,
0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF,
]);
let sw_version: SWVersion = from_utf8(&[
0x32, 0x35, 0x35, 0x2E, 0x32, 0x35, 0x35, 0x2E, 0x36, 0x35, 0x35, 0x33, 0x35, 0x0,
])
.unwrap()
.to_string();
let sw_type: SWType = from_utf8(&[
0x4D, 0x45, 0x41, 0x53, 0x55, 0x52, 0x45, 0x44, 0x5F, 0x42, 0x4F, 0x4F, 0x54, 0x5F,
0x54, 0x45, 0x53, 0x54, 0x53, 0x0,
])
.unwrap()
.to_string();
MeasurementMetaData {
signer_id,
sw_version,
algorithm,
sw_type,
}
}
fn value(len: usize) -> ValueHash {
let mut value: ValueHash = ValueHash::from([
0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2, 0x33, 0xff, 0x5d, 0x75, 0xd7, 0xea,
0x89, 0xa8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x05, 0x01, 0xEF,
0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x56, 0x46, 0x58, 0x49, 0x99, 0x31, 0xcf, 0x59,
0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c,
]);
value.truncate(len);
value
}
fn test_extend(
mgr: &mut MeasurementMgr,
slot_id: usize,
algorithm: MeasurementType,
value: ValueHash,
expected_value: &[u8],
) {
let metadata = metadata(algorithm);
let measurement = Measurement {
metadata: metadata.clone(),
value,
};
mgr.extend_measurement(slot_id, measurement, false).unwrap();
let (read_measurement, lock) = mgr.read_measurement(slot_id).unwrap();
assert_eq!(lock, false);
assert_eq!(metadata, read_measurement.metadata);
assert_eq!(&read_measurement.value[..], expected_value);
}
//---------------POSITIVE EXTEND/READ MEASUREMENT TESTS--------------------
#[test]
fn extend_256_with_256() {
let slot_id = 20;
let algorithm = MeasurementType::Sha256;
// First extend on slot 20
let value_256_0: ValueHash = [
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb,
]
.iter()
.cloned()
.collect();
let expected_value_256_0 = [
0x86, 0xbf, 0xbc, 0xe7, 0xf8, 0x8e, 0x77, 0xda, 0xb6, 0xbb, 0xfb, 0x92, 0x3b, 0xb7,
0x0e, 0x24, 0x11, 0xd3, 0x74, 0xdc, 0x65, 0x8d, 0xb7, 0x51, 0xc9, 0xbd, 0xec, 0x43,
0x8f, 0x5c, 0xce, 0x54,
];
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
test_extend(
&mut mgr,
slot_id,
algorithm,
value_256_0,
&expected_value_256_0,
);
// First extend on slot 21
let value_256_different_slot: ValueHash = [
0x75, 0xb2, 0x20, 0xfd, 0x5f, 0xfc, 0xdb, 0xfc, 0x20, 0x73, 0xe4, 0xa0, 0x2f, 0x8c,
0x53, 0x38, 0x3c, 0x74, 0xbd, 0xf3, 0xb6, 0xab, 0x9f, 0xb6, 0xb3, 0xd2, 0xbb, 0x7a,
0xa2, 0x08, 0xc5, 0x98,
]
.iter()
.cloned()
.collect();
let expected_value_256_different_slot = [
0x84, 0x8A, 0x8C, 0xA6, 0x4F, 0x17, 0x54, 0x6A, 0x71, 0x8E, 0xE2, 0x59, 0x45, 0x92,
0x01, 0xBE, 0x31, 0xF8, 0x85, 0xF1, 0xD3, 0x3F, 0x38, 0x09, 0xE6, 0xF6, 0xF1, 0x82,
0x3A, 0x90, 0x04, 0x5A,
];
test_extend(
&mut mgr,
slot_id + 1,
algorithm,
value_256_different_slot,
&expected_value_256_different_slot,
);
// Second extend on slot 20
let value_256_1: ValueHash = [
0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06, 0x54, 0xAB, 0x09, 0x01,
0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01, 0x83, 0x09, 0x22, 0xCD,
0x09, 0x61, 0xB6, 0xFF,
]
.iter()
.cloned()
.collect();
let expected_value_256_1 = [
0xd2, 0xab, 0xc1, 0x26, 0xeb, 0x5c, 0x25, 0x9d, 0x30, 0x33, 0x9c, 0x02, 0xd7, 0x49,
0x4f, 0x04, 0xe2, 0xd4, 0x49, 0xbe, 0x81, 0xa9, 0x60, 0x39, 0x56, 0x0e, 0x56, 0x90,
0xb3, 0xda, 0xaf, 0x25,
];
test_extend(
&mut mgr,
slot_id,
algorithm,
value_256_1,
&expected_value_256_1,
);
}
#[test]
fn test_extend_256_with_512() {
let slot_id = 22;
let algorithm = MeasurementType::Sha256;
let value_512_0 = ArrayVec::from([
0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2, 0x33, 0xff, 0x5d, 0x75, 0xd7, 0xea,
0x89, 0xa8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x05, 0x01, 0xEF,
0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x56, 0x46, 0x58, 0x49, 0x99, 0x31, 0xcf, 0x59,
0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c,
]);
let expected_value_256_0 = [
0x75, 0xb2, 0x20, 0xfd, 0x5f, 0xfc, 0xdb, 0xfc, 0x20, 0x73, 0xe4, 0xa0, 0x2f, 0x8c,
0x53, 0x38, 0x3c, 0x74, 0xbd, 0xf3, 0xb6, 0xab, 0x9f, 0xb6, 0xb3, 0xd2, 0xbb, 0x7a,
0xa2, 0x08, 0xc5, 0x98,
];
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
test_extend(
&mut mgr,
slot_id,
algorithm,
value_512_0,
&expected_value_256_0,
);
let value_512_1 = ArrayVec::from([
0x56, 0x46, 0x58, 0x49, 0x99, 0x31, 0xcf, 0x59, 0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79,
0x8a, 0x1c, 0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD,
0x09, 0x61, 0xB6, 0xFF, 0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c, 0x01, 0x05,
0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2,
0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF,
]);
let expected_value_256_1 = [
0x79, 0xc3, 0xb9, 0xca, 0xf7, 0x7b, 0xa7, 0xf3, 0x20, 0x65, 0x77, 0x04, 0x09, 0x60,
0x8a, 0x02, 0x4f, 0xa5, 0x45, 0x9c, 0x6d, 0x10, 0xa7, 0xca, 0x59, 0x3f, 0xf1, 0x4d,
0x9b, 0x37, 0xe8, 0x3c,
];
test_extend(
&mut mgr,
slot_id,
algorithm,
value_512_1,
&expected_value_256_1,
);
}
#[test]
fn test_extend_512_with_256() {
let slot_id = 23;
let algorithm = MeasurementType::Sha512;
let value_256_0: ValueHash = [
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb,
]
.iter()
.cloned()
.collect();
let expected_value_512_0 = [
0xa6, 0x34, 0xb5, 0xb6, 0xe5, 0xe9, 0x71, 0x5d, 0x47, 0x88, 0xf7, 0x2f, 0x1a, 0x39,
0xc3, 0xe2, 0xd2, 0xe1, 0x03, 0xde, 0xcf, 0xb8, 0xf8, 0xd6, 0x22, 0xcc, 0xff, 0x8c,
0xb2, 0xe3, 0xe8, 0x22, 0x74, 0x31, 0x6c, 0x4b, 0x8d, 0x66, 0x25, 0x11, 0xcc, 0x1c,
0xf9, 0x0a, 0x24, 0x56, 0xdf, 0xf2, 0xb6, 0x20, 0xd3, 0xbe, 0xf0, 0xe0, 0xb9, 0x56,
0xcf, 0x3a, 0xcc, 0x78, 0xe6, 0x58, 0xbe, 0x40,
];
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
test_extend(
&mut mgr,
slot_id,
algorithm,
value_256_0,
&expected_value_512_0,
);
let value_256_1: ValueHash = [
0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06, 0x54, 0xAB, 0x09, 0x01,
0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01, 0x83, 0x09, 0x22, 0xCD,
0x09, 0x61, 0xB6, 0xFF,
]
.iter()
.cloned()
.collect();
let expected_value_512_1 = [
0x53, 0x2e, 0x19, 0xa7, 0xdf, 0x21, 0xe7, 0x7f, 0x6a, 0xe0, 0xe6, 0x30, 0xda, 0xfb,
0x39, 0x67, 0x8c, 0xdd, 0x74, 0x5f, 0x30, 0x9f, 0x10, 0x80, 0xb3, 0xfa, 0x88, 0x75,
0x33, 0x31, 0x00, 0x46, 0x59, 0x4f, 0x76, 0xb8, 0xfe, 0x5b, 0xae, 0xc4, 0xeb, 0xe2,
0xe9, 0x15, 0x02, 0x4f, 0x34, 0x4e, 0x88, 0xc0, 0x43, 0xcd, 0x90, 0x14, 0xcd, 0xaa,
0xd1, 0xc5, 0x73, 0xba, 0xc3, 0x4c, 0x56, 0xbe,
];
test_extend(
&mut mgr,
slot_id,
algorithm,
value_256_1,
&expected_value_512_1,
);
}
#[test]
fn extend_512_with_512() {
let slot_id = NUM_OF_MEASUREMENT_SLOTS - 1;
let algorithm = MeasurementType::Sha512;
let value_512_0: ValueHash = [
0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2, 0x33, 0xff, 0x5d, 0x75, 0xd7, 0xea,
0x89, 0xa8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x05, 0x01, 0xEF,
0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x56, 0x46, 0x58, 0x49, 0x99, 0x31, 0xcf, 0x59,
0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c,
]
.iter()
.cloned()
.collect();
let expected_value_512_0 = [
0x8e, 0x17, 0x5a, 0x1d, 0xcd, 0x79, 0xb8, 0xb5, 0x1c, 0xe9, 0xe2, 0x59, 0xc2, 0x56,
0x83, 0x05, 0xb7, 0x3f, 0x5f, 0x26, 0xf5, 0x67, 0x3a, 0x8c, 0xf7, 0x81, 0xa9, 0x45,
0x98, 0xe4, 0x4f, 0x67, 0xfd, 0xf4, 0x92, 0x68, 0x69, 0xee, 0x76, 0x67, 0xe9, 0x12,
0x0b, 0x5c, 0x1b, 0x97, 0x62, 0x5c, 0xc9, 0x6d, 0x34, 0x7c, 0x23, 0xce, 0x3c, 0x5f,
0x76, 0x3b, 0xf1, 0xd9, 0xb5, 0x47, 0x81, 0xf6,
];
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
test_extend(
&mut mgr,
slot_id,
algorithm,
value_512_0,
&expected_value_512_0,
);
let value_512_1: ValueHash = [
0x56, 0x46, 0x58, 0x49, 0x99, 0x31, 0xcf, 0x59, 0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79,
0x8a, 0x1c, 0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD,
0x09, 0x61, 0xB6, 0xFF, 0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c, 0x01, 0x05,
0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2,
0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF,
]
.iter()
.cloned()
.collect();
let expected_value_512_1 = [
0x69, 0x8f, 0xc1, 0x9d, 0xc0, 0xfb, 0x93, 0xc9, 0x78, 0x31, 0x52, 0xd9, 0x33, 0x6f,
0x35, 0xa7, 0x9a, 0x2d, 0x48, 0xdb, 0x45, 0xa8, 0xd4, 0xc4, 0x8c, 0x0e, 0xef, 0xcb,
0xeb, 0xc0, 0x11, 0x0d, 0xa2, 0xe4, 0x0f, 0x62, 0x78, 0x34, 0xdd, 0x8e, 0x46, 0xa9,
0x2b, 0xaa, 0x23, 0x00, 0x6b, 0x36, 0xc6, 0x79, 0xc0, 0x4e, 0x14, 0xca, 0x91, 0x3f,
0xd2, 0xde, 0xe2, 0x38, 0x58, 0xd5, 0x43, 0xd2,
];
test_extend(
&mut mgr,
slot_id,
algorithm,
value_512_1,
&expected_value_512_1,
);
}
//---------------NEGATIVE WRONG PARAMETERS TESTS---------------------------
#[test]
fn test_prohibited_extend_after_lock() {
let slot_id = 9;
let measurement = Measurement {
metadata: metadata(MeasurementType::Sha256),
value: value(32),
};
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
mgr.extend_measurement(slot_id, measurement.clone(), true)
.unwrap();
assert_eq!(
mgr.extend_measurement(slot_id, measurement, false)
.unwrap_err(),
MeasurementError::BadState
);
}
#[test]
fn test_prohibited_algorithm_change() {
let slot_id = 10;
let value = value(32);
let mut metadata = metadata(MeasurementType::Sha256);
let measurement = Measurement {
metadata: metadata.clone(),
value: value.clone(),
};
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
mgr.extend_measurement(slot_id, measurement, false).unwrap();
metadata.algorithm = MeasurementType::Sha384;
let measurement = Measurement {
metadata: metadata.clone(),
value: value.clone(),
};
assert_eq!(
mgr.extend_measurement(slot_id, measurement, false)
.unwrap_err(),
MeasurementError::NotPermitted
);
}
#[test]
fn test_prohibited_signer_change() {
let slot_id = 10;
let value = value(32);
let mut metadata = metadata(MeasurementType::Sha256);
let measurement = Measurement {
metadata: metadata.clone(),
value: value.clone(),
};
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
mgr.extend_measurement(slot_id, measurement, false).unwrap();
metadata.signer_id[13] = 13;
let measurement = Measurement {
metadata: metadata.clone(),
value: value.clone(),
};
assert_eq!(
mgr.extend_measurement(slot_id, measurement, false)
.unwrap_err(),
MeasurementError::NotPermitted
);
}
#[test]
fn test_extend_slot_out_of_bounds() {
let slot_id = NUM_OF_MEASUREMENT_SLOTS;
let value = value(32);
let metadata = metadata(MeasurementType::Sha256);
let mut mgr = MeasurementMgr::init(Vec::new()).unwrap();
assert_eq!(
mgr.extend_measurement(slot_id, Measurement { metadata, value }, false)
.unwrap_err(),
MeasurementError::InvalidArgument
);
}
#[test]
fn test_read_slot_out_of_bounds() {
let slot_id = NUM_OF_MEASUREMENT_SLOTS;
let mgr = MeasurementMgr::init(Vec::new()).unwrap();
assert_eq!(
mgr.read_measurement(slot_id).unwrap_err(),
MeasurementError::InvalidArgument
);
}
#[test]
fn test_read_slot_unpopulated() {
let slot_id = 20;
let mgr = MeasurementMgr::init(Vec::new()).unwrap();
assert_eq!(
mgr.read_measurement(slot_id).unwrap_err(),
MeasurementError::DoesNotExist
);
}
//---------------BOOT MEASUREMENTS INITIALIZATION TESTS--------------------
fn boot_measurements() -> Vec<BootMeasurement> {
Vec::from([
BootMeasurement {
measurement_value: [
0x61, 0x97, 0x3b, 0x4f, 0x62, 0x0c, 0x2a, 0xe6, 0xc7, 0x63, 0x51, 0x18, 0xa0,
0xb4, 0x37, 0x6d, 0x15, 0x34, 0x4c, 0x1c, 0x53, 0xa2, 0x17, 0x89, 0xb1, 0xaa,
0x95, 0xd2, 0x0f, 0x3c, 0x45, 0x06,
]
.iter()
.cloned()
.collect(),
metadata: BootMeasurementMetadata {
signer_id: [
0xc6, 0xc3, 0x2a, 0x95, 0x7d, 0xf4, 0xc6, 0x69, 0x8c, 0x55, 0x0b, 0x69,
0x5d, 0x02, 0x2e, 0xd5, 0x18, 0x0c, 0xae, 0x71, 0xf8, 0xb4, 0x9c, 0xbb,
0x75, 0xe6, 0x06, 0x1c, 0x2e, 0xf4, 0x97, 0xe1,
]
.iter()
.cloned()
.collect(),
measurement_type: 0,
sw_type: b"BL1".iter().cloned().collect(),
sw_version: b"0.1.0".iter().cloned().collect(),
},
},
BootMeasurement {
measurement_value: [
0xf1, 0x5f, 0x95, 0x3b, 0xe5, 0x0d, 0xad, 0x92, 0xc3, 0xb2, 0xaa, 0x32, 0x97,
0xe6, 0xa4, 0xa8, 0xd6, 0x6d, 0x33, 0x63, 0x84, 0x49, 0xec, 0x19, 0x22, 0xb4,
0xa7, 0x92, 0x4a, 0x7b, 0x30, 0x22,
]
.iter()
.cloned()
.collect(),
metadata: BootMeasurementMetadata {
signer_id: [
0xa0, 0x64, 0xb1, 0xad, 0x60, 0xfa, 0x18, 0x33, 0x94, 0xdd, 0xa5, 0x78,
0x91, 0x35, 0x7f, 0x97, 0x2e, 0x4f, 0xe7, 0x22, 0x78, 0x2a, 0xdf, 0xf1,
0x85, 0x4c, 0x8b, 0x2a, 0x14, 0x2c, 0x04, 0x10,
]
.iter()
.cloned()
.collect(),
measurement_type: 0,
sw_type: b"BL2".iter().cloned().collect(),
sw_version: b"1.9.0+0".iter().cloned().collect(),
},
},
])
}
const BL_1_MEASUREMENT_SLOT_ID: usize = 0;
const BL_2_MEASUREMENT_SLOT_ID: usize = 1;
#[test]
fn test_boot_measurements_ok() {
let boot_measurements = boot_measurements();
let mgr = MeasurementMgr::init(boot_measurements.clone()).unwrap();
let bl1_measurement = &boot_measurements[0];
let (measurement, lock) = mgr.read_measurement(BL_1_MEASUREMENT_SLOT_ID).unwrap();
let expected_measurement_value: ValueHash = [
0x69, 0x7d, 0xe4, 0x40, 0x7d, 0xae, 0x45, 0xc0, 0x75, 0x06, 0xd1, 0xf0, 0x0b, 0x3d,
0xbf, 0x5c, 0xe1, 0xdb, 0x41, 0xf6, 0x9e, 0x17, 0x50, 0xa3, 0x11, 0xf9, 0x1d, 0x21,
0x3e, 0x11, 0x98, 0x89,
]
.iter()
.cloned()
.collect();
assert_eq!(lock, false);
assert_eq!(
measurement.metadata,
<BootMeasurement as TryInto<Measurement>>::try_into(bl1_measurement.clone())
.unwrap()
.metadata
);
assert_eq!(measurement.value, expected_measurement_value);
let bl2_measurement = &boot_measurements[1];
let (measurement, lock) = mgr.read_measurement(BL_2_MEASUREMENT_SLOT_ID).unwrap();
let expected_measurement_value_2: ValueHash = [
0xa1, 0x9b, 0x4c, 0xf9, 0x32, 0x89, 0xd6, 0x89, 0xc8, 0xa9, 0xb7, 0xfe, 0x16, 0x6b,
0x4c, 0x5c, 0x12, 0xab, 0xc1, 0x12, 0xb3, 0x5f, 0xba, 0x81, 0xdf, 0x12, 0xf1, 0x4a,
0x99, 0x6f, 0x9d, 0x81,
]
.iter()
.cloned()
.collect();
assert_eq!(lock, false);
assert_eq!(
measurement.metadata,
<BootMeasurement as TryInto<Measurement>>::try_into(bl2_measurement.clone())
.unwrap()
.metadata
);
assert_eq!(measurement.value, expected_measurement_value_2);
}
#[test]
#[should_panic(expected = "MeasurementMgr cannot contain HW measurements")]
fn test_boot_measurements_too_many() {
let boot_measurements = Vec::from_iter(
iter::repeat(BootMeasurement::default()).take(NUM_OF_MEASUREMENT_SLOTS + 1),
);
let _ = MeasurementMgr::init(boot_measurements);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/measured_boot/measurement.rs | hes/islet-hes/src/measured_boot/measurement.rs | use core::str::from_utf8;
use alloc::string::{String, ToString};
use tinyvec::ArrayVec;
use super::MeasurementError;
use crate::BootMeasurement;
use crate::ValueHash;
/// Minimal size based on the shortest hash algorithm - sha256
pub const MEASUREMENT_VALUE_MIN_SIZE: usize = 32;
/// Maximal size based on the longest hash algorithm - sha512
pub const MEASUREMENT_VALUE_MAX_SIZE: usize = 64;
/// Minimal size based on the shortest hash algorithm - sha256
pub const SIGNER_ID_MIN_SIZE: usize = MEASUREMENT_VALUE_MIN_SIZE;
/// Maximal size based on the longest hash algorithm - sha512
pub const SIGNER_ID_MAX_SIZE: usize = MEASUREMENT_VALUE_MAX_SIZE;
/// Set based on RSS imlementation.
pub const VERSION_MAX_SIZE: usize = 14;
/// Set based on RSS imlementation.
pub const SW_TYPE_MAX_SIZE: usize = 32;
/// Error message for MessageError::InvalidData(), when converted signer_id has wrong size.
const SIGNER_ID_SIZE_ERROR_MSG: &'static str = "SignerIdSize";
/// Error message for MessageError::InvalidData(), when converted sw_version has wrong size.
const SW_VERSION_SIZE_ERROR_MSG: &'static str = "SWVersionSize";
/// Error message for MessageError::InvalidData(), when converted sw_version is not a valid utf-8.
const SW_VERSION_VALUE_ERROR_MSG: &'static str = "SWVersionNotUtf8";
/// Error message for MessageError::InvalidData(), when converted sw_type has wrong size.
const SW_TYPE_SIZE_ERROR_MSG: &'static str = "SWTypeSize";
/// Error message for MessageError::InvalidData(), when converted sw_type is not a valid utf-8.
const SW_TYPE_VALUE_ERROR_MSG: &'static str = "SWTypeNotUtf8";
/// Error message for MessageError::InvalidData(), when converted measurement_value has wrong size.
const MEASUREMENT_VALUE_SIZE_ERROR_MSG: &'static str = "MeasurementValueSize";
/// Error message for MessageError::InvalidData(), when converted measurement_type has wrong value.
const MEASUREMENT_TYPE_ERROR_MSG: &'static str = "MeasurementType";
/// Represents hash algorithm used for calculating measurement value.
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum MeasurementType {
Sha256,
Sha384,
Sha512,
}
impl Default for MeasurementType {
/// Arbitrary default value - won't be used, because the root
/// MeasurementSlot will be set as not populated by default.
fn default() -> Self {
Self::Sha256
}
}
impl TryFrom<u16> for MeasurementType {
type Error = MeasurementError;
/// Converts the `MeasurementType` from given [`u16`].
/// Returns [`MeasurementError::InvalidData`] when `value` is out of scope
/// of `MeasurementType`.
fn try_from(value: u16) -> Result<Self, Self::Error> {
match value {
0 => Ok(Self::Sha256),
1 => Ok(Self::Sha384),
2 => Ok(Self::Sha512),
_ => Err(MeasurementError::InvalidData(MEASUREMENT_TYPE_ERROR_MSG)),
}
}
}
impl MeasurementType {
pub fn hash_len(&self) -> usize {
match self {
MeasurementType::Sha256 => 32,
MeasurementType::Sha384 => 48,
MeasurementType::Sha512 => 64,
}
}
}
pub type SignerHash = ArrayVec<[u8; SIGNER_ID_MAX_SIZE]>;
pub type SWVersion = String;
pub type SWType = String;
/// Keeps measurement slot metadata.
#[derive(Debug, Default, Clone, PartialEq)]
pub struct MeasurementMetaData {
/// Represents the hash o signing authority public key.
pub signer_id: SignerHash,
/// Represents the issued software version.
pub sw_version: SWVersion,
/// Represents the way in which the measurement value of
/// the software component is computed.
pub algorithm: MeasurementType,
/// Represents the role of the software component.
pub sw_type: SWType,
}
/// Keeps measurement metadata and value.
#[derive(Debug, Default, Clone, PartialEq)]
pub struct Measurement {
/// Keeps measurement metadata.
pub metadata: MeasurementMetaData,
/// Represent the hash value of the measurement.
pub value: ValueHash,
}
impl TryFrom<BootMeasurement> for Measurement {
type Error = MeasurementError;
/// Tries to convert the given [`BootMeasurement`] to `Measurement`.
/// Returns [`MeasurementError::InvalidData`], when values cannot be properly converted.
fn try_from(value: BootMeasurement) -> Result<Self, Self::Error> {
if value.metadata.signer_id.len() < SIGNER_ID_MIN_SIZE
|| value.metadata.signer_id.len() > SIGNER_ID_MAX_SIZE
{
return Err(MeasurementError::InvalidData(SIGNER_ID_SIZE_ERROR_MSG));
}
if value.metadata.sw_version.len() > VERSION_MAX_SIZE {
return Err(MeasurementError::InvalidData(SW_VERSION_SIZE_ERROR_MSG));
}
if value.metadata.sw_type.len() > SW_TYPE_MAX_SIZE {
return Err(MeasurementError::InvalidData(SW_TYPE_SIZE_ERROR_MSG));
}
if value.measurement_value.len() < MEASUREMENT_VALUE_MIN_SIZE
|| value.measurement_value.len() > MEASUREMENT_VALUE_MAX_SIZE
{
return Err(MeasurementError::InvalidData(
MEASUREMENT_VALUE_SIZE_ERROR_MSG,
));
}
let sw_version = match from_utf8(&value.metadata.sw_version) {
Ok(version_str) => version_str,
Err(_) => return Err(MeasurementError::InvalidData(SW_VERSION_VALUE_ERROR_MSG)),
}
.to_string();
let sw_type = match from_utf8(&value.metadata.sw_type) {
Ok(type_str) => type_str,
Err(_) => return Err(MeasurementError::InvalidData(SW_TYPE_VALUE_ERROR_MSG)),
}
.to_string();
Ok(Self {
metadata: MeasurementMetaData {
signer_id: value.metadata.signer_id.iter().cloned().collect(),
sw_version,
algorithm: value.metadata.measurement_type.try_into()?,
sw_type,
},
value: value.measurement_value,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
hw::{
BootMeasurementMetadata, HWHash, HWSWType, HWSWVersion, MAX_HW_HASH_VALUE_SIZE,
MAX_HW_SW_TYPE_SIZE, MAX_HW_SW_VERSION_SIZE,
},
BootMeasurement,
};
use alloc::{vec, vec::Vec};
fn boot_measurement_value(len: usize) -> HWHash {
let mut value: HWHash = HWHash::from([
0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2, 0x33, 0xff, 0x5d, 0x75, 0xd7, 0xea,
0x89, 0xa8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x05, 0x01, 0xEF,
0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x56, 0x46, 0x58, 0x49, 0x99, 0x31, 0xcf, 0x59,
0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c,
]);
value.truncate(len);
value
}
fn boot_signer_id(len: usize) -> HWHash {
let mut signer_id: HWHash = HWHash::from([
0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06, 0x54, 0xAB, 0x09, 0x01,
0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01, 0x83, 0x09, 0x22, 0xCD,
0x09, 0x61, 0xB6, 0xFF, 0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06,
0x54, 0xAB, 0x09, 0x01, 0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01,
0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF,
]);
signer_id.truncate(len);
signer_id
}
fn boot_sw_type(len: usize) -> HWSWType {
let mut sw_type: HWSWType =
HWSWType::from([0x4D, 0x45, 0x41, 0x53, 0x55, 0x52, 0x45, 0x44, 0x5F, 0x42]);
sw_type.truncate(len);
sw_type
}
fn boot_sw_version(len: usize) -> HWSWVersion {
let mut sw_version: HWSWVersion = HWSWVersion::from([
0x32, 0x35, 0x35, 0x2E, 0x32, 0x35, 0x35, 0x2E, 0x36, 0x35, 0x35, 0x33, 0x35, 0x0,
]);
sw_version.truncate(len);
sw_version
}
#[test]
fn measurement_type_conversion_ok() {
let measurement_types_u16: Vec<u16> = vec![0, 1, 2];
let measurement_types: Vec<MeasurementType> = vec![
MeasurementType::Sha256,
MeasurementType::Sha384,
MeasurementType::Sha512,
];
for (measurement_type_u16, measurement_type) in measurement_types_u16
.into_iter()
.zip(measurement_types.into_iter())
{
assert_eq!(
<u16 as TryInto<MeasurementType>>::try_into(measurement_type_u16).unwrap(),
measurement_type
);
}
}
#[test]
fn measurement_conversion_ok() {
let boot_measurement = BootMeasurement {
measurement_value: boot_measurement_value(MEASUREMENT_VALUE_MIN_SIZE),
metadata: BootMeasurementMetadata {
measurement_type: 0,
signer_id: boot_signer_id(MAX_HW_HASH_VALUE_SIZE),
sw_type: boot_sw_type(MAX_HW_SW_TYPE_SIZE),
sw_version: boot_sw_version(MAX_HW_SW_VERSION_SIZE),
},
};
let measurement: Measurement = boot_measurement.clone().try_into().unwrap();
assert_eq!(boot_measurement.measurement_value, measurement.value);
let boot_metadata = &boot_measurement.metadata;
let metadata = &measurement.metadata;
assert_eq!(boot_metadata.signer_id, metadata.signer_id);
assert_eq!(
<u16 as TryInto<MeasurementType>>::try_into(boot_metadata.measurement_type).unwrap(),
metadata.algorithm
);
assert_eq!(
&boot_metadata.sw_type[..],
&metadata.sw_type[..MAX_HW_SW_TYPE_SIZE].as_bytes()[..]
);
assert_eq!(boot_metadata.sw_version, metadata.sw_version.as_bytes());
}
#[test]
fn measurement_conversion_too_short_value() {
let boot_measurement = BootMeasurement {
// too short
measurement_value: boot_measurement_value(MEASUREMENT_VALUE_MIN_SIZE - 1),
metadata: BootMeasurementMetadata {
measurement_type: 0,
signer_id: boot_signer_id(MAX_HW_HASH_VALUE_SIZE),
sw_type: boot_sw_type(MAX_HW_SW_TYPE_SIZE),
sw_version: boot_sw_version(MAX_HW_SW_VERSION_SIZE),
},
};
assert_eq!(
<BootMeasurement as TryInto<Measurement>>::try_into(boot_measurement).unwrap_err(),
MeasurementError::InvalidData(MEASUREMENT_VALUE_SIZE_ERROR_MSG)
);
}
#[test]
fn measurement_conversion_too_short_signer_id() {
let boot_measurement = BootMeasurement {
measurement_value: boot_measurement_value(MAX_HW_HASH_VALUE_SIZE),
metadata: BootMeasurementMetadata {
measurement_type: 0,
// too short
signer_id: boot_signer_id(SIGNER_ID_MIN_SIZE - 1),
sw_type: boot_sw_type(MAX_HW_SW_TYPE_SIZE),
sw_version: boot_sw_version(MAX_HW_SW_VERSION_SIZE),
},
};
assert_eq!(
<BootMeasurement as TryInto<Measurement>>::try_into(boot_measurement).unwrap_err(),
MeasurementError::InvalidData(SIGNER_ID_SIZE_ERROR_MSG)
);
}
#[test]
fn measurement_conversion_bad_measurement_type() {
let boot_measurement = BootMeasurement {
measurement_value: boot_measurement_value(MAX_HW_HASH_VALUE_SIZE),
metadata: BootMeasurementMetadata {
// doesn't map to any proper value
measurement_type: 10,
signer_id: boot_signer_id(MAX_HW_HASH_VALUE_SIZE),
sw_type: boot_sw_type(MAX_HW_SW_TYPE_SIZE),
sw_version: boot_sw_version(MAX_HW_SW_VERSION_SIZE),
},
};
assert_eq!(
<BootMeasurement as TryInto<Measurement>>::try_into(boot_measurement).unwrap_err(),
MeasurementError::InvalidData(MEASUREMENT_TYPE_ERROR_MSG)
);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/measured_boot/mod.rs | hes/islet-hes/src/measured_boot/mod.rs | //! Error codes and utilities for error code conversion and formatting.
mod manager;
mod measurement;
pub use manager::{MeasurementMgr, NUM_OF_MEASUREMENT_SLOTS};
pub use measurement::{
Measurement, MeasurementMetaData, MeasurementType, SWType, SWVersion, SignerHash,
MEASUREMENT_VALUE_MAX_SIZE, MEASUREMENT_VALUE_MIN_SIZE, SIGNER_ID_MAX_SIZE, SIGNER_ID_MIN_SIZE,
SW_TYPE_MAX_SIZE, VERSION_MAX_SIZE,
};
/// Measurement error enumeration.
#[derive(Debug, PartialEq)]
pub enum MeasurementError {
/// TODO
InvalidArgument,
/// Signer_id doesn't match
NotPermitted,
/// Wrong slot_id
DoesNotExist,
/// Slot_id extension is locked
BadState,
/// HW data is out of bounds
InvalidData(&'static str),
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/hw/mod.rs | hes/islet-hes/src/hw/mod.rs | //! Hardware specific structures and interfaces.
use alloc::vec::Vec;
use tinyvec::ArrayVec;
pub const MAX_HW_HASH_VALUE_SIZE: usize = 64;
pub const MAX_HW_SW_TYPE_SIZE: usize = 10;
pub const MAX_HW_SW_VERSION_SIZE: usize = 14;
/// Represents a hash value. Calculated by sha256, sha384 or sha512.
pub type HWHash = ArrayVec<[u8; MAX_HW_HASH_VALUE_SIZE]>;
/// Represents a software type value.
pub type HWSWType = ArrayVec<[u8; MAX_HW_SW_TYPE_SIZE]>;
/// Represents a software version value.
pub type HWSWVersion = ArrayVec<[u8; MAX_HW_SW_VERSION_SIZE]>;
/// Structure representing boot measurement metadata,
/// as it is stored in emulated HW.
#[derive(Debug, Default, Clone)]
pub struct BootMeasurementMetadata {
/// Identifier of the measurement method used
/// to compute the measurement value.
pub measurement_type: u16,
/// Signer identity (hash of public key)
pub signer_id: HWHash,
/// Representing the role of the SW component
pub sw_type: HWSWType,
/// Version of the SW component in the form of:
/// "major.minor.revision+build"
pub sw_version: HWSWVersion,
}
/// Structure representing the boot measurement metadata and value.
#[derive(Debug, Default, Clone)]
pub struct BootMeasurement {
/// Contains boot measurement metadata
pub metadata: BootMeasurementMetadata,
/// Value of boot measurement (hash)
pub measurement_value: HWHash,
}
/// Represents a binary hardware 256bit symmetric key
pub type HWSymmetricKey = ArrayVec<[u8; 32]>;
/// Represents a binary hardware asymmetric key.
/// Currently using ECC Curve-P384 (384bit), might be a subject to change.
pub type HWAsymmetricKey = ArrayVec<[u8; 48]>;
/// Interface for fetching hardware specific data:
/// - Boot measurements,
/// - Hardware keys,
/// - Claims data,
/// In compliance with
/// [documentation-service.arm.com/static/610aaec33d73a34b640e333b](Arm CCA
/// Security Model 1.0).
pub trait HWData {
type Error;
// ---------------HW Keys -------------------
/// Hardware unique 256bit symmetric key. It represents a randomly unique
/// seed for each manufactured instance of CCA enabled system.
fn huk(&self) -> Result<HWSymmetricKey, Self::Error>;
/// Group unique 256bit symmetric key.
/// It represents a randomly unique seed that may be shared
/// with some group of manufactured CCA enabled systems
/// with the same immutable hardware security properties.
fn guk(&self) -> Result<HWSymmetricKey, Self::Error>;
/// Byte string representing CCA Platform Attestation Key.
/// Optional, can be derived in runtime.
fn cpak(&self) -> Result<Option<HWAsymmetricKey>, Self::Error>;
// ---------------HW Bootloader Hash---------
/// BL2 image signed hash.
fn bl_hash(&self) -> Result<HWHash, Self::Error>;
// -------------- HW claims -----------------
/// Software state of the system. Each entry represents a
/// [`BootMeasurement`] of software component within the device.
fn boot_measurements(&self) -> Result<Vec<BootMeasurement>, Self::Error>;
/// A byte string representing the original implementation signer
/// of the attestation key and indentifies contract between the report
/// and verification.
fn implementation_id(&self) -> Result<[u8; 32], Self::Error>;
/// Represents the current lifecycle state of the instance.
/// Custom claim with a value encoded as integer that
/// is divided to convey a major state and a minor state. The
/// PSA state and implementation state are encoded as follows:
/// - version\[15:8\] - PSA lifecycle state - major
/// - version\[7:0\] - IMPLEMENTATION DEFINED state - minor
/// Possible PSA lifecycle states:
/// - Unknown (0x1000u),
/// - PSA_RoT_Provisioning (0x2000u),
/// - Secured (0x3000u),
/// - Non_PSA_RoT_Debug(0x4000u),
/// - Recoverable_PSA_RoT_Debug (0x5000u),
/// - Decommissioned (0x6000u)
fn security_lifecycle(&self) -> Result<u32, Self::Error>;
/// Contains the name of a document that describes the 'profile'
/// of the token, being a full description of the claims, their usage,
/// verification and token signing. The document name may include
/// versioning. Custom claim with a value encoded as text string.
fn profile_definition(&self) -> Result<Option<ArrayVec<[u8; 35]>>, Self::Error>;
/// The value is a text string that can be used to locate the
/// service or a URL specifying the address of the service. t is used by
/// a Relying Party to locate a validation service for the token.
fn verification_service_url(&self) -> Result<Option<ArrayVec<[u8; 32]>>, Self::Error>;
/// Describes the set of chosen implementation options of the CCA platform.
fn platform_config(&self) -> Result<ArrayVec<[u8; 32]>, Self::Error>;
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes/src/attestation/mod.rs | hes/islet-hes/src/attestation/mod.rs | use core::mem;
use alloc::borrow::ToOwned;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use ciborium::{ser, Value};
use coset::{iana, AsCborValue, CoseKeyBuilder, CoseSign1, CoseSign1Builder, HeaderBuilder};
use ecdsa::{elliptic_curve::sec1::ToEncodedPoint, signature::Signer};
use key_derivation::{derive_p256_key, derive_p384_key, generate_seed};
use p384::ecdsa::Signature as P384Signature;
use sha2::{Digest, Sha256, Sha384, Sha512};
use tinyvec::ArrayVec;
use crate::utils::token_tag;
use crate::{utils, HWHash, HWSymmetricKey, Measurement, MeasurementType};
/// Supported ecc family types.
#[derive(Copy, Clone, Debug)]
pub enum ECCFamily {
/// The only one compliant with CCA Security Model 1.0
SecpR1,
}
/// Supported ecc key bit size.
#[derive(Copy, Clone, Debug)]
pub enum KeyBits {
Bits256,
Bits384,
// Not Supported
Bits521,
}
/// Supported public dak hash algorithms.
#[derive(Copy, Clone, Debug)]
pub enum HashAlgo {
Sha256,
Sha384,
Sha512,
}
impl HashAlgo {
/// Converts the given `HashAlgo` into [`usize`] length.
pub fn len(self) -> usize {
match self {
HashAlgo::Sha256 => 32,
HashAlgo::Sha384 => 48,
HashAlgo::Sha512 => 64,
}
}
}
impl Into<String> for HashAlgo {
/// Converts the given `HashAlgo` into [`String`] description.
fn into(self) -> String {
match self {
HashAlgo::Sha256 => "sha-256".to_string(),
HashAlgo::Sha384 => "sha-384".to_string(),
HashAlgo::Sha512 => "sha-512".to_string(),
}
}
}
impl Into<String> for MeasurementType {
/// Converts the given `MeasurementType` into [`String`].
fn into(self) -> String {
match self {
MeasurementType::Sha256 => "sha-256".to_string(),
MeasurementType::Sha384 => "sha-384".to_string(),
MeasurementType::Sha512 => "sha-512".to_string(),
}
}
}
/// Error kinds returned by AttestationMgr
#[derive(Debug, PartialEq)]
pub enum AttestationError {
/// Some parameter or combination of parameters are recognised as invalid:
/// - challenge size is not allowed
/// - challenge object is unavailable
/// - token buffer is unavailable
InvalidArgument,
/// An error occurred that does not correspond to any defined
/// failure cause.
GenericError,
/// The requested operation or a parameter is not supported
/// by this implementation.
NotSupported,
}
/// Represents data required for key derivation (CPAK/DAK).
#[derive(Clone, Debug)]
pub struct KeyMaterialData {
/// Bootloader image singed hash.
pub hash: HWHash,
/// Group unique 256bit symmetric key.
pub guk: HWSymmetricKey,
}
/// Hardware provisioned claims.
#[derive(Clone, Debug)]
pub struct HWClaims {
pub implementation_id: [u8; 32],
pub security_lifecycle: u32,
pub profile_definition: Option<String>,
pub verification_service_url: Option<String>,
pub platform_config: ArrayVec<[u8; 32]>,
}
/// Represents DAK specific data.
pub struct DAKInfo {
/// Hash algorithm as will be passed during token creation.
hash_algo: HashAlgo,
/// Key bit size
key_bits: KeyBits,
/// Generated DAK private key.
key: Vec<u8>,
}
type InstanceId = ArrayVec<[u8; 33]>;
/// Represents CPAK specific data.
struct CPAK {
// TODO: SigningKey is defacto SecretKey. Maybe change key derivation
// to return SigningKey instead of the SecretKey
/// CPAK private key.
key: p384::SecretKey,
/// CPAK sha256, used for creating instance id.
//RSS uses sha256 for instance id
instance_id: InstanceId,
}
/// Attestation manager implementing `get_delegated_key` and `get_platform_token` functinality.
pub struct AttestationMgr {
/// CPAK data
cpak: CPAK,
/// Key derivation material for DAK and CPAK generation
derivation_material: KeyMaterialData,
/// Claims from HW
claims: HWClaims,
/// When DAK is generated keeps data required for DAK verification and signing
dak: Option<DAKInfo>,
}
/// Convert SEC1 encoded EC2 public `key` to COSE/CBOR
pub fn ec_public_key_sec1_to_cose(key: &[u8]) -> Vec<u8> {
let p256_sec1_len = 1 + 2 * 32;
let p384_sec1_len = 1 + 2 * 48;
let p521_sec1_len = 1 + 2 * 66;
let key_cbor_value = match key.len() {
n if n == p256_sec1_len => {
let pk = p256::PublicKey::from_sec1_bytes(key).expect("Failed to load p256 sec1 key");
let ep = pk.to_encoded_point(false);
let x = ep.x().unwrap().to_owned().to_vec();
let y = ep.y().unwrap().to_owned().to_vec();
let key = CoseKeyBuilder::new_ec2_pub_key(iana::EllipticCurve::P_256, x, y).build();
key.to_cbor_value().expect("Failed to encode p256 as CBOR")
}
n if n == p384_sec1_len => {
let pk = p384::PublicKey::from_sec1_bytes(key).expect("Failed to load p384 sec1 key");
let ep = pk.to_encoded_point(false);
let x = ep.x().unwrap().to_owned().to_vec();
let y = ep.y().unwrap().to_owned().to_vec();
let key = CoseKeyBuilder::new_ec2_pub_key(iana::EllipticCurve::P_384, x, y).build();
key.to_cbor_value().expect("Failed to encode p384 as CBOR")
}
n if n == p521_sec1_len => {
let pk = p521::PublicKey::from_sec1_bytes(key).expect("Failed to load p521 sec1 key");
let ep = pk.to_encoded_point(false);
let x = ep.x().unwrap().to_owned().to_vec();
let y = ep.y().unwrap().to_owned().to_vec();
let key = CoseKeyBuilder::new_ec2_pub_key(iana::EllipticCurve::P_521, x, y).build();
key.to_cbor_value().expect("Failed to encode p521 as CBOR")
}
_ => panic!("Wrong sec1 key length"),
};
let mut key_cbor_bytes = Vec::new();
ser::into_writer(&key_cbor_value, &mut key_cbor_bytes).expect("Failed to serialize CBOR value");
key_cbor_bytes
}
/// Calculate hash for given `key` with chosen [`HashAlgo`]
pub fn calculate_public_key_hash(public_key: &[u8], hash_algo: HashAlgo) -> Vec<u8> {
match hash_algo {
HashAlgo::Sha256 => Sha256::digest(public_key).to_vec(),
HashAlgo::Sha384 => Sha384::digest(public_key).to_vec(),
HashAlgo::Sha512 => Sha512::digest(public_key).to_vec(),
}
}
impl AttestationMgr {
const CPAK_SEED_LABEL: &'static [u8] = b"BL1_CPAK_SEED_DERIVATION";
const DAK_SEED_LABEL: &'static [u8] = b"BL1_DAK_SEED_DERIVATION";
pub fn calculate_cpak_hash(&self) -> Vec<u8> {
calculate_public_key_hash(
&self.cpak.key.public_key().to_sec1_bytes(),
HashAlgo::Sha256,
)
}
// This function calculates a hash of a public key but not in sec1 format as
// was done previously but encoded as COSE/CBOR. I find it strange that HES
// module is supposed to return a raw key through PSA, but when asked for
// token be forced to encode that key as COSE. This is how TF-RMM does it
// now though. See here:
// https://github.com/TF-RMM/tf-rmm/commit/3aa34974bd21449e0be82f99e3e0c1888e67dfd6
pub fn calculate_dak_hash(&self, hash_algo: HashAlgo) -> Vec<u8> {
let dak_info = self.dak.as_ref().unwrap();
let key_public_sec1 = match dak_info.key_bits {
KeyBits::Bits256 => p256::SecretKey::from_slice(&dak_info.key)
.unwrap()
.public_key()
.to_sec1_bytes(),
KeyBits::Bits384 => p384::SecretKey::from_slice(&dak_info.key)
.unwrap()
.public_key()
.to_sec1_bytes(),
KeyBits::Bits521 => p521::SecretKey::from_slice(&dak_info.key)
.unwrap()
.public_key()
.to_sec1_bytes(),
};
let key_public_cose = ec_public_key_sec1_to_cose(&key_public_sec1);
calculate_public_key_hash(&key_public_cose, hash_algo)
}
fn generate_instance_id(cpak: &p384::SecretKey) -> InstanceId {
let hash = calculate_public_key_hash(&cpak.public_key().to_sec1_bytes(), HashAlgo::Sha256);
let mut instance_id: InstanceId = ArrayVec::new();
instance_id.push(0x01);
for item in hash {
instance_id.push(item)
}
instance_id
}
/// Initialize AttestationMgr using [`KeyMaterialData`] and [`HWClaims`].
/// Generates a CPAK using `key_material_data`.
pub fn init(key_derivation_material: KeyMaterialData, claims: HWClaims) -> Self {
let lcs: u32 = 3;
let reprovisioning_bits: u32 = 0;
let input = key_derivation_material.hash.as_slice();
let mut context = Vec::with_capacity(input.len() + mem::size_of::<u32>() * 2);
context.extend(input);
context.extend(&lcs.to_ne_bytes());
context.extend(&reprovisioning_bits.to_ne_bytes());
let seed = generate_seed(
&context,
&key_derivation_material.guk,
Self::CPAK_SEED_LABEL,
);
let cpak = derive_p384_key(&seed, None);
Self {
cpak: CPAK {
instance_id: Self::generate_instance_id(&cpak).into_iter().collect(),
key: cpak,
},
derivation_material: key_derivation_material,
claims,
dak: None,
}
}
/// Unmark DAK as created
pub fn reset(&mut self) {
self.dak = None;
}
/// Generates DAK with [`ECCFamily`] and uses `measurements` ([`Measurement`])
/// as salt in the process.
/// Returns bytes of a scalar primitive, which can be used to recreate DAK Private Key.
/// [`HashAlgo`] is used for verification process, when `get_platform_token` is called.
/// Returns [`AttestationError::GenericError`], when CBOR or crypto operation fails.
pub fn get_delegated_key(
&mut self,
_ecc_family: ECCFamily,
key_bits: KeyBits,
hash_algo: HashAlgo,
measurements: &[Measurement],
) -> Result<Vec<u8>, AttestationError> {
let mut context = Vec::new();
context.extend(&self.derivation_material.hash);
context.extend(&self.claims.security_lifecycle.to_ne_bytes());
context.extend(&0u32.to_ne_bytes());
let seed = generate_seed(
&context,
&self.derivation_material.guk,
&Self::DAK_SEED_LABEL,
);
let salt = utils::encode_measurements(measurements);
let mut salt_bytes: Vec<u8> = Vec::new();
ser::into_writer(&salt, &mut salt_bytes).map_err(|_| AttestationError::GenericError)?;
let dak = match key_bits {
KeyBits::Bits256 => derive_p256_key(&seed, Some(&salt_bytes))
.to_bytes()
.to_vec(),
KeyBits::Bits384 => derive_p384_key(&seed, Some(&salt_bytes))
.to_bytes()
.to_vec(),
KeyBits::Bits521 => return Err(AttestationError::NotSupported),
};
self.dak = Some(DAKInfo {
hash_algo,
key_bits,
key: dak.clone(),
});
Ok(dak)
}
fn encode_claims(&self, dak_hash: &[u8], measurements: &[Measurement]) -> Value {
let mut map = Vec::with_capacity(9);
map.push((
Value::Integer(token_tag::CCA_PLAT_CHALLENGE.into()),
Value::Bytes(dak_hash.to_vec()),
));
map.push((
Value::Integer(token_tag::CCA_PLAT_INSTANCE_ID.into()),
Value::Bytes(self.cpak.instance_id.to_vec()),
));
if let Some(profile_definition) = &self.claims.profile_definition {
map.push((
Value::Integer(token_tag::CCA_PLAT_PROFILE.into()),
Value::Text(profile_definition.clone()),
));
}
map.push((
Value::Integer(token_tag::CCA_PLAT_SECURITY_LIFECYCLE.into()),
Value::Integer((self.claims.security_lifecycle as u32).into()),
));
map.push((
Value::Integer(token_tag::CCA_PLAT_IMPLEMENTATION_ID.into()),
Value::Bytes(self.claims.implementation_id.to_vec()),
));
map.push((
Value::Integer(token_tag::CCA_PLAT_SW_COMPONENTS.into()),
utils::encode_measurements(measurements),
));
if let Some(verification_service_url) = &self.claims.verification_service_url {
map.push((
Value::Integer(token_tag::CCA_PLAT_VERIFICATION_SERVICE.into()),
Value::Text(verification_service_url.clone()),
));
}
map.push((
Value::Integer(token_tag::CCA_PLAT_CONFIGURATION.into()),
Value::Bytes(self.claims.platform_config.to_vec()),
));
map.push((
Value::Integer(token_tag::CCA_PLAT_HASH_ALGO_DESC.into()),
Value::Text(self.dak.as_ref().unwrap().hash_algo.into()),
));
Value::Map(map)
}
fn sign(&self, data: &[u8]) -> Result<Vec<u8>, AttestationError> {
let signing_key = p384::ecdsa::SigningKey::from_bytes(&self.cpak.key.to_bytes())
.map_err(|_| AttestationError::GenericError)?;
let signature: P384Signature = signing_key
.try_sign(data)
.map_err(|_| AttestationError::GenericError)?;
Ok(signature.to_vec())
}
fn verify_dak_hash(&self, dak_pub_hash: &[u8]) -> bool {
let DAKInfo { hash_algo, .. } = self.dak.as_ref().unwrap();
let calculated_hash = self.calculate_dak_hash(*hash_algo);
dak_pub_hash == &calculated_hash[..]
}
/// Creates a tagged [`CoseSign1`] of the platform token.
/// `dak_pub_hash` must be a valid hash of DAK Public Key using [`HashAlgo`] passed
/// in [`AttestationMgr::get_delegated_key`].
/// Returns [`AttestationError::GenericError`], when CBOR or crypto operation fails.
/// Returns [`AttestationError::InvalidArgument`], when DAK was not requsted before
/// this operation, or `dak_pub_hash` is not a valid hash of DAK Public Key.
pub fn get_platform_token(
&mut self,
dak_pub_hash: &[u8],
measurements: &[Measurement],
) -> Result<CoseSign1, AttestationError> {
if self.dak.is_none() {
return Err(AttestationError::InvalidArgument);
}
if !self.verify_dak_hash(dak_pub_hash) {
return Err(AttestationError::InvalidArgument);
}
let encoded_claims = self.encode_claims(dak_pub_hash, measurements);
let mut token = Vec::new();
ser::into_writer(&encoded_claims, &mut token).expect("Unable to encode token");
let protected = HeaderBuilder::new()
.algorithm(coset::iana::Algorithm::ES384)
.build();
let mut singning_error = None;
let sign1 = CoseSign1Builder::new()
.protected(protected)
.payload(token)
.create_signature(b"", |payload| match self.sign(payload) {
Ok(sign) => sign,
Err(e) => {
singning_error = Some(e);
Vec::new()
}
})
.build();
match singning_error {
None => Ok(sign1),
Some(e) => Err(e),
}
}
}
#[cfg(test)]
mod tests {
use core::str::from_utf8;
use alloc::vec;
use ciborium::de;
use crate::{MeasurementMetaData, SWType, SWVersion, SignerHash, ValueHash};
use super::*;
fn key_derivation_material() -> KeyMaterialData {
KeyMaterialData {
hash: [
0xf1, 0x5f, 0x95, 0x3b, 0xe5, 0x0d, 0xad, 0x92, 0xc3, 0xb2, 0xaa, 0x32, 0x97, 0xe6,
0xa4, 0xa8, 0xd6, 0x6d, 0x33, 0x63, 0x84, 0x49, 0xec, 0x19, 0x22, 0xb4, 0xa7, 0x92,
0x4a, 0x7b, 0x30, 0x22,
]
.iter()
.cloned()
.collect(),
guk: [
0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67,
0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45,
0x67, 0x89, 0x01, 0x23,
]
.into(),
}
}
fn hw_claims() -> HWClaims {
HWClaims {
implementation_id: [
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
0xBB, 0xBB, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xDD, 0xDD, 0xDD, 0xDD,
0xDD, 0xDD, 0xDD, 0xDD,
],
security_lifecycle: 0x4000,
profile_definition: Some("tag:arm.com,2023:cca_platform#1.0.0".to_string()),
verification_service_url: Some("http://whatever.com".to_string()),
platform_config: 0xDEADBEEFu32.to_ne_bytes().iter().cloned().collect(),
}
}
fn measurements() -> Vec<Measurement> {
let signer_id: SignerHash = ArrayVec::from([
0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06, 0x54, 0xAB, 0x09, 0x01,
0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01, 0x83, 0x09, 0x22, 0xCD,
0x09, 0x61, 0xB6, 0xFF, 0x01, 0x05, 0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x33, 0x06,
0x54, 0xAB, 0x09, 0x01, 0x74, 0x77, 0x49, 0x08, 0x93, 0xA8, 0x01, 0x07, 0xEF, 0x01,
0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF,
]);
let sw_version: SWVersion = from_utf8(&[
0x32, 0x35, 0x35, 0x2E, 0x32, 0x35, 0x35, 0x2E, 0x36, 0x35, 0x35, 0x33, 0x35, 0x0,
])
.unwrap()
.to_string();
let sw_type: SWType = from_utf8(&[
0x4D, 0x45, 0x41, 0x53, 0x55, 0x52, 0x45, 0x44, 0x5F, 0x42, 0x4F, 0x4F, 0x54, 0x5F,
0x54, 0x45, 0x53, 0x54, 0x53, 0x0,
])
.unwrap()
.to_string();
vec![Measurement {
metadata: MeasurementMetaData {
signer_id,
sw_version,
algorithm: MeasurementType::Sha512,
sw_type,
},
value: ValueHash::from([
0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2, 0x33, 0xff, 0x5d, 0x75, 0xd7, 0xea,
0x89, 0xa8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x05, 0x01, 0xEF,
0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6, 0xFF, 0xbb, 0xbb,
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x56, 0x46, 0x58, 0x49, 0x99, 0x31, 0xcf, 0x59,
0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c,
]),
}]
}
#[test]
fn token_before_dak_error() {
let mut mgr = AttestationMgr::init(key_derivation_material(), hw_claims());
assert_eq!(
mgr.get_platform_token(&[], &[]).unwrap_err(),
AttestationError::InvalidArgument
);
}
#[test]
fn token_bad_dak_hash_value() {
let mut mgr = AttestationMgr::init(key_derivation_material(), hw_claims());
let _dak = mgr
.get_delegated_key(ECCFamily::SecpR1, KeyBits::Bits384, HashAlgo::Sha256, &[])
.unwrap();
assert_eq!(
mgr.get_platform_token(&[], &[]).unwrap_err(),
AttestationError::InvalidArgument
);
}
#[test]
fn token_bad_dak_hash_algo() {
let mut mgr = AttestationMgr::init(key_derivation_material(), hw_claims());
let dak = mgr
.get_delegated_key(ECCFamily::SecpR1, KeyBits::Bits384, HashAlgo::Sha256, &[])
.unwrap();
let key_public_sec1 = p384::SecretKey::from_slice(&dak)
.unwrap()
.public_key()
.to_sec1_bytes();
let key_public_cose = ec_public_key_sec1_to_cose(&key_public_sec1);
let hash = calculate_public_key_hash(&key_public_cose, HashAlgo::Sha512);
assert_eq!(
mgr.get_platform_token(&hash, &[]).unwrap_err(),
AttestationError::InvalidArgument
);
}
#[test]
fn token_sign1_verify() {
let key_derivation_material = key_derivation_material();
let claims = hw_claims();
let boot_measurements = measurements();
let hash_algo = HashAlgo::Sha256;
let mut mgr = AttestationMgr::init(key_derivation_material.clone(), claims.clone());
let dak = mgr
.get_delegated_key(
ECCFamily::SecpR1,
KeyBits::Bits384,
hash_algo,
&boot_measurements,
)
.unwrap();
let key_public_sec1 = p384::SecretKey::from_slice(&dak)
.unwrap()
.public_key()
.to_sec1_bytes();
let key_public_cose = ec_public_key_sec1_to_cose(&key_public_sec1);
let hash = calculate_public_key_hash(&key_public_cose, hash_algo);
let token_sign1 = mgr.get_platform_token(&hash, &boot_measurements).unwrap();
assert!(token_sign1
.verify_signature(&[], |sig, data| {
(mgr.sign(data).unwrap() == sig).then_some(()).ok_or(())
})
.is_ok());
}
fn claims_occurence_vector() -> Vec<(u32, bool)> {
let occurence_vec = vec![
(token_tag::CCA_PLAT_CHALLENGE, false),
(token_tag::CCA_PLAT_INSTANCE_ID, false),
(token_tag::CCA_PLAT_SECURITY_LIFECYCLE, false),
(token_tag::CCA_PLAT_IMPLEMENTATION_ID, false),
(token_tag::CCA_PLAT_SW_COMPONENTS, false),
(token_tag::CCA_PLAT_PROFILE, false),
(token_tag::CCA_PLAT_VERIFICATION_SERVICE, false),
(token_tag::CCA_PLAT_CONFIGURATION, false),
(token_tag::CCA_PLAT_HASH_ALGO_DESC, false),
];
assert_eq!(occurence_vec.len(), 9);
occurence_vec
}
fn mark_occurence(vec: &mut Vec<(u32, bool)>, occured_tag: u32) {
let (_, tag_occurence) = vec
.iter_mut()
.find(|&&mut (tag, _)| tag == occured_tag)
.unwrap();
*tag_occurence = true;
}
fn verify_occurence(vec: &Vec<(u32, bool)>) -> bool {
!vec.iter()
.find(|&&(_, occurence)| occurence == false)
.is_some()
}
#[test]
fn token_decode_verify() {
let key_derivation_material = key_derivation_material();
let claims = hw_claims();
let measurements = measurements();
let hash_algo = HashAlgo::Sha256;
let mut mgr = AttestationMgr::init(key_derivation_material.clone(), claims.clone());
let dak = mgr
.get_delegated_key(
ECCFamily::SecpR1,
KeyBits::Bits384,
hash_algo,
&measurements,
)
.unwrap();
let key_public_sec1 = p384::SecretKey::from_slice(&dak)
.unwrap()
.public_key()
.to_sec1_bytes();
let key_public_cose = ec_public_key_sec1_to_cose(&key_public_sec1);
let hash = calculate_public_key_hash(&key_public_cose, hash_algo);
let token_sign1 = mgr.get_platform_token(&hash, &measurements).unwrap();
let payload = de::from_reader(&token_sign1.payload.unwrap()[..])
.expect("CoseSign1 is not a cbor Value");
let token_map = match payload {
Value::Map(platform_token_map) => platform_token_map,
_ => panic!("CoseSign1 payload is not a map!"),
};
let mut occurence_vec = claims_occurence_vector();
for (tag_value, value) in token_map {
let tag: u32 = match tag_value {
Value::Integer(tag_integer) => tag_integer.try_into().unwrap(),
_ => panic!("Tag is incorrect"),
};
match tag {
token_tag::CCA_PLAT_CHALLENGE => {
if let Value::Bytes(dak_hash) = value {
assert_eq!(dak_hash, hash);
} else {
panic!("CCA_PLAT_CHALLENGE incorrect");
}
}
token_tag::CCA_PLAT_CONFIGURATION => {
if let Value::Bytes(platform_config) = value {
assert_eq!(&platform_config[..], &claims.platform_config[..]);
} else {
panic!("CCA_PLAT_CONFIGURATION incorrect");
}
}
token_tag::CCA_PLAT_INSTANCE_ID => {
if let Value::Bytes(instance_id) = value {
assert_eq!(instance_id[0], 0x01);
assert_eq!(
instance_id[1..],
calculate_public_key_hash(
&mgr.cpak.key.public_key().to_sec1_bytes(),
HashAlgo::Sha256
)
);
} else {
panic!("CCA_PLAT_INSTANCE_ID incorrect");
}
}
token_tag::CCA_PLAT_PROFILE => {
if let Value::Text(profile) = value {
assert_eq!(profile, *claims.profile_definition.as_ref().unwrap());
} else {
panic!("CCA_PLAT_PROFILE incorrect");
}
}
token_tag::CCA_PLAT_SECURITY_LIFECYCLE => {
if let Value::Integer(security_lifecycle) = value {
let value_u32: u32 = security_lifecycle.try_into().unwrap();
assert_eq!(value_u32, claims.security_lifecycle as u32);
} else {
panic!("CCA_PLAT_PROFILE incorrect");
}
}
token_tag::CCA_PLAT_IMPLEMENTATION_ID => {
if let Value::Bytes(implementation_id) = value {
assert_eq!(implementation_id, &claims.implementation_id);
} else {
panic!("CCA_PLAT_IMPLEMENTATION_ID incorrect");
}
}
token_tag::CCA_PLAT_HASH_ALGO_DESC => {
if let Value::Text(algo_desc) = value {
let claim_desc: String = mgr.dak.as_ref().unwrap().hash_algo.into();
assert_eq!(algo_desc, claim_desc);
} else {
panic!("CCA_PLAT_HASH_ALGO_DESC incorrect");
}
}
token_tag::CCA_PLAT_VERIFICATION_SERVICE => {
if let Value::Text(verficiation_service) = value {
assert_eq!(
verficiation_service,
*claims.verification_service_url.as_ref().unwrap()
);
}
}
token_tag::CCA_PLAT_SW_COMPONENTS => {
if let Value::Array(measurements_array) = value {
// This code works only for measurements with one entry
for measurement_map in measurements_array {
if let Value::Map(measurement) = measurement_map {
for (tag_value, value) in measurement {
let tag: u32 = match tag_value {
Value::Integer(tag_integer) => {
tag_integer.try_into().unwrap()
}
_ => panic!("SW COMP map tag not an Integer"),
};
match tag {
token_tag::CCA_SW_COMP_HASH_ALGORITHM => {
if let Value::Text(algorithm) = value {
let claim_desc: String =
measurements[0].metadata.algorithm.into();
assert_eq!(algorithm, claim_desc);
} else {
panic!("CCA_SW_COMP_HASH_ALGORITHM incorrect");
}
}
token_tag::CCA_SW_COMP_TITLE => {
if let Value::Text(title) = value {
assert_eq!(title, measurements[0].metadata.sw_type);
} else {
panic!("CCA_SW_COMP_TITLE incorrect");
}
}
token_tag::CCA_SW_COMP_SIGNER_ID => {
if let Value::Bytes(signer_id) = value {
assert_eq!(
&signer_id[..],
&measurements[0].metadata.signer_id[..]
);
} else {
panic!("CCA_SW_COMP_SINGER_ID incorrect");
}
}
token_tag::CCA_SW_COMP_VERSION => {
if let Value::Text(version) = value {
assert_eq!(
version,
measurements[0].metadata.sw_version
);
} else {
panic!("CCA_SW_COMP_VERSION incorrect");
}
}
token_tag::CCA_SW_COMP_MEASUREMENT_VALUE => {
if let Value::Bytes(measurement_value) = value {
assert_eq!(
measurement_value,
&measurements[0].value[..]
);
} else {
panic!("CCA_SW_COMP_MEASUREMENT_VALUE incorrect");
}
}
_ => panic!("Invalid SW COMP tag value: {}", tag),
}
}
}
}
}
}
_ => panic!("Invalid tag value: {}", tag),
}
mark_occurence(&mut occurence_vec, tag);
}
assert!(verify_occurence(&occurence_vec));
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes-host-app/src/main.rs | hes/islet-hes-host-app/src/main.rs | mod comms;
use clap::Parser;
use comms::{CommsChannel, CommsError, Request, Response};
use coset::TaggedCborSerializable;
use daemonize::Daemonize;
use islet_hes::{
BootMeasurement, BootMeasurementMetadata, HWAsymmetricKey, HWData, HWHash, HWSymmetricKey,
IsletHES, IsletHESError,
};
use std::fs::{self, File};
use std::io::{Read, Result as IOResult};
use std::thread;
use std::time;
use tinyvec::ArrayVec;
use crate::comms::psa_serde::PSA_SUCCESS;
/// Creates a path to a resource file
macro_rules! resource_file {
($fname:expr) => {
// Ugly way to base path on workspace directory
concat!(env!("CARGO_MANIFEST_DIR"), "/../res/", $fname)
};
}
/// Islet HES Host App providing measured_boot and attestation functionalities
#[derive(Parser, Debug)]
#[command(author, version, long_about = None)]
#[command(about = "Islet HES Host App providing measured_boot and attestation functionalities")]
struct Args {
/// Path to binary file with BL2 hash
#[arg(short = 'b', long, value_name = "FILE")]
#[arg(default_value = resource_file!("bl2_signed_hash.bin"))]
hash_file: Option<String>,
/// Path to binary file with GUK
#[arg(short, long, value_name = "FILE")]
#[arg(default_value = resource_file!("dummy_guk.bin"))]
guk_file: Option<String>,
/// Address of TF-A telnet socket
#[arg(short, long, value_name = "IP:PORT")]
#[arg(default_value = "127.0.0.1:5002")]
addr: String,
/// Keep reconnecting, when connection is not yet established or is
/// shut down
#[arg(short, long)]
persistent: bool,
/// Whether to daemonize the app, implies 'persistent'
#[arg(short, long)]
daemonize: bool,
/// Daemonize working directory, pid file and logs will be placed here
#[arg(short = 'r', long, default_value = "/tmp")]
daemonize_root: String,
}
fn load_binary_file(filename: &str) -> IOResult<Vec<u8>> {
let mut f = File::open(filename)?;
let metadata = fs::metadata(filename)?;
let mut buffer = vec![0; metadata.len() as usize];
f.read(&mut buffer)?;
Ok(buffer)
}
// Fix me - gather all of the numbers of respective psa errors
fn islet_hes_error_to_ret_val(error: IsletHESError) -> i32 {
match error {
// PSA_ERROR_BAD_STATE
IsletHESError::BadState => -137,
// PSA_ERROR_DOES_NOT_EXIST
IsletHESError::DoesNotExist => -140,
// PSA_ERROR_GENERIC_ERROR
IsletHESError::GenericError => -132,
// PSA_ERROR_INVALID_ARGUMENT
IsletHESError::InvalidArgument => -135,
// PSA_ERROR_NOT_PERMITTED
IsletHESError::NotPermitted => -133,
// PSA_ERROR_NOT_SUPPORTED
IsletHESError::NotSupported => -134,
}
}
fn comms_error_to_ret_val(error: CommsError) -> i32 {
match error {
// PSA_ERROR_BUFFER_TOO_SMALL
CommsError::BufferTooSmall => -138,
// PSA_ERROR_GENERIC_ERROR
CommsError::GenericError => -132,
// PSA_ERROR_INVALID_ARGUMENT
CommsError::InvalidArgument => -135,
// PSA_ERROR_PROGRAMMER_ERROR
CommsError::ProgrammerError => -129,
// Internal error codes
CommsError::CommunicationError => {
panic!("Communication error cannot be translated as a return value!")
}
CommsError::PsaSerdeError => {
panic!("PSA (de)serialization error cannot be translated as a return value!")
}
CommsError::ServiceHandleError => {
panic!("Service handle error cannot be translated as a return value!")
}
}
}
fn process_requests(comms: &mut CommsChannel, islet_hes: &mut IsletHES) -> Result<(), CommsError> {
println!("Processing connection requests");
loop {
let (ret_val, response) = match comms.get_request() {
Ok(requests) => {
if requests.is_none() {
// Server disconnected gracefully
return Ok(());
}
println!("Request read: {:02X?}", requests);
let request = requests.unwrap();
match request {
Request::GetDAK(ecc_family, key_bits, hash_algo) => {
match islet_hes.get_delegated_key(ecc_family, key_bits, hash_algo) {
Ok(dak) => (PSA_SUCCESS, Some(Response::GetDAK(dak))),
Err(e) => (islet_hes_error_to_ret_val(e), None),
}
}
Request::GetPlatformToken(dak_pub_hash) => {
match islet_hes.get_platform_token(&dak_pub_hash) {
Ok(token) => (
PSA_SUCCESS,
Some(Response::GetPlatformToken(token.to_tagged_vec().unwrap())),
),
Err(e) => (islet_hes_error_to_ret_val(e), None),
}
}
Request::ExtendMeasurement(slot_id, measurement, lock) => {
match islet_hes.extend_measurement(slot_id, measurement, lock) {
Ok(()) => (PSA_SUCCESS, None),
Err(e) => (islet_hes_error_to_ret_val(e), None),
}
}
Request::ReadMeasurement(index, sw_type_len, version_len) => {
match islet_hes.read_measurement(index as usize) {
Ok((measurement, is_locked)) => {
if sw_type_len < measurement.metadata.sw_type.len()
|| version_len < measurement.metadata.sw_version.len()
{
(
islet_hes_error_to_ret_val(IsletHESError::InvalidArgument),
None,
)
} else {
(
PSA_SUCCESS,
Some(Response::ReadMeasurement(
measurement.clone(),
is_locked,
)),
)
}
}
Err(e) => (islet_hes_error_to_ret_val(e), None),
}
}
Request::GetVHuk(key_id) => {
let key_result = match key_id {
comms::VHukId::VHUK_A => islet_hes.get_authority_vhuk(),
comms::VHukId::VHUK_M => islet_hes.get_measurement_vhuk(),
};
match key_result {
Ok(key) => (PSA_SUCCESS, Some(Response::GetVHuk(key))),
Err(e) => (islet_hes_error_to_ret_val(e), None),
}
}
}
}
Err(e) => {
let ret_val = match e {
CommsError::CommunicationError => return Err(e),
CommsError::PsaSerdeError => {
panic!("Psa (de)serialization failed!");
}
CommsError::ServiceHandleError => {
println!("Got request not intended for us, ignoring...");
continue;
}
CommsError::ProgrammerError => {
panic!("Now go fix your code. Tut tut tut!\n");
}
e => comms_error_to_ret_val(e),
};
(ret_val, None)
}
};
println!("Generated response: {:02X?}, ret: {:?}", response, ret_val);
match comms.send_response(ret_val, response) {
Ok(()) => (),
Err(e) => match e {
CommsError::CommunicationError => return Err(e),
CommsError::PsaSerdeError => {
panic!("Psa (de)serialization failed!");
}
_ => panic!("No other error possible"),
},
}
}
}
fn daemonize(daemonize_root: String) -> std::io::Result<()> {
let root = std::fs::canonicalize(daemonize_root)?;
let hespid = root.join("hes.pid").to_string_lossy().to_string();
let hesout = root.join("hes.out").to_string_lossy().to_string();
let heserr = root.join("hes.err").to_string_lossy().to_string();
let root = root.to_string_lossy().to_string();
let stdout = File::create(&hesout).unwrap();
let stderr = File::create(&heserr).unwrap();
println!("Pidfile: {}, logs: {}, {}", hespid, hesout, heserr);
let daemonize = Daemonize::new()
.pid_file(hespid)
.working_directory(root)
.stdout(stdout)
.stderr(stderr);
match daemonize.start() {
Ok(_) => println!("Daemonization succeessful"),
Err(e) => panic!("Daemonization failed: {}", e),
}
Ok(())
}
fn main() -> std::io::Result<()> {
let mut args = Args::parse();
if args.daemonize {
println!("Daemonization requested");
// daemon without persistent makes little sense
args.persistent = true;
daemonize(args.daemonize_root)?;
}
// XXX: Workaround to a hazard between launching of FVP and HES
thread::sleep(time::Duration::from_millis(1000));
let bl_hash = match &args.hash_file {
Some(path) => Some(load_binary_file(path)?.iter().cloned().collect()),
None => None,
};
let guk = match &args.guk_file {
Some(path) => Some(load_binary_file(path)?.iter().cloned().collect()),
None => None,
};
let hw_data = DummyHW::init(guk, bl_hash);
let mut islet_hes = IsletHES::init(hw_data.clone()).unwrap();
let mut comms = CommsChannel::new(args.addr);
let is_persistent = args.persistent;
comms.connect(is_persistent)?;
loop {
match process_requests(&mut comms, &mut islet_hes) {
// Graceful disconnection
Ok(()) => {
if is_persistent {
islet_hes.reset(hw_data.clone()).unwrap();
println!("Connection was shut down, reconnecting...");
comms.connect(true)?;
continue;
} else {
return Ok(());
}
}
// Some connection error
Err(_) => {
if is_persistent {
islet_hes.reset(hw_data.clone()).unwrap();
println!("Connection failed, reconnecting...");
comms.connect(true)?;
continue;
} else {
return Err(std::io::Error::last_os_error());
}
}
}
}
}
// ================================ DUMMY DATA ===================================
#[derive(Debug, Clone)]
struct DummyHW {
guk: Option<HWSymmetricKey>,
bl_hash: Option<HWHash>,
}
type DummyError = ();
impl DummyHW {
fn init(guk: Option<HWSymmetricKey>, bl_hash: Option<HWHash>) -> Self {
Self { guk, bl_hash }
}
}
impl HWData for DummyHW {
type Error = DummyError;
fn boot_measurements(&self) -> Result<Vec<BootMeasurement>, DummyError> {
Ok(Vec::from([
BootMeasurement {
measurement_value: [
0x61, 0x97, 0x3b, 0x4f, 0x62, 0x0c, 0x2a, 0xe6, 0xc7, 0x63, 0x51, 0x18, 0xa0,
0xb4, 0x37, 0x6d, 0x15, 0x34, 0x4c, 0x1c, 0x53, 0xa2, 0x17, 0x89, 0xb1, 0xaa,
0x95, 0xd2, 0x0f, 0x3c, 0x45, 0x06,
]
.iter()
.cloned()
.collect(),
metadata: BootMeasurementMetadata {
signer_id: [
0xc6, 0xc3, 0x2a, 0x95, 0x7d, 0xf4, 0xc6, 0x69, 0x8c, 0x55, 0x0b, 0x69,
0x5d, 0x02, 0x2e, 0xd5, 0x18, 0x0c, 0xae, 0x71, 0xf8, 0xb4, 0x9c, 0xbb,
0x75, 0xe6, 0x06, 0x1c, 0x2e, 0xf4, 0x97, 0xe1,
]
.iter()
.cloned()
.collect(),
measurement_type: 0,
sw_type: b"Dummy BL1".iter().cloned().collect(),
sw_version: b"0.1.0".iter().cloned().collect(),
},
},
BootMeasurement {
measurement_value: [
0x8a, 0x66, 0x01, 0xf6, 0x70, 0x74, 0x8b, 0xe2, 0x33, 0xff, 0x5d, 0x75, 0xd7,
0xea, 0x89, 0xa8, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x01, 0x05,
0x01, 0xEF, 0x68, 0x07, 0x88, 0xCC, 0x83, 0x09, 0x22, 0xCD, 0x09, 0x61, 0xB6,
0xFF, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x56, 0x46, 0x58, 0x49,
0x99, 0x31, 0xcf, 0x59, 0x7d, 0xbc, 0x3a, 0x4e, 0x68, 0x79, 0x8a, 0x1c,
]
.into(),
metadata: BootMeasurementMetadata {
signer_id: [
0xa0, 0x64, 0xb1, 0xad, 0x60, 0xfa, 0x18, 0x33, 0x94, 0xdd, 0xa5, 0x78,
0x91, 0x35, 0x7f, 0x97, 0x2e, 0x4f, 0xe7, 0x22, 0x78, 0x2a, 0xdf, 0xf1,
0x85, 0x4c, 0x8b, 0x2a, 0x14, 0x2c, 0x04, 0x10,
]
.iter()
.cloned()
.collect(),
measurement_type: 2,
sw_type: b"Dummy BL2".iter().cloned().collect(),
sw_version: b"1.9.0+0".iter().cloned().collect(),
},
},
]))
}
fn huk(&self) -> Result<HWSymmetricKey, DummyError> {
Ok([
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
]
.into())
}
// Equivalent to res/dummy_guk.bin
fn guk(&self) -> Result<HWSymmetricKey, DummyError> {
Ok(self.guk.unwrap_or(
[
0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67,
0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45,
0x67, 0x89, 0x01, 0x23,
]
.into(),
))
}
// Equivalent to res/bl2_signed_hash.bin
fn bl_hash(&self) -> Result<HWHash, Self::Error> {
Ok(self.bl_hash.unwrap_or(
[
0xf1, 0x5f, 0x95, 0x3b, 0xe5, 0x0d, 0xad, 0x92, 0xc3, 0xb2, 0xaa, 0x32, 0x97, 0xe6,
0xa4, 0xa8, 0xd6, 0x6d, 0x33, 0x63, 0x84, 0x49, 0xec, 0x19, 0x22, 0xb4, 0xa7, 0x92,
0x4a, 0x7b, 0x30, 0x22,
]
.iter()
.cloned()
.collect(),
))
}
fn cpak(&self) -> Result<Option<HWAsymmetricKey>, DummyError> {
Ok(None)
}
fn implementation_id(&self) -> Result<[u8; 32], DummyError> {
Ok([
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
0xBB, 0xBB, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xDD, 0xDD, 0xDD, 0xDD,
0xDD, 0xDD, 0xDD, 0xDD,
])
}
fn profile_definition(&self) -> Result<Option<ArrayVec<[u8; 35]>>, DummyError> {
Ok(Some(
b"tag:arm.com,2023:cca_platform#1.0.0"
.iter()
.cloned()
.collect(),
))
}
fn security_lifecycle(&self) -> Result<u32, DummyError> {
Ok(0x3000)
}
fn verification_service_url(&self) -> Result<Option<ArrayVec<[u8; 32]>>, DummyError> {
Ok(Some(b"http://whatever.com".iter().cloned().collect()))
}
fn platform_config(&self) -> Result<ArrayVec<[u8; 32]>, DummyError> {
Ok(0xDEADBEEFu32.to_ne_bytes().iter().cloned().collect())
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes-host-app/src/comms/psa_serde.rs | hes/islet-hes-host-app/src/comms/psa_serde.rs | #![allow(non_camel_case_types)]
use islet_hes::{SW_TYPE_MAX_SIZE, VERSION_MAX_SIZE};
type psa_handle_t = u32;
pub const RSS_MEASURED_BOOT_SERVICE_HANDLE: psa_handle_t = 0x40000110;
pub const RSS_MEASURED_BOOT_READ: i16 = 1001;
pub const RSS_MEASURED_BOOT_EXTEND: i16 = 1002;
pub const RSS_DELEGATED_SERVICE_HANDLE: psa_handle_t = 0x40000111;
pub const RSS_DELEGATED_ATTEST_GET_DELEGATED_KEY: i16 = 1001;
pub const RSS_DELEGATED_ATTEST_GET_PLATFORM_TOKEN: i16 = 1002;
pub const RSS_VHUK_SERVICE_HANDLE: psa_handle_t = 0x40000115;
pub const RSS_VHUK_GET_KEY: i16 = 1006;
pub const PSA_MAX_IOVEC: usize = 4;
const PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE: usize = 0x1000;
const TYPE_OFFSET: u8 = 0;
const TYPE_MASK: u32 = 0xFFFF << TYPE_OFFSET;
const IN_LEN_OFFSET: u8 = 24;
const IN_LEN_MASK: u32 = 0x7 << IN_LEN_OFFSET;
const OUT_LEN_OFFSET: u8 = 16;
const OUT_LEN_MASK: u32 = 0x7 << OUT_LEN_OFFSET;
pub const PSA_SUCCESS: i32 = 0;
#[derive(Debug, Clone, Copy)]
#[repr(C, packed)]
struct serialized_rss_comms_header_t {
protocol_ver: u8,
seq_num: u8,
client_id: u16,
}
#[derive(Debug, Clone, Copy)]
#[repr(C, packed)]
struct rss_embed_msg_t {
handle: psa_handle_t,
ctrl_param: u32, /* type, in_len, out_len */
io_size: [u16; PSA_MAX_IOVEC],
trailer: [u8; PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE],
}
#[derive(Debug, Clone, Copy)]
#[repr(C, packed)]
struct rss_embed_reply_t {
return_val: i32,
out_size: [u16; PSA_MAX_IOVEC],
trailer: [u8; PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE],
}
#[derive(Debug)]
#[repr(C, packed)]
struct serialized_rss_comms_msg_t {
header: serialized_rss_comms_header_t,
msg: rss_embed_msg_t,
}
#[derive(Debug)]
#[repr(C, packed)]
struct serialized_rss_comms_reply_t {
header: serialized_rss_comms_header_t,
reply: rss_embed_reply_t,
}
#[derive(Debug)]
#[repr(C)]
struct measured_boot_extend_iovec_t {
index: u8,
lock_measurement: u8,
measurement_algo: u32,
sw_type: [u8; SW_TYPE_MAX_SIZE],
sw_type_size: u8,
}
#[derive(Debug)]
#[repr(C)]
struct measured_boot_read_iovec_in_t {
index: u8,
sw_type_size: u8,
version_size: u8,
}
#[derive(Debug)]
#[repr(C)]
struct measured_boot_read_iovec_out_t {
is_locked: u8,
measurement_algo: u32,
sw_type: [u8; SW_TYPE_MAX_SIZE],
sw_type_len: u8,
version: [u8; VERSION_MAX_SIZE],
version_len: u8,
}
#[derive(Debug, Clone)]
pub(super) struct PSARequest {
pub protocol_ver: u8,
pub seq_num: u8,
pub client_id: u16,
pub handle: psa_handle_t,
pub psa_type: i16,
pub in_vecs: [Vec<u8>; PSA_MAX_IOVEC],
pub out_lens: [usize; PSA_MAX_IOVEC],
}
pub enum PSAError {
WrongDataLength,
}
impl PSARequest {
pub(super) fn de(input: &[u8]) -> Result<Self, PSAError> {
if input.len() > std::mem::size_of::<rss_embed_msg_t>() {
return Err(PSAError::WrongDataLength);
}
let ptr = input.as_ptr() as *const serialized_rss_comms_msg_t;
let msg: &serialized_rss_comms_msg_t = unsafe { &*ptr };
let mut counter;
let psa_type: i16 = ((msg.msg.ctrl_param & TYPE_MASK) >> TYPE_OFFSET)
.try_into()
.unwrap();
let num_in_vecs: usize = ((msg.msg.ctrl_param & IN_LEN_MASK) >> IN_LEN_OFFSET)
.try_into()
.unwrap();
let num_out_vecs: usize = ((msg.msg.ctrl_param & OUT_LEN_MASK) >> OUT_LEN_OFFSET)
.try_into()
.unwrap();
/* required to copy on stack, msg is packed */
let io_sizes = msg.msg.io_size;
let mut in_vecs: [Vec<u8>; PSA_MAX_IOVEC] = Default::default();
let mut offset = 0;
counter = 0;
for len in &io_sizes[..num_in_vecs] {
let len = *len as usize;
in_vecs[counter] = msg.msg.trailer[offset..offset + len].to_vec();
counter = counter + 1;
offset = offset + len;
}
let mut out_len = [0usize; PSA_MAX_IOVEC];
counter = 0;
for len in &io_sizes[num_in_vecs..num_in_vecs + num_out_vecs] {
out_len[counter] = *len as usize;
counter = counter + 1;
}
Ok(PSARequest {
protocol_ver: msg.header.protocol_ver,
seq_num: msg.header.seq_num,
client_id: msg.header.client_id,
handle: msg.msg.handle,
psa_type,
in_vecs,
out_lens: out_len,
})
}
}
#[derive(Default, Debug)]
pub(super) struct PSAResponse {
pub(super) protocol_ver: u8,
pub(super) seq_num: u8,
pub(super) client_id: u16,
pub(super) return_val: i32,
pub(super) out_vecs: [Vec<u8>; PSA_MAX_IOVEC],
}
impl PSAResponse {
pub(super) fn ser(&self) -> Result<Vec<u8>, PSAError> {
/* pack data */
let header = serialized_rss_comms_header_t {
protocol_ver: self.protocol_ver,
seq_num: self.seq_num,
client_id: self.client_id,
};
let mut out_size = [0u16; PSA_MAX_IOVEC];
let mut trailer = [0u8; PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE];
let mut counter = 0;
let mut offset = 0;
for out_vec in &self.out_vecs {
let len = out_vec.len();
if len == 0 {
break;
}
out_size[counter] = len.try_into().unwrap();
let to_offset = offset + len;
if to_offset >= PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE {
return Err(PSAError::WrongDataLength);
}
trailer[offset..to_offset].clone_from_slice(&out_vec);
offset = to_offset;
counter = counter + 1;
}
let reply = rss_embed_reply_t {
return_val: self.return_val,
out_size,
trailer,
};
let res = serialized_rss_comms_reply_t { header, reply };
/* convert to bytes */
let length = std::mem::size_of::<serialized_rss_comms_reply_t>()
- PLAT_RSS_COMMS_PAYLOAD_MAX_SIZE as usize
+ offset;
let ptr = &res as *const serialized_rss_comms_reply_t as *const u8;
let output = unsafe { std::slice::from_raw_parts(ptr, length) }.to_vec();
Ok(output)
}
}
#[derive(Debug)]
pub(super) struct ExtendRequest {
pub(super) index: u8,
pub(super) lock_measurement: u8,
pub(super) measurement_algo: u32,
pub(super) sw_type: [u8; SW_TYPE_MAX_SIZE],
pub(super) sw_type_size: u8,
}
impl ExtendRequest {
pub(super) fn de(input: &[u8]) -> Result<Self, PSAError> {
if input.len() != std::mem::size_of::<measured_boot_extend_iovec_t>() {
return Err(PSAError::WrongDataLength);
}
let ptr = input.as_ptr() as *const measured_boot_extend_iovec_t;
let msg: &measured_boot_extend_iovec_t = unsafe { &*ptr };
Ok(ExtendRequest {
index: msg.index,
lock_measurement: msg.lock_measurement,
measurement_algo: msg.measurement_algo,
sw_type: msg.sw_type,
sw_type_size: msg.sw_type_size,
})
}
}
#[derive(Debug)]
pub struct ReadRequest {
pub index: u8,
pub sw_type_size: u8,
pub version_size: u8,
}
impl ReadRequest {
pub fn de(input: &[u8]) -> Result<Self, PSAError> {
if input.len() != std::mem::size_of::<measured_boot_read_iovec_in_t>() {
return Err(PSAError::WrongDataLength);
}
let ptr = input.as_ptr() as *const measured_boot_read_iovec_in_t;
let msg: &measured_boot_read_iovec_in_t = unsafe { &*ptr };
Ok(ReadRequest {
index: msg.index,
sw_type_size: msg.sw_type_size,
version_size: msg.version_size,
})
}
}
pub struct ReadResponse {
pub is_locked: u8,
pub measurement_algo: u32,
pub sw_type: [u8; SW_TYPE_MAX_SIZE],
pub sw_type_len: u8,
pub version: [u8; VERSION_MAX_SIZE],
pub version_len: u8,
}
impl ReadResponse {
pub(super) fn ser(&self) -> Result<Vec<u8>, PSAError> {
/* pack data */
let reply = measured_boot_read_iovec_out_t {
is_locked: self.is_locked,
measurement_algo: self.measurement_algo,
sw_type: self.sw_type,
sw_type_len: self.sw_type_len,
version: self.version,
version_len: self.version_len,
};
/* convert to bytes */
let length = std::mem::size_of::<measured_boot_read_iovec_out_t>();
let ptr = &reply as *const measured_boot_read_iovec_out_t as *const u8;
let output = unsafe { std::slice::from_raw_parts(ptr, length) }.to_vec();
Ok(output)
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/islet-hes-host-app/src/comms/mod.rs | hes/islet-hes-host-app/src/comms/mod.rs | pub mod psa_serde;
use std::{
io::{ErrorKind, Read, Write},
net::TcpStream,
str::from_utf8,
thread::sleep,
time::Duration,
};
use islet_hes::{
ECCFamily, HashAlgo, KeyBits, Measurement, MeasurementMetaData, MeasurementType, ValueHash,
NUM_OF_MEASUREMENT_SLOTS, SW_TYPE_MAX_SIZE,
};
use psa_serde::{RSS_VHUK_GET_KEY, RSS_VHUK_SERVICE_HANDLE};
use self::psa_serde::{
ExtendRequest, PSAError, PSARequest, PSAResponse, ReadRequest, ReadResponse, PSA_MAX_IOVEC,
RSS_DELEGATED_ATTEST_GET_DELEGATED_KEY, RSS_DELEGATED_ATTEST_GET_PLATFORM_TOKEN,
RSS_DELEGATED_SERVICE_HANDLE, RSS_MEASURED_BOOT_EXTEND, RSS_MEASURED_BOOT_READ,
RSS_MEASURED_BOOT_SERVICE_HANDLE,
};
#[derive(Debug)]
pub enum CommsError {
BufferTooSmall,
InvalidArgument,
GenericError,
ProgrammerError,
PsaSerdeError,
CommunicationError,
ServiceHandleError,
}
type ResponseParams = [usize; PSA_MAX_IOVEC];
struct MsgMetadata {
pub protocol_ver: u8,
pub seq_num: u8,
pub client_id: u16,
pub response_params: ResponseParams,
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub enum VHukId {
VHUK_A = 0x1,
VHUK_M = 0x2,
}
#[derive(Debug)]
pub enum Request {
GetDAK(ECCFamily, KeyBits, HashAlgo),
GetPlatformToken(ValueHash),
// (index, sw_type_len, sw_version_len)
ReadMeasurement(usize, usize, usize),
ExtendMeasurement(usize, Measurement, bool),
GetVHuk(VHukId),
}
#[derive(Debug)]
pub enum Response {
GetDAK(Vec<u8>),
GetPlatformToken(Vec<u8>),
ReadMeasurement(Measurement, bool),
GetVHuk(Vec<u8>),
}
struct Channel {
stream: Option<TcpStream>,
addr: String,
}
pub struct CommsChannel {
channel: Channel,
msg_metadata: Option<MsgMetadata>,
}
impl From<std::io::Error> for CommsError {
fn from(_value: std::io::Error) -> Self {
CommsError::CommunicationError
}
}
impl From<PSAError> for CommsError {
fn from(_value: PSAError) -> Self {
CommsError::PsaSerdeError
}
}
impl CommsChannel {
pub fn new(addr: String) -> Self {
Self {
channel: Channel { stream: None, addr },
msg_metadata: None,
}
}
pub fn connect(&mut self, persistent: bool) -> Result<(), std::io::Error> {
let stream = loop {
match TcpStream::connect(&self.channel.addr) {
Ok(stream) => break stream,
Err(e) => {
if e.kind() == ErrorKind::ConnectionRefused && persistent {
const RECONNECT_SEC: u64 = 1;
println!("Couldn't connect, retrying in {} seconds...", RECONNECT_SEC);
sleep(Duration::from_secs(RECONNECT_SEC));
continue;
} else {
println!("Connection failed");
return Err(e);
}
}
}
};
println!("Connection established");
self.channel.stream = Some(stream);
Ok(())
}
fn convert_attestation_request(
request_type: i16,
in_vecs: &[Vec<u8>],
) -> Result<Request, CommsError> {
match request_type {
RSS_DELEGATED_ATTEST_GET_DELEGATED_KEY => {
if in_vecs[0].len() != std::mem::size_of::<u8>()
|| in_vecs[1].len() != std::mem::size_of::<u32>()
|| in_vecs[2].len() != std::mem::size_of::<u32>()
{
return Err(CommsError::GenericError);
}
// FIXME: Currently TF-A returns only zeroes for these parameters.
// let request_ecc_family: u8 =
// u8::from_ne_bytes(in_vecs[0].clone().try_into().unwrap());
// let request_key_bits: u32 =
// u32::from_ne_bytes(in_vecs[1].clone().try_into().unwrap());
// let request_hash_algo: u32 =
// u32::from_ne_bytes(in_vecs[1].clone().try_into().unwrap());
// println!("DEBUG: ecc_family: {:x?}, key_bits: {}, hash_algo: {:x?}",
// request_ecc_family, request_key_bits, request_hash_algo);
// let ecc_family = match request_ecc_family {
// 0x12 => ECCFamily::SecpR1,
// _ => return Err(CommsError::InvalidArgument),
// };
// let key_bits = match request_key_bits {
// 256 => KeyBits::Bits256,
// 384 => KeyBits::Bits384,
// 521 => return Err(CommsError::InvalidArgument),
// _ => return Err(CommsError::InvalidArgument),
// };
// let hash_algo = match request_hash_algo {
// 0x2000009 => HashAlgo::Sha256,
// 0x200000a => HashAlgo::Sha384,
// 0x200000b => HashAlgo::Sha512,
// _ => return Err(CommsError::InvalidArgument),
// };
// Ok(Request::GetDAK(ecc_family, key_bits, hash_algo))
Ok(Request::GetDAK(
ECCFamily::SecpR1,
KeyBits::Bits384,
HashAlgo::Sha256,
))
}
RSS_DELEGATED_ATTEST_GET_PLATFORM_TOKEN => {
let dak_pub_hash_size = in_vecs[0].len();
if dak_pub_hash_size != HashAlgo::Sha256.len()
&& dak_pub_hash_size != HashAlgo::Sha384.len()
&& dak_pub_hash_size != HashAlgo::Sha512.len()
{
println!("dak_pub_hash_size is invalid: {}", dak_pub_hash_size);
return Err(CommsError::InvalidArgument);
}
Ok(Request::GetPlatformToken(
in_vecs[0].iter().cloned().collect(),
))
}
_ => {
// This doesn't happen in case of real psa
Err(CommsError::ProgrammerError)
}
}
}
fn convert_vhuk_request(request_type: i16, in_vecs: &[Vec<u8>]) -> Result<Request, CommsError> {
match request_type {
RSS_VHUK_GET_KEY => {
if in_vecs[0].len() != std::mem::size_of::<u8>() {
return Err(CommsError::GenericError);
}
let raw_key_id = u8::from_ne_bytes(in_vecs[0].clone().try_into().unwrap());
let key_id = match raw_key_id {
0x1 => VHukId::VHUK_A,
0x2 => VHukId::VHUK_M,
_ => return Err(CommsError::InvalidArgument),
};
Ok(Request::GetVHuk(key_id))
}
_ => {
// This doesn't happen in case of real psa
Err(CommsError::ProgrammerError)
}
}
}
fn convert_measured_boot_request(
request_type: i16,
in_vecs: &[Vec<u8>],
) -> Result<Request, CommsError> {
match request_type {
RSS_MEASURED_BOOT_READ => {
let read_request = ReadRequest::de(&in_vecs[0])?;
let slot_id = read_request.index as usize;
if slot_id >= NUM_OF_MEASUREMENT_SLOTS {
return Err(CommsError::InvalidArgument);
}
Ok(Request::ReadMeasurement(
slot_id,
read_request.sw_type_size as usize,
read_request.version_size as usize,
))
}
RSS_MEASURED_BOOT_EXTEND => {
let extend_request = ExtendRequest::de(&in_vecs[0])?;
let measurement_type = match extend_request.measurement_algo {
0x02000009 => MeasurementType::Sha256,
0x0200000a => MeasurementType::Sha384,
0x0200000b => MeasurementType::Sha512,
_ => {
println!(
"Unknown measurement type: {}",
extend_request.measurement_algo
);
return Err(CommsError::InvalidArgument);
}
};
if extend_request.sw_type_size as usize > SW_TYPE_MAX_SIZE {
return Err(CommsError::InvalidArgument);
}
let sw_type =
from_utf8(&extend_request.sw_type[..extend_request.sw_type_size as usize])
.unwrap()
.to_string();
let signer_id: ValueHash = in_vecs[1].iter().cloned().collect();
let sw_version = from_utf8(&in_vecs[2]).unwrap().to_string();
let measurement_value: ValueHash = in_vecs[3].iter().cloned().collect();
let measurement = Measurement {
metadata: MeasurementMetaData {
algorithm: measurement_type,
signer_id,
sw_version,
sw_type,
},
value: measurement_value,
};
Ok(Request::ExtendMeasurement(
extend_request.index as usize,
measurement,
extend_request.lock_measurement != 0,
))
}
_ => Err(CommsError::ProgrammerError),
}
}
fn convert_request(&mut self, psa_request: PSARequest) -> Result<Request, CommsError> {
self.msg_metadata = Some(MsgMetadata {
protocol_ver: psa_request.protocol_ver,
seq_num: psa_request.seq_num,
client_id: psa_request.client_id,
response_params: psa_request.out_lens,
});
let request = match psa_request.handle {
RSS_DELEGATED_SERVICE_HANDLE => {
Self::convert_attestation_request(psa_request.psa_type, &psa_request.in_vecs)?
}
RSS_MEASURED_BOOT_SERVICE_HANDLE => {
Self::convert_measured_boot_request(psa_request.psa_type, &psa_request.in_vecs)?
}
RSS_VHUK_SERVICE_HANDLE => {
Self::convert_vhuk_request(psa_request.psa_type, &psa_request.in_vecs)?
}
_ => {
println!("Unknown service handle: {}", psa_request.handle);
return Err(CommsError::ServiceHandleError);
}
};
Ok(request)
}
pub(crate) fn read_stream(stream: &mut TcpStream) -> std::io::Result<Option<Vec<u8>>> {
stream.set_read_timeout(None)?;
let mut data = [0u8; 0x1000];
let mut count = stream.read(&mut data)?;
if count == 0 {
return Ok(None);
}
/* ugly, but should work */
stream.set_read_timeout(Some(Duration::from_millis(50)))?;
loop {
let result = stream.read(&mut data[count..]);
if let Err(e) = &result {
if e.kind() == std::io::ErrorKind::WouldBlock {
break;
}
}
let left = result?;
if left > 0 {
count = count + left;
} else {
break;
}
}
stream.set_read_timeout(None)?;
Ok(Some(data[..count].to_vec()))
}
pub fn get_request(&mut self) -> Result<Option<Request>, CommsError> {
let mut stream = self.channel.stream.as_mut().unwrap();
let data = match Self::read_stream(&mut stream)? {
Some(data) => data,
None => return Ok(None),
};
println!("Received {} bytes", data.len());
let psa_request = PSARequest::de(&data)?;
Ok(self.convert_request(psa_request.clone()).map(|r| Some(r))?)
}
fn convert_response(
&mut self,
return_val: i32,
response: Option<Response>,
) -> Result<PSAResponse, CommsError> {
let msg_metadata = self.msg_metadata.take().unwrap();
let mut out_vecs = <[Vec<u8>; PSA_MAX_IOVEC]>::default();
if return_val == 0 {
match response {
Some(Response::GetDAK(dak)) => {
if dak.len() > msg_metadata.response_params[0] {
return Err(CommsError::BufferTooSmall);
}
out_vecs[0] = dak;
}
Some(Response::GetPlatformToken(token)) => {
if token.len() > msg_metadata.response_params[0] {
return Err(CommsError::BufferTooSmall);
}
out_vecs[0] = token;
}
Some(Response::ReadMeasurement(measurement, is_locked)) => {
if measurement.metadata.signer_id.len() > msg_metadata.response_params[1]
|| measurement.value.len() > msg_metadata.response_params[2]
{
return Err(CommsError::BufferTooSmall);
}
let read_response = ReadResponse {
is_locked: is_locked as u8,
measurement_algo: match measurement.metadata.algorithm {
MeasurementType::Sha256 => 0x02000009,
MeasurementType::Sha384 => 0x0200000a,
MeasurementType::Sha512 => 0x0200000b,
},
sw_type: measurement.metadata.sw_type.as_bytes().try_into().unwrap(),
sw_type_len: measurement.metadata.sw_type.len() as u8,
version: measurement
.metadata
.sw_version
.as_bytes()
.try_into()
.unwrap(),
version_len: measurement.metadata.sw_version.len() as u8,
};
out_vecs[0] = read_response.ser()?;
out_vecs[1] = measurement.metadata.signer_id.to_vec();
out_vecs[2] = measurement.value.to_vec();
}
Some(Response::GetVHuk(key)) => {
if key.len() > msg_metadata.response_params[0] {
println!("Key too big for buffer!");
return Err(CommsError::BufferTooSmall);
}
out_vecs[0] = key;
}
None => {
if msg_metadata.response_params[0] != 0 {
println!("No response but client expected some");
return Err(CommsError::ProgrammerError);
}
}
}
}
Ok(PSAResponse {
out_vecs,
client_id: msg_metadata.client_id,
protocol_ver: msg_metadata.protocol_ver,
return_val,
seq_num: msg_metadata.seq_num,
})
}
pub fn send_response(
&mut self,
ret_val: i32,
response: Option<Response>,
) -> Result<(), CommsError> {
let psa_response = self.convert_response(ret_val, response)?;
let data = psa_response.ser()?;
println!("Sending {} bytes", data.len());
self.channel
.stream
.as_ref()
.unwrap()
.write_all(&data)?;
Ok(())
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/key-derivation/src/lib.rs | hes/key-derivation/src/lib.rs | #![no_std]
extern crate alloc;
use aes::cipher::generic_array::GenericArray;
use aes::cipher::{BlockEncrypt, KeyInit};
use aes::Aes256;
use alloc::{vec, vec::Vec};
use core::mem;
use elliptic_curve::ScalarPrimitive;
use p256::U256;
use p384::elliptic_curve::Curve;
use p384::U384;
use sha2::{Digest, Sha256};
/// Derives key material from a symmetric key, some label and input data.
/// Key material is a derived 256-bit symmetric key using counter-mode KDF complying
/// with NIST SP800-108, where the PRF is a combined sha256 hash and an ECB-mode
/// AES encryption.
///
/// # Arguments
///
/// * `input` - A binary data
/// * `input_key` - A 256-bit symmetric input derivation key
/// * `label` - Unique label describing seed purpose
///
pub fn generate_seed(context: &[u8], input_key: &[u8], label: &[u8]) -> Vec<u8> {
let mut state =
vec![0; context.len() + label.len() + mem::size_of::<u8>() + mem::size_of::<u32>() * 2];
let block_index: u32 = 1;
let seed_output_length: u32 = 32;
state[mem::size_of::<u32>()..mem::size_of::<u32>() + label.len()].copy_from_slice(&label);
state[mem::size_of::<u32>() + label.len()
..mem::size_of::<u32>() + label.len() + mem::size_of::<u8>()]
.copy_from_slice(&0u8.to_ne_bytes());
state[mem::size_of::<u32>() + label.len() + mem::size_of::<u8>()
..mem::size_of::<u32>() + label.len() + mem::size_of::<u8>() + context.len()]
.copy_from_slice(&context);
state[mem::size_of::<u32>() + label.len() + mem::size_of::<u8>() + context.len()..]
.copy_from_slice(&seed_output_length.to_ne_bytes());
state[..mem::size_of::<u32>()].copy_from_slice(&block_index.to_ne_bytes());
let mut hasher = Sha256::new();
hasher.update(&state);
let state_hash = hasher.finalize();
let mut seed_buffer = state_hash.to_vec();
let cipher = Aes256::new_from_slice(&input_key).unwrap();
let mut block = GenericArray::from_mut_slice(&mut seed_buffer[..16]);
cipher.encrypt_block(&mut block);
block = GenericArray::from_mut_slice(&mut seed_buffer[16..]);
cipher.encrypt_block(&mut block);
seed_buffer
}
/// Derives a Secp256r1 public key using HKDF(Sha256) on a given key material.
///
/// # Arguments
///
/// * `seed` - input secret key
/// * `info` - info string used in expand step
///
pub fn derive_p256_key(seed: &[u8], info: Option<&[u8]>) -> p256::SecretKey {
let n = p256::NistP256::ORDER;
let bits = n.bits();
let bytes = (bits + 7) / 8;
let n_2 = n.saturating_sub(&U256::from_u32(2));
// RSS never passes salt. And what passes named as salt in reality is an info.
let hk = hkdf::Hkdf::<Sha256>::new(None, seed);
let mut okm = vec![0; bytes];
let mut k;
loop {
hk.expand(
match info {
Some(i) => i,
None => &[],
},
&mut okm,
)
.expect("hkdf could not expand to 42 bytes");
k = U256::from_be_slice(&okm);
if k <= n_2 {
break;
}
}
let private_key_scalar = k.saturating_add(&U256::from_u32(1));
p256::SecretKey::new(ScalarPrimitive::new(private_key_scalar).unwrap())
}
/// Derives a Secp384r1 public key using HKDF(Sha256) on a given key material.
///
/// # Arguments
///
/// * `seed` - input secret key
/// * `info` - info string used in expand step
///
pub fn derive_p384_key(seed: &[u8], info: Option<&[u8]>) -> p384::SecretKey {
let n = p384::NistP384::ORDER;
let bits = n.bits();
let bytes = (bits + 7) / 8;
let n_2 = n.saturating_sub(&U384::from_u32(2));
// RSS never passes salt. And what passes named as salt in reality is an info.
let hk = hkdf::Hkdf::<Sha256>::new(None, seed);
let mut okm = vec![0; bytes];
let mut k;
loop {
hk.expand(
match info {
Some(i) => i,
None => &[],
},
&mut okm,
)
.expect("hkdf could not expand to 42 bytes");
k = U384::from_be_slice(&okm);
if k <= n_2 {
break;
}
}
let private_key_scalar = k.saturating_add(&U384::from_u32(1));
p384::SecretKey::new(ScalarPrimitive::new(private_key_scalar).unwrap())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/hes/cpak-generator/src/main.rs | hes/cpak-generator/src/main.rs | use clap::Parser;
use clean_path::clean;
use p384::pkcs8::{EncodePublicKey, LineEnding};
use std::fs::{self, create_dir_all, File};
use std::io::{Read, Result as IOResult, Write};
use std::mem;
/// Creates a path to a resource file
macro_rules! resource_file {
($fname:expr) => {
// Ugly way to base path on workspace directory
concat!(env!("CARGO_MANIFEST_DIR"), "/../res/", $fname)
};
}
/// Creates a path to a default output dir
macro_rules! default_output_dir {
() => {
// Ugly way to base path on workspace directory
concat!(env!("CARGO_MANIFEST_DIR"), "/../out/")
};
}
/// Program for CPAK generation based on given BL2 hash and GUK
#[derive(Parser, Debug)]
#[command(author, version, long_about = None)]
#[command(
about = "Program for CPAK generation in binary and PEM formats based on given BL2 hash and GUK"
)]
struct Args {
/// Path to binary file with BL2 hash
#[arg(short = 'b', long, value_name = "FILE")]
#[arg(default_value = resource_file!("bl2_signed_hash.bin"))]
hash_file: String,
/// Path to binary file with GUK
#[arg(short, long, value_name = "FILE")]
#[arg(default_value = resource_file!("dummy_guk.bin"))]
guk_file: String,
/// Output directory to save CPAK files
#[arg(short, long, value_name = "DIR")]
#[arg(default_value = default_output_dir!())]
output_dir: String,
}
fn load_binary_file(filename: &str) -> IOResult<Vec<u8>> {
let mut f = File::open(filename)?;
let metadata = fs::metadata(filename)?;
let mut buffer = vec![0; metadata.len() as usize];
f.read(&mut buffer)?;
Ok(buffer)
}
fn save_binary_file(filename: &str, data: &[u8]) -> IOResult<()> {
let filename = clean(&filename);
println!("Saving file {}", filename.display());
let mut f = File::create(filename)?;
f.write_all(data)
}
const PUBLIC_KEY_BIN: &str = "cpak_public.bin";
const PUBLIC_KEY_PEM: &str = "cpak_public.pem";
fn main() -> std::io::Result<()> {
let args = Args::parse();
let bl2_hash = load_binary_file(&args.hash_file)?;
let guk = load_binary_file(&args.guk_file)?;
const CPAK_SEED_LABEL: &[u8] = b"BL1_CPAK_SEED_DERIVATION";
let lcs: u32 = 3;
let reprovisioning_bits: u32 = 0;
let input = bl2_hash.as_slice();
let mut context = Vec::with_capacity(input.len() + mem::size_of::<u32>() * 2);
context.extend(input);
context.extend(&lcs.to_ne_bytes());
context.extend(&reprovisioning_bits.to_ne_bytes());
let seed = key_derivation::generate_seed(&context, &guk, &CPAK_SEED_LABEL);
let public_key = key_derivation::derive_p384_key(&seed, None).public_key();
if args.output_dir == default_output_dir!() {
println!("Creating out dir");
create_dir_all(&args.output_dir).unwrap();
}
save_binary_file(
&format!("{}/{}", args.output_dir.clone(), PUBLIC_KEY_BIN),
&public_key.to_sec1_bytes(),
)?;
save_binary_file(
&format!("{}/{}", args.output_dir.clone(), PUBLIC_KEY_PEM),
&public_key
.to_public_key_pem(LineEnding::LF)
.unwrap()
.as_bytes(),
)?;
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/lib.rs | model-checking/src/lib.rs | mod common;
#[cfg(feature = "mc_rmi_features")]
mod rmi_features;
#[cfg(feature = "mc_rmi_granule_delegate")]
mod rmi_granule_delegate;
#[cfg(feature = "mc_rmi_granule_undelegate")]
mod rmi_granule_undelegate;
#[cfg(feature = "mc_rmi_realm_activate")]
mod rmi_realm_activate;
#[cfg(feature = "mc_rmi_realm_destroy")]
mod rmi_realm_destroy;
#[cfg(feature = "mc_rmi_rec_aux_count")]
mod rmi_rec_aux_count;
#[cfg(feature = "mc_rmi_rec_destroy")]
mod rmi_rec_destroy;
#[cfg(feature = "mc_rmi_version")]
mod rmi_version;
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_rec_destroy.rs | model-checking/src/rmi_rec_destroy.rs | use crate::common::addr_is_granule_aligned;
use crate::common::initialize;
use crate::common::post_granule_state;
use crate::common::post_rec_aux_state;
use crate::common::pre_granule_state;
use crate::common::pre_rec_state;
use islet_rmm::granule::validate_addr;
use islet_rmm::granule::GranuleState;
use islet_rmm::monitor::Monitor;
use islet_rmm::rec::State;
use islet_rmm::rmi;
use islet_rmm::rmi::error::Error;
#[kani::proof]
#[kani::unwind(7)]
fn verify_rec_destroy() {
initialize();
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::REC_DESTROY);
// TODO: check the below again
let rec = regs[1];
// Pre-conditions
let failure_rec_align_pre = !addr_is_granule_aligned(rec);
let failure_rec_bound_pre = !validate_addr(rec);
let failure_rec_gran_state_pre = pre_granule_state(rec) != GranuleState::Rec;
let failure_rec_state_pre = pre_rec_state(rec) == State::Running;
let no_failures_pre = !failure_rec_align_pre
&& !failure_rec_bound_pre
&& !failure_rec_gran_state_pre
&& !failure_rec_state_pre;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
// Failure condition assertions
let prop_failure_rec_align_ante = failure_rec_align_pre;
kani::cover!();
if prop_failure_rec_align_ante {
let failure_rec_align_post = result == Error::RmiErrorInput.into();
let prop_failure_rec_align_cons = failure_rec_align_post;
kani::cover!();
assert!(prop_failure_rec_align_cons);
}
let prop_failure_rec_bound_ante = !failure_rec_align_pre && failure_rec_bound_pre;
kani::cover!();
if prop_failure_rec_bound_ante {
let failure_rec_bound_post = result == Error::RmiErrorInput.into();
let prop_failure_rec_bound_cons = failure_rec_bound_post;
kani::cover!();
assert!(prop_failure_rec_bound_cons);
}
let prop_failure_rec_gran_state_ante =
!failure_rec_align_pre && !failure_rec_bound_pre && failure_rec_gran_state_pre;
kani::cover!();
if prop_failure_rec_gran_state_ante {
let failure_rec_gran_state_post = result == Error::RmiErrorInput.into();
let prop_failure_rec_gran_state_cons = failure_rec_gran_state_post;
kani::cover!();
assert!(prop_failure_rec_gran_state_cons);
}
let prop_failure_rec_state_ante = !failure_rec_align_pre
&& !failure_rec_bound_pre
&& !failure_rec_gran_state_pre
&& failure_rec_state_pre;
kani::cover!();
if prop_failure_rec_state_ante {
let failure_rec_state_post = result == Error::RmiErrorRec.into();
let prop_failure_rec_state_cons = failure_rec_state_post;
kani::cover!();
assert!(prop_failure_rec_state_cons);
}
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = result == rmi::SUCCESS;
kani::cover!();
assert!(prop_result_cons);
}
// Success condition assertions
let prop_success_rec_gran_state_ante = no_failures_pre;
kani::cover!();
if prop_success_rec_gran_state_ante {
let success_rec_gran_state_post = post_granule_state(rec) == GranuleState::Delegated;
let prop_success_rec_gran_state_cons =
success_rec_gran_state_post && result == rmi::SUCCESS;
kani::cover!();
assert!(prop_success_rec_gran_state_cons);
}
let prop_success_rec_aux_state_ante = no_failures_pre;
kani::cover!();
if prop_success_rec_aux_state_ante {
let success_rec_aux_state_post = post_rec_aux_state(rec) == GranuleState::Delegated;
let prop_success_rec_aux_state_cons = success_rec_aux_state_post && result == rmi::SUCCESS;
kani::cover!();
assert!(prop_success_rec_aux_state_cons);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_granule_delegate.rs | model-checking/src/rmi_granule_delegate.rs | use crate::common::addr_is_granule_aligned;
use crate::common::{post_granule_gpt, post_granule_state, pre_granule_gpt, pre_granule_state};
use crate::get_granule;
use islet_rmm::granule::entry::GranuleGpt;
use islet_rmm::granule::validate_addr;
use islet_rmm::granule::GranuleState;
use islet_rmm::monitor::Monitor;
use islet_rmm::rmi;
use islet_rmm::rmi::error::Error;
#[kani::proof]
#[kani::unwind(9)]
fn verify_granule_delegate() {
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::GRANULE_DELEGATE);
// TODO: check the below again
let addr = regs[1];
// Pre-conditions
let failure_gran_align_pre = !addr_is_granule_aligned(addr);
let failure_gran_bound_pre = !validate_addr(addr);
let failure_gran_state_pre = pre_granule_state(addr) != GranuleState::Undelegated;
let failure_gran_gpt_pre = pre_granule_gpt(addr) != GranuleGpt::GPT_NS;
let no_failures_pre = !failure_gran_align_pre
&& !failure_gran_bound_pre
&& !failure_gran_state_pre
&& !failure_gran_gpt_pre;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
// Post conditions have been moved to be inside if statements
// to constrain the conditions in order not to touch the panic in unwrap();
// Failure condition assertions
let prop_failure_gran_align_ante = failure_gran_align_pre;
kani::cover!();
if prop_failure_gran_align_ante {
let failure_gran_align_post = result == Error::RmiErrorInput.into();
let prop_failure_gran_align_cons = failure_gran_align_post;
kani::cover!();
assert!(prop_failure_gran_align_cons);
}
let prop_failure_gran_bound_ante = !failure_gran_align_pre && failure_gran_bound_pre;
kani::cover!();
if prop_failure_gran_bound_ante {
let failure_gran_bound_post = result == Error::RmiErrorInput.into();
let prop_failure_gran_bound_cons = failure_gran_bound_post;
kani::cover!();
assert!(prop_failure_gran_bound_cons);
}
let prop_failure_gran_state_ante =
!failure_gran_align_pre && !failure_gran_bound_pre && failure_gran_state_pre;
kani::cover!();
if prop_failure_gran_state_ante {
let failure_gran_state_post = result == Error::RmiErrorInput.into();
let prop_failure_gran_state_cons = failure_gran_state_post;
kani::cover!();
assert!(prop_failure_gran_state_cons);
}
let prop_failure_gran_gpt_ante = !failure_gran_align_pre
&& !failure_gran_bound_pre
&& !failure_gran_state_pre
&& failure_gran_gpt_pre;
kani::cover!();
if prop_failure_gran_gpt_ante {
let failure_gran_gpt_post = result == Error::RmiErrorInput.into();
let prop_failure_gran_gpt_cons = failure_gran_gpt_post;
kani::cover!();
assert!(prop_failure_gran_gpt_cons);
}
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = result == rmi::SUCCESS;
kani::cover!();
assert!(prop_result_cons);
}
// Success condition assertions
let prop_success_gran_state_ante = no_failures_pre;
kani::cover!();
if prop_success_gran_state_ante {
let success_gran_state_post = post_granule_state(addr) == GranuleState::Delegated;
let prop_success_gran_state_cons = success_gran_state_post && (result == rmi::SUCCESS);
kani::cover!();
assert!(prop_success_gran_state_cons);
}
let prop_success_gran_gpt_ante = no_failures_pre;
kani::cover!();
if prop_success_gran_gpt_ante {
let success_gran_gpt_post = post_granule_gpt(addr) == GranuleGpt::GPT_REALM;
let prop_success_gran_gpt_cons = success_gran_gpt_post && (result == rmi::SUCCESS);
kani::cover!();
assert!(prop_success_gran_gpt_cons);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_realm_activate.rs | model-checking/src/rmi_realm_activate.rs | use crate::common::addr_is_granule_aligned;
use crate::common::initialize;
use crate::common::{post_rd_state, pre_granule_state, pre_rd_state};
use crate::get_granule;
use islet_rmm::granule::validate_addr;
use islet_rmm::granule::GranuleState;
use islet_rmm::monitor::Monitor;
use islet_rmm::realm::rd::Rd;
use islet_rmm::realm::rd::State;
use islet_rmm::rmi;
use islet_rmm::rmi::error::Error;
#[kani::proof]
#[kani::unwind(9)]
fn verify_realm_activate() {
initialize();
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::REALM_ACTIVATE);
// TODO: check the below again
let rd = regs[1];
// Pre-conditions
let failure_rd_align_pre = !addr_is_granule_aligned(rd);
let failure_rd_bound_pre = !validate_addr(rd);
let failure_rd_state_pre = pre_granule_state(rd) != GranuleState::RD;
let failure_realm_state_pre = pre_rd_state(rd) != State::New;
let no_failures_pre = !failure_rd_align_pre
&& !failure_rd_bound_pre
&& !failure_rd_state_pre
&& !failure_realm_state_pre;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
// Failure condition assertions
let prop_failure_rd_align_ante = failure_rd_align_pre;
kani::cover!();
if prop_failure_rd_align_ante {
let failure_rd_align_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_align_cons = failure_rd_align_post;
kani::cover!();
assert!(prop_failure_rd_align_cons);
}
let prop_failure_rd_bound_ante = !failure_rd_align_pre && failure_rd_bound_pre;
kani::cover!();
if prop_failure_rd_bound_ante {
let failure_rd_bound_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_bound_cons = failure_rd_bound_post;
kani::cover!();
assert!(prop_failure_rd_bound_cons);
}
let prop_failure_rd_state_ante =
!failure_rd_align_pre && !failure_rd_bound_pre && failure_rd_state_pre;
kani::cover!();
if prop_failure_rd_state_ante {
let failure_rd_state_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_state_cons = failure_rd_state_post;
kani::cover!();
assert!(prop_failure_rd_state_cons);
}
let prop_failure_realm_state_ante = !failure_rd_align_pre
&& !failure_rd_bound_pre
&& !failure_rd_state_pre
&& failure_realm_state_pre;
kani::cover!();
if prop_failure_realm_state_ante {
let failure_realm_state_post = result == Error::RmiErrorRealm(0).into();
let prop_failure_realm_state_cons = failure_realm_state_post;
kani::cover!();
assert!(prop_failure_realm_state_cons);
}
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = result == rmi::SUCCESS;
kani::cover!();
assert!(prop_result_cons);
}
// Success condition assertions
let prop_success_realm_state_ante = no_failures_pre;
kani::cover!();
if prop_success_realm_state_ante {
let success_realm_state_post = post_rd_state(rd) == State::Active;
let prop_success_realm_state_cons = success_realm_state_post && result == rmi::SUCCESS;
kani::cover!();
assert!(prop_success_realm_state_cons);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_rec_aux_count.rs | model-checking/src/rmi_rec_aux_count.rs | use crate::common::addr_is_granule_aligned;
use crate::common::{post_rd_state, pre_granule_state, pre_rd_state};
use islet_rmm::granule::validate_addr;
use islet_rmm::granule::GranuleState;
use islet_rmm::monitor::Monitor;
use islet_rmm::rmi;
use islet_rmm::rmi::error::Error;
#[kani::proof]
#[kani::unwind(9)]
fn verify_rec_aux_count() {
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::REC_AUX_COUNT);
// TODO: check the below again
let rd = regs[1];
// Pre-conditions
let failure_rd_align_pre = !addr_is_granule_aligned(rd);
let failure_rd_bound_pre = !validate_addr(rd);
let failure_rd_state_pre = pre_granule_state(rd) != GranuleState::RD;
let no_failures_pre = !failure_rd_align_pre && !failure_rd_bound_pre && !failure_rd_state_pre;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
let aux_count = out[1];
// Failure condition assertions
let prop_failure_rd_align_ante = failure_rd_align_pre;
kani::cover!();
if prop_failure_rd_align_ante {
let failure_rd_align_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_align_cons = failure_rd_align_post;
kani::cover!();
assert!(prop_failure_rd_align_cons);
}
let prop_failure_rd_bound_ante = !failure_rd_align_pre && failure_rd_bound_pre;
kani::cover!();
if prop_failure_rd_bound_ante {
let failure_rd_bound_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_bound_cons = failure_rd_bound_post;
kani::cover!();
assert!(prop_failure_rd_bound_cons);
}
let prop_failure_rd_state_ante =
!failure_rd_align_pre && !failure_rd_bound_pre && failure_rd_state_pre;
kani::cover!();
if prop_failure_rd_state_ante {
let failure_rd_state_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_state_cons = failure_rd_state_post;
kani::cover!();
assert!(prop_failure_rd_state_cons);
}
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = result == rmi::SUCCESS;
kani::cover!();
assert!(prop_result_cons);
}
// Success condition assertions
let prop_success_aux_count_ante = no_failures_pre;
kani::cover!();
if prop_success_aux_count_ante {
let success_aux_count_post = aux_count == rmi::MAX_REC_AUX_GRANULES;
let prop_success_aux_count_cons = success_aux_count_post && result == rmi::SUCCESS;
kani::cover!();
assert!(prop_success_aux_count_cons);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_version.rs | model-checking/src/rmi_version.rs | use islet_rmm::monitor::Monitor;
use islet_rmm::rmi;
#[kani::proof]
#[kani::unwind(4)]
fn verify_version() {
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::VERSION);
// Pre-conditions
let no_failures_pre = true;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
let lower = out[1];
let higher = out[2];
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = (lower == (rmi::ABI_MAJOR_VERSION << 16) | rmi::ABI_MINOR_VERSION)
&& (higher == (rmi::ABI_MAJOR_VERSION << 16) | rmi::ABI_MINOR_VERSION);
kani::cover!();
assert!(prop_result_cons);
}
kani::cover!();
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_realm_destroy.rs | model-checking/src/rmi_realm_destroy.rs | use crate::common::addr_is_granule_aligned;
use crate::common::initialize;
use crate::common::{post_granule_state, post_rtt_state, pre_granule_state, pre_realm_is_live};
use islet_rmm::granule::validate_addr;
use islet_rmm::granule::GranuleState;
use islet_rmm::monitor::Monitor;
use islet_rmm::rmi;
use islet_rmm::rmi::error::Error;
#[kani::proof]
#[kani::unwind(7)]
fn verify_realm_destroy() {
initialize();
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::REALM_DESTROY);
// TODO: check the below again
let rd = regs[1];
// Pre-conditions
let failure_rd_align_pre = !addr_is_granule_aligned(rd);
let failure_rd_bound_pre = !validate_addr(rd);
let failure_rd_state_pre = pre_granule_state(rd) != GranuleState::RD;
let failure_realm_live_pre = pre_realm_is_live(rd);
let no_failures_pre = !failure_rd_align_pre
&& !failure_rd_bound_pre
&& !failure_rd_state_pre
&& !failure_realm_live_pre;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
// Failure condition assertions
let prop_failure_rd_align_ante = failure_rd_align_pre;
kani::cover!();
if prop_failure_rd_align_ante {
let failure_rd_align_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_align_cons = failure_rd_align_post;
kani::cover!();
assert!(prop_failure_rd_align_cons);
}
let prop_failure_rd_bound_ante = !failure_rd_align_pre && failure_rd_bound_pre;
kani::cover!();
if prop_failure_rd_bound_ante {
let failure_rd_bound_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_bound_cons = failure_rd_bound_post;
kani::cover!();
assert!(prop_failure_rd_bound_cons);
}
let prop_failure_rd_state_ante =
!failure_rd_align_pre && !failure_rd_bound_pre && failure_rd_state_pre;
kani::cover!();
if prop_failure_rd_state_ante {
let failure_rd_state_post = result == Error::RmiErrorInput.into();
let prop_failure_rd_state_cons = failure_rd_state_post;
kani::cover!();
assert!(prop_failure_rd_state_cons);
}
let prop_failure_realm_live_ante = !failure_rd_align_pre
&& !failure_rd_bound_pre
&& !failure_rd_state_pre
&& failure_realm_live_pre;
kani::cover!();
if prop_failure_realm_live_ante {
let failure_realm_live_post = result == Error::RmiErrorRealm(0).into();
let prop_failure_realm_live_cons = failure_realm_live_post;
kani::cover!();
assert!(prop_failure_realm_live_cons);
}
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = result == rmi::SUCCESS;
kani::cover!();
assert!(prop_result_cons);
}
// Success condition assertions
let prop_success_rtt_state_ante = no_failures_pre;
kani::cover!();
if prop_success_rtt_state_ante {
let success_rtt_state_post = post_rtt_state(rd) == GranuleState::Delegated;
let prop_success_rtt_state_cons = success_rtt_state_post && result == rmi::SUCCESS;
kani::cover!();
assert!(prop_success_rtt_state_cons);
}
let prop_success_rd_state_ante = no_failures_pre;
kani::cover!();
if prop_success_rd_state_ante {
let success_rd_state_post = post_granule_state(rd) == GranuleState::Delegated;
let prop_success_rd_state_cons = success_rd_state_post && result == rmi::SUCCESS;
kani::cover!();
assert!(prop_success_rd_state_cons);
}
// TODO: add prop_sucess_vmid_ante
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/common.rs | model-checking/src/common.rs | use islet_rmm::granule::array::{GRANULE_REGION, GRANULE_SIZE};
use islet_rmm::granule::entry::GranuleGpt;
use islet_rmm::granule::validate_addr;
use islet_rmm::realm::rd::Rd;
use islet_rmm::realm::rd::State; // tmp
use islet_rmm::rec::Rec;
use islet_rmm::rec::State as RecState;
extern "C" {
fn CPROVER_havoc_object(address: usize);
}
#[macro_export]
// DIFF: `islet_rmm` is used to find the names outside the `islet_rmm` crate
// [before]
// use crate::granule::array::{GRANULE_STATUS_TABLE, GRANULE_STATUS_TABLE_SIZE};
// [after]
// use islet_rmm::granule::array::{GRANULE_STATUS_TABLE, GRANULE_STATUS_TABLE_SIZE};
macro_rules! get_granule {
($addr:expr) => {{
use islet_rmm::granule::array::{GRANULE_STATUS_TABLE, GRANULE_STATUS_TABLE_SIZE};
use islet_rmm::granule::{granule_addr_to_index, validate_addr};
use islet_rmm::rmi::error::Error;
if !validate_addr($addr) {
Err(Error::RmiErrorInput)
} else {
let idx = granule_addr_to_index($addr);
if idx >= GRANULE_STATUS_TABLE_SIZE {
Err(Error::RmiErrorInput)
} else {
let gst = &GRANULE_STATUS_TABLE;
match gst.entries[idx].lock() {
Ok(guard) => Ok(guard),
Err(e) => Err(e),
}
}
}
}};
}
// TODO: find an object to which life should be bound
fn content_mut<T>(addr: usize) -> &'static mut T {
unsafe { &mut *(addr as *mut T) }
}
// TODO: find an object to which life should be bound
fn content<T>(addr: usize) -> &'static T {
unsafe { &*(addr as *const T) }
}
pub fn addr_is_granule_aligned(addr: usize) -> bool {
addr % GRANULE_SIZE == 0
}
// This should be exclusively used by pre-condition
// to retrieve a granule's state value.
// `unwrap()` is not called to avoid a panic condition.
pub fn pre_granule_state(addr: usize) -> u8 {
let gran_state_res = get_granule!(addr).map(|guard| guard.state());
let gran_state = if let Ok(state) = gran_state_res {
state
} else {
kani::any()
};
gran_state
}
// This should be exclusively used by post-condition
// to retrieve a granule's state value.
// `unwrap()` is guaranteed not to be reached.
pub fn post_granule_state(addr: usize) -> u8 {
get_granule!(addr).map(|guard| guard.state()).unwrap()
}
// This should be exclusively used by pre-condition
// to retrieve a granule's gpt value.
// `unwrap()` is not called to avoid a panic condition.
pub fn pre_granule_gpt(addr: usize) -> GranuleGpt {
let gran_gpt_res = get_granule!(addr).map(|guard| guard.gpt);
let gran_gpt = if let Ok(gpt) = gran_gpt_res {
gpt
} else {
kani::any()
};
gran_gpt
}
// This should be exclusively used by post-condition
// to retrieve a granule's gpt value.
// `unwrap()` is guaranteed not to be reached.
pub fn post_granule_gpt(addr: usize) -> GranuleGpt {
get_granule!(addr).map(|guard| guard.gpt).unwrap()
}
fn pre_valid_addr(addr: usize) -> usize {
let indexed_addr = get_granule!(addr).map(|guard| guard.index_to_addr());
let valid_addr = if let Ok(addr) = indexed_addr {
addr
} else {
let addr = kani::any();
kani::assume(validate_addr(addr));
addr
};
valid_addr
}
pub fn pre_rd_state(addr: usize) -> State {
let valid_addr = pre_valid_addr(addr);
let rd = content_mut::<Rd>(valid_addr);
rd.state()
}
pub fn post_rd_state(addr: usize) -> State {
let valid_addr = get_granule!(addr)
.map(|guard| guard.index_to_addr())
.unwrap();
let rd = content::<Rd>(valid_addr);
rd.state()
}
pub fn post_rtt_state(addr: usize) -> u8 {
let valid_addr = pre_valid_addr(addr);
let rd = content::<Rd>(valid_addr);
// XXX: we currently check only the first entry to
// reduce the overall verification time
let rtt_base = rd.rtt_base();
post_granule_state(rtt_base)
}
pub fn pre_realm_is_live(addr: usize) -> bool {
let res = get_granule!(addr).map(|guard| guard.num_children());
let rd_num_children = if let Ok(v) = res { v } else { kani::any() };
let valid_addr = pre_valid_addr(addr);
let rd = content::<Rd>(valid_addr);
// XXX: we currently check only the first entry to
// reduce the overall verification time
let rtt_base = rd.rtt_base();
let rtt_res = get_granule!(rtt_base).map(|guard| guard.num_children());
let rtt_num_children = if let Ok(v) = rtt_res { v } else { kani::any() };
rd_num_children > 0 || rtt_num_children > 0
}
pub fn pre_rec_state(addr: usize) -> RecState {
let valid_addr = pre_valid_addr(addr);
let rec = content::<Rec>(valid_addr);
rec.get_state()
}
pub fn post_rec_aux_state(addr: usize) -> u8 {
let valid_addr = pre_valid_addr(addr);
let rec = content::<Rec>(valid_addr);
// XXX: we currently check only the first entry to
// reduce the overall verification time
let rec_aux = rec.aux(0) as usize;
post_granule_state(rec_aux)
}
pub fn initialize() {
unsafe {
CPROVER_havoc_object(GRANULE_REGION.as_ptr() as usize);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_features.rs | model-checking/src/rmi_features.rs | use islet_rmm::monitor::Monitor;
use islet_rmm::rmi;
#[kani::proof]
#[kani::unwind(4)]
fn verify_features() {
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::FEATURES);
// TODO: check the below again
let index = regs[1];
// Pre-conditions
let no_failures_pre = true;
let success_index_pre = index != 0;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
let value = out[1];
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = result == rmi::SUCCESS;
kani::cover!();
assert!(prop_result_cons);
}
// Success condition assertions
let prop_success_index_ante = no_failures_pre && success_index_pre;
kani::cover!();
if prop_success_index_ante {
let success_index_post = value == 0;
let prop_success_index_cons = success_index_post && (result == rmi::SUCCESS);
kani::cover!();
assert!(prop_success_index_cons);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/model-checking/src/rmi_granule_undelegate.rs | model-checking/src/rmi_granule_undelegate.rs | use crate::common::addr_is_granule_aligned;
use crate::common::initialize;
use crate::common::{post_granule_gpt, post_granule_state, pre_granule_state};
use crate::get_granule;
use islet_rmm::granule::entry::GranuleGpt;
use islet_rmm::granule::validate_addr;
use islet_rmm::granule::GranuleState;
use islet_rmm::monitor::Monitor;
use islet_rmm::rmi;
use islet_rmm::rmi::error::Error;
#[kani::proof]
#[kani::unwind(9)]
fn verify_granule_undelegate() {
initialize();
// Initialize registers (symbolic input)
let regs: [usize; 8] = kani::any();
kani::assume(regs[0] == rmi::GRANULE_UNDELEGATE);
// TODO: check the below again
let addr = regs[1];
// Pre-conditions
let failure_gran_align_pre = !addr_is_granule_aligned(addr);
let failure_gran_bound_pre = !validate_addr(addr);
let failure_gran_state_pre = pre_granule_state(addr) != GranuleState::Delegated;
let no_failures_pre =
!failure_gran_align_pre && !failure_gran_bound_pre && !failure_gran_state_pre;
// Execute command and read the result.
let out = Monitor::new().run(regs);
let result = out[0];
// Post conditions have been moved to be inside if statements
// to constrain the conditions in order not to touch the panic in unwrap();
// Failure condition assertions
let prop_failure_gran_align_ante = failure_gran_align_pre;
kani::cover!();
if prop_failure_gran_align_ante {
let failure_gran_align_post = result == Error::RmiErrorInput.into();
let prop_failure_gran_align_cons = failure_gran_align_post;
kani::cover!();
assert!(prop_failure_gran_align_cons);
}
let prop_failure_gran_bound_ante = !failure_gran_align_pre && failure_gran_bound_pre;
kani::cover!();
if prop_failure_gran_bound_ante {
let failure_gran_bound_post = result == Error::RmiErrorInput.into();
let prop_failure_gran_bound_cons = failure_gran_bound_post;
kani::cover!();
assert!(prop_failure_gran_bound_cons);
}
let prop_failure_gran_state_ante =
!failure_gran_align_pre && !failure_gran_bound_pre && failure_gran_state_pre;
kani::cover!();
if prop_failure_gran_state_ante {
let failure_gran_state_post = result == Error::RmiErrorInput.into();
let prop_failure_gran_state_cons = failure_gran_state_post;
kani::cover!();
assert!(prop_failure_gran_state_cons);
}
// Result assertion
let prop_result_ante = no_failures_pre;
kani::cover!();
if prop_result_ante {
let prop_result_cons = result == rmi::SUCCESS;
kani::cover!();
assert!(prop_result_cons);
}
// Success condition assertions
let prop_success_gran_gpt_ante = no_failures_pre;
kani::cover!();
if prop_success_gran_gpt_ante {
let success_gran_gpt_post = post_granule_gpt(addr) == GranuleGpt::GPT_NS;
let prop_success_gran_gpt_cons = success_gran_gpt_post && (result == rmi::SUCCESS);
kani::cover!();
assert!(prop_success_gran_gpt_cons);
}
let prop_success_gran_state_ante = no_failures_pre;
kani::cover!();
if prop_success_gran_state_ante {
let success_gran_state_post = post_granule_state(addr) == GranuleState::Undelegated;
let prop_success_gran_state_cons = success_gran_state_post && (result == rmi::SUCCESS);
kani::cover!();
assert!(prop_success_gran_state_cons);
}
let prop_success_gran_content_ante = no_failures_pre;
kani::cover!();
if prop_success_gran_content_ante {
let success_gran_content = get_granule!(addr)
.map(|guard| guard.index_to_addr())
.unwrap();
// check the first byte to reduce the proof overhead
let success_gran_content_post = unsafe { *(success_gran_content as *const u8) } == 0;
let prop_success_gran_content_cons = success_gran_content_post && (result == rmi::SUCCESS);
kani::cover!();
assert!(prop_success_gran_content_cons);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/plat/build.rs | plat/build.rs | use std::env;
fn main() {
let platform = env::var("PLATFORM").unwrap_or_else(|_| {
"fvp".to_string()
//panic!("Please set the PLATFORM environment variable (e.g., PLATFORM=fvp)")
});
let memory_file = format!("plat/{}/memory.x", platform);
println!("cargo:rustc-link-arg=-T{}", memory_file);
println!("cargo:rustc-cfg=plat_{}", platform);
// Re-run build if platform or memory.x changes
println!("cargo:rerun-if-env-changed=PLATFORM");
println!("cargo:rerun-if-changed={}", memory_file);
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/plat/src/plat.rs | plat/src/plat.rs | #[cfg(any(feature = "fvp", not(feature = "qemu")))]
include!("../fvp/plat.rs");
#[cfg(feature = "qemu")]
include!("../qemu/plat.rs");
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/plat/src/main.rs | plat/src/main.rs | #![no_std]
#![no_main]
#![warn(rust_2018_idioms)]
#![deny(warnings)]
#[macro_use]
extern crate log;
mod entry;
mod plat;
use islet_rmm::allocator;
use islet_rmm::config::PlatformMemoryLayout;
use islet_rmm::cpu;
extern "C" {
static __RMM_BASE__: u64;
static __RW_START__: u64;
static __RW_END__: u64;
static __RMM_STACK_BASE__: u64;
}
#[no_mangle]
pub unsafe fn main(x0: u64, x1: u64, x2: u64, x3: u64) -> ! {
let cpuid: usize = x0 as usize;
// Do not print here until MMU is turned on, except on cpu0.
// Cores other than cpu0 at this point are still in its mmu
// off state with d-cache disabled and i-cache enabled.
// This may cause incosistencies between cpus with mmu enabled
// and cpus with mmu disabled.
// Logging involves buffer allocation and its internal data struct
// for heap (linked_list) could be corrupted due to the reason above.
if x0 == 0 {
info!(
"boot args: x0:0x{:X}, x1:0x{:X}, x2:0x{:X}, x3:0x{:X}",
x0, x1, x2, x3
);
}
if cpuid != cpu::get_cpu_id() {
panic!(
"x0:{:X} != cpu::get_cput_id()(=={:X})",
cpuid,
cpu::get_cpu_id()
);
}
let layout = unsafe {
PlatformMemoryLayout {
rmm_base: &__RMM_BASE__ as *const u64 as u64,
rw_start: &__RW_START__ as *const u64 as u64,
rw_end: &__RW_END__ as *const u64 as u64,
stack_base: &__RMM_STACK_BASE__ as *const u64 as u64,
uart_phys: plat::UART_BASE as u64,
el3_shared_buf: x3,
}
};
islet_rmm::start(cpuid, layout);
panic!("failed to run the mainloop");
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/plat/src/entry.rs | plat/src/entry.rs | use crate::allocator;
use crate::log::LevelFilter;
use aarch64_cpu::registers::*;
use core::ptr::{addr_of, addr_of_mut};
use io::stdout;
use islet_rmm::config::{NUM_OF_CPU, RMM_STACK_GUARD_SIZE, RMM_STACK_SIZE};
use islet_rmm::logger;
use crate::plat;
/// Configure the first page of the stack section as a stack guard page
#[no_mangle]
#[link_section = ".stack"]
static mut RMM_STACK: [[u8; RMM_STACK_SIZE + RMM_STACK_GUARD_SIZE]; NUM_OF_CPU] =
[[0; RMM_STACK_SIZE + RMM_STACK_GUARD_SIZE]; NUM_OF_CPU];
/// # Safety
///
/// This function only reads the address of the stack.
#[no_mangle]
pub unsafe extern "C" fn current_cpu_stack(cpu_id: usize) -> usize {
if cpu_id >= NUM_OF_CPU {
panic!("Invalid CPU ID!");
}
&RMM_STACK[cpu_id] as *const u8 as usize + RMM_STACK_SIZE
}
// Entrypoint boot args
// x0 : CPUID
// x1 : Version for this Boot interface
// x2 : platform core count
// x3 : Base address for the EL3 <-> RMM shared area
#[unsafe(naked)]
#[link_section = ".head.text"]
#[no_mangle]
unsafe extern "C" fn rmm_entry() -> ! {
core::arch::naked_asm!(
"
// save boot args to preserved registers (x20-x23)
mov x20, x0 // CPUID
mov x21, x1 // Version
mov x22, x2 // Core count
mov x23, x3 // Shared area address
msr spsel, #1
bl current_cpu_stack
mov sp, x0
// save boot args to the initialized stack
stp x20, x21, [sp, #-16]!
stp x22, x23, [sp, #-16]!
bl setup
1:
// restore boot args
ldp x2, x3, [sp], #16
ldp x0, x1, [sp], #16
bl main
b 1b"
)
}
extern "C" {
static __BSS_START__: usize;
static __BSS_SIZE__: usize;
}
unsafe fn clear_bss() {
let bss = core::slice::from_raw_parts_mut(
&__BSS_START__ as *const usize as *mut u64,
&__BSS_SIZE__ as *const usize as usize / core::mem::size_of::<u64>(),
);
bss.fill(0);
}
pub fn init_console() {
let _ = stdout().attach(uart::pl011::device(plat::UART_BASE));
logger::register_global_logger(LevelFilter::Trace); // Control log level
info!("Initialized the console!");
}
/// Initialize the memory management configuration.
/// This function is called once in cold boot.
unsafe fn init_mm() {
// Assert 4KB granules are supported.
assert_eq!(
ID_AA64MMFR0_EL1.read(ID_AA64MMFR0_EL1::TGran4),
0,
"4KB granules are not supported"
);
// Assert ID_AA64MMFR0_EL1::PARange
let pa_bits_table = [32, 36, 40, 42, 44, 48, 52];
let pa = ID_AA64MMFR0_EL1.read(ID_AA64MMFR0_EL1::PARange) as usize;
let pa_range = pa_bits_table[pa]; // Panic if pa > 6
info!("pa range is {}", pa_range);
}
#[no_mangle]
#[allow(unused)]
unsafe fn setup() {
static mut COLD_BOOT: bool = true;
if (addr_of!(COLD_BOOT) as *const bool).read_volatile() {
clear_bss();
allocator::init();
init_console();
init_mm();
(addr_of_mut!(COLD_BOOT) as *mut bool).write_volatile(false);
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/plat/qemu/plat.rs | plat/qemu/plat.rs | // TODO: get these from the manifest provided by el3 on rmm's entry
pub const UART_BASE: usize = 0x900_0000;
//pub const UART_BAUDRATE: usize = 115200;
//pub const UART_CLK_IN_HZ: usize = 1;
// Last page of Realm PAS assigned to RMM contains manifest written by EL3
//pub const EL3_SHARED_BUF: u64 = 0x428F_F000;
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/plat/fvp/plat.rs | plat/fvp/plat.rs | // TODO: get these from the manifest provided by el3 on rmm's entry
pub const UART_BASE: usize = 0x1C0C_0000;
//pub const UART_BAUDRATE: usize = 115200;
//pub const UART_CLK_IN_HZ: usize = 24000000;
// Last page of Realm PAS assigned to RMM contains manifest written by EL3
// pub const EL3_SHARED_BUF: u64 = 0xFFBFF000;
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/examples/veraison/reliant-party/src/main.rs | examples/veraison/reliant-party/src/main.rs | use clap::Parser;
use realm_verifier::{
parser_json::parse_value,
RealmVerifier,
};
use std::{error::Error, fs::File, io::{Read, BufReader}, sync::Arc};
use ratls::{ChainVerifier, RaTlsServer};
use veraison_verifier::VeraisonTokenVerifer;
use log::{error, info};
/// Creates a path to a resource file
macro_rules! resource_file {
($fname:expr) => {
concat!(env!("CARGO_MANIFEST_DIR"), "/res/", $fname)
};
}
#[derive(Debug, Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
/// RaTls server bind address
#[arg(short = 'b', long, default_value = "0.0.0.0:1337")]
server_bind_address: String,
/// JSON containing reference values
#[arg(short, long, value_name = "FILE",
default_value = resource_file!("example.json"))]
reference_json: String,
/// Path to server cert
#[arg(short = 'c', long, value_name = "FILE",
default_value = resource_file!("cert/server.crt"))]
server_cert: String,
/// Path to server private key
#[arg(short = 'k', long, value_name = "FILE",
default_value = resource_file!("cert/server.key"))]
server_privkey: String,
/// Veraison verification service host
#[arg(short = 'v', long, default_value = "https://localhost:8080")]
veraison_url: String,
/// Veraisons public key to verify attestation results
#[arg(short = 'p', long, default_value = resource_file!("keys/pkey.jwk"))]
veraison_pubkey: String,
}
fn main() -> Result<(), Box<dyn Error>> {
env_logger::init();
let args = Cli::parse();
let json_reader = BufReader::new(File::open(args.reference_json)?);
let mut reference_json: serde_json::Value = serde_json::from_reader(json_reader)?;
let reference_measurements = parse_value(reference_json["realm"]["reference-values"].take())?;
let mut pubkey = String::new();
let mut file = File::open(args.veraison_pubkey).map_err(|e| {
error!("Failed to open veraison pubkey file: {:?}", e);
e
})?;
file.read_to_string(&mut pubkey)?;
let server = RaTlsServer::new(ratls::ServerMode::AttestedClient {
client_token_verifier: Arc::new(ChainVerifier::new(vec![
Arc::new(VeraisonTokenVerifer::new(args.veraison_url, pubkey, None).unwrap()),
Arc::new(RealmVerifier::init(reference_measurements)),
])),
server_certificate_path: args.server_cert,
server_privatekey_path: args.server_privkey,
})?;
let mut conn_iter = server.connections(args.server_bind_address)?;
loop {
info!("Awaiting connection");
let conn_iter_next = conn_iter.next();
if conn_iter_next.is_none() {
break;
}
match conn_iter_next.unwrap() {
Ok(mut conn) => {
info!("New connection accepted");
let mut buf = Vec::new();
buf.resize(0x100, 0u8);
while let Ok(len) = conn.stream().read(&mut buf) {
info!(
"Message from client: {:?}",
String::from_utf8(buf[0..len].to_vec())?
);
}
info!("Connection closed");
}
Err(e) => {
error!("Connection failed: {:?}", e);
}
}
}
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/examples/veraison/realm-application/src/resolver.rs | examples/veraison/realm-application/src/resolver.rs | use ratls::{InternalTokenResolver, RaTlsError};
#[derive(Debug)]
pub struct IoctlTokenResolver();
impl InternalTokenResolver for IoctlTokenResolver
{
fn resolve(&self, challenge: &[u8]) -> Result<Vec<u8>, RaTlsError> {
if challenge.len() != rust_rsi::CHALLENGE_LEN as usize {
return Err(RaTlsError::GenericTokenResolverError("Challange needs to be exactly 64 bytes".into()));
}
match rust_rsi::attestation_token(&challenge.try_into().unwrap())
{
Err(e) => Err(RaTlsError::GenericTokenResolverError(Box::new(e))),
Ok(v) => Ok(v),
}
}
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/examples/veraison/realm-application/src/main.rs | examples/veraison/realm-application/src/main.rs | mod resolver;
use clap::Parser;
use ratls::RaTlsClient;
use std::{io::Write, sync::Arc};
#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Cli
{
/// Path to root CA cert
#[arg(short, long)]
root_ca: String,
/// Url to ratls server
#[arg(short = 'u', long, default_value = "localhost:1337")]
server_url: String,
/// Server name, overriden if server is attested
#[clap(short = 'n', long, default_value = "localhost")]
server_name: String,
}
fn main() -> Result<(), Box<dyn std::error::Error>>
{
ratls::init_logger();
let cli = Cli::parse();
let client = RaTlsClient::new(ratls::ClientMode::AttestedClient {
client_token_resolver: Arc::new(resolver::IoctlTokenResolver()),
root_ca_path: cli.root_ca.to_string()
})?;
let mut connection = client.connect(cli.server_url.to_string(), cli.server_name.to_string())?;
println!("Connection established");
write!(connection.stream(), "GIT")?;
println!("Work finished, exiting");
Ok(())
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/lib/uart/src/lib.rs | lib/uart/src/lib.rs | #![no_std]
#![warn(rust_2018_idioms)]
#![deny(warnings)]
pub mod pl011;
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/lib/uart/src/pl011.rs | lib/uart/src/pl011.rs | extern crate alloc;
use alloc::boxed::Box;
use spinning_top::Spinlock;
use io::{self, ConsoleWriter, Error, ErrorKind, Result, Write};
const CLK_IN_HZ: usize = 24000000;
const BAUDRATE: usize = 115200;
const REG_LEN: isize = core::mem::size_of::<u32>() as isize;
const UARTDR: isize = 0x000 / REG_LEN;
#[allow(dead_code)]
const UARTRSR: isize = 0x004 / REG_LEN;
const UARTECR: isize = 0x004 / REG_LEN;
#[allow(dead_code)]
const UARTFR: isize = 0x018 / REG_LEN;
#[allow(dead_code)]
const UARTIMSC: isize = 0x038 / REG_LEN;
#[allow(dead_code)]
const UARTRIS: isize = 0x03C / REG_LEN;
#[allow(dead_code)]
const UARTICR: isize = 0x044 / REG_LEN;
#[allow(dead_code)]
const UARTILPR: isize = 0x020 / REG_LEN;
const UARTIBRD: isize = 0x024 / REG_LEN;
const UARTFBRD: isize = 0x028 / REG_LEN;
const UARTLCR_H: isize = 0x02C / REG_LEN;
const UARTCR: isize = 0x030 / REG_LEN;
#[allow(dead_code)]
const UARTIFLS: isize = 0x034 / REG_LEN;
#[allow(dead_code)]
const UARTMIS: isize = 0x040 / REG_LEN;
#[allow(dead_code)]
const UARTDMACR: isize = 0x048 / REG_LEN;
const UARTFR_TXFF: u32 = 1 << 5;
#[allow(dead_code)]
enum UARTCR {
CTSEN = 1 << 15, /* CTS hardware flow control enable */
RTSEN = 1 << 14, /* RTS hardware flow control enable */
RTS = 1 << 11, /* Request to send */
DTR = 1 << 10, /* Data transmit ready. */
RXE = 1 << 9, /* Receive enable */
TXE = 1 << 8, /* Transmit enable */
LBE = 1 << 7, /* Loopback enable */
EN = 1 << 0, /* UART Enable */
}
#[allow(dead_code)]
#[allow(non_camel_case_types)]
enum UARTLCR_H {
SPS = 1 << 7, /* Stick parity select */
WLEN_8 = 3 << 5,
WLEN_7 = 2 << 5,
WLEN_6 = 1 << 5,
WLEN_5 = 0 << 5,
FEN = 1 << 4, /* FIFOs Enable */
STP2 = 1 << 3, /* Two stop bits select */
EPS = 1 << 2, /* Even parity select */
PEN = 1 << 1, /* Parity Enable */
BRK = 1 << 0, /* Send break */
}
const LINE_CONTROL: u32 = UARTLCR_H::FEN as u32 | UARTLCR_H::WLEN_8 as u32;
struct DeviceInner {
register: *mut u32,
ready: bool,
}
impl DeviceInner {
pub const fn new() -> Self {
Self {
register: 0 as *mut u32,
ready: false,
}
}
pub fn set_base(&mut self, base: usize) {
self.register = base as *mut u32;
}
pub fn putc(&mut self, byte: u8) -> Result<()> {
if self.ready {
unsafe {
while self.register.offset(UARTFR).read_volatile() & UARTFR_TXFF != 0 {}
self.register.offset(UARTDR).write_volatile(byte as u32);
}
Ok(())
} else {
Err(Error::new(ErrorKind::NotConnected))
}
}
}
impl io::Device for DeviceInner {
fn initialized(&self) -> bool {
self.ready
}
fn initialize(&mut self) -> Result<()> {
if !self.ready {
unsafe {
//Disable uart before programming
self.register.offset(UARTCR).write_volatile(
self.register.offset(UARTCR).read_volatile() & !(UARTCR::EN as u32),
);
//Program the baudrate
let divisor = (CLK_IN_HZ << 2) / BAUDRATE;
let ibrd = (divisor >> 6) as u32;
self.register.offset(UARTIBRD).write_volatile(ibrd);
//Write the FBRD
let fbrd = (ibrd & 0x3f) as u32;
self.register.offset(UARTFBRD).write_volatile(fbrd);
self.register.offset(UARTLCR_H).write_volatile(LINE_CONTROL);
//Clear any pending errors
self.register.offset(UARTECR).write_volatile(0);
//Enable tx, rx, and uart overall */
self.register
.offset(UARTCR)
.write_volatile(UARTCR::RXE as u32 | UARTCR::TXE as u32 | UARTCR::EN as u32);
}
self.ready = true;
Ok(())
} else {
Err(Error::new(ErrorKind::AlreadyExists))
}
}
}
impl Write for DeviceInner {
fn write_all(&mut self, buf: &[u8]) -> Result<()> {
for byte in buf {
//Prepand '\r' to '\n'
if *byte == 0xa {
self.putc(0xd)?;
}
self.putc(*byte)?;
}
Ok(())
}
}
unsafe impl Send for DeviceInner {}
static DEVICE_INNER: Spinlock<DeviceInner> = Spinlock::new(DeviceInner::new());
pub struct Device(usize);
impl io::Device for Device {
fn initialized(&self) -> bool {
DEVICE_INNER.lock().initialized()
}
fn initialize(&mut self) -> Result<()> {
DEVICE_INNER.lock().set_base(self.0);
DEVICE_INNER.lock().initialize()
}
}
impl Write for Device {
fn write_all(&mut self, buf: &[u8]) -> Result<()> {
DEVICE_INNER.lock().write_all(buf)
}
}
impl ConsoleWriter for Device {}
pub fn device(base: usize) -> Box<Device> {
Box::new(Device(base))
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
islet-project/islet | https://github.com/islet-project/islet/blob/5f541377a34c5daaf01aa148e406370e304fb661/lib/armv9a/src/lib.rs | lib/armv9a/src/lib.rs | #![no_std]
#![warn(rust_2018_idioms)]
#![deny(warnings)]
#[macro_use]
pub mod r#macro;
pub mod regs;
pub use regs::pmu::*;
pub use regs::*;
pub use tock_registers::registers::InMemoryRegister;
pub const fn bits_in_reg(mask: u64, val: u64) -> u64 {
(val << (mask.trailing_zeros())) & mask
}
| rust | Apache-2.0 | 5f541377a34c5daaf01aa148e406370e304fb661 | 2026-01-04T20:21:26.369655Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.