feat: upgrade crypto ecosystem to latest RustCrypto stack

Upgrade all core cryptographic dependencies to their latest versions:

Dependencies:
- digest: 0.10 to 0.11
- elliptic-curve: 0.13 to 0.14
- hkdf: 0.12 to 0.13
- hmac: 0.12 to 0.13
- rand: 0.8 to 0.10
- rand_chacha: 0.3 to 0.10
- sha2: 0.10 to 0.11
- getrandom: 0.2 to 0.4 (WASM)
- ml-kem: 0.3.0-rc.0 to 0.3
- ecdsa: 0.16 to 0.17.0-rc.23
- rfc6979: 0.4 to 0.6 (now internal to ecdsa)
- p256/p384/p521: 0.13 to 0.14.0-rc.15
- curve25519-dalek: 4 to 5.0.0-rc
- ed25519-dalek: 2 to 3.0.0-rc
- cryptoki: 0.9 to 0.12
- rustyline: 17 to 18
- scrypt: 0.11 to 0.12
- voprf replaced by voprf-vx 1.0.0-pre.0

Migration changes:
- generic-array 0.14 to 1.4 with hybrid-array 0.4 interop
- ArrayLength<u8> to ArrayLength (generic-array 1.x)
- Added ConcatExt trait to disambiguate from [T]::concat
- Replaced Hmac with SimpleHmac for digest 0.11 compatibility
- Added OutputSize<H>: ArrayLength bounds throughout Hash trait
- Converted hybrid_array::Array between GenericArray at API boundaries
- Updated GroupEncoding Repr bound to hybrid_array::Array
- ECDSA sign now uses ecdsa::hazmat::sign_prehashed_rfc6979
- Removed direct rfc6979 dependency (handled by ecdsa internally)
- Replaced bincode with postcard for no_std serialization
- Re-exported hybrid_array from crate root

Other changes:
- Renamed crate to opaque-vx
- Increased MSRV to 1.88
- Added cryptography to Cargo.toml categories
- Removed Facebook-specific contributions from CONTRIBUTING.md
- Removed v3 to v4 migration test
- Removed unstable rustfmt configurations for stable compatibility

src/tests/full_test.rs

@@ -19,8 +19,9 @@ use generic_array::{ArrayLength, GenericArray};
 #[cfg(feature = "kem")]
 use ml_kem::MlKem768;
 use rand::SeedableRng;
-use rand::rngs::OsRng;
+use rand::rngs::SysRng;
 use rand_chacha::ChaCha20Rng;
+use rand_core::UnwrapErr;
 use serde_json::Value;
 use subtle::ConstantTimeEq;
 use voprf::Group as _;
@@ -42,6 +43,7 @@ use crate::messages::{
     RegistrationResponseLen, RegistrationUploadLen,
 };
 use crate::opaque::*;
+use crate::tests::decode;
 use crate::tests::mock_rng::CycleRng;
 use crate::*;
 
