chore: bump to 0.6.0-rc.0, migrate to elliptic-curve 0.14, hash2curve 0.14, rand_core 0.10 (#1)

Reviewed-on: vexahub/voprf-vexahub#1 Co-authored-by: UneBaguette <[email protected]> Co-committed-by: UneBaguette <[email protected]>
2026-06-27 17:04:58 +02:00
parent d42e7948a1
commit 3ce3ac8817
23 changed files with 598 additions and 499 deletions
@@ -14,14 +14,14 @@ use core::iter::{self, Map, Repeat, Zip};

 use derive_where::derive_where;
 use digest::{Digest, Output};
-use generic_array::typenum::Unsigned;
-use generic_array::GenericArray;
-use rand_core::{TryCryptoRng, TryRngCore};
+use hybrid_array::Array;
+use hybrid_array::typenum::Unsigned;
+use rand_core::{TryCryptoRng, TryRng};

 use crate::common::{
+    BlindedElement, EvaluationElement, Mode, PreparedEvaluationElement, Proof, STR_FINALIZE,
    derive_keypair, deterministic_blind_unchecked, generate_proof, hash_to_group, i2osp_2,
-    server_evaluate_hash_input, verify_proof, BlindedElement, EvaluationElement, Mode,
-    PreparedEvaluationElement, Proof, STR_FINALIZE,
+    server_evaluate_hash_input, verify_proof,
 };
 #[cfg(feature = "serde")]
 use crate::serialization::serde::{Element, Scalar};
@@ -75,7 +75,7 @@ impl<CS: CipherSuite> VoprfClient<CS> {
    ///
    /// # Errors
    /// [`Error::Input`] if the `input` is empty or longer then [`u16::MAX`].
-    pub fn blind<R: TryRngCore + TryCryptoRng>(
+    pub fn blind<R: TryRng + TryCryptoRng>(
        input: &[u8],
        blinding_factor_rng: &mut R,
    ) -> Result<VoprfClientBlindResult<CS>> {
@@ -196,8 +196,8 @@ impl<CS: CipherSuite> VoprfServer<CS> {
    ///
    /// # Errors
    /// [`Error::Protocol`] if the protocol fails and can't be completed.
-    pub fn new<R: TryRngCore + TryCryptoRng>(rng: &mut R) -> Result<Self> {
-        let mut seed = GenericArray::<_, <CS::Group as Group>::ScalarLen>::default();
+    pub fn new<R: TryRng + TryCryptoRng>(rng: &mut R) -> Result<Self> {
+        let mut seed = Array::<_, <CS::Group as Group>::ScalarLen>::default();
        rng.try_fill_bytes(&mut seed).map_err(|_| Error::Protocol)?;
        // This can't fail as the hash output is type constrained.
        Self::new_from_seed(&seed, &[])
@@ -238,7 +238,7 @@ impl<CS: CipherSuite> VoprfServer<CS> {
    /// Computes the second step for the multiplicative blinding version of
    /// DH-OPRF. This message is sent from the server (who holds the OPRF key)
    /// to the client.
-    pub fn blind_evaluate<R: TryRngCore + TryCryptoRng>(
+    pub fn blind_evaluate<R: TryRng + TryCryptoRng>(
        &self,
        rng: &mut R,
        blinded_element: &BlindedElement<CS>,
@@ -271,7 +271,7 @@ impl<CS: CipherSuite> VoprfServer<CS> {
    /// [`Error::Batch`] if the number of `blinded_elements` and
    /// `evaluation_elements` don't match or is longer then [`u16::MAX`]
    #[cfg(feature = "alloc")]
-    pub fn batch_blind_evaluate<'a, R: TryRngCore + TryCryptoRng, I>(
+    pub fn batch_blind_evaluate<'a, R: TryRng + TryCryptoRng, I>(
        &self,
        rng: &mut R,
        blinded_elements: &'a I,
@@ -322,7 +322,7 @@ impl<CS: CipherSuite> VoprfServer<CS> {
    pub fn batch_blind_evaluate_finish<
        'a,
        'b,
-        R: TryRngCore + TryCryptoRng,
+        R: TryRng + TryCryptoRng,
        IB: Iterator<Item = &'a BlindedElement<CS>> + ExactSizeIterator,
        IE,
    >(
@@ -343,14 +343,14 @@ impl<CS: CipherSuite> VoprfServer<CS> {
            g,
            self.pk,
            blinded_elements.map(|element| element.0),
-            evaluation_elements.into_iter().map(|element| element.0 .0),
+            evaluation_elements.into_iter().map(|element| element.0.0),
            Mode::Voprf,
        )?;

        let messages = evaluation_elements.into_iter().map(<fn(
            &PreparedEvaluationElement<CS>,
        ) -> EvaluationElement<CS>>::from(
-            |element| EvaluationElement(element.0 .0),
+            |element| EvaluationElement(element.0.0),
        ));

        Ok(VoprfServerBatchEvaluateFinishResult { messages, proof })
@@ -550,18 +550,18 @@ mod tests {

    use ::alloc::vec;
    use ::alloc::vec::Vec;
-    use rand::rngs::OsRng;
+    use rand::rngs::SysRng;

    use super::*;
-    use crate::common::{Dst, STR_HASH_TO_GROUP};
    use crate::Group;
+    use crate::common::{Dst, STR_HASH_TO_GROUP};

    fn prf<CS: CipherSuite>(
        input: &[u8],
        key: <CS::Group as Group>::Scalar,
        mode: Mode,
    ) -> Output<CS::Hash> {
-        let dst = Dst::new::<CS, _, _>(STR_HASH_TO_GROUP, mode);
+        let dst = Dst::new::<CS, _>(STR_HASH_TO_GROUP, mode);
        let point = CS::Group::hash_to_curve::<CS::Hash>(&[input], &dst.as_dst()).unwrap();

        let res = point * &key;
@@ -574,7 +574,7 @@ mod tests {

    fn verifiable_retrieval<CS: CipherSuite>() {
        let input = b"input";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let client_blind_result = VoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server = VoprfServer::<CS>::new(&mut rng).unwrap();
        let server_result = server.blind_evaluate(&mut rng, &client_blind_result.message);
@@ -592,7 +592,7 @@ mod tests {
    }

    fn verifiable_batch_retrieval<CS: CipherSuite>() {
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let mut inputs = vec![];
        let mut client_states = vec![];
        let mut client_messages = vec![];
@@ -636,7 +636,7 @@ mod tests {
    }

    fn verifiable_batch_bad_public_key<CS: CipherSuite>() {
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let mut inputs = vec![];
        let mut client_states = vec![];
        let mut client_messages = vec![];
@@ -662,7 +662,7 @@ mod tests {
            .unwrap();
        let messages: Vec<_> = messages.collect();
        let wrong_pk = {
-            let dst = Dst::new::<CS, _, _>(STR_HASH_TO_GROUP, Mode::Oprf);
+            let dst = Dst::new::<CS, _>(STR_HASH_TO_GROUP, Mode::Oprf);
            // Choose a group element that is unlikely to be the right public key
            CS::Group::hash_to_curve::<CS::Hash>(&[b"msg"], &dst.as_dst()).unwrap()
        };
@@ -673,12 +673,12 @@ mod tests {

    fn verifiable_bad_public_key<CS: CipherSuite>() {
        let input = b"input";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let client_blind_result = VoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server = VoprfServer::<CS>::new(&mut rng).unwrap();
        let server_result = server.blind_evaluate(&mut rng, &client_blind_result.message);
        let wrong_pk = {
-            let dst = Dst::new::<CS, _, _>(STR_HASH_TO_GROUP, Mode::Oprf);
+            let dst = Dst::new::<CS, _>(STR_HASH_TO_GROUP, Mode::Oprf);
            // Choose a group element that is unlikely to be the right public key
            CS::Group::hash_to_curve::<CS::Hash>(&[b"msg"], &dst.as_dst()).unwrap()
        };
@@ -693,7 +693,7 @@ mod tests {

    fn verifiable_server_evaluate<CS: CipherSuite>() {
        let input = b"input";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let client_blind_result = VoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server = VoprfServer::<CS>::new(&mut rng).unwrap();
        let server_result = server.blind_evaluate(&mut rng, &client_blind_result.message);
@@ -722,7 +722,7 @@ mod tests {

    fn zeroize_voprf_client<CS: CipherSuite>() {
        let input = b"input";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let client_blind_result = VoprfClient::<CS>::blind(input, &mut rng).unwrap();

        let mut state = client_blind_result.state;
@@ -736,7 +736,7 @@ mod tests {

    fn zeroize_voprf_server<CS: CipherSuite>() {
        let input = b"input";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let client_blind_result = VoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server = VoprfServer::<CS>::new(&mut rng).unwrap();
        let server_result = server.blind_evaluate(&mut rng, &client_blind_result.message);