diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml new file mode 100644 index 0000000..2214f4b --- /dev/null +++ b/.github/workflows/rust.yml @@ -0,0 +1,131 @@ +name: Rust + +on: + push: + branches: [ '*' ] + pull_request: + branches: [ main, develop ] + +env: + CARGO_TERM_COLOR: always + +jobs: + test-u32: + name: Test u32 backend + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + override: true + - uses: actions-rs/cargo@v1 + with: + command: test + args: --no-default-features --features "std u32_backend" + + test-u64: + name: Test u64 backend + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + override: true + - uses: actions-rs/cargo@v1 + with: + command: test + args: --no-default-features --features "std u64_backend" + + test-simd: + name: Test simd backend (nightly) + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: nightly + override: true + - uses: actions-rs/cargo@v1 + with: + command: test + args: --no-default-features --features "std simd_backend" + + test-defaults-serde: + name: Test default feature selection and serde + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + override: true + - uses: actions-rs/cargo@v1 + with: + command: test + args: --features "serde" + + test-alloc-u32: + name: Test no_std+alloc with u32 backend + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + override: true + - uses: actions-rs/cargo@v1 + with: + command: test + args: --lib --no-default-features --features "alloc u32_backend" + + nightly: + name: Test nightly compiler + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: nightly + override: true + - uses: actions-rs/cargo@v1 + with: + command: test + args: --features "nightly" + + msrv: + name: Current MSRV is 1.41 + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: 1.41 + override: true + - uses: actions-rs/cargo@v1 + with: + command: build + + bench: + name: Check that benchmarks compile + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + override: true + - uses: actions-rs/cargo@v1 + with: + command: bench + # This filter selects no benchmarks, so we don't run any, only build them. + args: "DONTRUNBENCHMARKS" diff --git a/CHANGELOG.md b/CHANGELOG.md index 1d42492..000b965 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,22 @@ major series. ## 3.x series +### 3.2.0 + +* Add support for getting the identity element for the Montgomery + form of curve25519, which is useful in certain protocols for + checking contributory behaviour in derivation of shared secrets. + +### 3.1.2 + +* Revert a commit which mistakenly removed support for `zeroize` traits + for some point types, as well as elligator2 support for Edwards points. + +### 3.1.1 + +* Fix documentation builds on nightly due to syntax changes to + `#![cfg_attr(feature = "nightly", doc = include_str!("../README.md"))]`. + ### 3.1.0 * Add support for the Elligator2 encoding for Edwards points. @@ -20,9 +36,15 @@ major series. consumers of `curve25519-dalek` should call these methods manually when needed. +### 3.0.3 + +* Fix documentation builds on nightly due to syntax changes to + `#![cfg_attr(feature = "nightly", doc = include_str!("../README.md"))]`. + ### 3.0.2 -* Fixes to make using alloc+no_std possible for stable Rust. +* Multiple documentation typo fixes. +* Fixes to make using `alloc`+`no_std` possible for stable Rust. ### 3.0.1 @@ -37,9 +59,15 @@ major series. ## 2.x series +### 2.1.3 + +* Fix documentation builds on nightly due to syntax changes to + `#![fg_attr(feature = "nightly", doc = include_str!("../README.md"))]`. + ### 2.1.2 -* Fixes to make using alloc+no_std possible for stable Rust. +* Multiple documenation typo fixes. +* Fix `alloc` feature working with stable rust. ### 2.1.1 diff --git a/Cargo.toml b/Cargo.toml index 416195a..2b04fd2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,11 +4,10 @@ name = "curve25519-dalek" # - update CHANGELOG # - update html_root_url # - update README if required by semver -version = "3.1.0" -authors = [ - "Isis Lovecruft ", - "Henry de Valence ", -] +# - if README was updated, also update module documentation in src/lib.rs +version = "3.2.1" +authors = ["Isis Lovecruft ", + "Henry de Valence "] readme = "README.md" license = "BSD-3-Clause" repository = "https://github.com/dalek-cryptography/curve25519-dalek" @@ -30,7 +29,7 @@ travis-ci = { repository = "dalek-cryptography/curve25519-dalek", branch = "mast [dev-dependencies] sha2 = { version = "0.9", default-features = false } bincode = "1" -criterion = "0.3.0" +criterion = { version = "0.3.0", features = ["html_reports"] } hex = "0.4.2" rand = "0.7" @@ -50,11 +49,9 @@ serde = { version = "1.0", default-features = false, optional = true, features = ] } # The original packed_simd package was orphaned, see # https://github.com/rust-lang/packed_simd/issues/303#issuecomment-701361161 -packed_simd = { version = "0.3.4", package = "packed_simd_2", features = [ - "into_bits", -], optional = true } -zeroize = { version = "1", default-features = false } -fiat-crypto = { version = "0.1.6", optional = true } +packed_simd = { version = "0.3.4", package = "packed_simd_2", features = ["into_bits"], optional = true } +zeroize = { version = ">=1, <1.4", default-features = false } +fiat-crypto = { version = "0.1.6", optional = true} # Betrusted/Precursor dependency set log = { version = "0.4", optional = true } diff --git a/Makefile b/Makefile index e447175..7d87057 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -FEATURES := nightly yolocrypto avx2_backend +FEATURES := nightly simd_backend doc: cargo rustdoc --features "$(FEATURES)" -- --html-in-header docs/assets/rustdoc-include-katex-header.html diff --git a/README.md b/README.md index 19679f9..acad0f9 100644 --- a/README.md +++ b/README.md @@ -177,7 +177,7 @@ that primitive. Please see [CONTRIBUTING.md][contributing]. Patches and pull requests should be make against the `develop` -branch, **not** `master`. +branch, **not** `main`. # About @@ -207,7 +207,13 @@ optimised batch inversion was contributed by Sean Bowe and Daira Hopwood. The `no_std` and `zeroize` support was contributed by Tony Arcieri. -Thanks also to Ashley Hauck, Lucas Salibian, and Manish Goregaokar for their +The formally verified backends, `fiat_u32_backend` and `fiat_u64_backend`, which +integrate with the Rust generated by the +[Fiat Crypto project](https://github.com/mit-plv/fiat-crypto) were contributed +by François Garillot. + +Thanks also to Ashley Hauck, Lucas Salibian, Manish Goregaokar, Jack Grigg, +Pratyush Mishra, Michael Rosenberg, and countless others for their contributions. [ed25519-dalek]: https://github.com/dalek-cryptography/ed25519-dalek diff --git a/benches/dalek_benchmarks.rs b/benches/dalek_benchmarks.rs index 136d0e7..308545c 100644 --- a/benches/dalek_benchmarks.rs +++ b/benches/dalek_benchmarks.rs @@ -180,12 +180,12 @@ mod multiscalar_benches { dynamic_fraction: f64, ) { for multiscalar_size in &MULTISCALAR_SIZES { - c.bench_with_input( - BenchmarkId::new( - "Variable-time mixed-base multiscalar multiplication ({:.0}pct dyn)", - format!("({:.0}pct dyn)", 100.0 * dynamic_fraction), - ), - &multiscalar_size, + let bench_id = BenchmarkId::new( + "Variable-time mixed-base", + format!("(size: {:?}), ({:.0}pct dyn)", multiscalar_size, 100.0 * dynamic_fraction), + ); + + c.bench_with_input(bench_id, &multiscalar_size, move |b, &&total_size| { let dynamic_size = ((total_size as f64) * dynamic_fraction) as usize; let static_size = total_size - dynamic_size; @@ -221,16 +221,18 @@ mod multiscalar_benches { } fn multiscalar_multiplications(c: &mut Criterion) { - let mut group: BenchmarkGroup<_> = c.benchmark_group("Multiscalar muls"); + let mut group: BenchmarkGroup<_> = c.benchmark_group("Multiscalar multiplications"); consttime_multiscalar_mul(&mut group); vartime_multiscalar_mul(&mut group); vartime_precomputed_pure_static(&mut group); let dynamic_fracs = [0.0, 0.2, 0.5]; + for frac in dynamic_fracs.iter() { vartime_precomputed_helper(&mut group, *frac); } + group.finish(); } diff --git a/src/backend/serial/scalar_mul/pippenger.rs b/src/backend/serial/scalar_mul/pippenger.rs index bffe140..575291d 100644 --- a/src/backend/serial/scalar_mul/pippenger.rs +++ b/src/backend/serial/scalar_mul/pippenger.rs @@ -58,7 +58,7 @@ use prelude::*; /// However, if `w` is too big and `n` is not too big, then `(2^w/2)*A` could dominate. /// Therefore, the optimal choice of `w` grows slowly as `n` grows. /// -/// This algorithm is adapted from section 4 of https://eprint.iacr.org/2012/549.pdf. +/// This algorithm is adapted from section 4 of . pub struct Pippenger; #[cfg(any(feature = "alloc", feature = "std"))] diff --git a/src/edwards.rs b/src/edwards.rs index 7c97ca4..f33df95 100644 --- a/src/edwards.rs +++ b/src/edwards.rs @@ -101,11 +101,14 @@ use core::ops::{Add, Neg, Sub}; use core::ops::{AddAssign, SubAssign}; use core::ops::{Mul, MulAssign}; +use digest::{generic_array::typenum::U64, Digest}; use subtle::Choice; use subtle::ConditionallyNegatable; use subtle::ConditionallySelectable; use subtle::ConstantTimeEq; +use zeroize::Zeroize; + use constants; use field::FieldElement; @@ -374,6 +377,28 @@ impl Default for EdwardsPoint { } } +// ------------------------------------------------------------------------ +// Zeroize implementations for wiping points from memory +// ------------------------------------------------------------------------ + +impl Zeroize for CompressedEdwardsY { + /// Reset this `CompressedEdwardsY` to the compressed form of the identity element. + fn zeroize(&mut self) { + self.0.zeroize(); + self.0[0] = 1; + } +} + +impl Zeroize for EdwardsPoint { + /// Reset this `CompressedEdwardsPoint` to the identity element. + fn zeroize(&mut self) { + self.X.zeroize(); + self.Y = FieldElement::one(); + self.Z = FieldElement::one(); + self.T.zeroize(); + } +} + // ------------------------------------------------------------------------ // Validity checks (for debugging, not CT) // ------------------------------------------------------------------------ @@ -500,6 +525,31 @@ impl EdwardsPoint { s[31] ^= x.is_negative().unwrap_u8() << 7; CompressedEdwardsY(s) } + + /// Perform hashing to the group using the Elligator2 map + /// + /// See https://tools.ietf.org/html/draft-irtf-cfrg-hash-to-curve-10#section-6.7.1 + pub fn hash_from_bytes(bytes: &[u8]) -> EdwardsPoint + where + D: Digest + Default, + { + let mut hash = D::new(); + hash.update(bytes); + let h = hash.finalize(); + let mut res = [0u8; 32]; + res.copy_from_slice(&h[..32]); + + let sign_bit = (res[31] & 0x80) >> 7; + + let fe = FieldElement::from_bytes(&res); + + let M1 = crate::montgomery::elligator_encode(&fe); + let E1_opt = M1.to_edwards(sign_bit); + + E1_opt + .expect("Montgomery conversion to Edwards point in Elligator failed") + .mul_by_cofactor() + } } // ------------------------------------------------------------------------ @@ -1696,4 +1746,65 @@ mod test { let bp: EdwardsPoint = bincode::deserialize(raw_bytes).unwrap(); assert_eq!(bp, constants::ED25519_BASEPOINT_POINT); } + + //////////////////////////////////////////////////////////// + // Signal tests from // + // https://github.com/signalapp/libsignal-protocol-c/ // + //////////////////////////////////////////////////////////// + + fn test_vectors() -> Vec> { + vec![ + vec![ + "214f306e1576f5a7577636fe303ca2c625b533319f52442b22a9fa3b7ede809f", + "c95becf0f93595174633b9d4d6bbbeb88e16fa257176f877ce426e1424626052", + ], + vec![ + "2eb10d432702ea7f79207da95d206f82d5a3b374f5f89f17a199531f78d3bea6", + "d8f8b508edffbb8b6dab0f602f86a9dd759f800fe18f782fdcac47c234883e7f", + ], + vec![ + "84cbe9accdd32b46f4a8ef51c85fd39d028711f77fb00e204a613fc235fd68b9", + "93c73e0289afd1d1fc9e4e78a505d5d1b2642fbdf91a1eff7d281930654b1453", + ], + vec![ + "c85165952490dc1839cb69012a3d9f2cc4b02343613263ab93a26dc89fd58267", + "43cbe8685fd3c90665b91835debb89ff1477f906f5170f38a192f6a199556537", + ], + vec![ + "26e7fc4a78d863b1a4ccb2ce0951fbcd021e106350730ee4157bacb4502e1b76", + "b6fc3d738c2c40719479b2f23818180cdafa72a14254d4016bbed8f0b788a835", + ], + vec![ + "1618c08ef0233f94f0f163f9435ec7457cd7a8cd4bb6b160315d15818c30f7a2", + "da0b703593b29dbcd28ebd6e7baea17b6f61971f3641cae774f6a5137a12294c", + ], + vec![ + "48b73039db6fcdcb6030c4a38e8be80b6390d8ae46890e77e623f87254ef149c", + "ca11b25acbc80566603eabeb9364ebd50e0306424c61049e1ce9385d9f349966", + ], + vec![ + "a744d582b3a34d14d311b7629da06d003045ae77cebceeb4e0e72734d63bd07d", + "fad25a5ea15d4541258af8785acaf697a886c1b872c793790e60a6837b1adbc0", + ], + vec![ + "80a6ff33494c471c5eff7efb9febfbcf30a946fe6535b3451cda79f2154a7095", + "57ac03913309b3f8cd3c3d4c49d878bb21f4d97dc74a1eaccbe5c601f7f06f47", + ], + vec![ + "f06fc939bc10551a0fd415aebf107ef0b9c4ee1ef9a164157bdd089127782617", + "785b2a6a00a5579cc9da1ff997ce8339b6f9fb46c6f10cf7a12ff2986341a6e0", + ], + ] + } + + #[test] + fn elligator_signal_test_vectors() { + for vector in test_vectors().iter() { + let input = hex::decode(vector[0]).unwrap(); + let output = hex::decode(vector[1]).unwrap(); + + let point = EdwardsPoint::hash_from_bytes::(&input); + assert_eq!(point.compress().to_bytes(), output[..]); + } + } } diff --git a/src/lib.rs b/src/lib.rs index 2d56e78..d1fbbc3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,21 +11,240 @@ #![no_std] #![cfg_attr(feature = "nightly", feature(test))] -#![cfg_attr(feature = "nightly", feature(external_doc))] #![cfg_attr(feature = "nightly", feature(doc_cfg))] #![cfg_attr(feature = "simd_backend", feature(stdsimd))] -// Refuse to compile if documentation is missing, but only on nightly. -// -// This means that missing docs will still fail CI, but means we can use -// README.md as the crate documentation. -#![cfg_attr(feature = "nightly", deny(missing_docs))] -#![cfg_attr(feature = "nightly", doc(include = "../README.md"))] +// Refuse to compile if documentation is missing. +#![deny(missing_docs)] + #![doc(html_logo_url = "https://doc.dalek.rs/assets/dalek-logo-clear.png")] -#![doc(html_root_url = "https://docs.rs/curve25519-dalek/3.1.0")] +#![doc(html_root_url = "https://docs.rs/curve25519-dalek/3.2.1")] -//! Note that docs will only build on nightly Rust until -//! [RFC 1990 stabilizes](https://github.com/rust-lang/rust/issues/44732). +//! # curve25519-dalek [![](https://img.shields.io/crates/v/curve25519-dalek.svg)](https://crates.io/crates/curve25519-dalek) [![](https://img.shields.io/badge/dynamic/json.svg?label=docs&uri=https%3A%2F%2Fcrates.io%2Fapi%2Fv1%2Fcrates%2Fcurve25519-dalek%2Fversions&query=%24.versions%5B0%5D.num&colorB=4F74A6)](https://doc.dalek.rs) [![](https://travis-ci.org/dalek-cryptography/curve25519-dalek.svg?branch=master)](https://travis-ci.org/dalek-cryptography/curve25519-dalek) +//! +//! +//! +//! **A pure-Rust implementation of group operations on Ristretto and Curve25519.** +//! +//! `curve25519-dalek` is a library providing group operations on the Edwards and +//! Montgomery forms of Curve25519, and on the prime-order Ristretto group. +//! +//! `curve25519-dalek` is not intended to provide implementations of any particular +//! crypto protocol. Rather, implementations of those protocols (such as +//! [`x25519-dalek`][x25519-dalek] and [`ed25519-dalek`][ed25519-dalek]) should use +//! `curve25519-dalek` as a library. +//! +//! `curve25519-dalek` is intended to provide a clean and safe _mid-level_ API for use +//! implementing a wide range of ECC-based crypto protocols, such as key agreement, +//! signatures, anonymous credentials, rangeproofs, and zero-knowledge proof +//! systems. +//! +//! In particular, `curve25519-dalek` implements Ristretto, which constructs a +//! prime-order group from a non-prime-order Edwards curve. This provides the +//! speed and safety benefits of Edwards curve arithmetic, without the pitfalls of +//! cofactor-related abstraction mismatches. +//! +//! # Documentation +//! +//! The semver-stable, public-facing `curve25519-dalek` API is documented +//! [here][docs-external]. In addition, the unstable internal implementation +//! details are documented [here][docs-internal]. +//! +//! The `curve25519-dalek` documentation requires a custom HTML header to include +//! KaTeX for math support. Unfortunately `cargo doc` does not currently support +//! this, but docs can be built using +//! ```sh +//! make doc +//! make doc-internal +//! ``` +//! +//! # Use +//! +//! To import `curve25519-dalek`, add the following to the dependencies section of +//! your project's `Cargo.toml`: +//! ```toml +//! curve25519-dalek = "3" +//! ``` +//! +//! The sole breaking change in the `3.x` series was an update to the `digest` +//! version, and in terms of non-breaking changes it includes: +//! +//! * support for using `alloc` instead of `std` on stable Rust, +//! * the Elligator2 encoding for Edwards points, +//! * a fix to use `packed_simd2`, +//! * various documentation fixes and improvements, +//! * support for configurably-sized, precomputed lookup tables for basepoint scalar +//! multiplication, +//! * two new formally-verified field arithmetic backends which use the Fiat Crypto +//! Rust code, which is generated from proofs of functional correctness checked by +//! the Coq theorem proving system, and +//! * support for explicitly calling the `zeroize` traits for all point types. +//! +//! The `2.x` series has API almost entirely unchanged from the `1.x` series, +//! except that: +//! +//! * an error in the data modeling for the (optional) `serde` feature was +//! corrected, so that when the `2.x`-series `serde` implementation is used +//! with `serde-bincode`, the derived serialization matches the usual X/Ed25519 +//! formats; +//! * the `rand` version was updated. +//! +//! See `CHANGELOG.md` for more details. +//! +//! # Backends and Features +//! +//! The `nightly` feature enables features available only when using a Rust nightly +//! compiler. In particular, it is required for rendering documentation and for +//! the SIMD backends. +//! +//! Curve arithmetic is implemented using one of the following backends: +//! +//! * a `u32` backend using serial formulas and `u64` products; +//! * a `u64` backend using serial formulas and `u128` products; +//! * an `avx2` backend using [parallel formulas][parallel_doc] and `avx2` instructions (sets speed records); +//! * an `ifma` backend using [parallel formulas][parallel_doc] and `ifma` instructions (sets speed records); +//! +//! By default the `u64` backend is selected. To select a specific backend, use: +//! ```sh +//! cargo build --no-default-features --features "std u32_backend" +//! cargo build --no-default-features --features "std u64_backend" +//! # Requires nightly, RUSTFLAGS="-C target_feature=+avx2" to use avx2 +//! cargo build --no-default-features --features "std simd_backend" +//! # Requires nightly, RUSTFLAGS="-C target_feature=+avx512ifma" to use ifma +//! cargo build --no-default-features --features "std simd_backend" +//! ``` +//! Crates using `curve25519-dalek` can either select a backend on behalf of their +//! users, or expose feature flags that control the `curve25519-dalek` backend. +//! +//! The `std` feature is enabled by default, but it can be disabled for no-`std` +//! builds using `--no-default-features`. Note that this requires explicitly +//! selecting an arithmetic backend using one of the `_backend` features. +//! If no backend is selected, compilation will fail. +//! +//! # Safety +//! +//! The `curve25519-dalek` types are designed to make illegal states +//! unrepresentable. For example, any instance of an `EdwardsPoint` is +//! guaranteed to hold a point on the Edwards curve, and any instance of a +//! `RistrettoPoint` is guaranteed to hold a valid point in the Ristretto +//! group. +//! +//! All operations are implemented using constant-time logic (no +//! secret-dependent branches, no secret-dependent memory accesses), +//! unless specifically marked as being variable-time code. +//! We believe that our constant-time logic is lowered to constant-time +//! assembly, at least on `x86_64` targets. +//! +//! As an additional guard against possible future compiler optimizations, +//! the `subtle` crate places an optimization barrier before every +//! conditional move or assignment. More details can be found in [the +//! documentation for the `subtle` crate][subtle_doc]. +//! +//! Some functionality (e.g., multiscalar multiplication or batch +//! inversion) requires heap allocation for temporary buffers. All +//! heap-allocated buffers of potentially secret data are explicitly +//! zeroed before release. +//! +//! However, we do not attempt to zero stack data, for two reasons. +//! First, it's not possible to do so correctly: we don't have control +//! over stack allocations, so there's no way to know how much data to +//! wipe. Second, because `curve25519-dalek` provides a mid-level API, +//! the correct place to start zeroing stack data is likely not at the +//! entrypoints of `curve25519-dalek` functions, but at the entrypoints of +//! functions in other crates. +//! +//! The implementation is memory-safe, and contains no significant +//! `unsafe` code. The SIMD backend uses `unsafe` internally to call SIMD +//! intrinsics. These are marked `unsafe` only because invoking them on an +//! inappropriate CPU would cause `SIGILL`, but the entire backend is only +//! compiled with appropriate `target_feature`s, so this cannot occur. +//! +//! # Performance +//! +//! Benchmarks are run using [`criterion.rs`][criterion]: +//! +//! ```sh +//! cargo bench --no-default-features --features "std u32_backend" +//! cargo bench --no-default-features --features "std u64_backend" +//! # Uses avx2 or ifma only if compiled for an appropriate target. +//! export RUSTFLAGS="-C target_cpu=native" +//! cargo bench --no-default-features --features "std simd_backend" +//! ``` +//! +//! Performance is a secondary goal behind correctness, safety, and +//! clarity, but we aim to be competitive with other implementations. +//! +//! # FFI +//! +//! Unfortunately, we have no plans to add FFI to `curve25519-dalek` directly. The +//! reason is that we use Rust features to provide an API that maintains safety +//! invariants, which are not possible to maintain across an FFI boundary. For +//! instance, as described in the _Safety_ section above, invalid points are +//! impossible to construct, and this would not be the case if we exposed point +//! operations over FFI. +//! +//! However, `curve25519-dalek` is designed as a *mid-level* API, aimed at +//! implementing other, higher-level primitives. Instead of providing FFI at the +//! mid-level, our suggestion is to implement the higher-level primitive (a +//! signature, PAKE, ZKP, etc) in Rust, using `curve25519-dalek` as a dependency, +//! and have that crate provide a minimal, byte-buffer-oriented FFI specific to +//! that primitive. +//! +//! # Contributing +//! +//! Please see [CONTRIBUTING.md][contributing]. +//! +//! Patches and pull requests should be make against the `develop` +//! branch, **not** `main`. +//! +//! # About +//! +//! **SPOILER ALERT:** *The Twelfth Doctor's first encounter with the Daleks is in +//! his second full episode, "Into the Dalek". A beleaguered ship of the "Combined +//! Galactic Resistance" has discovered a broken Dalek that has turned "good", +//! desiring to kill all other Daleks. The Doctor, Clara and a team of soldiers +//! are miniaturized and enter the Dalek, which the Doctor names Rusty. They +//! repair the damage, but accidentally restore it to its original nature, causing +//! it to go on the rampage and alert the Dalek fleet to the whereabouts of the +//! rebel ship. However, the Doctor manages to return Rusty to its previous state +//! by linking his mind with the Dalek's: Rusty shares the Doctor's view of the +//! universe's beauty, but also his deep hatred of the Daleks. Rusty destroys the +//! other Daleks and departs the ship, determined to track down and bring an end +//! to the Dalek race.* +//! +//! `curve25519-dalek` is authored by Isis Agora Lovecruft and Henry de Valence. +//! +//! Portions of this library were originally a port of [Adam Langley's +//! Golang ed25519 library](https://!github.com/agl/ed25519), which was in +//! turn a port of the reference `ref10` implementation. Most of this code, +//! including the 32-bit field arithmetic, has since been rewritten. +//! +//! The fast `u32` and `u64` scalar arithmetic was implemented by Andrew Moon, and +//! the addition chain for scalar inversion was provided by Brian Smith. The +//! optimised batch inversion was contributed by Sean Bowe and Daira Hopwood. +//! +//! The `no_std` and `zeroize` support was contributed by Tony Arcieri. +//! +//! The formally verified backends, `fiat_u32_backend` and `fiat_u64_backend`, which +//! integrate with the Rust generated by the +//! [Fiat Crypto project](https://github.com/mit-plv/fiat-crypto) were contributed +//! by François Garillot. +//! +//! Thanks also to Ashley Hauck, Lucas Salibian, Manish Goregaokar, Jack Grigg, +//! Pratyush Mishra, Michael Rosenberg, and countless others for their +//! contributions. +//! +//! [ed25519-dalek]: https://github.com/dalek-cryptography/ed25519-dalek +//! [x25519-dalek]: https://github.com/dalek-cryptography/x25519-dalek +//! [contributing]: https://github.com/dalek-cryptography/curve25519-dalek/blob/master/CONTRIBUTING.md +//! [docs-external]: https://doc.dalek.rs/curve25519_dalek/ +//! [docs-internal]: https://doc-internal.dalek.rs/curve25519_dalek/ +//! [criterion]: https://github.com/japaric/criterion.rs +//! [parallel_doc]: https://doc-internal.dalek.rs/curve25519_dalek/backend/vector/avx2/index.html +//! [subtle_doc]: https://doc.dalek.rs/subtle/ // needed for engine25519-as. Note vscode is still broken: // https://github.com/rust-analyzer/rust-analyzer/issues/8640 diff --git a/src/montgomery.rs b/src/montgomery.rs index e4e69cf..627695d 100644 --- a/src/montgomery.rs +++ b/src/montgomery.rs @@ -98,6 +98,13 @@ impl PartialEq for MontgomeryPoint { impl Eq for MontgomeryPoint {} +impl Identity for MontgomeryPoint { + /// Return the group identity element, which has order 4. + fn identity() -> MontgomeryPoint { + MontgomeryPoint([0u8; 32]) + } +} + impl Zeroize for MontgomeryPoint { fn zeroize(&mut self) { self.0.zeroize(); @@ -163,7 +170,7 @@ impl MontgomeryPoint { /// Perform the Elligator2 mapping to a Montgomery point. /// -/// See https://tools.ietf.org/html/draft-irtf-cfrg-hash-to-curve-10#section-6.7.1 +/// See // // TODO Determine how much of the hash-to-group API should be exposed after the CFRG // draft gets into a more polished/accepted state. @@ -992,6 +999,19 @@ mod test { use rand_core::OsRng; + #[test] + fn identity_in_different_coordinates() { + let id_projective = ProjectivePoint::identity(); + let id_montgomery = id_projective.to_affine(); + + assert!(id_montgomery == MontgomeryPoint::identity()); + } + + #[test] + fn identity_in_different_models() { + assert!(EdwardsPoint::identity().to_montgomery() == MontgomeryPoint::identity()); + } + #[test] #[cfg(feature = "serde")] fn serde_bincode_basepoint_roundtrip() { diff --git a/src/ristretto.rs b/src/ristretto.rs index 97cb68a..bd5dc6a 100644 --- a/src/ristretto.rs +++ b/src/ristretto.rs @@ -178,6 +178,8 @@ use subtle::ConditionallySelectable; use subtle::ConditionallyNegatable; use subtle::ConstantTimeEq; +use zeroize::Zeroize; + use edwards::EdwardsBasepointTable; use edwards::EdwardsPoint; @@ -1080,6 +1082,22 @@ impl Debug for RistrettoPoint { } } +// ------------------------------------------------------------------------ +// Zeroize traits +// ------------------------------------------------------------------------ + +impl Zeroize for CompressedRistretto { + fn zeroize(&mut self) { + self.0.zeroize(); + } +} + +impl Zeroize for RistrettoPoint { + fn zeroize(&mut self) { + self.0.zeroize(); + } +} + // ------------------------------------------------------------------------ // Tests // ------------------------------------------------------------------------