Merge upstream changes

Cargo.toml

@@ -10,3 +10,11 @@ resolver = "2"
 [profile.dev]
 opt-level = 2
 
+[patch.crates-io.crypto-bigint]
+git = "https://github.com/risc0/RustCrypto-crypto-bigint"
+tag = "v0.5.2-risc0"
+
+[patch.crates-io.sha2]
+git = "https://github.com/risc0/RustCrypto-hashes"
+tag = "sha2-v0.10.6-risc0"
+

curve25519-dalek-derive/tests/tests.rs

@@ -23,10 +23,6 @@ where
     a - b
 }
 
-#[unsafe_target_feature("sse2")]
-#[cfg(feature = "dummy")]
-fn function_with_cfg() {}
-
 #[unsafe_target_feature("sse2")]
 #[rustfmt::skip]
 fn function_with_rustfmt_skip() {}
@@ -45,9 +41,6 @@ impl Struct {
     fn member_function_with_const_arg<const N: u32>(self) -> u32 {
         self.a - N
     }
-
-    #[cfg(feature = "dummy")]
-    fn member_function_with_cfg() {}
 }
 
 struct StructWithGenerics<T>
@@ -93,7 +86,7 @@ mod inner {
     }
 }
 
-#[unsafe_target_feature_specialize("sse2", "avx2", conditional("avx512ifma", disabled))]
+#[unsafe_target_feature_specialize("sse2", "avx2")]
 mod inner_spec {
     #[for_target_feature("sse2")]
     const CONST: u32 = 1;

curve25519-dalek/Cargo.toml

@@ -30,15 +30,13 @@ rustdoc-args = [
 features = ["serde", "rand_core", "digest", "legacy_compatibility", "group-bits"]
 
 [dev-dependencies]
+hex = "0.4"
 sha2 = { version = "0.10", default-features = false }
 bincode = "1"
-criterion = { version = "0.5", features = ["html_reports"] }
-hex = "0.4.2"
 rand = "0.8"
 rand_core = { version = "0.6", default-features = false, features = ["getrandom"] }
 
 [build-dependencies]
-platforms = "3.0.2"
 rustc_version = "0.4.0"
 
 [[bench]]
@@ -56,12 +54,19 @@ subtle = { version = "2.3.0", default-features = false }
 serde = { version = "1.0", default-features = false, optional = true, features = ["derive"] }
 zeroize = { version = "1", default-features = false, optional = true }
 
+[target.'cfg(target_os = "zkvm")'.dependencies]
+# Use crypto-bigint v0.5.2, which is overridden with a patch for RISC Zero acceleration.
+crypto-bigint = { version = "=0.5.2", default-features = false, features = ["zeroize"] }
+
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 cpufeatures = "0.2.6"
 
 [target.'cfg(curve25519_dalek_backend = "fiat")'.dependencies]
 fiat-crypto = { version = "0.2.1", default-features = false }
 
+[target.'cfg(not(target_os = "zkvm"))'.dev-dependencies]
+criterion = { version = "0.5.1", features = ["html_reports"] }
+
 [features]
 default = ["alloc", "precomputed-tables", "zeroize"]
 alloc = ["zeroize?/alloc"]

curve25519-dalek/build.rs

@@ -9,17 +9,31 @@ enum DalekBits {
     Dalek64,
 }
 
+use std::fmt::Formatter;
+
+impl std::fmt::Display for DalekBits {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let w_bits = match self {
+            DalekBits::Dalek32 => "32",
+            DalekBits::Dalek64 => "64",
+        };
+        write!(f, "{}", w_bits)
+    }
+}
+
 fn main() {
+    let target_arch = match std::env::var("CARGO_CFG_TARGET_ARCH") {
+        Ok(arch) => arch,
+        _ => "".to_string(),
+    };
+
     let curve25519_dalek_bits = match std::env::var("CARGO_CFG_CURVE25519_DALEK_BITS").as_deref() {
         Ok("32") => DalekBits::Dalek32,
         Ok("64") => DalekBits::Dalek64,
-        _ => deterministic::determine_curve25519_dalek_bits(),
+        _ => deterministic::determine_curve25519_dalek_bits(&target_arch),
     };
 
-    match curve25519_dalek_bits {
-        DalekBits::Dalek64 => println!("cargo:rustc-cfg=curve25519_dalek_bits=\"64\""),
-        DalekBits::Dalek32 => println!("cargo:rustc-cfg=curve25519_dalek_bits=\"32\""),
-    }
+    println!("cargo:rustc-cfg=curve25519_dalek_bits=\"{curve25519_dalek_bits}\"");
 
     if rustc_version::version_meta()
         .expect("failed to detect rustc version")
@@ -36,11 +50,6 @@ fn main() {
         println!("cargo:rustc-cfg=allow_unused_unsafe");
     }
 
-    let target_arch = match std::env::var("CARGO_CFG_TARGET_ARCH") {
-        Ok(arch) => arch,
-        _ => "".to_string(),
-    };
-
     // Backend overrides / defaults
     let curve25519_dalek_backend =
         match std::env::var("CARGO_CFG_CURVE25519_DALEK_BACKEND").as_deref() {
@@ -74,53 +83,43 @@ mod deterministic {
 
     use super::*;
 
-    // Standard Cargo TARGET environment variable of triplet is required
-    static ERR_MSG_NO_TARGET: &str = "Standard Cargo TARGET environment variable is not set";
+    // Custom Rust non-cargo build tooling needs to set CARGO_CFG_TARGET_POINTER_WIDTH
+    static ERR_MSG_NO_POINTER_WIDTH: &str =
+        "Standard Cargo TARGET_POINTER_WIDTH environment variable is not set.";
 
-    // Custom Non-Rust standard target platforms require explicit settings.
-    static ERR_MSG_NO_PLATFORM: &str = "Unknown Rust target platform.";
+    // When either non-32 or 64 TARGET_POINTER_WIDTH detected
+    static ERR_MSG_UNKNOWN_POINTER_WIDTH: &str = "Unknown TARGET_POINTER_WIDTH detected.";
 
     // Warning when the curve25519_dalek_bits cannot be determined
     fn determine_curve25519_dalek_bits_warning(cause: &str) {
         println!("cargo:warning=\"Defaulting to curve25519_dalek_bits=32: {cause}\"");
     }
 
     // Determine the curve25519_dalek_bits based on Rust standard TARGET triplet
-    pub(super) fn determine_curve25519_dalek_bits() -> DalekBits {
-        use platforms::target::PointerWidth;
-
-        // TARGET environment is supplied by Cargo
-        // https://doc.rust-lang.org/cargo/reference/environment-variables.html
-        let target_triplet = match std::env::var("TARGET") {
-            Ok(t) => t,
+    pub(super) fn determine_curve25519_dalek_bits(target_arch: &String) -> DalekBits {
+        let target_pointer_width = match std::env::var("CARGO_CFG_TARGET_POINTER_WIDTH") {
+            Ok(pw) => pw,
             Err(_) => {
-                determine_curve25519_dalek_bits_warning(ERR_MSG_NO_TARGET);
-                return DalekBits::Dalek32;
-            }
-        };
-
-        // platforms crate is the source of truth used to determine the platform
-        let platform = match platforms::Platform::find(&target_triplet) {
-            Some(p) => p,
-            None => {
-                determine_curve25519_dalek_bits_warning(ERR_MSG_NO_PLATFORM);
+                determine_curve25519_dalek_bits_warning(ERR_MSG_NO_POINTER_WIDTH);
                 return DalekBits::Dalek32;
             }
         };
 
         #[allow(clippy::match_single_binding)]
-        match platform.target_arch {
+        match &target_arch {
             //Issues: 449 and 456
+            //TODO: When adding arch defaults use proper types not String match
             //TODO(Arm): Needs tests + benchmarks to back this up
-            //platforms::target::Arch::Arm => DalekBits::Dalek64,
             //TODO(Wasm32): Needs tests + benchmarks to back this up
-            //platforms::target::Arch::Wasm32 => DalekBits::Dalek64,
-            _ => match platform.target_pointer_width {
-                PointerWidth::U64 => DalekBits::Dalek64,
-                PointerWidth::U32 => DalekBits::Dalek32,
+            _ => match target_pointer_width.as_ref() {
+                "64" => DalekBits::Dalek64,
+                "32" => DalekBits::Dalek32,
                 // Intended default solely for non-32/64 target pointer widths
                 // Otherwise known target platforms only.
-                _ => DalekBits::Dalek32,
+                _ => {
+                    determine_curve25519_dalek_bits_warning(ERR_MSG_UNKNOWN_POINTER_WIDTH);
+                    DalekBits::Dalek32
+                }
             },
         }
     }

curve25519-dalek/src/backend/mod.rs

@@ -87,24 +87,24 @@ where
     match get_selected_backend() {
         #[cfg(curve25519_dalek_backend = "simd")]
         BackendKind::Avx2 =>
-            self::vector::scalar_mul::pippenger::spec_avx2::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
+            vector::scalar_mul::pippenger::spec_avx2::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
         #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
         BackendKind::Avx512 =>
-            self::vector::scalar_mul::pippenger::spec_avx512ifma_avx512vl::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
+            vector::scalar_mul::pippenger::spec_avx512ifma_avx512vl::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
         BackendKind::Serial =>
-            self::serial::scalar_mul::pippenger::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
+            serial::scalar_mul::pippenger::Pippenger::optional_multiscalar_mul::<I, J>(scalars, points),
     }
 }
 
 #[cfg(feature = "alloc")]
 pub(crate) enum VartimePrecomputedStraus {
     #[cfg(curve25519_dalek_backend = "simd")]
-    Avx2(self::vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus),
+    Avx2(vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus),
     #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
     Avx512ifma(
-        self::vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus,
+        vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus,
     ),
-    Scalar(self::serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus),
+    Scalar(serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus),
 }
 
 #[cfg(feature = "alloc")]
@@ -119,12 +119,12 @@ impl VartimePrecomputedStraus {
         match get_selected_backend() {
             #[cfg(curve25519_dalek_backend = "simd")]
             BackendKind::Avx2 =>
-                VartimePrecomputedStraus::Avx2(self::vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus::new(static_points)),
+                VartimePrecomputedStraus::Avx2(vector::scalar_mul::precomputed_straus::spec_avx2::VartimePrecomputedStraus::new(static_points)),
             #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
             BackendKind::Avx512 =>
-                VartimePrecomputedStraus::Avx512ifma(self::vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus::new(static_points)),
+                VartimePrecomputedStraus::Avx512ifma(vector::scalar_mul::precomputed_straus::spec_avx512ifma_avx512vl::VartimePrecomputedStraus::new(static_points)),
             BackendKind::Serial =>
-                VartimePrecomputedStraus::Scalar(self::serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus::new(static_points))
+                VartimePrecomputedStraus::Scalar(serial::scalar_mul::precomputed_straus::VartimePrecomputedStraus::new(static_points))
         }
     }
 
@@ -179,19 +179,16 @@ where
     match get_selected_backend() {
         #[cfg(curve25519_dalek_backend = "simd")]
         BackendKind::Avx2 => {
-            self::vector::scalar_mul::straus::spec_avx2::Straus::multiscalar_mul::<I, J>(
-                scalars, points,
-            )
+            vector::scalar_mul::straus::spec_avx2::Straus::multiscalar_mul::<I, J>(scalars, points)
         }
         #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
         BackendKind::Avx512 => {
-            self::vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::multiscalar_mul::<
-                I,
-                J,
-            >(scalars, points)
+            vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::multiscalar_mul::<I, J>(
+                scalars, points,
+            )
         }
         BackendKind::Serial => {
-            self::serial::scalar_mul::straus::Straus::multiscalar_mul::<I, J>(scalars, points)
+            serial::scalar_mul::straus::Straus::multiscalar_mul::<I, J>(scalars, points)
         }
     }
 }
@@ -209,21 +206,19 @@ where
     match get_selected_backend() {
         #[cfg(curve25519_dalek_backend = "simd")]
         BackendKind::Avx2 => {
-            self::vector::scalar_mul::straus::spec_avx2::Straus::optional_multiscalar_mul::<I, J>(
+            vector::scalar_mul::straus::spec_avx2::Straus::optional_multiscalar_mul::<I, J>(
                 scalars, points,
             )
         }
         #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
         BackendKind::Avx512 => {
-            self::vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::optional_multiscalar_mul::<
+            vector::scalar_mul::straus::spec_avx512ifma_avx512vl::Straus::optional_multiscalar_mul::<
                 I,
                 J,
             >(scalars, points)
         }
         BackendKind::Serial => {
-            self::serial::scalar_mul::straus::Straus::optional_multiscalar_mul::<I, J>(
-                scalars, points,
-            )
+            serial::scalar_mul::straus::Straus::optional_multiscalar_mul::<I, J>(scalars, points)
         }
     }
 }
@@ -232,12 +227,12 @@ where
 pub fn variable_base_mul(point: &EdwardsPoint, scalar: &Scalar) -> EdwardsPoint {
     match get_selected_backend() {
         #[cfg(curve25519_dalek_backend = "simd")]
-        BackendKind::Avx2 => self::vector::scalar_mul::variable_base::spec_avx2::mul(point, scalar),
+        BackendKind::Avx2 => vector::scalar_mul::variable_base::spec_avx2::mul(point, scalar),
         #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
         BackendKind::Avx512 => {
-            self::vector::scalar_mul::variable_base::spec_avx512ifma_avx512vl::mul(point, scalar)
+            vector::scalar_mul::variable_base::spec_avx512ifma_avx512vl::mul(point, scalar)
         }
-        BackendKind::Serial => self::serial::scalar_mul::variable_base::mul(point, scalar),
+        BackendKind::Serial => serial::scalar_mul::variable_base::mul(point, scalar),
     }
 }
 
@@ -246,11 +241,11 @@ pub fn variable_base_mul(point: &EdwardsPoint, scalar: &Scalar) -> EdwardsPoint
 pub fn vartime_double_base_mul(a: &Scalar, A: &EdwardsPoint, b: &Scalar) -> EdwardsPoint {
     match get_selected_backend() {
         #[cfg(curve25519_dalek_backend = "simd")]
-        BackendKind::Avx2 => self::vector::scalar_mul::vartime_double_base::spec_avx2::mul(a, A, b),
+        BackendKind::Avx2 => vector::scalar_mul::vartime_double_base::spec_avx2::mul(a, A, b),
         #[cfg(all(curve25519_dalek_backend = "simd", nightly))]
         BackendKind::Avx512 => {
-            self::vector::scalar_mul::vartime_double_base::spec_avx512ifma_avx512vl::mul(a, A, b)
+            vector::scalar_mul::vartime_double_base::spec_avx512ifma_avx512vl::mul(a, A, b)
         }
-        BackendKind::Serial => self::serial::scalar_mul::vartime_double_base::mul(a, A, b),
+        BackendKind::Serial => serial::scalar_mul::vartime_double_base::mul(a, A, b),
     }
 }