Pull Request Review Checklist

  • [ ] Code is completely panic-free (no unwrap/expect/panic/indexing)
  • [ ] All fallible operations return Result or Option
  • [ ] Integer operations use checked/saturating/wrapping methods where needed
  • [ ] Array/slice access uses get() or pattern matching, not direct indexing
  • [ ] Error cases are well documented and handled appropriately
  • [ ] Tests verify error handling paths, not just happy paths
  • [ ] Unsafe code blocks are documented with safety comments
  • [ ] Hardware register access uses proper volatile operations
  • [ ] Cryptographic operations use constant-time implementations where applicable
  • [ ] Code is no_std compatible (no heap allocation: Vec, HashMap, String, etc.)
  • [ ] Fixed-size arrays and heapless collections used instead of dynamic allocation
  • [ ] Stack usage is bounded and reasonable for embedded targets
  • [ ] Shared/reused scratch buffers are not aliased across multiple batched results — each consumer's data is copied or encoded before the buffer is overwritten for the next one
  • [ ] Untrusted IPC input is validated in the server, not in the hardware driver. Client-controlled address, size, and length meet the driver's documented preconditions (supported size, alignment, in-bounds range) before the handler calls into the HAL or driver

Quick Reference: Forbidden Patterns

Forbidden PatternRequired Alternative
value.unwrap()match value { Some(v) => v, None => return Err(...) }
result.expect("msg")match result { Ok(v) => v, Err(e) => return Err(e.into()) }
collection[index]collection.get(index).ok_or(Error::OutOfBounds)?
a + b (integers)a.checked_add(b).ok_or(Error::Overflow)?
ptr.read()ptr.read_volatile() (for MMIO)
Vec<T>, HashMap<K,V>Fixed-size arrays [T; N], heapless::Vec<T, N>
StringFixed-size string heapless::String<N> or &str
Box<T>Stack allocation or &mut T reference
Reuse one shared buffer across a batch, process after the loopEncode/consume each result immediately, before the buffer is reused

Example — buffer aliasing:

// ❌ Bad: scratch_buf is overwritten each iteration; the second loop reads
// it back after the fact, so every item except the last-resolved one is
// delivered a *different* item's data instead of its own.
let mut ready = Vec::new();
for item in pending {
    if let Some(msg) = item.take_ready() {
        let meta = copy_into(msg, scratch_buf);   // overwrites scratch_buf
        ready.push((item.id(), meta));
    }
}
for (id, meta) in ready {
    deliver(id, &scratch_buf[..meta.len]);        // id A gets id B's data
}

// ✅ Good: encode/deliver immediately, before scratch_buf is reused.
for item in pending {
    if let Some(msg) = item.take_ready() {
        let meta = copy_into(msg, scratch_buf);
        deliver(item.id(), &scratch_buf[..meta.len]); // consumed now, while still valid
    }
}

Security-Specific Guidelines

  • Timing attacks: Use constant-time comparisons for secrets (subtle crate)
  • Zeroization: Use zeroize crate for sensitive data cleanup (keys, passwords, etc.)
  • Memory safety: Ensure sensitive data is properly zeroized after use
  • Hardware abstraction: All register access must go through HAL traits
  • Error information: Don't leak sensitive data in error messages
  • Buffer aliasing (CWE-488): Never collect metadata for multiple pending/ready items against a single shared buffer and process them afterward — the buffer only ever holds the last write. Each item must be fully encoded/consumed before the buffer is reused for the next.
  • IPC trust boundary: Do not rely on clients, including third-party code, to send valid addresses, sizes, or lengths. Validate them in the IPC server. The driver assumes they are valid.