From 03e91fefce8821cbd5575ed9abcdd89b42c0e105 Mon Sep 17 00:00:00 2001 From: bunnie Date: Sun, 11 Jul 2021 02:03:00 +0800 Subject: [PATCH] finish u32e_backend variant for bootloader use --- Cargo.toml | 2 +- src/backend/serial/u32/field.rs | 7 +- src/backend/serial/u32e/field.rs | 19 ++---- src/backend/serial/u32e/scalar.rs | 1 - src/debug.rs | 104 ------------------------------ src/edwards.rs | 20 +----- src/field.rs | 18 ------ src/lib.rs | 6 +- src/ristretto.rs | 2 +- src/scalar.rs | 2 +- 10 files changed, 13 insertions(+), 168 deletions(-) delete mode 100644 src/debug.rs diff --git a/Cargo.toml b/Cargo.toml index 0d137a6..9c9f1dc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -81,7 +81,7 @@ std = ["alloc", "subtle/std", "rand_core/std"] alloc = ["zeroize/alloc"] # The u32 backend uses u32s with u64 products. -u32_backend = ["utralib"] +u32_backend = [] # The u32e backend uses u32s with u64 products + field25519 accelerator. u32e_backend = ["engine25519-as", "utralib"] # The u64 backend uses u64s with u128 products. diff --git a/src/backend/serial/u32/field.rs b/src/backend/serial/u32/field.rs index 31711d1..c8f3e5e 100644 --- a/src/backend/serial/u32/field.rs +++ b/src/backend/serial/u32/field.rs @@ -27,9 +27,6 @@ use subtle::ConditionallySelectable; use zeroize::Zeroize; -#[macro_use] -use debug; - /// A `FieldElement2625` represents an element of the field /// \\( \mathbb Z / (2\^{255} - 19)\\). /// @@ -218,9 +215,7 @@ impl<'a, 'b> Mul<&'b FieldElement2625> for &'a FieldElement2625 { // // So z[0] fits into a u64 if 51 + 2*b + lg(249) < 64 // if b < 2.5. - let ret = FieldElement2625::reduce([z0, z1, z2, z3, z4, z5, z6, z7, z8, z9]); - //println!("a:{:?}\n\rb:{:?}\n\rout:{:?}", self.to_bytes(), _rhs.to_bytes(), ret.to_bytes()); - ret + FieldElement2625::reduce([z0, z1, z2, z3, z4, z5, z6, z7, z8, z9]) } } diff --git a/src/backend/serial/u32e/field.rs b/src/backend/serial/u32e/field.rs index d5a8586..df367a0 100644 --- a/src/backend/serial/u32e/field.rs +++ b/src/backend/serial/u32e/field.rs @@ -16,7 +16,6 @@ //! implementation, and was then rewritten to use unsigned limbs instead //! of signed limbs. -use core::fmt::Debug; use core::ops::Neg; use core::ops::{Add, AddAssign}; use core::ops::{Mul, MulAssign}; @@ -50,17 +49,10 @@ use zeroize::Zeroize; /// The backend-specific type `Engine25519` should not be used /// outside of the `curve25519_dalek::field` module. -//#[macro_use] -//mod debug; - -#[macro_use] -use debug; - #[derive(Copy, Clone, Debug)] pub struct Engine25519( pub (crate) [u8; 32] ); -#[derive(Debug)] pub(crate) enum EngineOp { Mul, Add, @@ -68,7 +60,6 @@ pub(crate) enum EngineOp { } pub(crate) fn engine(a: &[u8; 32], b: &[u8; 32], op: EngineOp) -> Engine25519 { - use core::convert::TryInto; use utralib::generated::*; let mut engine = utralib::CSR::new(utra::engine::HW_ENGINE_BASE as *mut u32); let mcode: &'static mut [u32] = unsafe{ core::slice::from_raw_parts_mut(utralib::HW_ENGINE_MEM as *mut u32, 1024) }; @@ -121,12 +112,17 @@ pub(crate) fn engine(a: &[u8; 32], b: &[u8; 32], op: EngineOp) -> Engine25519 { } // copy a arg for (src, dst) in a.chunks_exact(4).zip(rf[0].iter_mut()) { - unsafe{ (dst as *mut u32).write_volatile(u32::from_le_bytes(src[0..4].try_into().unwrap()));} + let bytes: [u8; 4] = [src[0], src[1], src[2], src[3]]; + unsafe{ (dst as *mut u32).write_volatile(u32::from_le_bytes(bytes));} + /* this is a bad idea: src[0..4].try_into().unwrap() + because "unwrap()" adds in a whole bunch of string formatting stuff, adds +16k or so to the binary size + */ } // copy b arg for (src, dst) in b.chunks_exact(4).zip(rf[1].iter_mut()) { - unsafe{ (dst as *mut u32).write_volatile(u32::from_le_bytes(src[0..4].try_into().unwrap()));} + let bytes: [u8; 4] = [src[0], src[1], src[2], src[3]]; + unsafe{ (dst as *mut u32).write_volatile(u32::from_le_bytes(bytes));} } engine.wfo(utra::engine::CONTROL_GO, 1); @@ -192,7 +188,6 @@ impl<'a, 'b> Mul<&'b Engine25519> for &'a Engine25519 { type Output = Engine25519; fn mul(self, _rhs: &'b Engine25519) -> Engine25519 { let ret = engine(&self.0, &_rhs.0, EngineOp::Mul); - //println!("a:{:?}\n\rb:{:?}\n\rout:{:?}", self.0, _rhs.0, ret.0); ret } } diff --git a/src/backend/serial/u32e/scalar.rs b/src/backend/serial/u32e/scalar.rs index e5f7803..cc31315 100644 --- a/src/backend/serial/u32e/scalar.rs +++ b/src/backend/serial/u32e/scalar.rs @@ -10,7 +10,6 @@ //! -0x1ffffffe00000008 (62 bits with sign bit) to //! 0x43fffffbc0000011 (63 bits), which is still safe. -use core::fmt::Debug; use core::ops::{Index, IndexMut}; use zeroize::Zeroize; diff --git a/src/debug.rs b/src/debug.rs deleted file mode 100644 index bde1e14..0000000 --- a/src/debug.rs +++ /dev/null @@ -1,104 +0,0 @@ -use utralib::generated::*; -pub struct Uart { - // pub base: *mut u32, -} - -impl Uart { - fn put_digit(&mut self, d: u8) { - let nyb = d & 0xF; - if nyb < 10 { - self.putc(nyb + 0x30); - } else { - self.putc(nyb + 0x61 - 10); - } - } - 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 putc(&self, c: u8) { - let base = utra::uart::HW_UART_BASE as *mut u32; - let mut uart = CSR::new(base); - // Wait until TXFULL is `0` - while uart.r(utra::uart::TXFULL) != 0 {} - uart.wo(utra::uart::RXTX, c as u32) - } - - pub fn getc(&self) -> Option { - let base = utra::uart::HW_UART_BASE as *mut u32; - let mut uart = CSR::new(base); - match uart.rf(utra::uart::EV_PENDING_RX) { - 0 => None, - ack => { - let c = Some(uart.rf(utra::uart::RXTX_RXTX) as u8); - uart.wfo(utra::uart::EV_PENDING_RX, ack); - c - } - } - } - - pub fn tiny_write_str(&mut self, s: &str) { - for c in s.bytes() { - self.putc(c); - } - } - -} - -use core::fmt::{Error, Write}; -impl Write for Uart { - fn write_str(&mut self, s: &str) -> Result<(), Error> { - for c in s.bytes() { - self.putc(c); - } - Ok(()) - } -} - -#[macro_use] -pub mod debug_print_hardware { - #[macro_export] - macro_rules! print - { - ($($args:tt)+) => ({ - use core::fmt::Write; - let _ = write!(debug::Uart {}, $($args)+); - }); - } -} - -#[macro_use] -#[cfg(test)] -mod debug_print_hardware { - #[macro_export] - #[allow(unused_variables)] - macro_rules! print { - ($($args:tt)+) => ({ - std::print!($($args)+) - }); - } -} - -#[macro_export] -macro_rules! println -{ - () => ({ - $crate::print!("\r\n") - }); - ($fmt:expr) => ({ - $crate::print!(concat!($fmt, "\r\n")) - }); - ($fmt:expr, $($args:tt)+) => ({ - $crate::print!(concat!($fmt, "\r\n"), $($args)+) - }); -} diff --git a/src/edwards.rs b/src/edwards.rs index 8b5c641..7c97ca4 100644 --- a/src/edwards.rs +++ b/src/edwards.rs @@ -172,9 +172,6 @@ impl Debug for CompressedEdwardsY { } } -#[macro_use] -use debug; - impl CompressedEdwardsY { /// View this `CompressedEdwardsY` as an array of bytes. pub fn as_bytes(&self) -> &[u8; 32] { @@ -191,36 +188,21 @@ impl CompressedEdwardsY { /// Returns `None` if the input is not the \\(y\\)-coordinate of a /// curve point. pub fn decompress(&self) -> Option { - println!("self.bytes: {:?}", self.as_bytes()); let Y = FieldElement::from_bytes(self.as_bytes()); - println!("Y: {:?}", Y.to_bytes()); let Z = FieldElement::one(); - println!("Z: {:?}", Z.to_bytes()); let YY = Y.square(); - println!("YY: {:?}", YY.to_bytes()); let u = &YY - &Z; // u = y²-1 - println!("u: {:?}", u.to_bytes()); let v = &(&YY * &constants::EDWARDS_D) + &Z; // v = dy²+1 - println!("v: {:?}", v.to_bytes()); let (is_valid_y_coord, mut X) = FieldElement::sqrt_ratio_i(&u, &v); - println!("isvalid: {:?}", is_valid_y_coord); - println!("X: {:?}", X.to_bytes()); if is_valid_y_coord.unwrap_u8() != 1u8 { return None; } - println!("valid"); // FieldElement::sqrt_ratio_i always returns the nonnegative square root, // so we negate according to the supplied sign bit. let compressed_sign_bit = Choice::from(self.as_bytes()[31] >> 7); X.conditional_negate(compressed_sign_bit); - println!("negate"); - println!("X: {:?}", X.to_bytes()); - println!("Y: {:?}", Y.to_bytes()); - println!("Z: {:?}", Z.to_bytes()); - let t = &X * &Y; - println!("T: {:?}", t.to_bytes()); - Some(EdwardsPoint{ X, Y, Z, T: t }) + Some(EdwardsPoint{ X, Y, Z, T: &X * &Y }) } } diff --git a/src/field.rs b/src/field.rs index 53fb29d..16d5d03 100644 --- a/src/field.rs +++ b/src/field.rs @@ -94,8 +94,6 @@ impl ConstantTimeEq for FieldElement { self.to_bytes().ct_eq(&other.to_bytes()) } } -#[macro_use] -use debug; impl FieldElement { /// Determine if this `FieldElement` is negative, in the sense @@ -264,41 +262,25 @@ impl FieldElement { // If v is zero, r is also zero. let v3 = &v.square() * v; - println!("v3: {:?}", v3.to_bytes()); let v7 = &v3.square() * v; - println!("v7: {:?}", v7.to_bytes()); let mut r = &(u * &v3) * &(u * &v7).pow_p58(); - println!("r: {:?}", r.to_bytes()); let check = v * &r.square(); - println!("check: {:?}", check.to_bytes()); let i = &constants::SQRT_M1; - println!("i: {:?}", i.to_bytes()); let correct_sign_sqrt = check.ct_eq( u); let flipped_sign_sqrt = check.ct_eq( &(-u)); let flipped_sign_sqrt_i = check.ct_eq(&(&(-u)*i)); - println!("correct_sign_sqrt: {:?}", correct_sign_sqrt); - println!("u: {:?}", u.to_bytes()); - println!("flipped_sign_sqrt: {:?}", flipped_sign_sqrt); - println!("-u: {:?}", &(-u).to_bytes()); - println!("flipped_sign_sqrt_i: {:?}", flipped_sign_sqrt_i); - println!("-u * i: {:?}", &(&(-u)*i)); let r_prime = &constants::SQRT_M1 * &r; - println!("r_prime: {:?}", r_prime.to_bytes()); r.conditional_assign(&r_prime, flipped_sign_sqrt | flipped_sign_sqrt_i); - println!("r_assign1: {:?}", r.to_bytes()); - // Choose the nonnegative square root. let r_is_negative = r.is_negative(); r.conditional_negate(r_is_negative); - println!("r_assign2: {:?}", r.to_bytes()); let was_nonzero_square = correct_sign_sqrt | flipped_sign_sqrt; - println!("final r: {:?}", r.to_bytes()); (was_nonzero_square, r) } diff --git a/src/lib.rs b/src/lib.rs index d7aa3e7..2d56e78 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -73,13 +73,9 @@ extern crate engine25519_as; #[cfg(feature = "betrusted")] extern crate engine_25519; -//#[cfg(feature = "u32e_backend")] +#[cfg(feature = "u32e_backend")] extern crate utralib; -//#[cfg(feature = "u32e_backend")] -#[macro_use] -mod debug; - //------------------------------------------------------------------------ // curve25519-dalek public modules //------------------------------------------------------------------------ diff --git a/src/ristretto.rs b/src/ristretto.rs index b29fd33..97cb68a 100644 --- a/src/ristretto.rs +++ b/src/ristretto.rs @@ -194,7 +194,7 @@ use traits::{MultiscalarMul, VartimeMultiscalarMul, VartimePrecomputedMultiscala feature = "simd_backend", any(target_feature = "avx2", target_feature = "avx512ifma") )))] -#[cfg(not(feature = "betrusted"))] +#[cfg(all(not(feature = "betrusted"), not(feature = "u32e_backend")))] use backend::serial::scalar_mul; #[cfg(all( feature = "simd_backend", diff --git a/src/scalar.rs b/src/scalar.rs index 9b97c3b..4a1e4c8 100644 --- a/src/scalar.rs +++ b/src/scalar.rs @@ -1018,7 +1018,7 @@ impl Scalar { /// Returns a size hint indicating how many entries of the return /// value of `to_radix_2w` are nonzero. - #[cfg(not(feature = "betrusted"))] + #[cfg(all(not(feature = "betrusted"), not(feature = "u32e_backend")))] pub(crate) fn to_radix_2w_size_hint(w: usize) -> usize { debug_assert!(w >= 4); debug_assert!(w <= 8);