cleanup boot0 code

remove things that we don't need in boot0. Boot0 originated from
a much larger, more featureful space and needs to be whittled down
to remove attack surface and space for bugs.

Some further cleanup to do would include:

- hardening the PLL setting. Right now it's done computationally
based on the demanded frequency. But in practice, because the
target frequency is hard-coded, we could just compute the actual PLL value
results and jam them into the register and lose a whole bunch of
code.

Actually I think that's all that needs to be cleaned up off the
top of my head.
This commit is contained in:
bunnie 2025-09-29 13:46:42 +08:00
parent 150e46d9c0
commit 8cbdb75dc8
9 changed files with 180 additions and 522 deletions

View file

@ -2,8 +2,8 @@
name = "bao1x-boot0"
version = "0.1.0"
authors = ["bunnie <bunnie@kosagi.com>"]
edition = "2018"
description = "Boot0 loader"
edition = "2021"
description = "Boot0 partition"
[dependencies]
xous = "0.9.66"
@ -13,20 +13,7 @@ bao1x-api = { path = "../../libs/bao1x-api", optional = true, default-features =
vexriscv = { version = "0.5.6", package = "xous-riscv" }
riscv = { version = "0.14.0", features = ["critical-section-single-hart"] }
linked_list_allocator = { version = "0.10.5", optional = true }
xous-bio-bdma = { path = "../../libs/xous-bio-bdma", optional = true, default-features = false }
critical-section = "1.2.0"
ux-api = { path = "../../libs/ux-api", optional = true, default-features = false }
simple-fatfs = { git = "https://github.com/betrusted-io/simple-fatfs.git", branch = "baosec", optional = true, default-features = false }
digest = { version = "^0.10.7", optional = true }
ed25519-dalek = { package = "ed25519-dalek-bao1x", path = "../ed25519-dalek-bao1x", default-features = false, features = [
"digest",
"debug",
] }
base64 = { version = "0.22.1", optional = true, default-features = false, features = [
"alloc",
] }
sha2-bao1x = { path = "../sha2-bao1x", optional = true, default-features = false }
hex-literal = "1.0.0"
[features]
# Baochip feature tree below
@ -34,10 +21,10 @@ bao1x = [
"utralib/bao1x",
"linked_list_allocator",
"bao1x-hal/loader-baosec",
# "bao1x-hal/debug-print-usb",
"bao1x-api",
"sha2-bao1x/bao1x",
"digest",
]
# turns on a bunch of developer debug features. No production build should have this feature activated!
unsafe-dev = []
default = ["bao1x"]

View file

@ -2,7 +2,7 @@
MEMORY
{
/* Note: ORIGIN is updated by xtask for baremetal targets */
FLASH : ORIGIN = 0x60000400, LENGTH = 256k - 1024
FLASH : ORIGIN = 0x60000400, LENGTH = 127k
RAM : ORIGIN = 0x61000000, LENGTH = 2048k
}

View file

@ -3,7 +3,6 @@ use core::arch::asm;
use crate::platform;
#[link_section = ".text.init"]
#[export_name = "_start"]
#[cfg(feature = "bao1x")]
pub extern "C" fn _start() {
unsafe {
#[rustfmt::skip]
@ -21,8 +20,8 @@ pub extern "C" fn _start() {
"sw t1, 0xc(t0)",
"li t1, 0x1",
"sw t1, 0x4(t0)", // CR is 1
// print 32 instances of 'Z' (0x5A) (provided to measure baud)
"li t2, 32",
// print 8 instances of 'Z' (0x5A) (provided to help measure baud)
"li t2, 8",
"li t1, 0x5A",
"10:",
"sw t1, 0x0(t0)",

View file

@ -6,11 +6,14 @@ extern crate alloc;
mod asm;
mod platform;
#[cfg(feature = "unsafe-dev")]
mod repl;
mod sigcheck;
#[cfg(feature = "unsafe-dev")]
use alloc::collections::VecDeque;
#[cfg(feature = "unsafe-dev")]
use core::cell::RefCell;
#[cfg(feature = "unsafe-dev")]
use critical_section::Mutex;
use platform::*;
#[allow(unused_imports)]
@ -19,11 +22,10 @@ use utralib::*;
#[allow(unused_imports)]
use crate::delay;
#[cfg(feature = "unsafe-dev")]
static UART_RX: Mutex<RefCell<VecDeque<u8>>> = Mutex::new(RefCell::new(VecDeque::new()));
#[allow(dead_code)]
static USB_RX: Mutex<RefCell<VecDeque<u8>>> = Mutex::new(RefCell::new(VecDeque::new()));
static USB_TX: Mutex<RefCell<VecDeque<u8>>> = Mutex::new(RefCell::new(VecDeque::new()));
#[cfg(feature = "unsafe-dev")]
pub fn uart_irq_handler() {
use crate::debug::SerialRead;
let mut uart = crate::debug::Uart {};
@ -50,8 +52,10 @@ pub unsafe extern "C" fn rust_entry() -> ! {
crate::platform::early_init();
crate::println!("\n~~boot0 up!~~\n");
#[cfg(feature = "unsafe-dev")]
let mut repl = crate::repl::Repl::new();
// do the main loop through the serial port
#[cfg(feature = "unsafe-dev")]
loop {
// Handle keyboard events.
critical_section::with(|cs| {
@ -72,4 +76,63 @@ pub unsafe extern "C" fn rust_entry() -> ! {
_ => (),
};
}
if bao1x_hal::sigcheck::validate_image(
bao1x_api::BOOT0_START as *const u32,
bao1x_api::BOOT0_REVOCATION_OFFSET,
false,
)
.is_ok()
{
seal_boot0_keys();
let one_way_access = bao1x_hal::acram::OneWayCounter::new();
match one_way_access.get_decoded::<bao1x_api::AltBootCoding>() {
Ok(bao1x_api::AltBootCoding::PrimaryPartition) => {
// Primary boot selected. Check Boot1 first, then fall back to LOADER/BAREMETAL.
bao1x_hal::sigcheck::validate_image(
bao1x_api::BOOT1_START as *const u32,
bao1x_api::BOOT1_REVOCATION_OFFSET,
true,
)
.ok();
bao1x_hal::sigcheck::validate_image(
bao1x_api::LOADER_START as *const u32,
bao1x_api::LOADER_REVOCATION_OFFSET,
true,
)
.ok();
}
Ok(bao1x_api::AltBootCoding::AlternatePartition) => {
// Alternate boot selected. Check LOADER/BAREMETAL, then fall back to Boot1.
bao1x_hal::sigcheck::validate_image(
bao1x_api::LOADER_START as *const u32,
bao1x_api::LOADER_REVOCATION_OFFSET,
true,
)
.ok();
bao1x_hal::sigcheck::validate_image(
bao1x_api::BOOT1_START as *const u32,
bao1x_api::BOOT1_REVOCATION_OFFSET,
true,
)
.ok();
}
Err(_) => {
crate::println!("Internal error: alt boot encoding is invalid!");
bao1x_hal::sigcheck::die_no_std();
}
}
}
bao1x_hal::sigcheck::die_no_std();
}
fn seal_boot0_keys() {
// TODO:
// - setup an initial coreuser table
// - set an ASID that locks out any boot0 secrets (currently none, as it's PK based)
// - this does not offer strong security, but prevents someone with an arbitrary read primitive from
// accessing any boot0 secrets. An arbitrary-exec primitive at this point can, of course, undo the ASID
// mapping.
//
// Only necessary if we have secrets to seal. The current implementation only contains a public key,
// so there's no secrets to seal.
}

View file

@ -1,9 +1,9 @@
use bao1x_api::signatures::SIGBLOCK_LEN;
use bao1x_hal::udma;
use utralib::CSR;
use utralib::utra;
use utralib::utra::sysctrl;
#[cfg(feature = "unsafe-dev")]
use crate::platform::{
debug::setup_rx,
irq::{enable_irq, irq_setup},
@ -22,14 +22,18 @@ const DATA_SIZE_BYTES: usize = 0x6000;
pub const HEAP_START: usize = RAM_BASE + DATA_SIZE_BYTES;
pub const HEAP_LEN: usize = 1024 * 256;
// scratch page for exceptions located at top of RAM
// NOTE: there is an additional page above this for exception stack
pub const SCRATCH_PAGE: usize = HEAP_START - 8192;
// scratch page for exceptions
// - scratch data is stored in positive offsets from here
// - exception stack is stored in negative offsets from here, hence the +4096
// total occupied area is [HEAP_START + HEAP_LEN..HEAP_START + HEAP_LEN + 8192]
pub const SCRATCH_PAGE: usize = HEAP_START + HEAP_LEN + 4096;
pub const UART_IFRAM_ADDR: usize = bao1x_hal::board::UART_DMA_TX_BUF_PHYS;
// Run at 400MHz to ensure we can boot even without an external VDD85 regulator!
pub const SYSTEM_CLOCK_FREQUENCY: u32 = 400_000_000;
/// Run at 400MHz to ensure we can boot even without an external VDD85 regulator!
/// Also relying on the IFR region setting the SRAM trimming to work at this safe default
/// so we don't have to initialize it in boot0.
pub const DEFAULT_FCLK_FREQUENCY: u32 = 400_000_000;
pub const SYSTEM_TICK_INTERVAL_MS: u32 = 1;
pub fn early_init() {
@ -62,7 +66,6 @@ pub fn early_init() {
// sram0 requires 1 wait state for writes
let mut sramtrm = CSR::new(utra::coresub_sramtrm::HW_CORESUB_SRAMTRM_BASE as *mut u32);
sramtrm.wo(utra::coresub_sramtrm::SFR_SRAM0, 0x8);
sramtrm.wo(utra::coresub_sramtrm::SFR_SRAM1, 0x8);
// Now that SRAM trims are setup, initialize all the statics by writing to memory.
// For baremetal, the statics structure is just at the flash base.
@ -86,11 +89,8 @@ pub fn early_init() {
}
}
let uart = crate::debug::Uart {};
uart.putc('*' as u32 as u8);
// set the clock
let perclk = unsafe { init_clock_asic(SYSTEM_CLOCK_FREQUENCY) };
// set the clock.
let perclk = unsafe { init_clock_asic(DEFAULT_FCLK_FREQUENCY) };
crate::println!("scratch page: {:x}, heap start: {:x}", SCRATCH_PAGE, HEAP_START);
@ -99,16 +99,25 @@ pub fn early_init() {
setup_timer();
// this is a security-critical initialization. Failure to do this correctly breaks
// all the hardware hashes. It's done once, in boot0. Note that the constants *are*
// malleable (no hardware lock to prevent update), which is a potential vulnerability.
init_hash();
// Rx setup
let mut udma_uart = setup_rx(perclk);
irq_setup();
enable_irq(utra::irqarray5::IRQARRAY5_IRQ);
// TxRx setup
#[cfg(feature = "unsafe-dev")]
let mut udma_uart = {
let mut udma_uart = setup_rx(perclk);
irq_setup();
enable_irq(utra::irqarray5::IRQARRAY5_IRQ);
udma_uart
};
// Tx-only setup
#[cfg(not(feature = "unsafe-dev"))]
let _udma_uart = crate::debug::setup_tx(perclk);
udma_uart.write("console up\r\n".as_bytes());
crate::debug::USE_CONSOLE.store(true, core::sync::atomic::Ordering::SeqCst);
crate::println!("This debug print should be on the UDMA UART");
crate::println!("boot0 console up");
}
pub fn setup_timer() {
@ -122,7 +131,7 @@ pub fn setup_timer() {
timer.wfo(utra::timer0::EN_EN, 0b0); // disable the timer
// load its values
timer.wfo(utra::timer0::LOAD_LOAD, 0);
timer.wfo(utra::timer0::RELOAD_RELOAD, (SYSTEM_CLOCK_FREQUENCY / 1_000) * ms);
timer.wfo(utra::timer0::RELOAD_RELOAD, (DEFAULT_FCLK_FREQUENCY / 1_000) * ms);
// enable the timer
timer.wfo(utra::timer0::EN_EN, 0b1);
}
@ -138,7 +147,7 @@ pub fn setup_alloc() {
/// This function loads all the round constants into the combohasher's local memory.
pub fn init_hash() {
use bao1x_hal::sce::combohash::*;
use bao1x_api::sce::combohash::*;
// safety: this one is a little less clear from the register set extraction. But in the case of
// system initialization, the SCE uses its entire RAM range (10kiB worth) as a single buffer, so
// none of the buffer boundaries are respected. Thus we set the length of the segment to 10kiB
@ -196,6 +205,7 @@ pub fn delay_at_sysfreq(ms: usize, sysclk_freq: u32) {
}
/// Delay function that delays a given number of milliseconds.
#[allow(dead_code)]
pub fn delay(ms: usize) {
let mut timer = utralib::CSR::new(utra::timer0::HW_TIMER0_BASE as *mut u32);
timer.wfo(utra::timer0::EV_PENDING_ZERO, 1);
@ -215,28 +225,6 @@ mod panic_handler {
}
}
/// This takes in the FD input frequency (the frequency to be divided) in MHz
/// and the fd value, and returns the resulting divided frequency.
/// *not tested*
#[allow(dead_code)]
pub fn fd_to_clk(fd_in_mhz: u32, fd_val: u32) -> u32 { (fd_in_mhz * (fd_val + 1)) / 256 }
/// Takes in the FD input frequencyin MHz, and then the desired frequency.
/// Returns Some((fd value, deviation in *hz*, not MHz)) if the requirement is satisfiable
/// Returns None if the equation is ill-formed.
/// *not tested*
#[allow(dead_code)]
pub fn clk_to_fd(fd_in_mhz: u32, desired_mhz: u32) -> Option<(u32, i32)> {
let platonic_fd: u32 = (desired_mhz * 256) / fd_in_mhz;
if platonic_fd > 0 {
let actual_fd = platonic_fd - 1;
let actual_clk = fd_to_clk(fd_in_mhz, actual_fd);
Some((actual_fd, desired_mhz as i32 - actual_clk as i32))
} else {
None
}
}
/// Takes in the top clock in MHz, desired perclk in MHz, and returns a tuple of
/// (min cycle, fd, actual freq)
/// *tested*
@ -258,13 +246,7 @@ pub fn clk_to_per(top_in_mhz: u32, perclk_in_mhz: u32) -> Option<(u8, u8, u32)>
}
}
// This function supercedes init_clock_asic() and needs to be back-ported
// into xous-core
// TODO:
// - [ ] Case of clocks <= 48MHz: turn off PLL, divide directly from OSC
// - [ ] Derive clock dividers from freq targets, instead of hard-coding them
// - [ ] Maybe improve dividers to optimize hclk/iclk/pclk settings in lower power?
// - [ ] Very maybe consider setting hclk/iclk/pclk in case of overclocking
/// TODO: pare this down for the boot0 function
pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
use utra::sysctrl;
let daric_cgu = sysctrl::HW_SYSCTRL_BASE as *mut u32;
@ -313,35 +295,19 @@ pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
// perclk divider - set to divide by 8 off of an 800Mhz base. Only found on bao1x.
// TODO: this only works for two clock settings. Broken @ 600. Need to fix this to instead derive
// what pclk is instead of always reporting 100mhz
let (min_cycle, fd, perclk) = if let Some((min_cycle, fd, perclk)) = clk_to_per(freq_hz / 1_000_000, 100)
{
daric_cgu
.add(utra::sysctrl::SFR_CGUFDPER.offset())
.write_volatile((min_cycle as u32) << 16 | (fd as u32) << 8 | fd as u32);
(min_cycle, fd, perclk * 1_000_000)
} else if freq_hz > 400_000_000 {
daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x07_ff_ff);
(7, 0xff, freq_hz / 8)
} else {
daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x03_ff_ff);
(3, 0xff, freq_hz / 4)
};
/*
perclk fields: min-cycle-lp | min-cycle | fd-lp | fd
clkper fd
0xff : Fperclk = Fclktop/2
0x7f: Fperclk = Fclktop/4
0x3f : Fperclk = Fclktop/8
0x1f : Fperclk = Fclktop/16
0x0f : Fperclk = Fclktop/32
0x07 : Fperclk = Fclktop/64
0x03: Fperclk = Fclktop/128
0x01: Fperclk = Fclktop/256
min cycle of clktop, F means frequency
Fperclk Max = Fperclk/(min cycle+1)*2
*/
let (_min_cycle, _fd, perclk) =
if let Some((min_cycle, fd, perclk)) = clk_to_per(freq_hz / 1_000_000, 100) {
daric_cgu
.add(utra::sysctrl::SFR_CGUFDPER.offset())
.write_volatile((min_cycle as u32) << 16 | (fd as u32) << 8 | fd as u32);
(min_cycle, fd, perclk * 1_000_000)
} else if freq_hz > 400_000_000 {
daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x07_ff_ff);
(7, 0xff, freq_hz / 8)
} else {
daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x03_ff_ff);
(3, 0xff, freq_hz / 4)
};
// turn off gates
daric_cgu.add(utra::sysctrl::SFR_ACLKGR.offset()).write_volatile(0xff);
@ -465,180 +431,18 @@ pub unsafe fn init_clock_asic(freq_hz: u32) -> u32 {
}
crate::println!("PLL delay 2");
//printf("read reg a0 : %08" PRIx32"\n", *((volatile uint32_t* )0x400400a0));
//printf("read reg a4 : %04" PRIx16"\n", *((volatile uint16_t* )0x400400a4));
//printf("read reg a8 : %04" PRIx16"\n", *((volatile uint16_t* )0x400400a8));
// TODO wait/poll lock status?
// DARIC_CGU->cgusel0 = 1; // clktop sel, 0:clksys, 1:clkpll0
cgu.wo(sysctrl::SFR_CGUSEL0, 1);
// __DSB();
// DARIC_CGU->cguset = 0x32; // commit
cgu.wo(sysctrl::SFR_CGUSET, 0x32);
crate::println!("clocks set");
// __DSB();
// printf (" MN: 0x%05x, F: 0x%06x, Q: 0x%04x\n",
// DARIC_IPC->pll_mn, DARIC_IPC->pll_f, DARIC_IPC->pll_q);
// printf (" LPEN: 0x%01x, OSC: 0x%04x, BIAS: 0x%04x,\n",
// DARIC_IPC->lpen, DARIC_IPC->osc, DARIC_IPC->ipc);
}
crate::println!(
"mn {:x}, q{:x}",
(0x400400a0 as *const u32).read_volatile(),
(0x400400a8 as *const u32).read_volatile()
);
crate::println!("fsvalid: {}", daric_cgu.add(sysctrl::SFR_CGUFSVLD.offset()).read_volatile());
let clk_desc: [(&'static str, u32, usize); 8] = [
("fclk", 16, 0x40 / size_of::<u32>()),
("pke", 0, 0x40 / size_of::<u32>()),
("ao", 16, 0x44 / size_of::<u32>()),
("aoram", 0, 0x44 / size_of::<u32>()),
("osc", 16, 0x48 / size_of::<u32>()),
("xtal", 0, 0x48 / size_of::<u32>()),
("pll0", 16, 0x4c / size_of::<u32>()),
("pll1", 0, 0x4c / size_of::<u32>()),
];
for (name, shift, offset) in clk_desc {
let fsfreq = (daric_cgu.add(offset).read_volatile() >> shift) & 0xffff;
crate::println!("{}: {} MHz", name, fsfreq);
}
// Taken in from latest daric_util.c
let mut udmacore = CSR::new(utra::udma_ctrl::HW_UDMA_CTRL_BASE as *mut u32);
udmacore.wo(utra::udma_ctrl::REG_CG, 0xFFFF_FFFF);
crate::println!("Perclk solution: {:x}|{:x} -> {} MHz", min_cycle, fd, perclk / 1_000_000);
crate::println!("PLL configured to {} MHz", freq_hz / 1_000_000);
perclk
}
/// used to generate some test vectors
#[allow(dead_code)]
pub fn lfsr_next_u32(state: u32) -> u32 {
let bit = ((state >> 31) ^ (state >> 21) ^ (state >> 1) ^ (state >> 0)) & 1;
(state << 1) + bit
}
pub fn clockset_wrapper(freq: u32) -> u32 {
// reset the baud rate on the console UART
let perclk = unsafe { crate::platform::init_clock_asic(freq) };
let uart_buf_addr = crate::platform::UART_IFRAM_ADDR;
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(utra::udma_uart_2::HW_UDMA_UART_2_BASE, uart_buf_addr, uart_buf_addr)
};
let baudrate: u32 = crate::UART_BAUD;
let freq: u32 = perclk / 2;
udma_uart.set_baud(baudrate, freq);
crate::println!("clock set done, perclk is {} MHz", perclk / 1_000_000);
udma_uart.write("console up with clocks\r\n".as_bytes());
perclk
}
#[allow(dead_code)]
pub unsafe fn low_power() -> u32 {
const FREQ_OSC_MHZ: u32 = 48; // 48MHz
use utra::sysctrl;
let daric_cgu = sysctrl::HW_SYSCTRL_BASE as *mut u32;
let mut cgu = CSR::new(daric_cgu);
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_0.offset()).write_volatile(0x3f3f); // fclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_1.offset()).write_volatile(0x3f3f); // aclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_2.offset()).write_volatile(0x1f1f); // hclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_3.offset()).write_volatile(0x0f0f); // iclk
daric_cgu.add(utra::sysctrl::SFR_CGUFD_CFGFDCR_0_4_4.offset()).write_volatile(0x0707); // pclk
let (min_cycle, fd, perclk) = if let Some((min_cycle, fd, perclk)) = clk_to_per(48, 24) {
daric_cgu
.add(utra::sysctrl::SFR_CGUFDPER.offset())
.write_volatile((min_cycle as u32) << 16 | (fd as u32) << 8 | fd as u32);
crate::println!("perclk {}", perclk);
(min_cycle, fd, perclk * 1_000_000)
} else {
crate::println!("couldn't find perclk solution");
daric_cgu.add(utra::sysctrl::SFR_CGUFDPER.offset()).write_volatile(0x03_ff_ff);
(3, 0xff, 48_000_000 / 4)
};
let perclk = perclk;
// DARIC_CGU->cgusel1 = 1; // 0: RC, 1: XTAL
cgu.wo(sysctrl::SFR_CGUSEL0, 0);
cgu.wo(sysctrl::SFR_CGUSEL1, 1);
cgu.wo(sysctrl::SFR_CGUFSCR, FREQ_OSC_MHZ);
cgu.wo(sysctrl::SFR_CGUSET, 0x32);
let duart = utra::duart::HW_DUART_BASE as *mut u32;
duart.add(utra::duart::SFR_CR.offset()).write_volatile(0);
// set the ETUC now that we're on the xosc.
duart.add(utra::duart::SFR_ETUC.offset()).write_volatile(FREQ_OSC_MHZ);
duart.add(utra::duart::SFR_CR.offset()).write_volatile(1);
cgu.wo(sysctrl::SFR_IPCOSC, FREQ_OSC_MHZ * 1_000_000);
cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32);
// lower core voltage to 0.7v
let mut ao_sysctrl = CSR::new(utralib::HW_AO_SYSCTRL_BASE as *mut u32);
ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRM0CSR, 0x08420002);
// ao_sysctrl.wo(utra::ao_sysctrl::SFR_PMUTRM1CSR, 0x1);
cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x57);
// power down the PLL
cgu.wo(sysctrl::SFR_IPCLPEN, cgu.r(sysctrl::SFR_IPCLPEN) & !0x2);
cgu.wo(sysctrl::SFR_IPCCR, 0x53);
cgu.wo(sysctrl::SFR_IPCARIPFLOW, 0x32);
for _ in 0..1024 {
unsafe { core::arch::asm!("nop") };
}
crate::println!("PLL pd delay 1");
crate::println!("fsvalid: {}", daric_cgu.add(sysctrl::SFR_CGUFSVLD.offset()).read_volatile());
let clk_desc: [(&'static str, u32, usize); 8] = [
("fclk", 16, 0x40 / size_of::<u32>()),
("pke", 0, 0x40 / size_of::<u32>()),
("ao", 16, 0x44 / size_of::<u32>()),
("aoram", 0, 0x44 / size_of::<u32>()),
("osc", 16, 0x48 / size_of::<u32>()),
("xtal", 0, 0x48 / size_of::<u32>()),
("pll0", 16, 0x4c / size_of::<u32>()),
("pll1", 0, 0x4c / size_of::<u32>()),
];
for (name, shift, offset) in clk_desc {
let fsfreq = (daric_cgu.add(offset).read_volatile() >> shift) & 0xffff;
crate::println!("{}: {} MHz", name, fsfreq);
}
// gates off
daric_cgu.add(utra::sysctrl::SFR_ACLKGR.offset()).write_volatile(0x00);
daric_cgu.add(utra::sysctrl::SFR_HCLKGR.offset()).write_volatile(0x00);
daric_cgu.add(utra::sysctrl::SFR_ICLKGR.offset()).write_volatile(0x00);
daric_cgu.add(utra::sysctrl::SFR_PCLKGR.offset()).write_volatile(0x00);
// commit dividers
daric_cgu.add(utra::sysctrl::SFR_CGUSET.offset()).write_volatile(0x32);
let mut udmacore = CSR::new(utra::udma_ctrl::HW_UDMA_CTRL_BASE as *mut u32);
udmacore.wo(utra::udma_ctrl::REG_CG, 0x0000_000F); // lower four are the UART
// reset the UART
let uart_buf_addr = crate::platform::UART_IFRAM_ADDR;
let mut udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling
// new.
udma::Uart::get_handle(utra::udma_uart_2::HW_UDMA_UART_2_BASE, uart_buf_addr, uart_buf_addr)
};
let baudrate: u32 = crate::UART_BAUD;
let freq: u32 = perclk / 2;
udma_uart.set_baud(baudrate, freq);
crate::println!("Perclk solution: {:x}|{:x} -> {} MHz", min_cycle, fd, perclk / 1_000_000);
crate::println!("powerdown: perclk is {} MHz", perclk / 1_000_000);
udma_uart.write("powerdown with clocks\r\n".as_bytes());
perclk
}

