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.
curve25519-dalek alternatives and similar packages
Based on the "Cryptography" category.
Alternatively, view curve25519-dalek alternatives based on common mentions on social networks and blogs.
8.3 9.9 curve25519-dalek VS OckamBuild Trust with a simple developer experience and powerful primitives that orchestrate end-to-end encryption, key management, authorization policy enforcement, and mutual authentication.
7.8 4.2 curve25519-dalek VS exonumAn extensible open-source framework for creating private/permissioned blockchain applications
6.8 1.0 curve25519-dalek VS sodiumoxide[DEPRECATED] Sodium Oxide: Fast cryptographic library for Rust (bindings to libsodium)
Fast and efficient ed25519 signing and verification in Rust.
6.1 0.0 curve25519-dalek VS miscreantMeta-repository for Miscreant: misuse-resistant symmetric encryption library with AES-SIV (RFC 5297) and AES-PMAC-SIV support
5.5 7.1 curve25519-dalek VS RustCryptoAuthenticated Encryption with Associated Data Algorithms: high-level encryption ciphers
Collection of pure Rust elliptic curve implementations: NIST P-256, P-384, secp256k1
4.8 6.6 curve25519-dalek VS orionUsable, easy and safe pure-Rust crypto [Moved to: https://github.com/orion-rs/orion]
3.5 4.5 curve25519-dalek VS recryptA set of cryptographic primitives for building a multi-hop Proxy Re-encryption scheme, known as Transform Encryption.
0.5 0.0 curve25519-dalek VS rncryptor-rsPure Rust implementation of the RNCryptor cryptographic format by Rob Napier
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of curve25519-dalek or a related project?
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
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
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.
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
make doc make doc-internal
curve25519-dalek, add the following to the dependencies section of
curve25519-dalek = "3"
The sole breaking change in the
3.x series was an update to the
version, and in terms of non-breaking changes it includes:
- support for using
stdon stable Rust,
- the Elligator2 encoding for Edwards points,
- a fix to use
- 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
zeroizetraits for all point types.
2.x series has API almost entirely unchanged from the
- an error in the data modeling for the (optional)
serdefeature was corrected, so that when the
serdeimplementation is used with
serde-bincode, the derived serialization matches the usual X/Ed25519 formats;
randversion was updated.
CHANGELOG.md for more details.
Backends and Features
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:
u32backend using serial formulas and
u64backend using serial formulas and
avx2backend using parallel formulas and
avx2instructions (sets speed records);
ifmabackend using parallel formulas and
ifmainstructions (sets speed records);
By default the
u64 backend is selected. To select a specific backend, use:
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"
curve25519-dalek can either select a backend on behalf of their
users, or expose feature flags that control the
std feature is enabled by default, but it can be disabled for no-
--no-default-features. Note that this requires explicitly
selecting an arithmetic backend using one of the
If no backend is selected, compilation will fail.
curve25519-dalek types are designed to make illegal states
unrepresentable. For example, any instance of an
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
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
As an additional guard against possible future compiler optimizations,
subtle crate places an optimization barrier before every
conditional move or assignment. More details can be found in the
documentation for the
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
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_features, so this cannot occur.
Benchmarks are run using
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.
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.
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
Please see CONTRIBUTING.md.
Patches and pull requests should be make against the
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, 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.
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.
zeroize support was contributed by Tony Arcieri.
The formally verified backends,
integrate with the Rust generated by the
Fiat Crypto project 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.