cryspen · wysiwys · Apr 16, 2025 · Apr 10, 2025 · Apr 10, 2025 · Apr 10, 2025
diff --git a/.gitignore b/.gitignore
@@ -2,7 +2,7 @@
 Cargo.lock
 **/*.rs.bk
 .vscode/
-evercrypt_provider/target
+libcrux_provider/target
 no-std-support-check/target
 rust_crypto_provider/target
 traits/target/

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [0.2.1] - Unreleased
 
+- [#72](https://github.com/cryspen/hpke-rs/pull/72):
+  -  add support for X-Wing KEM
+  -  upgrade rand dependency from 0.8 -> 0.9
+  -  replace Evercrypt provider with Libcrux provider
 - [#66](https://github.com/franziskuskiefer/hpke-rs/pull/66): add support for secp256k1 curve. This adds `DhKemK256 = 0x0016` to the `KemAlgorithms`
 
 ## [0.2.0] - 2023-12-01

diff --git a/Cargo.toml b/Cargo.toml
@@ -1,42 +1,48 @@
 [package]
 name = "hpke-rs"
-version = "0.2.1-pre.1"
+version = "0.2.1-alpha.1"
 authors = ["Franziskus Kiefer <[email protected]>"]
 edition = "2021"
 license = "MPL-2.0"
 documentation = "https://docs.rs/hpke-rs"
 description = "HPKE Implementation"
 readme = "Readme.md"
-repository = "https://github.com/franziskuskiefer/hpke-rs"
+repository = "https://github.com/cryspen/hpke-rs"
 exclude = ["/tests"]
 
 [dependencies]
 log = "0.4"
 serde = { version = "1.0", features = ["derive"], optional = true }
 tls_codec = { version = "0.4.1-pre.1", features = ["derive"], optional = true }
 zeroize = { version = "1.5", features = ["zeroize_derive"] }
-hpke-rs-crypto = { version = "0.2.0", path = "./traits" }
+hpke-rs-crypto = { version = "0.3.0-alpha.1", path = "./traits", default-features = false }
+rand_core = { version = "0.9", default-features = false}
+libcrux-sha3 = { version = "0.0.2" }
 
 [features]
 default = []
-std = []
+std = ["rand_core/std", "hpke-rs-crypto/std"]
 serialization = ["serde", "tls_codec", "tls_codec/serde", "std"]
 hazmat = []
 hpke-test = ["std"]
-hpke-test-prng = []                                                     # ⚠️ Enable testing PRNG - DO NOT USE
+hpke-test-prng = []                                              # ⚠️ Enable testing PRNG - DO NOT USE
 
 [dev-dependencies]
-hpke-rs-crypto = { version = "0.2.0", path = "./traits", features = ["std"] }
+hpke-rs-crypto = { version = "0.3.0-alpha.1", path = "./traits", features = [
+    "std",
+] }
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 lazy_static = "1.4"
 rayon = "1.5"
 hpke-rs = { path = ".", features = ["hpke-test", "hazmat"] }
-hpke-rs-rust-crypto = { version = "0.2.0", path = "./rust_crypto_provider", features = [
+hpke-rs-rust-crypto = { version = "0.3.0-alpha.1", path = "./rust_crypto_provider", features = [
+    "deterministic-prng",
+] }
+hpke-rs-libcrux = { version = "0.2.0-alpha.1", path = "./libcrux_provider", features = [
     "deterministic-prng",
 ] }
-# hpke-rs-evercrypt = { version = "0.1.3-pre.1", path = "./evercrypt_provider", features = ["deterministic-prng"] }
-rand = { version = "0.8" }
+rand = { version = "0.9" }
 pretty_env_logger = "0.5"
 criterion = { version = "0.5", features = ["html_reports"] }
 

diff --git a/Readme.md b/Readme.md
@@ -50,7 +50,7 @@ Instead it expects an implementation of the [HpkeCrypto] trait.
 [crate-link]: https://crates.io/crates/hpke-rs
 [docs-badge]: https://img.shields.io/badge/docs-rs-blue.svg?style=for-the-badge
 [docs-link]: https://docs.rs/hpke-rs
-[evercrypt]: https://github.com/franziskuskiefer/evercrypt-rust
+[libcrux]: https://github.com/cryspen/libcrux
 [hpke (RFC 9180)]: https://www.rfc-editor.org/rfc/rfc9180.html
 [hpkecrypto]: https://docs.rs/hpke-rs-crypto
 [rustc-image]: https://img.shields.io/badge/rustc-1.56+-blue.svg?style=for-the-badge
diff --git a/benches/bench.rs b/benches/bench.rs
@@ -4,9 +4,8 @@ use hpke_rs_crypto::{
     types::{AeadAlgorithm, KdfAlgorithm, KemAlgorithm},
     HpkeCrypto, RngCore,
 };
-// use hpke_rs_evercrypt::*;
+use hpke_rs_libcrux::HpkeLibcrux;
 use hpke_rs_rust_crypto::*;
-use rand::rngs::OsRng;
 
 const MODES: [Mode; 4] = [
     HpkeMode::Base,
@@ -81,13 +80,13 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                             (None, None)
                         };
 
-                    let mut group = c.benchmark_group(format!("{}", label));
+                    let mut group = c.benchmark_group(label.to_string());
                     group.bench_function("Setup Sender", |b| {
                         b.iter(|| {
                             let mut hpke =
                                 Hpke::<Crypto>::new(hpke_mode, kem_mode, kdf_mode, aead_mode);
                             hpke.setup_sender(
-                                &pk_rm,
+                                pk_rm,
                                 &info,
                                 psk.as_ref().map(Vec::as_ref),
                                 psk_id.as_ref().map(Vec::as_ref),
@@ -102,7 +101,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                                 Hpke::<Crypto>::new(hpke_mode, kem_mode, kdf_mode, aead_mode);
                             hpke.setup_receiver(
                                 enc,
-                                &sk_rm,
+                                sk_rm,
                                 &info,
                                 psk.as_ref().map(Vec::as_ref),
                                 psk_id.as_ref().map(Vec::as_ref),
@@ -112,24 +111,24 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                         })
                     });
 
-                    group.bench_function(&format!("Seal {}({})", AEAD_PAYLOAD, AEAD_AAD), |b| {
+                    group.bench_function(format!("Seal {}({})", AEAD_PAYLOAD, AEAD_AAD), |b| {
                         b.iter_batched(
                             || {
                                 let mut hpke =
                                     Hpke::<Crypto>::new(hpke_mode, kem_mode, kdf_mode, aead_mode);
                                 let (_enc, context) = hpke
                                     .setup_sender(
-                                        &pk_rm,
+                                        pk_rm,
                                         &info,
                                         psk.as_ref().map(Vec::as_ref),
                                         psk_id.as_ref().map(Vec::as_ref),
                                         sk_sm.as_ref(),
                                     )
                                     .unwrap();
                                 let mut aad = vec![0u8; AEAD_AAD];
-                                OsRng.fill_bytes(&mut aad);
+                                rand::rng().fill_bytes(&mut aad);
                                 let mut ptxt = vec![0u8; AEAD_PAYLOAD];
-                                OsRng.fill_bytes(&mut ptxt);
+                                rand::rng().fill_bytes(&mut ptxt);
                                 (context, aad, ptxt)
                             },
                             |(mut context, aad, ptxt)| {
@@ -138,30 +137,30 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                             BatchSize::SmallInput,
                         )
                     });
-                    group.bench_function(&format!("Open {}({})", AEAD_PAYLOAD, AEAD_AAD), |b| {
+                    group.bench_function(format!("Open {}({})", AEAD_PAYLOAD, AEAD_AAD), |b| {
                         b.iter_batched(
                             || {
                                 let mut hpke =
                                     Hpke::<Crypto>::new(hpke_mode, kem_mode, kdf_mode, aead_mode);
                                 let (enc, mut sender_context) = hpke
                                     .setup_sender(
-                                        &pk_rm,
+                                        pk_rm,
                                         &info,
                                         psk.as_ref().map(Vec::as_ref),
                                         psk_id.as_ref().map(Vec::as_ref),
                                         sk_sm.as_ref(),
                                     )
                                     .unwrap();
                                 let mut aad = vec![0u8; AEAD_AAD];
-                                OsRng.fill_bytes(&mut aad);
+                                rand::rng().fill_bytes(&mut aad);
                                 let mut ptxt = vec![0u8; AEAD_PAYLOAD];
-                                OsRng.fill_bytes(&mut ptxt);
+                                rand::rng().fill_bytes(&mut ptxt);
                                 let ctxt = sender_context.seal(&aad, &ptxt).unwrap();
 
                                 let context = hpke
                                     .setup_receiver(
                                         &enc,
-                                        &sk_rm,
+                                        sk_rm,
                                         &info,
                                         psk.as_ref().map(Vec::as_ref),
                                         psk_id.as_ref().map(Vec::as_ref),
@@ -178,23 +177,23 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                     });
 
                     group.bench_function(
-                        &format!("Single-Shot Seal {}({})", AEAD_PAYLOAD, AEAD_AAD),
+                        format!("Single-Shot Seal {}({})", AEAD_PAYLOAD, AEAD_AAD),
                         |b| {
                             b.iter_batched(
                                 || {
                                     let hpke = Hpke::<Crypto>::new(
                                         hpke_mode, kem_mode, kdf_mode, aead_mode,
                                     );
                                     let mut aad = vec![0u8; AEAD_AAD];
-                                    OsRng.fill_bytes(&mut aad);
+                                    rand::rng().fill_bytes(&mut aad);
                                     let mut ptxt = vec![0u8; AEAD_PAYLOAD];
-                                    OsRng.fill_bytes(&mut ptxt);
+                                    rand::rng().fill_bytes(&mut ptxt);
                                     (hpke, aad, ptxt)
                                 },
                                 |(mut hpke, aad, ptxt)| {
                                     let _ctxt = hpke
                                         .seal(
-                                            &pk_rm,
+                                            pk_rm,
                                             &info,
                                             &aad,
                                             &ptxt,
@@ -209,7 +208,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                         },
                     );
                     group.bench_function(
-                        &format!("Single-Shot Open {}({})", AEAD_PAYLOAD, AEAD_AAD),
+                        format!("Single-Shot Open {}({})", AEAD_PAYLOAD, AEAD_AAD),
                         |b| {
                             b.iter_batched(
                                 || {
@@ -218,17 +217,17 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                                     );
                                     let (enc, mut sender_context) = hpke
                                         .setup_sender(
-                                            &pk_rm,
+                                            pk_rm,
                                             &info,
                                             psk.as_ref().map(Vec::as_ref),
                                             psk_id.as_ref().map(Vec::as_ref),
                                             sk_sm.as_ref(),
                                         )
                                         .unwrap();
                                     let mut aad = vec![0u8; AEAD_AAD];
-                                    OsRng.fill_bytes(&mut aad);
+                                    rand::rng().fill_bytes(&mut aad);
                                     let mut ptxt = vec![0u8; AEAD_PAYLOAD];
-                                    OsRng.fill_bytes(&mut ptxt);
+                                    rand::rng().fill_bytes(&mut ptxt);
                                     let ctxt = sender_context.seal(&aad, &ptxt).unwrap();
 
                                     (hpke, aad, ctxt, enc)
@@ -237,7 +236,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
                                     let _ctxt_out = hpke
                                         .open(
                                             &enc,
-                                            &sk_rm,
+                                            sk_rm,
                                             &info,
                                             &aad,
                                             &ctxt,
@@ -259,7 +258,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>(c: &mut Criterion) {
 
 criterion_group!(
     benches,
-    // benchmark::<HpkeEvercrypt>,
+    benchmark::<HpkeLibcrux>,
     benchmark::<HpkeRustCrypto>,
 );
 criterion_main!(benches);
diff --git a/benches/manual_benches.rs b/benches/manual_benches.rs
@@ -5,9 +5,8 @@ use hpke_rs_crypto::{
     types::{AeadAlgorithm, KdfAlgorithm, KemAlgorithm},
     HpkeCrypto, RngCore,
 };
-// use hpke_rs_evercrypt::*;
+use hpke_rs_libcrux::HpkeLibcrux;
 use hpke_rs_rust_crypto::*;
-use rand::rngs::OsRng;
 
 fn duration(d: Duration) -> f64 {
     ((d.as_secs() as f64) + (d.subsec_nanos() as f64 * 1e-9)) * 1000000f64
@@ -103,7 +102,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>() {
                             Hpke::<Crypto>::new(hpke_mode, kem_mode, kdf_mode, aead_mode);
                         let _sender = hpke
                             .setup_sender(
-                                &pk_rm,
+                                pk_rm,
                                 &info,
                                 psk.as_ref().map(Vec::as_ref),
                                 psk_id.as_ref().map(Vec::as_ref),
@@ -121,7 +120,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>() {
                         let _receiver = hpke
                             .setup_receiver(
                                 enc,
-                                &sk_rm,
+                                sk_rm,
                                 &info,
                                 psk.as_ref().map(Vec::as_ref),
                                 psk_id.as_ref().map(Vec::as_ref),
@@ -135,17 +134,17 @@ fn benchmark<Crypto: HpkeCrypto + 'static>() {
 
                     let (enc, mut context) = hpke
                         .setup_sender(
-                            &pk_rm,
+                            pk_rm,
                             &info,
                             psk.as_ref().map(Vec::as_ref),
                             psk_id.as_ref().map(Vec::as_ref),
                             sk_sm.as_ref(),
                         )
                         .unwrap();
                     let mut aad = vec![0u8; AEAD_AAD];
-                    OsRng.fill_bytes(&mut aad);
+                    rand::rng().fill_bytes(&mut aad);
                     let mut ptxt = vec![0u8; AEAD_PAYLOAD];
-                    OsRng.fill_bytes(&mut ptxt);
+                    rand::rng().fill_bytes(&mut ptxt);
 
                     let mut ctxts = Vec::with_capacity((AEAD_PAYLOAD + 16) * ITERATIONS);
                     let start = Instant::now();
@@ -165,7 +164,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>() {
                     let mut context = hpke
                         .setup_receiver(
                             &enc,
-                            &sk_rm,
+                            sk_rm,
                             &info,
                             psk.as_ref().map(Vec::as_ref),
                             psk_id.as_ref().map(Vec::as_ref),
@@ -190,17 +189,17 @@ fn benchmark<Crypto: HpkeCrypto + 'static>() {
                     assert_eq!(ptxts[0], ptxt);
 
                     let mut aad = vec![0u8; AEAD_AAD];
-                    OsRng.fill_bytes(&mut aad);
+                    rand::rng().fill_bytes(&mut aad);
                     let mut ptxt = vec![0u8; AEAD_PAYLOAD];
-                    OsRng.fill_bytes(&mut ptxt);
+                    rand::rng().fill_bytes(&mut ptxt);
 
                     let mut enc = Vec::<u8>::new();
                     let mut ctxt = Vec::<u8>::new();
                     let start = Instant::now();
                     for _ in 0..ITERATIONS {
                         let (new_enc, new_ctxt) = hpke
                             .seal(
-                                &pk_rm,
+                                pk_rm,
                                 &info,
                                 &aad,
                                 &ptxt,
@@ -227,7 +226,7 @@ fn benchmark<Crypto: HpkeCrypto + 'static>() {
                         ptxt_out = hpke
                             .open(
                                 &enc,
-                                &sk_rm,
+                                sk_rm,
                                 &info,
                                 &aad,
                                 &ctxt,
@@ -253,6 +252,6 @@ fn benchmark<Crypto: HpkeCrypto + 'static>() {
 }
 
 fn main() {
-    // benchmark::<HpkeEvercrypt>();
+    benchmark::<HpkeLibcrux>();
     benchmark::<HpkeRustCrypto>();
 }
diff --git a/evercrypt_provider/Cargo.toml b/evercrypt_provider/Cargo.toml