View file

@ -2,6 +2,7 @@ use core::sync::atomic::{AtomicBool, Ordering::SeqCst};
use bao1x_api::*;
use bao1x_hal::iox::Iox;
#[cfg(feature = "unsafe-dev")]
use bao1x_hal::udma::UartIrq;
use bao1x_hal::{udma, udma::GlobalConfig};
use utralib::generated::*;
@ -9,14 +10,13 @@ use utralib::generated::*;
pub static USE_CONSOLE: AtomicBool = AtomicBool::new(false);
/// A trait for serial like drivers which allows reading from a source.
#[allow(dead_code)]
#[cfg(feature = "unsafe-dev")]
pub trait SerialRead {
/// Read a single byte.
fn getc(&mut self) -> Option<u8>;
}
pub struct Uart {}
#[allow(dead_code)]
impl Uart {
pub fn putc(&self, c: u8) {
if !USE_CONSOLE.load(SeqCst) {
@ -37,35 +37,6 @@ impl Uart {
udma_uart.write(&buf);
}
}
fn put_digit(&mut self, d: u8) {
let nyb = d & 0xF;
let c = if nyb < 10 { nyb + 0x30 } else { nyb + 0x61 - 10 };
assert!(c >= 0x30, "conversion failed!");
self.putc(c);
}
pub fn put_hex(&mut self, c: u8) {
self.put_digit(c >> 4);
self.put_digit(c & 0xF);
}
pub fn newline(&mut self) {
self.putc(0xa);
self.putc(0xd);
}
pub fn print_hex_word(&mut self, word: u32) {
for &byte in word.to_be_bytes().iter() {
self.put_hex(byte);
}
}
pub fn tiny_write_str(&mut self, s: &str) {
for c in s.bytes() {
self.putc(c);
}
}
}
use core::fmt::{Error, Write};
@ -78,6 +49,7 @@ impl Write for Uart {
}
}
#[cfg(feature = "unsafe-dev")]
impl SerialRead for Uart {
fn getc(&mut self) -> Option<u8> {
let uart_buf_addr = crate::platform::UART_IFRAM_ADDR;
@ -123,6 +95,7 @@ macro_rules! println
});
}
#[cfg(feature = "unsafe-dev")]
pub fn setup_rx(perclk: u32) -> bao1x_hal::udma::Uart {
let iox = Iox::new(utra::iox::HW_IOX_BASE as *mut u32);
let udma_global = GlobalConfig::new();
@ -168,3 +141,35 @@ pub fn setup_rx(perclk: u32) -> bao1x_hal::udma::Uart {
udma_uart
}
#[cfg(not(feature = "unsafe-dev"))]
pub fn setup_tx(perclk: u32) -> bao1x_hal::udma::Uart {
let iox = Iox::new(utra::iox::HW_IOX_BASE as *mut u32);
let udma_global = GlobalConfig::new();
iox.set_alternate_function(IoxPort::PB, 14, IoxFunction::AF1);
// tx as output
iox.set_gpio_dir(IoxPort::PB, 14, IoxDir::Output);
udma_global.clock_on(PeriphId::Uart2);
udma_global.map_event(
PeriphId::Uart2,
PeriphEventType::Uart(EventUartOffset::Tx),
EventChannel::Channel1,
);
let baudrate: u32 = crate::UART_BAUD;
let freq: u32 = perclk / 2;
// the address of the UART buffer is "hard-allocated" at an offset one page from the top of
// IFRAM0. This is a convention that must be respected by the UDMA UART library implementation
// for things to work.
let uart_buf_addr = crate::platform::UART_IFRAM_ADDR;
let udma_uart = unsafe {
// safety: this is safe to call, because we set up clock and events prior to calling new.
udma::Uart::get_handle(utra::udma_uart_2::HW_UDMA_UART_2_BASE, uart_buf_addr, uart_buf_addr)
};
udma_uart.set_baud(baudrate, freq);
udma_uart
}

View file

@ -1,8 +1,13 @@
use riscv::register::{mcause, mie, mstatus};
use vexriscv::register::vexriscv::{mim, mip};
#[cfg(feature = "unsafe-dev")]
use riscv::register::mstatus;
use riscv::register::{mcause, mie};
#[cfg(feature = "unsafe-dev")]
use vexriscv::register::vexriscv::mim;
use vexriscv::register::vexriscv::mip;
use crate::*;
#[cfg(feature = "unsafe-dev")]
pub fn irq_setup() {
unsafe {
#[rustfmt::skip]
@ -23,6 +28,7 @@ pub fn irq_setup() {
unsafe { mie::set_mext() };
}
#[cfg(feature = "unsafe-dev")]
pub fn enable_irq(irq_no: usize) {
// Note that the vexriscv "IRQ Mask" register is inverse-logic --
// that is, setting a bit in the "mask" register unmasks (i.e. enables) it.
@ -43,7 +49,7 @@ pub unsafe extern "C" fn _start_trap() -> ! {
#[rustfmt::skip]
core::arch::asm!(
"csrw mscratch, sp",
"li sp, {scratch_page}", // crate::platform::SCRATCH_PAGE - has to be hard-coded
"li sp, {scratch_page}", // scratch_page, grows up
"sw x1, 0*4(sp)",
// Skip SP for now
"sw x3, 2*4(sp)",
@ -79,23 +85,17 @@ pub unsafe extern "C" fn _start_trap() -> ! {
// Save MEPC
"csrr t0, mepc",
"sw t0, 31*4(sp)",
// Save x1, which was used to calculate the offset. Prior to
// calculating, it was stashed at 0x61006000.
//"li t0, 0x61006000",
//"lw t1, 0*4(t0)",
//"sw t1, 0*4(sp)",
// Finally, save SP
"csrr t0, mscratch",
"sw t0, 1*4(sp)",
// Restore a default stack pointer
"li sp, {heap_base}", // heap base, grows down
"li sp, {scratch_page}", // scratch_page, grows down
// Note that registers $a0-$a7 still contain the arguments
"j _start_trap_rust",
scratch_page = const SCRATCH_PAGE,
heap_base = const HEAP_START
scratch_page = const SCRATCH_PAGE
);
}
_start_trap_aligned();
@ -191,8 +191,9 @@ pub extern "C" fn trap_handler(
let ms = SYSTEM_TICK_INTERVAL_MS;
let mut timer0 = CSR::new(utra::timer0::HW_TIMER0_BASE as *mut u32);
timer0.wfo(utra::timer0::EV_PENDING_ZERO, 1);
timer0.wfo(utra::timer0::RELOAD_RELOAD, (SYSTEM_CLOCK_FREQUENCY / 1_000) * ms);
timer0.wfo(utra::timer0::RELOAD_RELOAD, (crate::DEFAULT_FCLK_FREQUENCY / 1_000) * ms);
} else if (irqs_pending & (1 << utra::irqarray5::IRQARRAY5_IRQ)) != 0 {
#[cfg(feature = "unsafe-dev")]
crate::uart_irq_handler();
} else if (irqs_pending & (1 << utra::irqarray2::IRQARRAY2_IRQ)) != 0 {
// just clear it for now

View file

@ -22,17 +22,6 @@ pub struct Repl {
do_cmd: bool,
}
// courtesy of claude
const K_DATA: &'static [u8; 853] = b"The quick brown fox jumps over the lazy dog while contemplating \
the meaning of existence in a digital world. Numbers like 123456789 and symbols @#$%^&*() add variety to this test \
message. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore \
magna aliqua. Testing patterns: ABCDEFGHIJKLMNOPQRSTUVWXYZ and abcdefghijklmnopqrstuvwxyz provide full alphabet coverage. \
Special characters !@#$%^&*()_+-=[]{}|;':.,.<>?/ enhance the diversity of this sample text. The year 2024 brings new \
challenges and opportunities for software development and testing methodologies. Random words like elephant, butterfly, \
quantum, nebula, crystalline, harmonic, and serendipity fill the remaining space. Pi equals 3.14159265358979323846 \
approximately. This text serves as a placeholder for various testing scenarios!!!";
const COLUMNS: usize = 4;
impl Repl {
pub fn new() -> Self { Self { cmdline: String::new(), do_cmd: false } }
@ -117,53 +106,6 @@ impl Repl {
crate::println!("{}.{} bogomips", (count * 2 * 10_000) / 1_000_000, (count * 2) % 10_000);
crate::platform::setup_timer();
}
"peek" => {
if args.len() == 1 || args.len() == 2 {
let addr = usize::from_str_radix(&args[0], 16)
.map_err(|_| Error::help("Peek address is in hex"))?;
let count = if args.len() == 2 {
if let Ok(count) = u32::from_str_radix(&args[1], 10) { count } else { 1 }
} else {
1
};
// safety: it's not safe to do this, the user peeks at their own risk
let peek = unsafe { core::slice::from_raw_parts(addr as *const u32, count as usize) };
for (i, &d) in peek.iter().enumerate() {
if (i % COLUMNS) == 0 {
crate::print!("\n\r{:08x}: ", addr + i * size_of::<u32>());
}
crate::print!("{:08x} ", d);
}
crate::println!("");
} else {
return Err(Error::help("Help: peek <addr> [count], addr is in hex, count in decimal"));
}
}
"poke" => {
if args.len() == 2 || args.len() == 3 {
let addr = u32::from_str_radix(&args[0], 16)
.map_err(|_| Error::help("Poke address is in hex"))?;
let value =
u32::from_str_radix(&args[1], 16).map_err(|_| Error::help("Poke value is in hex"))?;
let count = if args.len() == 3 {
if let Ok(count) = u32::from_str_radix(&args[2], 10) { count } else { 1 }
} else {
1
};
// safety: it's not safe to do this, the user pokes at their own risk
let poke = unsafe { core::slice::from_raw_parts_mut(addr as *mut u32, count as usize) };
for d in poke.iter_mut() {
*d = value;
}
crate::println!("Poked {:x} into {:x}, {} times", value, addr, count);
} else {
return Err(Error::help(
"Help: poke <addr> <value> [count], addr/value is in hex, count in decimal",
));
}
}
"reset" => {
let mut rcurst = CSR::new(utra::sysctrl::HW_SYSCTRL_BASE as *mut u32);
rcurst.wo(utra::sysctrl::SFR_RCURST0, 0x55AA);
@ -191,61 +133,10 @@ impl Repl {
}
crate::println!("");
}
"sha2" => {
use digest::Digest;
use hex_literal::hex;
use sha2_bao1x::Sha256;
const K_EXPECTED_DIGEST_256: [u8; 32] =
hex!("de1b3b58e16d6b12c906898025d4bc5a594075f4fd4252fa88128b2e0b7a266a");
let mut pass: bool = true;
let mut hasher = Sha256::new();
hasher.update(K_DATA);
// hasher.update(data);
let digest = hasher.finalize();
for (&expected, result) in K_EXPECTED_DIGEST_256.iter().zip(digest) {
if expected != result {
pass = false;
}
}
if pass {
crate::println!("Sha256 passed.");
} else {
crate::println!("Sha256 failed: {:x?}", digest);
}
}
"sha5" => {
use digest::Digest;
use hex_literal::hex;
use sha2_bao1x::Sha512;
// generated by claude.
const K_EXPECTED_DIGEST_512: [u8; 64] = hex!(
"e827276a7d5f2653fe27abc0b0c86533e75acfd4d75253b1229bf86aee19e4a0722691e9ef60510892dc60f4edff795d7875d0d8293a39a7a327a7e1bf07000a"
);
let mut pass: bool = true;
let mut hasher = Sha512::new();
hasher.update(K_DATA);
// hasher.update(data);
let digest = hasher.finalize();
for (&expected, result) in K_EXPECTED_DIGEST_512.iter().zip(digest) {
if expected != result {
pass = false;
}
}
if pass {
crate::println!("Sha512 passed.");
} else {
crate::println!("Sha512 failed: {:x?}", digest);
}
}
"check" => match crate::sigcheck::validate_image(crate::FLASH_BASE as *const u32) {
"check" => match bao1x_hal::sigcheck::validate_image(
crate::FLASH_BASE as *const u32,
bao1x_api::BOOT0_REVOCATION_OFFSET,
) {
Ok(key_number) => crate::println!("sigcheck passed on key {}", key_number),
Err(e) => crate::println!("sigcheck failed: {}", e),
},
@ -267,12 +158,19 @@ impl Repl {
if new_time >= start_time + 5 {
break;
}
crate::sigcheck::validate_image(crate::FLASH_BASE as *const u32).ok();
bao1x_hal::sigcheck::validate_image(
crate::FLASH_BASE as *const u32,
bao1x_api::BOOT0_REVOCATION_OFFSET,
)
.ok();
count += 1;
}
crate::println!("{} reps/sec", count / 5);
crate::platform::setup_timer();
}
"boot1" => unsafe {
crate::asm::jump_to(bao1x_api::BOOT1_START);
},
_ => {
crate::println!("Command not recognized: {}", cmd);
crate::print!("Commands include: echo, bogomips, peek, poke, sha256check");

View file

@ -1,99 +0,0 @@
use alloc::string::String;
use bao1x_api::signatures::*;
use bao1x_hal::acram::OneWayCounter;
use digest::Digest;
use sha2_bao1x::Sha512;
/// Offset in the one-way counter array for key revocations
pub const REVOCATION_OFFSET: usize = 124;
/// Current draw @ 200MHz CPU ACLK (400MHz FCLK), VDD85 = 0.80V nom (measured @0.797V): ~71mA peak @ 27C,
/// measured on VDD33 (LDO path places strict upper bounds on IDD85). Target: < 100mA under all PVT.
///
/// Other notes: active current is only 2-4mA over idle current for this loop, so idle current is a good
/// proxy for current draw in boot0.
///
/// Why this matters: boot0 has to boot the chip under all modes. An external power source is needed for
/// IDD85 > 100mA. Thus we can't boot at max speed config, as not all system configurations have the
/// external regulator. So, we have to work at reduced VDD/frequency and make sure this constraint is met.
pub fn validate_image(img_offset: *const u32) -> Result<usize, String> {
// conjure the signature struct directly out of memory. super unsafe.
let sig_ptr = img_offset as *const SignatureInFlash;
let sig: &SignatureInFlash = unsafe { sig_ptr.as_ref().unwrap() };
let signed_len = sig.sealed_data.signed_len;
let image: &[u8] = unsafe {
core::slice::from_raw_parts((img_offset as usize + UNSIGNED_LEN) as *const u8, signed_len as usize)
};
if sig.sealed_data.version != BAOCHIP_SIG_VERSION {
crate::println!(
"Version {:x} sig found, should be {:x}",
sig.sealed_data.version,
BAOCHIP_SIG_VERSION
);
return Err(String::from("invalid sigblock version"));
}
// checking the function code prevents exploiting code meant for other partitions signed
// with a valid signature as code for the next stage boot.
if !(sig.sealed_data.function_code == FunctionCode::Boot0 as u32
|| sig.sealed_data.function_code == FunctionCode::Boot1 as u32
|| sig.sealed_data.function_code == FunctionCode::UpdatedBoot1 as u32)
{
return Err(String::from("Partition has invalid function code"));
}
let one_way_counters = OneWayCounter::new();
let mut secure = false;
let mut passing_key: Option<usize> = None;
for (i, key) in sig.sealed_data.pubkeys.iter().enumerate() {
if key.iter().all(|&x| x == 0) {
continue;
}
let revocation_value = one_way_counters.get(REVOCATION_OFFSET + i).expect("internal error");
if revocation_value != 0 {
crate::println!("Key at index {} is revoked ({}), skipping", i, revocation_value);
continue;
}
let verifying_key =
ed25519_dalek::VerifyingKey::from_bytes(key).or(Err(String::from("invalid public key")))?;
let ed25519_signature = ed25519_dalek::Signature::from(sig.signature);
let mut h: Sha512 = Sha512::new();
h.update(&image);
// debugging note: h.clone() does *not* work. You have to print the hash by modifying
// the function inside the ed25519 crate.
match verifying_key.verify_prehashed(h, None, &ed25519_signature) {
Ok(_) => {
passing_key = Some(i);
if i != sig.sealed_data.pubkeys.len() - 1 {
secure = true;
break;
} else if i == sig.sealed_data.pubkeys.len() - 1 {
// this is the developer key slot
secure = false;
break;
}
}
_ => {}
}
}
if !secure {
erase_secrets();
}
if let Some(valid_key) = passing_key {
Ok(valid_key)
} else {
Err(String::from("No valid pubkeys found or signature invalid"))
}
}
fn erase_secrets() {
// actually, this should check first if the data is 0, then 0 it. Can't afford
// to wear-out the memory every boot by repeatedly overwriting it...
crate::println!("TODO: erase secret data stores on boot to devmode!");
}