From 24c5e8cb794271ca1560f90e6b26ee02920c4711 Mon Sep 17 00:00:00 2001 From: Kirill Mikhailov <62840029+playfulFence@users.noreply.github.com> Date: Wed, 27 Sep 2023 18:03:06 +0200 Subject: [PATCH] Adding `async` support for `RSA` peripheral (#790) * Adding async support for RSA peripheral * Add esp32 support (doesn't work properly yet) * Xtensa chips are supported (except of esp32) Add modular multiplication for esp32 Adding a CHANGELOG entry Rebase issue fix * Code cleanup * Add `.await` on `RsaFuture::new()` calls * Refactor and rebase Made `read_results` functions to be `async`, got rid of `nb` usage * Change API methods naming + refactor `start_step2` method * Adjust example to the API change + documentation * Code cleaning + refactoring Update examples --- CHANGELOG.md | 1 + esp-hal-common/src/rsa/esp32.rs | 19 +-- esp-hal-common/src/rsa/mod.rs | 250 ++++++++++++++++++++++++++++---- esp32-hal/examples/rsa.rs | 11 +- esp32c3-hal/examples/rsa.rs | 9 +- esp32c6-hal/examples/rsa.rs | 9 +- esp32h2-hal/examples/rsa.rs | 9 +- esp32s2-hal/examples/rsa.rs | 9 +- esp32s3-hal/examples/rsa.rs | 9 +- 9 files changed, 258 insertions(+), 68 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6dcd53038..3ace065c4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -66,6 +66,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Add `defmt` feature to enable log output (#773) - A new macro to load LP core code on ESP32-C6 (#779) - Add `ECC`` peripheral driver (#785) +- Adding async support for RSA peripheral(doesn't work properly for `esp32` chip - issue will be created)(#790) ### Changed diff --git a/esp-hal-common/src/rsa/esp32.rs b/esp-hal-common/src/rsa/esp32.rs index 956d75e12..032ab026f 100644 --- a/esp-hal-common/src/rsa/esp32.rs +++ b/esp-hal-common/src/rsa/esp32.rs @@ -127,16 +127,17 @@ where /// This is a non blocking function that returns without an error if /// operation is completed successfully. `start_step1` must be called /// before calling this function. - pub fn start_step2(&mut self, operand_b: &T::InputType) -> nb::Result<(), Infallible> { - if !self.rsa.is_idle() { - return Err(nb::Error::WouldBlock); + pub fn start_step2(&mut self, operand_b: &T::InputType) { + loop { + if self.rsa.is_idle() { + self.rsa.clear_interrupt(); + unsafe { + self.rsa.write_operand_a(operand_b); + } + self.set_start(); + break; + } } - self.rsa.clear_interrupt(); - unsafe { - self.rsa.write_operand_a(operand_b); - } - self.set_start(); - Ok(()) } fn set_start(&mut self) { diff --git a/esp-hal-common/src/rsa/mod.rs b/esp-hal-common/src/rsa/mod.rs index 2365d6bd7..ff2cf6d0b 100644 --- a/esp-hal-common/src/rsa/mod.rs +++ b/esp-hal-common/src/rsa/mod.rs @@ -27,6 +27,31 @@ //! //! let mut rsa = Rsa::new(peripherals.RSA); //! ``` +//! +//! ### Async (modular exponentiation) +//! ```no_run +//! #[embassy_executor::task] +//! async fn mod_exp_example(mut rsa: Rsa<'static>) { +//! let mut outbuf = [0_u8; U512::BYTES]; +//! let mut mod_exp = RsaModularExponentiation::::new( +//! &mut rsa, +//! &BIGNUM_2.to_le_bytes(), +//! &BIGNUM_3.to_le_bytes(), +//! compute_mprime(&BIGNUM_3), +//! ); +//! let r = compute_r(&BIGNUM_3).to_le_bytes(); +//! let base = &BIGNUM_1.to_le_bytes(); +//! mod_exp.exponentiation(&base, &r, &mut outbuf).await; +//! let residue_params = DynResidueParams::new(&BIGNUM_3); +//! let residue = DynResidue::new(&BIGNUM_1, residue_params); +//! let sw_out = residue.pow(&BIGNUM_2); +//! assert_eq!(U512::from_le_bytes(outbuf), sw_out.retrieve()); +//! println!("modular exponentiation done"); +//! } +//! ``` + +//! This peripheral supports `async` on every available chip except of `esp32` +//! (to be solved). //! //! ⚠️: The examples for RSA peripheral are quite extensive, so for a more //! detailed study of how to use this driver please visit [the repository @@ -35,7 +60,7 @@ //! [nb]: https://docs.rs/nb/1.1.0/nb/ //! [the repository with corresponding example]: https://github.com/esp-rs/esp-hal/blob/main/esp32-hal/examples/rsa.rs -use core::{convert::Infallible, marker::PhantomData, ptr::copy_nonoverlapping}; +use core::{marker::PhantomData, ptr::copy_nonoverlapping}; use crate::{ peripheral::{Peripheral, PeripheralRef}, @@ -169,15 +194,16 @@ where /// This is a non blocking function that returns without an error if /// operation is completed successfully. `start_exponentiation` must be /// called before calling this function. - pub fn read_results(&mut self, outbuf: &mut T::InputType) -> nb::Result<(), Infallible> { - if !self.rsa.is_idle() { - return Err(nb::Error::WouldBlock); + pub fn read_results(&mut self, outbuf: &mut T::InputType) { + loop { + if self.rsa.is_idle() { + unsafe { + self.rsa.read_out(outbuf); + } + self.rsa.clear_interrupt(); + break; + } } - unsafe { - self.rsa.read_out(outbuf); - } - self.rsa.clear_interrupt(); - Ok(()) } } @@ -197,15 +223,16 @@ where /// Reads the result to the given buffer. /// This is a non blocking function that returns without an error if /// operation is completed successfully. - pub fn read_results(&mut self, outbuf: &mut T::InputType) -> nb::Result<(), Infallible> { - if !self.rsa.is_idle() { - return Err(nb::Error::WouldBlock); + pub fn read_results(&mut self, outbuf: &mut T::InputType) { + loop { + if self.rsa.is_idle() { + unsafe { + self.rsa.read_out(outbuf); + } + self.rsa.clear_interrupt(); + break; + } } - unsafe { - self.rsa.read_out(outbuf); - } - self.rsa.clear_interrupt(); - Ok(()) } } @@ -226,20 +253,187 @@ where /// This is a non blocking function that returns without an error if /// operation is completed successfully. `start_multiplication` must be /// called before calling this function. - pub fn read_results<'b, const O: usize>( - &mut self, - outbuf: &mut T::OutputType, - ) -> nb::Result<(), Infallible> + pub fn read_results<'b, const O: usize>(&mut self, outbuf: &mut T::OutputType) where T: Multi, { - if !self.rsa.is_idle() { - return Err(nb::Error::WouldBlock); + loop { + if self.rsa.is_idle() { + unsafe { + self.rsa.read_out(outbuf); + } + self.rsa.clear_interrupt(); + break; + } } - unsafe { - self.rsa.read_out(outbuf); - } - self.rsa.clear_interrupt(); - Ok(()) + } +} + +#[cfg(feature = "async")] +pub(crate) mod asynch { + use core::task::Poll; + + use embassy_sync::waitqueue::AtomicWaker; + use procmacros::interrupt; + + use crate::rsa::{ + Multi, + RsaMode, + RsaModularExponentiation, + RsaModularMultiplication, + RsaMultiplication, + }; + + static WAKER: AtomicWaker = AtomicWaker::new(); + + pub(crate) struct RsaFuture<'d> { + instance: &'d crate::peripherals::RSA, + } + + impl<'d> RsaFuture<'d> { + pub async fn new(instance: &'d crate::peripherals::RSA) -> Self { + #[cfg(not(any(esp32, esp32s2, esp32s3)))] + instance.int_ena.modify(|_, w| w.int_ena().set_bit()); + + #[cfg(any(esp32s2, esp32s3))] + instance + .interrupt_ena + .modify(|_, w| w.interrupt_ena().set_bit()); + + #[cfg(esp32)] + instance.interrupt.modify(|_, w| w.interrupt().set_bit()); + + Self { instance } + } + + fn event_bit_is_clear(&self) -> bool { + #[cfg(not(any(esp32, esp32s2, esp32s3)))] + return self.instance.int_ena.read().int_ena().bit_is_clear(); + + #[cfg(any(esp32s2, esp32s3))] + return self + .instance + .interrupt_ena + .read() + .interrupt_ena() + .bit_is_clear(); + + #[cfg(esp32)] + return self.instance.interrupt.read().interrupt().bit_is_clear(); + } + } + + impl<'d> core::future::Future for RsaFuture<'d> { + type Output = (); + + fn poll( + self: core::pin::Pin<&mut Self>, + cx: &mut core::task::Context<'_>, + ) -> core::task::Poll { + WAKER.register(cx.waker()); + if self.event_bit_is_clear() { + Poll::Ready(()) + } else { + Poll::Pending + } + } + } + + impl<'a, 'd, T: RsaMode, const N: usize> RsaModularExponentiation<'a, 'd, T> + where + T: RsaMode, + { + pub async fn exponentiation( + &mut self, + base: &T::InputType, + r: &T::InputType, + outbuf: &mut T::InputType, + ) { + self.start_exponentiation(&base, &r); + RsaFuture::new(&self.rsa.rsa).await; + self.read_results(outbuf); + } + } + + impl<'a, 'd, T: RsaMode, const N: usize> RsaModularMultiplication<'a, 'd, T> + where + T: RsaMode, + { + #[cfg(not(esp32))] + pub async fn modular_multiplication( + &mut self, + r: &T::InputType, + outbuf: &mut T::InputType, + ) { + self.start_modular_multiplication(r); + RsaFuture::new(&self.rsa.rsa).await; + self.read_results(outbuf); + } + + #[cfg(esp32)] + pub async fn modular_multiplication( + &mut self, + operand_a: &T::InputType, + operand_b: &T::InputType, + r: &T::InputType, + outbuf: &mut T::InputType, + ) { + self.start_step1(operand_a, r); + self.start_step2(operand_b); + RsaFuture::new(&self.rsa.rsa).await; + self.read_results(outbuf); + } + } + + impl<'a, 'd, T: RsaMode + Multi, const N: usize> RsaMultiplication<'a, 'd, T> + where + T: RsaMode, + { + #[cfg(not(esp32))] + pub async fn multiplication<'b, const O: usize>( + &mut self, + operand_b: &T::InputType, + outbuf: &mut T::OutputType, + ) where + T: Multi, + { + self.start_multiplication(operand_b); + RsaFuture::new(&self.rsa.rsa).await; + self.read_results(outbuf); + } + + #[cfg(esp32)] + pub async fn multiplication<'b, const O: usize>( + &mut self, + operand_a: &T::InputType, + operand_b: &T::InputType, + outbuf: &mut T::OutputType, + ) where + T: Multi, + { + self.start_multiplication(operand_a, operand_b); + RsaFuture::new(&self.rsa.rsa).await; + self.read_results(outbuf); + } + } + + #[interrupt] + fn RSA() { + #[cfg(not(any(esp32, esp32s2, esp32s3)))] + unsafe { &*crate::peripherals::RSA::ptr() } + .int_ena + .modify(|_, w| w.int_ena().clear_bit()); + + #[cfg(esp32)] + unsafe { &*crate::peripherals::RSA::ptr() } + .interrupt + .modify(|_, w| w.interrupt().clear_bit()); + + #[cfg(any(esp32s2, esp32s3))] + unsafe { &*crate::peripherals::RSA::ptr() } + .interrupt_ena + .modify(|_, w| w.interrupt_ena().clear_bit()); + + WAKER.wake(); } } diff --git a/esp32-hal/examples/rsa.rs b/esp32-hal/examples/rsa.rs index c86bf1026..87047ef6b 100644 --- a/esp32-hal/examples/rsa.rs +++ b/esp32-hal/examples/rsa.rs @@ -26,7 +26,6 @@ use esp32_hal::{ }; use esp_backtrace as _; use esp_println::println; -use nb::block; const BIGNUM_1: U512 = Uint::from_be_hex( "c7f61058f96db3bd87dbab08ab03b4f7f2f864eac249144adea6a65f97803b719d8ca980b7b3c0389c1c7c6\ @@ -61,7 +60,7 @@ fn main() -> ! { let rsa = peripherals.RSA; let mut rsa = Rsa::new(rsa); - block!(rsa.ready()).unwrap(); + nb::block!(rsa.ready()).unwrap(); mod_exp_example(&mut rsa); mod_multi_example(&mut rsa); multiplication_example(&mut rsa); @@ -78,8 +77,8 @@ fn mod_multi_example(rsa: &mut Rsa) { let r = compute_r(&BIGNUM_3).to_le_bytes(); let pre_hw_modmul = xtensa_lx::timer::get_cycle_count(); mod_multi.start_step1(&BIGNUM_1.to_le_bytes(), &r); - block!(mod_multi.start_step2(&BIGNUM_2.to_le_bytes())).unwrap(); - block!(mod_multi.read_results(&mut outbuf)).unwrap(); + mod_multi.start_step2(&BIGNUM_2.to_le_bytes()); + mod_multi.read_results(&mut outbuf); let post_hw_modmul = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw modular multiplication", @@ -112,7 +111,7 @@ fn mod_exp_example(rsa: &mut Rsa) { let base = &BIGNUM_1.to_le_bytes(); let pre_hw_exp = xtensa_lx::timer::get_cycle_count(); mod_exp.start_exponentiation(base, &r); - block!(mod_exp.read_results(&mut outbuf)).unwrap(); + mod_exp.read_results(&mut outbuf); let post_hw_exp = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw modular exponentiation", @@ -138,7 +137,7 @@ fn multiplication_example(rsa: &mut Rsa) { let operand_b = &BIGNUM_2.to_le_bytes(); let pre_hw_mul = xtensa_lx::timer::get_cycle_count(); rsamulti.start_multiplication(&operand_a, &operand_b); - block!(rsamulti.read_results(&mut out)).unwrap(); + rsamulti.read_results(&mut out); let post_hw_mul = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw multiplication", diff --git a/esp32c3-hal/examples/rsa.rs b/esp32c3-hal/examples/rsa.rs index 08704fdce..b23b16eed 100644 --- a/esp32c3-hal/examples/rsa.rs +++ b/esp32c3-hal/examples/rsa.rs @@ -26,7 +26,6 @@ use esp32c3_hal::{ }; use esp_backtrace as _; use esp_println::println; -use nb::block; const BIGNUM_1: U512 = Uint::from_be_hex( "c7f61058f96db3bd87dbab08ab03b4f7f2f864eac249144adea6a65f97803b719d8ca980b7b3c0389c1c7c6\ @@ -61,7 +60,7 @@ fn main() -> ! { let mut rsa = Rsa::new(peripherals.RSA); - block!(rsa.ready()).unwrap(); + nb::block!(rsa.ready()).unwrap(); mod_exp_example(&mut rsa); mod_multi_example(&mut rsa); multiplication_example(&mut rsa); @@ -80,7 +79,7 @@ fn mod_multi_example(rsa: &mut Rsa) { let r = compute_r(&BIGNUM_3).to_le_bytes(); let pre_hw_modmul = SystemTimer::now(); mod_multi.start_modular_multiplication(&r); - block!(mod_multi.read_results(&mut outbuf)).unwrap(); + mod_multi.read_results(&mut outbuf); let post_hw_modmul = SystemTimer::now(); println!( "it took {} cycles for hw modular multiplication", @@ -114,7 +113,7 @@ fn mod_exp_example(rsa: &mut Rsa) { let base = &BIGNUM_1.to_le_bytes(); let pre_hw_exp = SystemTimer::now(); mod_exp.start_exponentiation(&base, &r); - block!(mod_exp.read_results(&mut outbuf)).unwrap(); + mod_exp.read_results(&mut outbuf); let post_hw_exp = SystemTimer::now(); println!( "it took {} cycles for hw modular exponentiation", @@ -140,7 +139,7 @@ fn multiplication_example(rsa: &mut Rsa) { let mut rsamulti = RsaMultiplication::::new(rsa, &operand_a); let pre_hw_mul = SystemTimer::now(); rsamulti.start_multiplication(&operand_b); - block!(rsamulti.read_results(&mut out)).unwrap(); + rsamulti.read_results(&mut out); let post_hw_mul = SystemTimer::now(); println!( "it took {} cycles for hw multiplication", diff --git a/esp32c6-hal/examples/rsa.rs b/esp32c6-hal/examples/rsa.rs index 961ba80dc..c0b1e1a68 100644 --- a/esp32c6-hal/examples/rsa.rs +++ b/esp32c6-hal/examples/rsa.rs @@ -26,7 +26,6 @@ use esp32c6_hal::{ }; use esp_backtrace as _; use esp_println::println; -use nb::block; const BIGNUM_1: U512 = Uint::from_be_hex( "c7f61058f96db3bd87dbab08ab03b4f7f2f864eac249144adea6a65f97803b719d8ca980b7b3c0389c1c7c6\ @@ -61,7 +60,7 @@ fn main() -> ! { let mut rsa = Rsa::new(peripherals.RSA); - block!(rsa.ready()).unwrap(); + nb::block!(rsa.ready()).unwrap(); mod_exp_example(&mut rsa); mod_multi_example(&mut rsa); multiplication_example(&mut rsa); @@ -80,7 +79,7 @@ fn mod_multi_example(rsa: &mut Rsa) { let r = compute_r(&BIGNUM_3).to_le_bytes(); let pre_hw_modmul = SystemTimer::now(); mod_multi.start_modular_multiplication(&r); - block!(mod_multi.read_results(&mut outbuf)).unwrap(); + mod_multi.read_results(&mut outbuf); let post_hw_modmul = SystemTimer::now(); println!( "it took {} cycles for hw modular multiplication", @@ -114,7 +113,7 @@ fn mod_exp_example(rsa: &mut Rsa) { let base = &BIGNUM_1.to_le_bytes(); let pre_hw_exp = SystemTimer::now(); mod_exp.start_exponentiation(&base, &r); - block!(mod_exp.read_results(&mut outbuf)).unwrap(); + mod_exp.read_results(&mut outbuf); let post_hw_exp = SystemTimer::now(); println!( "it took {} cycles for hw modular exponentiation", @@ -140,7 +139,7 @@ fn multiplication_example(rsa: &mut Rsa) { let mut rsamulti = RsaMultiplication::::new(rsa, &operand_a); let pre_hw_mul = SystemTimer::now(); rsamulti.start_multiplication(&operand_b); - block!(rsamulti.read_results(&mut out)).unwrap(); + rsamulti.read_results(&mut out); let post_hw_mul = SystemTimer::now(); println!( "it took {} cycles for hw multiplication", diff --git a/esp32h2-hal/examples/rsa.rs b/esp32h2-hal/examples/rsa.rs index 3a19a40fc..102d8dcef 100644 --- a/esp32h2-hal/examples/rsa.rs +++ b/esp32h2-hal/examples/rsa.rs @@ -26,7 +26,6 @@ use esp32h2_hal::{ }; use esp_backtrace as _; use esp_println::println; -use nb::block; const BIGNUM_1: U512 = Uint::from_be_hex( "c7f61058f96db3bd87dbab08ab03b4f7f2f864eac249144adea6a65f97803b719d8ca980b7b3c0389c1c7c6\ @@ -61,7 +60,7 @@ fn main() -> ! { let mut rsa = Rsa::new(peripherals.RSA); - block!(rsa.ready()).unwrap(); + nb::block!(rsa.ready()).unwrap(); mod_exp_example(&mut rsa); mod_multi_example(&mut rsa); multiplication_example(&mut rsa); @@ -80,7 +79,7 @@ fn mod_multi_example(rsa: &mut Rsa) { let r = compute_r(&BIGNUM_3).to_le_bytes(); let pre_hw_modmul = SystemTimer::now(); mod_multi.start_modular_multiplication(&r); - block!(mod_multi.read_results(&mut outbuf)).unwrap(); + mod_multi.read_results(&mut outbuf); let post_hw_modmul = SystemTimer::now(); println!( "it took {} cycles for hw modular multiplication", @@ -114,7 +113,7 @@ fn mod_exp_example(rsa: &mut Rsa) { let base = &BIGNUM_1.to_le_bytes(); let pre_hw_exp = SystemTimer::now(); mod_exp.start_exponentiation(&base, &r); - block!(mod_exp.read_results(&mut outbuf)).unwrap(); + mod_exp.read_results(&mut outbuf); let post_hw_exp = SystemTimer::now(); println!( "it took {} cycles for hw modular exponentiation", @@ -140,7 +139,7 @@ fn multiplication_example(rsa: &mut Rsa) { let mut rsamulti = RsaMultiplication::::new(rsa, &operand_a); let pre_hw_mul = SystemTimer::now(); rsamulti.start_multiplication(&operand_b); - block!(rsamulti.read_results(&mut out)).unwrap(); + rsamulti.read_results(&mut out); let post_hw_mul = SystemTimer::now(); println!( "it took {} cycles for hw multiplication", diff --git a/esp32s2-hal/examples/rsa.rs b/esp32s2-hal/examples/rsa.rs index ba233658c..aa3e305a3 100644 --- a/esp32s2-hal/examples/rsa.rs +++ b/esp32s2-hal/examples/rsa.rs @@ -26,7 +26,6 @@ use esp32s2_hal::{ }; use esp_backtrace as _; use esp_println::println; -use nb::block; const BIGNUM_1: U512 = Uint::from_be_hex( "c7f61058f96db3bd87dbab08ab03b4f7f2f864eac249144adea6a65f97803b719d8ca980b7b3c0389c1c7c6\ @@ -61,7 +60,7 @@ fn main() -> ! { let mut rsa = Rsa::new(peripherals.RSA); - block!(rsa.ready()).unwrap(); + nb::block!(rsa.ready()).unwrap(); mod_exp_example(&mut rsa); mod_multi_example(&mut rsa); multiplication_example(&mut rsa); @@ -81,7 +80,7 @@ fn mod_multi_example(rsa: &mut Rsa) { let r = compute_r(&BIGNUM_3).to_le_bytes(); let pre_hw_modmul = xtensa_lx::timer::get_cycle_count(); mod_multi.start_modular_multiplication(&r); - block!(mod_multi.read_results(&mut outbuf)).unwrap(); + mod_multi.read_results(&mut outbuf); let post_hw_modmul = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw modular multiplication", @@ -115,7 +114,7 @@ fn mod_exp_example(rsa: &mut Rsa) { let base = &BIGNUM_1.to_le_bytes(); let pre_hw_exp = xtensa_lx::timer::get_cycle_count(); mod_exp.start_exponentiation(&base, &r); - block!(mod_exp.read_results(&mut outbuf)).unwrap(); + mod_exp.read_results(&mut outbuf); let post_hw_exp = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw modular exponentiation", @@ -141,7 +140,7 @@ fn multiplication_example(rsa: &mut Rsa) { let mut rsamulti = RsaMultiplication::::new(rsa, &operand_a); let pre_hw_mul = xtensa_lx::timer::get_cycle_count(); rsamulti.start_multiplication(&operand_b); - block!(rsamulti.read_results(&mut out)).unwrap(); + rsamulti.read_results(&mut out); let post_hw_mul = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw multiplication", diff --git a/esp32s3-hal/examples/rsa.rs b/esp32s3-hal/examples/rsa.rs index de7afe0c4..cb99bca5d 100644 --- a/esp32s3-hal/examples/rsa.rs +++ b/esp32s3-hal/examples/rsa.rs @@ -26,7 +26,6 @@ use esp32s3_hal::{ }; use esp_backtrace as _; use esp_println::println; -use nb::block; const BIGNUM_1: U512 = Uint::from_be_hex( "c7f61058f96db3bd87dbab08ab03b4f7f2f864eac249144adea6a65f97803b719d8ca980b7b3c0389c1c7c6\ @@ -61,7 +60,7 @@ fn main() -> ! { let mut rsa = Rsa::new(peripherals.RSA); - block!(rsa.ready()).unwrap(); + nb::block!(rsa.ready()).unwrap(); mod_exp_example(&mut rsa); mod_multi_example(&mut rsa); multiplication_example(&mut rsa); @@ -81,7 +80,7 @@ fn mod_multi_example(rsa: &mut Rsa) { let r = compute_r(&BIGNUM_3).to_le_bytes(); let pre_hw_modmul = xtensa_lx::timer::get_cycle_count(); mod_multi.start_modular_multiplication(&r); - block!(mod_multi.read_results(&mut outbuf)).unwrap(); + mod_multi.read_results(&mut outbuf); let post_hw_modmul = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw modular multiplication", @@ -115,7 +114,7 @@ fn mod_exp_example(rsa: &mut Rsa) { let base = &BIGNUM_1.to_le_bytes(); let pre_hw_exp = xtensa_lx::timer::get_cycle_count(); mod_exp.start_exponentiation(&base, &r); - block!(mod_exp.read_results(&mut outbuf)).unwrap(); + mod_exp.read_results(&mut outbuf); let post_hw_exp = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw modular exponentiation", @@ -141,7 +140,7 @@ fn multiplication_example(rsa: &mut Rsa) { let mut rsamulti = RsaMultiplication::::new(rsa, &operand_a); let pre_hw_mul = xtensa_lx::timer::get_cycle_count(); rsamulti.start_multiplication(&operand_b); - block!(rsamulti.read_results(&mut out)).unwrap(); + rsamulti.read_results(&mut out); let post_hw_mul = xtensa_lx::timer::get_cycle_count(); println!( "it took {} cycles for hw multiplication",