@@ -261,10 +263,6 @@ pub struct TestVectorParameters {
 
 static STR_PASSWORD: &str = "password";
 
-fn decode(values: &Value, key: &str) -> Option<Vec<u8>> {
-    values[key].as_str().and_then(|s| hex::decode(s).ok())
-}
-
 fn populate_test_vectors(values: &Value) -> TestVectorParameters {
     TestVectorParameters {
         client_s_pk: decode(values, "client_s_pk").unwrap(),
@@ -521,37 +519,37 @@ where
     <CS::KeyExchange as KeyExchange>::KE3Message: Serialize,
     // ClientRegistration: KgSk + KgPk
     <OprfGroup<CS> as voprf::Group>::ScalarLen: Add<<OprfGroup<CS> as voprf::Group>::ElemLen>,
-    ClientRegistrationLen<CS>: ArrayLength<u8>,
+    ClientRegistrationLen<CS>: ArrayLength,
     // RegistrationResponse: KgPk + KePk
     <OprfGroup<CS> as voprf::Group>::ElemLen: Add<<KeGroup<CS> as Group>::PkLen>,
-    RegistrationResponseLen<CS>: ArrayLength<u8>,
+    RegistrationResponseLen<CS>: ArrayLength,
     // RegistrationUpload: (KePk + Hash) + Envelope
     <KeGroup<CS> as Group>::PkLen: Add<OutputSize<OprfHash<CS>>>,
     Sum<<KeGroup<CS> as Group>::PkLen, OutputSize<OprfHash<CS>>>:
-        ArrayLength<u8> + Add<EnvelopeLen<CS>>,
-    RegistrationUploadLen<CS>: ArrayLength<u8>,
+        ArrayLength + Add<EnvelopeLen<CS>>,
+    RegistrationUploadLen<CS>: ArrayLength,
     // ServerRegistration = RegistrationUpload
     // CredentialRequest: KgPk + Ke1Message
     <CS::KeyExchange as KeyExchange>::KE1Message: Serialize,
     <OprfGroup<CS> as voprf::Group>::ElemLen: Add<Ke1MessageLen<CS>>,
-    CredentialRequestLen<CS>: ArrayLength<u8>,
+    CredentialRequestLen<CS>: ArrayLength,
     // ClientLogin: KgSk + CredentialRequest + Ke1State
     <OprfGroup<CS> as voprf::Group>::ScalarLen: Add<CredentialRequestLen<CS>>,
     <CS::KeyExchange as KeyExchange>::KE1State: Serialize,
     Sum<<OprfGroup<CS> as voprf::Group>::ScalarLen, CredentialRequestLen<CS>>:
-        ArrayLength<u8> + Add<Ke1StateLen<CS>>,
-    ClientLoginLen<CS>: ArrayLength<u8>,
+        ArrayLength + Add<Ke1StateLen<CS>>,
+    ClientLoginLen<CS>: ArrayLength,
     // CredentialResponseWithoutKeLen: (KgPk + Nonce) + MaskedResponse
     <OprfGroup<CS> as voprf::Group>::ElemLen: Add<NonceLen>,
     Sum<<OprfGroup<CS> as voprf::Group>::ElemLen, NonceLen>:
-        ArrayLength<u8> + Add<MaskedResponseLen<CS>>,
-    CredentialResponseWithoutKeLen<CS>: ArrayLength<u8>,
+        ArrayLength + Add<MaskedResponseLen<CS>>,
+    CredentialResponseWithoutKeLen<CS>: ArrayLength,
     // CredentialResponse: CredentialResponseWithoutKeLen + Ke2Message
     <CS::KeyExchange as KeyExchange>::KE2Message: Serialize,
     CredentialResponseWithoutKeLen<CS>: Add<Ke2MessageLen<CS>>,
-    CredentialResponseLen<CS>: ArrayLength<u8>,
+    CredentialResponseLen<CS>: ArrayLength,
 {
-    use rand::RngCore;
+    use rand::Rng;
 
     use crate::keypair::KeyPair;
 
@@ -588,20 +586,19 @@ where
     let dummy_client_pk = dummy_client_pk.serialize();
     let server_setup = ServerSetup::<CS>::deserialize(
         &[
-            oprf_seed.as_ref(),
-            &server_s_kp.private().serialize(),
-            &dummy_client_pk,
+            oprf_seed.as_slice(),
+            server_s_kp.private().serialize().as_slice(),
+            dummy_client_pk.as_slice(),
         ]
         .concat(),
-    )
-    .unwrap();
+    )?;
 
-    let blinding_factor = <OprfGroup<CS> as voprf::Group>::random_scalar(&mut rng);
+    let blinding_factor = <OprfGroup<CS> as voprf::Group>::random_scalar(&mut rng)?;
     let blinding_factor_bytes = OprfGroup::<CS>::serialize_scalar(blinding_factor);
 
     let mut blinding_factor_registration_rng = CycleRng::new(blinding_factor_bytes.to_vec());
     let client_registration_start_result =
-        ClientRegistration::<CS>::start(&mut blinding_factor_registration_rng, password).unwrap();
+        ClientRegistration::<CS>::start(&mut blinding_factor_registration_rng, password)?;
     let blinding_factor_bytes_returned = OprfGroup::<CS>::serialize_scalar(
         client_registration_start_result
             .state
@@ -620,8 +617,8 @@ where
         &server_setup,
         client_registration_start_result.message,
         credential_identifier,
-    )
-    .unwrap();
+    )?;
+
     let registration_response_bytes = server_registration_start_result.message.serialize();
 
     let mut client_s_sk_and_nonce: Vec<u8> = Vec::new();
@@ -629,21 +626,18 @@ where
     client_s_sk_and_nonce.extend_from_slice(&envelope_nonce);
 
     let mut finish_registration_rng = CycleRng::new(client_s_sk_and_nonce);
-    let client_registration_finish_result = client_registration_start_result
-        .state
-        .finish(
-            &mut finish_registration_rng,
-            password,
-            server_registration_start_result.message,
-            ClientRegistrationFinishParameters::new(
-                Identifiers {
-                    client: Some(id_u),
-                    server: Some(id_s),
-                },
-                None,
-            ),
-        )
-        .unwrap();
+    let client_registration_finish_result = client_registration_start_result.state.finish(
+        &mut finish_registration_rng,
+        password,
+        server_registration_start_result.message,
+        ClientRegistrationFinishParameters::new(
+            Identifiers {
+                client: Some(id_u),
+                server: Some(id_s),
+            },
+            None,
+        ),
+    )?;
     let registration_upload_bytes = client_registration_finish_result.message.serialize();
 
     let password_file = ServerRegistration::finish(client_registration_finish_result.message);
@@ -656,7 +650,7 @@ where
 
     let mut client_login_start_rng = CycleRng::new(client_login_start);
     let client_login_start_result =
-        ClientLogin::<CS>::start(&mut client_login_start_rng, password).unwrap();
+        ClientLogin::<CS>::start(&mut client_login_start_rng, password)?;
     let credential_request_bytes = client_login_start_result.message.serialize();
     let client_login_state = client_login_start_result.state.serialize().to_vec();
 
@@ -683,27 +677,23 @@ where
                 server: Some(id_s),
             },
         },
