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]>

src/tests/mock_rng.rs

@@ -9,7 +9,8 @@
 use alloc::vec::Vec;
 use core::cmp::min;
 
-use rand_core::{CryptoRng, RngCore};
+use core::convert::Infallible;
+use rand_core::{TryCryptoRng, TryRng};
 
 /// A simple implementation of `RngCore` for testing purposes.
 ///
@@ -38,23 +39,35 @@ fn rotate_left<T>(data: &mut [T], steps: usize) {
     data.reverse();
 }
 
-impl RngCore for CycleRng {
-    fn next_u32(&mut self) -> u32 {
-        unimplemented!()
+impl TryRng for CycleRng {
+    type Error = Infallible;
+
+    fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
+        let mut buf = [0u8; 4];
+
+        self.try_fill_bytes(&mut buf)?;
+
+        Ok(u32::from_le_bytes(buf))
     }
 
-    #[inline]
-    fn next_u64(&mut self) -> u64 {
-        unimplemented!()
+    fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
+        let mut buf = [0u8; 8];
+
+        self.try_fill_bytes(&mut buf)?;
+
+        Ok(u64::from_le_bytes(buf))
     }
 
-    #[inline]
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Self::Error> {
         let len = min(self.v.len(), dest.len());
+
         dest[..len].copy_from_slice(&self.v[..len]);
+
         rotate_left(&mut self.v, len);
+
+        Ok(())
     }
 }
 
 // This is meant for testing only
-impl CryptoRng for CycleRng {}
+impl TryCryptoRng for CycleRng {}

src/tests/mod.rs

@@ -10,3 +10,21 @@ mod cfrg_vectors;
 mod mock_rng;
 mod parser;
 mod test_cfrg_vectors;
+
+impl crate::CipherSuite for p256::NistP256 {
+    const ID: &'static [u8] = <p256::NistP256 as hash2curve::OprfParameters>::ID;
+    type Group = p256::NistP256;
+    type Hash = sha2::Sha256;
+}
+
+impl crate::CipherSuite for p384::NistP384 {
+    const ID: &'static [u8] = <p384::NistP384 as hash2curve::OprfParameters>::ID;
+    type Group = p384::NistP384;
+    type Hash = sha2::Sha384;
+}
+
+impl crate::CipherSuite for p521::NistP521 {
+    const ID: &'static [u8] = <p521::NistP521 as hash2curve::OprfParameters>::ID;
+    type Group = p521::NistP521;
+    type Hash = sha2::Sha512;
+}

src/tests/parser.rs

@@ -15,55 +15,50 @@ pub(crate) fn rfc_to_json(input: &str) -> String {
 }
 
 fn parse_ciphersuites(input: &str) -> String {
-    let re = regex::Regex::new(r"\nA\.\d\.  (?P<ciphersuite>.+?)\n\n").unwrap();
+    let re = regex::Regex::new(r"\nA\.\d\. {2}(?P<ciphersuite>.+?)\n\n").unwrap();
     let mut ciphersuites = vec![];
 
     let chunks: Vec<&str> = re.split(input).collect();
-    let mut count = 1;
-    for caps in re.captures_iter(input) {
+    for (count, caps) in (1..).zip(re.captures_iter(input)) {
         let ciphersuite = format!(
             "\"{}\": {{ {} }}",
             &caps["ciphersuite"],
             parse_modes(chunks[count])
         );
+
         ciphersuites.push(ciphersuite);
-        count += 1;
     }
 
     ciphersuites.join(",\n")
 }
 
 fn parse_modes(input: &str) -> String {
-    let re = regex::Regex::new(r"A\.\d.\d\.  (?P<mode>.*?) Mode").unwrap();
+    let re = regex::Regex::new(r"A\.\d.\d\. {2}(?P<mode>.*?) Mode").unwrap();
     let mut modes = vec![];
 
     let chunks: Vec<&str> = re.split(input).collect();
-    let mut count = 1;
-    for caps in re.captures_iter(input) {
+    for (count, caps) in (1..).zip(re.captures_iter(input)) {
         let mode = format!(
             "\"{}\": [\n {} \n]",
             &caps["mode"],
             parse_vectors(chunks[count])
         );
         modes.push(mode);
-        count += 1;
     }
 
     modes.join(",\n")
 }
 
 fn parse_vectors(input: &str) -> String {
-    let re = regex::Regex::new(r"A\.\d.\d\.\d\.  Test Vector.*+\n").unwrap();
+    let re = regex::Regex::new(r"A\.\d.\d\.\d\. {2}Test Vector.*+\n").unwrap();
     let mut vectors = vec![];
 
     let chunks: Vec<&str> = re.split(input).collect();
     let init_params = parse_params(chunks[0]);
 
-    let mut count = 1;
-    for _ in re.captures_iter(input) {
+    for (count, _) in (1..).zip(re.captures_iter(input)) {
         let params = format!("{{\n{},\n{}\n}}", init_params, parse_params(chunks[count]));
         vectors.push(params);
-        count += 1;
     }
 
     vectors.join(",\n")

src/tests/test_cfrg_vectors.rs

@@ -360,7 +360,7 @@ fn test_voprf_blind_evaluate<CS: CipherSuite>(tvs: &[VOPRFTestVectorParameters])
             assert_eq!(&parameter, &message.serialize().as_slice());
         }
 
-        assert_eq!(&parameters.proof, &proof.serialize().as_slice());
+        assert_eq!(&parameters.proof, &proof.serialize().to_vec());
     }
     Ok(())
 }
@@ -386,8 +386,7 @@ fn test_poprf_blind_evaluate<CS: CipherSuite>(tvs: &[VOPRFTestVectorParameters])
                 blinded_elements.iter(),
                 &prepared_evaluation_elements,
                 &prepared_tweak,
-            )
-            .unwrap();
+            )?;
 
         let messages: Vec<_> = messages.collect();
 
@@ -395,7 +394,7 @@ fn test_poprf_blind_evaluate<CS: CipherSuite>(tvs: &[VOPRFTestVectorParameters])
             assert_eq!(&parameter, &message.serialize().as_slice());
         }
 
-        assert_eq!(&parameters.proof, &proof.serialize().as_slice());
+        assert_eq!(&parameters.proof, &proof.serialize().to_vec());
     }
     Ok(())
 }