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, OutputSizeUser};
-use generic_array::typenum::Unsigned;
-use generic_array::{ArrayLength, GenericArray};
-use rand_core::{TryCryptoRng, TryRngCore};
+use hybrid_array::typenum::Unsigned;
+use hybrid_array::{Array, ArraySize};
+use rand_core::{TryCryptoRng, TryRng};

 use crate::common::{
-    derive_keypair, deterministic_blind_unchecked, generate_proof, hash_to_group, i2osp_2,
-    server_evaluate_hash_input, verify_proof, BlindedElement, Dst, EvaluationElement, Mode,
-    PreparedEvaluationElement, Proof, STR_FINALIZE, STR_HASH_TO_SCALAR, STR_INFO,
+    BlindedElement, Dst, EvaluationElement, Mode, PreparedEvaluationElement, Proof, STR_FINALIZE,
+    STR_HASH_TO_SCALAR, STR_INFO, derive_keypair, deterministic_blind_unchecked, generate_proof,
+    hash_to_group, i2osp_2, server_evaluate_hash_input, verify_proof,
 };
 #[cfg(feature = "serde")]
 use crate::serialization::serde::{Element, Scalar};
@@ -75,7 +75,7 @@ impl<CS: CipherSuite> PoprfClient<CS> {
    ///
    /// # Errors
    /// [`Error::Input`] if the `input` is empty or longer than [`u16::MAX`].
-    pub fn blind<R: TryRngCore + TryCryptoRng>(
+    pub fn blind<R: TryRng + TryCryptoRng>(
        input: &[u8],
        blinding_factor_rng: &mut R,
    ) -> Result<PoprfClientBlindResult<CS>> {
@@ -134,7 +134,7 @@ impl<CS: CipherSuite> PoprfClient<CS> {
        info: Option<&[u8]>,
    ) -> Result<Output<CS::Hash>>
    where
-        <<CS as CipherSuite>::Hash as OutputSizeUser>::OutputSize: ArrayLength,
+        <<CS as CipherSuite>::Hash as OutputSizeUser>::OutputSize: ArraySize,
    {
        let clients = core::array::from_ref(self);
        let messages = core::array::from_ref(evaluation_element);
@@ -170,7 +170,7 @@ impl<CS: CipherSuite> PoprfClient<CS> {
        <&'a IC as IntoIterator>::IntoIter: ExactSizeIterator,
        &'a IM: 'a + IntoIterator<Item = &'a EvaluationElement<CS>>,
        <&'a IM as IntoIterator>::IntoIter: ExactSizeIterator,
-        <<CS as CipherSuite>::Hash as OutputSizeUser>::OutputSize: ArrayLength,
+        <<CS as CipherSuite>::Hash as OutputSizeUser>::OutputSize: ArraySize,
    {
        let unblinded_elements = poprf_unblind(clients, messages, pk, proof, info)?;

@@ -189,8 +189,8 @@ impl<CS: CipherSuite> PoprfServer<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)?;

        Self::new_from_seed(&seed, &[])
@@ -235,7 +235,7 @@ impl<CS: CipherSuite> PoprfServer<CS> {
    /// # Errors
    /// - [`Error::Info`] if the `info` is longer than `u16::MAX`.
    /// - [`Error::Protocol`] if the protocol fails and can't be completed.
-    pub fn blind_evaluate<R: TryRngCore + TryCryptoRng>(
+    pub fn blind_evaluate<R: TryRng + TryCryptoRng>(
        &self,
        rng: &mut R,
        blinded_element: &BlindedElement<CS>,
@@ -273,7 +273,7 @@ impl<CS: CipherSuite> PoprfServer<CS> {
    /// - [`Error::Info`] if the `info` is longer than `u16::MAX`.
    /// - [`Error::Protocol`] if the protocol fails and can't be completed.
    #[cfg(feature = "alloc")]
-    pub fn batch_blind_evaluate<'a, R: TryRngCore + TryCryptoRng, IE>(
+    pub fn batch_blind_evaluate<'a, R: TryRng + TryCryptoRng, IE>(
        &self,
        rng: &mut R,
        blinded_elements: &'a IE,
@@ -346,7 +346,7 @@ impl<CS: CipherSuite> PoprfServer<CS> {
    pub fn batch_blind_evaluate_finish<
        'a,
        'b,
-        R: TryRngCore + TryCryptoRng,
+        R: TryRng + TryCryptoRng,
        IB: Iterator<Item = &'a BlindedElement<CS>> + ExactSizeIterator,
        IE,
    >(
@@ -371,7 +371,7 @@ impl<CS: CipherSuite> PoprfServer<CS> {
            tweaked_key,
            prepared_evaluation_elements
                .into_iter()
-                .map(|element| element.0 .0),
+                .map(|element| element.0.0),
            blinded_elements.map(|element| element.0),
            Mode::Poprf,
        )?;
@@ -379,7 +379,7 @@ impl<CS: CipherSuite> PoprfServer<CS> {
        let messages = prepared_evaluation_elements.into_iter().map(<fn(
            &PreparedEvaluationElement<CS>,
        ) -> _>::from(
-            |element| EvaluationElement(element.0 .0),
+            |element| EvaluationElement(element.0.0),
        ));

        Ok(PoprfServerBatchEvaluateFinishResult { messages, proof })
@@ -569,7 +569,7 @@ fn compute_tweaked_key<CS: CipherSuite>(
    let info_len = i2osp_2(info.len()).map_err(|_| Error::Info)?;
    let framed_info = [STR_INFO.as_slice(), &info_len, info];

-    let dst = Dst::new::<CS, _, _>(STR_HASH_TO_SCALAR, Mode::Poprf);
+    let dst = Dst::new::<CS, _>(STR_HASH_TO_SCALAR, Mode::Poprf);
    // This can't fail, the size of the `input` is known.
    let m = CS::Group::hash_to_scalar::<CS::Hash>(&framed_info, &dst.as_dst()).unwrap();

@@ -602,7 +602,7 @@ fn compute_tweak<CS: CipherSuite>(
    let info_len = i2osp_2(info.len()).map_err(|_| Error::Info)?;
    let framed_info = [STR_INFO.as_slice(), &info_len, info];

-    let dst = Dst::new::<CS, _, _>(STR_HASH_TO_SCALAR, Mode::Poprf);
+    let dst = Dst::new::<CS, _>(STR_HASH_TO_SCALAR, Mode::Poprf);
    // This can't fail, the size of the `input` is known.
    let m = CS::Group::hash_to_scalar::<CS::Hash>(&framed_info, &dst.as_dst()).unwrap();

@@ -692,7 +692,7 @@ fn finalize_after_unblind<
    info: Option<&'a [u8]>,
 ) -> Result<FinalizeAfterUnblindResult<'a, CS, IE, II>>
 where
-    <<CS as CipherSuite>::Hash as OutputSizeUser>::OutputSize: ArrayLength,
+    <<CS as CipherSuite>::Hash as OutputSizeUser>::OutputSize: ArraySize,
 {
    if unblinded_elements.len() != inputs.len() {
        return Err(Error::Batch);
@@ -733,11 +733,11 @@ where
 mod tests {
    use core::ptr;

-    use rand::rngs::OsRng;
+    use rand::rngs::SysRng;

    use super::*;
-    use crate::common::STR_HASH_TO_GROUP;
    use crate::Group;
+    use crate::common::STR_HASH_TO_GROUP;

    fn prf<CS: CipherSuite>(
        input: &[u8],
@@ -747,7 +747,7 @@ mod tests {
    ) -> Output<CS::Hash> {
        let t = compute_tweak::<CS>(key, Some(info)).unwrap();

-        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();

        // evaluatedElement = G.ScalarInverse(t) * blindedElement
@@ -763,7 +763,7 @@ mod tests {
    fn verifiable_retrieval<CS: CipherSuite>() {
        let input = b"input";
        let info = b"info";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let server = PoprfServer::<CS>::new(&mut rng).unwrap();
        let client_blind_result = PoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server_result = server
@@ -786,14 +786,14 @@ mod tests {
    fn verifiable_bad_public_key<CS: CipherSuite>() {
        let input = b"input";
        let info = b"info";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let server = PoprfServer::<CS>::new(&mut rng).unwrap();
        let client_blind_result = PoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server_result = server
            .blind_evaluate(&mut rng, &client_blind_result.message, Some(info))
            .unwrap();
        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()
        };
@@ -810,7 +810,7 @@ mod tests {
    fn verifiable_server_evaluate<CS: CipherSuite>() {
        let input = b"input";
        let info = Some(b"info".as_slice());
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let client_blind_result = PoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server = PoprfServer::<CS>::new(&mut rng).unwrap();
        let server_result = server
@@ -842,7 +842,7 @@ mod tests {

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

        let mut state = client_blind_result.state;
@@ -857,7 +857,7 @@ mod tests {
    fn zeroize_verifiable_server<CS: CipherSuite>() {
        let input = b"input";
        let info = b"info";
-        let mut rng = OsRng;
+        let mut rng = SysRng;
        let server = PoprfServer::<CS>::new(&mut rng).unwrap();
        let client_blind_result = PoprfClient::<CS>::blind(input, &mut rng).unwrap();
        let server_result = server