Ferrous Systems Rust Exercises

This exercise focuses on implementing and interacting with Arm TrustZone-M (Cortex-M Security Extensions) on an STM32U5A5ZJ-Q microcontroller. You will develop two concurrent applications on a NUCLEO-U5A5ZJ-Q board to practice the following concepts:

• Arm TrustZone-M (CMSE): Understanding the security architecture.
• Security Attribution Unit (SAU): Managing memory security attributes.
• STM32U5 Global Trust Zone Controller: Configuring the hardware-specific security controller.
• State Transitions: Starting a Nonsecure State binary from a Secure State.
• Secure APIs: Calling Secure State APIs from a Nonsecure State.
• Dual Debugging: Using semihosting and defmt over RTT simultaneously for debug output from two different programs.

This repository contains exercises for working with STM32 TrustZone, specifically designed for the ST Micro NUCLEO-U5A5ZJ-Q board (featuring an STM32U5A5ZJ microcontroller).

The exercises demonstrate a Secure/Nonsecure execution model where a secure-loader (running in Secure State) initializes hardware and then boots a nonsecure-app (running in Nonsecure State). The nonsecure-app can interact with services exported by the secure-loader.

The rust-exercises repository is organized into several learning tracks, ranging from fundamental syntax to specialized embedded systems development. You can navigate the curriculum through the following categories:

• Rust Fundamentals: Basic concepts like Fizzbuzz, Iterators, and SimpleDB.
• Applied Rust: Practical applications including TCP servers and mailbox implementations.
• Self-check Project: A dedicated project for self-assessment.
• Advanced Rust: Complex topics like Async TCP Chat Servers, formal verification with Kani, and Linux Kernel Drivers.
• Rust for Microcontrollers: Deep dives into nRF52 (Radio, HAL, USB) and STM32 (TrustZone).
• Rust for Real-Time Systems: Working without std and bare-metal firmware on Cortex-R52.

This exercise focuses on building a toy USB device application that runs in a fully event-driven fashion (only performing work when requested by the host). By completing this exercise, you will learn how to:

• Work with registers and peripherals from Rust.
• Handle external events in embedded Rust applications using RTIC (Real-Time Interrupt-driven Concurrency).
• Debug event-driven applications.
• Test no_std code.

The dongle crate provides a Board Support Package (BSP) specifically for the nRF52840 USB Dongle. Use this package when developing Rust applications targeting this specific hardware platform.

For hardware specifications and details, refer to the official Nordic Semiconductor product page: https://www.nordicsemi.com/Products/Development-hardware/nrf52840-dongle

A tuple is a collection of values of different types. Tuples are constructed using parentheses () and each tuple is a value with a type signature (T1, T2, ...) where T1, T2, etc., are the types of its members. Tuples can hold any number of values and are useful for returning multiple values from a function or grouping related state for pattern matching.

// A tuple with a bunch of different types.
let long_tuple = (1u8, 2u16, 3u32, 4u64,
                      -1i8, -2i16, -3i32, -4i64,
                      0.1f32, 0.2f64,
                      'a', true);

TrustZone is an Arm security extension that provides two execution states:

• Secure State: Has higher permissions and can affect the Nonsecure state.
• Nonsecure State: Cannot affect the Secure state.

On the STM32U5A5ZJ-Q (Cortex-M33), state transitions are managed via:

• Non-volatile Option Bytes (e.g., the TZEN bit) to control the boot state.
• Special branch instructions for Secure-to-Nonsecure or Nonsecure-to-Secure calls (the latter requiring a Secure Gateway marker).

This architecture allows sensitive data, like encryption keys, to be isolated in the Secure state even if the Nonsecure state code is compromised.

When the Rust compiler cannot infer the specific type required by an iterator method, use the turbofish operator ::<> to provide explicit type hints. This is common with methods like .parse(), which can return different types (e.g., i32 vs f64) depending on the target type.

let numbers: Vec<_> = ["1", "2", "3"]
    .iter()
    .map(|s| s.parse::<i32>().unwrap())
    .map(|n| n + 1)
    .collect();