-    )
-    .unwrap();
+    )?;
     let credential_response_bytes = server_login_start_result.message.serialize();
     let server_login_state = server_login_start_result.state.serialize();
 
-    let client_login_finish_result = client_login_start_result
-        .state
-        .finish(
-            &mut CycleRng::new(client_sig_rng.to_vec()),
-            password,
-            server_login_start_result.message,
-            ClientLoginFinishParameters::new(
-                Some(context),
-                Identifiers {
-                    client: Some(id_u),
-                    server: Some(id_s),
-                },
-                None,
-            ),
-        )
-        .unwrap();
+    let client_login_finish_result = client_login_start_result.state.finish(
+        &mut CycleRng::new(client_sig_rng.to_vec()),
+        password,
+        server_login_start_result.message,
+        ClientLoginFinishParameters::new(
+            Some(context),
+            Identifiers {
+                client: Some(id_u),
+                server: Some(id_s),
+            },
+            None,
+        ),
+    )?;
     let credential_finalization_bytes = client_login_finish_result.message.serialize();
 
     Ok(TestVectorParameters {
@@ -787,7 +777,7 @@ fn test_registration_request() -> Result<(), ProtocolError> {
     where
         // ClientRegistration: KgSk + KgPk
         <OprfGroup<CS> as voprf::Group>::ScalarLen: Add<<OprfGroup<CS> as voprf::Group>::ElemLen>,
-        ClientRegistrationLen<CS>: ArrayLength<u8>,
+        ClientRegistrationLen<CS>: ArrayLength,
     {
         let parameters = populate_test_vectors(&serde_json::from_str(test_vector).unwrap());
         let mut rng = CycleRng::new(parameters.blinding_factor.to_vec());
@@ -821,15 +811,15 @@ fn test_serialization() -> Result<(), ProtocolError> {
         let client_registration_start_result =
             ClientRegistration::<CS>::start(&mut rng, &parameters.password)?;
 
-        // Test the bincode serialization (binary).
+        // Test the postcard serialization (binary).
         let registration_request =
-            bincode::serialize(&client_registration_start_result.message).unwrap();
+            postcard::to_allocvec(&client_registration_start_result.message).unwrap();
         assert_eq!(
             registration_request.len(),
             RegistrationRequestLen::<CS>::USIZE
         );
         let registration_request: RegistrationRequest<CS> =
-            bincode::deserialize(&registration_request).unwrap();
+            postcard::from_bytes(&registration_request).unwrap();
         assert_eq!(
             hex::encode(client_registration_start_result.message.serialize()),
             hex::encode(registration_request.serialize()),
@@ -852,7 +842,7 @@ fn test_registration_response() -> Result<(), ProtocolError> {
     where
         // RegistrationResponse: KgPk + KePk
         <OprfGroup<CS> as voprf::Group>::ElemLen: Add<<KeGroup<CS> as Group>::PkLen>,
-        RegistrationResponseLen<CS>: ArrayLength<u8>,
+        RegistrationResponseLen<CS>: ArrayLength,
     {
         let parameters = populate_test_vectors(
             &serde_json::from_str(test_vector).map_err(|_| ProtocolError::SerializationError)?,
@@ -894,8 +884,8 @@ fn test_registration_upload() -> Result<(), ProtocolError> {
         // RegistrationUpload: (KePk + Hash) + Envelope
         <KeGroup<CS> as Group>::PkLen: Add<OutputSize<OprfHash<CS>>>,
         Sum<<KeGroup<CS> as Group>::PkLen, OutputSize<OprfHash<CS>>>:
-            ArrayLength<u8> + Add<EnvelopeLen<CS>>,
-        RegistrationUploadLen<CS>: ArrayLength<u8>,
+            ArrayLength + Add<EnvelopeLen<CS>>,
+        RegistrationUploadLen<CS>: ArrayLength,
     {
         let parameters = populate_test_vectors(
             &serde_json::from_str(test_vector).map_err(|_| ProtocolError::SerializationError)?,
@@ -945,8 +935,8 @@ fn test_password_file() -> Result<(), ProtocolError> {
         // RegistrationUpload: (KePk + Hash) + Envelope
         <KeGroup<CS> as Group>::PkLen: Add<OutputSize<OprfHash<CS>>>,
         Sum<<KeGroup<CS> as Group>::PkLen, OutputSize<OprfHash<CS>>>:
-            ArrayLength<u8> + Add<EnvelopeLen<CS>>,
-        RegistrationUploadLen<CS>: ArrayLength<u8>,
+            ArrayLength + Add<EnvelopeLen<CS>>,
+        RegistrationUploadLen<CS>: ArrayLength,
         // ServerRegistration = RegistrationUpload
     {
         let parameters = populate_test_vectors(&serde_json::from_str(test_vector).unwrap());
@@ -977,13 +967,13 @@ fn test_credential_request() -> Result<(), ProtocolError> {
         // CredentialRequest: KgPk + Ke1Message
         <CS::KeyExchange as KeyExchange>::KE1Message: Serialize,
         <OprfGroup<CS> as voprf::Group>::ElemLen: Add<Ke1MessageLen<CS>>,
-        CredentialRequestLen<CS>: ArrayLength<u8>,
+        CredentialRequestLen<CS>: ArrayLength,
         // ClientLogin: KgSk + CredentialRequest + Ke1State
         <OprfGroup<CS> as voprf::Group>::ScalarLen: Add<CredentialRequestLen<CS>>,
         <CS::KeyExchange as KeyExchange>::KE1State: Serialize,
         Sum<<OprfGroup<CS> as voprf::Group>::ScalarLen, CredentialRequestLen<CS>>:
-            ArrayLength<u8> + Add<Ke1StateLen<CS>>,
-        ClientLoginLen<CS>: ArrayLength<u8>,
+            ArrayLength + Add<Ke1StateLen<CS>>,
+        ClientLoginLen<CS>: ArrayLength,
     {
         let parameters = populate_test_vectors(&serde_json::from_str(test_vector).unwrap());
 
@@ -1024,12 +1014,12 @@ fn test_credential_response() -> Result<(), ProtocolError> {
         // CredentialResponseWithoutKeLen: (KgPk + Nonce) + MaskedResponse
         <OprfGroup<CS> as voprf::Group>::ElemLen: Add<NonceLen>,
         Sum<<OprfGroup<CS> as voprf::Group>::ElemLen, NonceLen>:
-            ArrayLength<u8> + Add<MaskedResponseLen<CS>>,
-        CredentialResponseWithoutKeLen<CS>: ArrayLength<u8>,
+            ArrayLength + Add<MaskedResponseLen<CS>>,
+        CredentialResponseWithoutKeLen<CS>: ArrayLength,
         // CredentialResponse: CredentialResponseWithoutKeLen + Ke2Message
         <CS::KeyExchange as KeyExchange>::KE2Message: Serialize,
         CredentialResponseWithoutKeLen<CS>: Add<Ke2MessageLen<CS>>,
-        CredentialResponseLen<CS>: ArrayLength<u8>,
+        CredentialResponseLen<CS>: ArrayLength,
     {
         let parameters = populate_test_vectors(&serde_json::from_str(test_vector).unwrap());
 
@@ -1182,8 +1172,8 @@ fn test_complete_flow<CS: CipherSuite>(
     login_password: &[u8],
 ) -> Result<(), ProtocolError> {
     let credential_identifier = b"credentialIdentifier";
-    let mut client_rng = OsRng;
-    let mut server_rng = OsRng;
+    let mut client_rng = UnwrapErr(SysRng);
+    let mut server_rng = UnwrapErr(SysRng);
     let server_setup = ServerSetup::<CS>::new(&mut server_rng);
     let client_registration_start_result =
         ClientRegistration::<CS>::start(&mut client_rng, registration_password)?;
@@ -1330,8 +1320,8 @@ fn test_reflected_value_error_registration() -> Result<(), ProtocolError> {
     fn inner<CS: CipherSuite>(_test_vector: &str) -> Result<(), ProtocolError> {
         let credential_identifier = b"credentialIdentifier";
         let password = b"password";
-        let mut client_rng = OsRng;
-        let mut server_rng = OsRng;
+        let mut client_rng = UnwrapErr(SysRng);
+        let mut server_rng = UnwrapErr(SysRng);
         let server_setup = ServerSetup::<CS>::new(&mut server_rng);
         let client_registration_start_result =
             ClientRegistration::<CS>::start(&mut client_rng, password)?;
@@ -1377,8 +1367,8 @@ fn test_reflected_value_error_login() -> Result<(), ProtocolError> {
     fn inner<CS: CipherSuite>(_test_vector: &str) -> Result<(), ProtocolError> {
         let credential_identifier = b"credentialIdentifier";
         let password = b"password";
-        let mut client_rng = OsRng;
-        let mut server_rng = OsRng;
+        let mut client_rng = UnwrapErr(SysRng);
+        let mut server_rng = UnwrapErr(SysRng);
         let server_setup = ServerSetup::<CS>::new(&mut server_rng);
         let client_registration_start_result =
             ClientRegistration::<CS>::start(&mut client_rng, password)?;