Remove the last superfluous constant

This required purgin the usage of the low-level Key access, but now we
should be able to replace the Key type piecemeal.

src/ciphersuite.rs

@@ -6,12 +6,8 @@
 //! Defines the CipherSuite trait to specify the underlying primitives for OPAQUE
 
 use crate::{
-    errors::InternalPakeError,
-    hash::Hash,
-    key_exchange::traits::KeyExchange,
-    keypair::{Key, KeyPair},
-    map_to_curve::GroupWithMapToCurve,
-    slow_hash::SlowHash,
+    errors::InternalPakeError, hash::Hash, key_exchange::traits::KeyExchange, keypair::KeyPair,
+    map_to_curve::GroupWithMapToCurve, slow_hash::SlowHash,
 };
 
 use rand_core::{CryptoRng, RngCore};
@@ -32,7 +28,7 @@ pub trait CipherSuite {
     /// `map_to_curve::GroupWithMapToCurve`.
     type Group: GroupWithMapToCurve;
     /// A keypair type composed of public and private components
-    type KeyFormat: KeyPair<Repr = Key> + PartialEq;
+    type KeyFormat: KeyPair + PartialEq;
     /// A key exchange protocol
     type KeyExchange: KeyExchange<Self::Hash, Self::KeyFormat>;
     /// The main hash function use (for HKDF computations and hashing transcripts)

src/opaque.rs

@@ -12,7 +12,7 @@ use crate::{
     group::Group,
     hash::Hash,
     key_exchange::traits::{KeyExchange, ToBytes},
-    keypair::{Key, KeyPair, SizedBytes},
+    keypair::{KeyPair, SizedBytes},
     oprf,
     oprf::OprfClientBytes,
     slow_hash::SlowHash,
@@ -519,7 +519,7 @@ where
         let mut output: Vec<u8> = CS::Group::scalar_as_bytes(&self.oprf_key).to_vec();
         self.client_s_pk
             .iter()
-            .for_each(|v| output.extend_from_slice(&v));
+            .for_each(|v| output.extend_from_slice(&v.to_arr()));
         self.envelope
             .iter()
             .for_each(|v| output.extend_from_slice(&v.to_bytes()));
@@ -794,7 +794,7 @@ impl<CS: CipherSuite> ClientLogin<CS> {
             l2.ke2_message,
             &self.ke1_state,
             server_s_pk.clone(),
-            Key::from_bytes(&opened_envelope.plaintext)?,
+            <CS::KeyFormat as KeyPair>::Repr::from_bytes(&opened_envelope.plaintext)?,
         )?;
 
         Ok((
@@ -869,7 +869,7 @@ impl<CS: CipherSuite> ServerLogin<CS> {
     /// ```
     pub fn start<R: RngCore + CryptoRng>(
         password_file: ServerRegistration<CS>,
-        server_s_sk: &Key,
+        server_s_sk: &<CS::KeyFormat as KeyPair>::Repr,
         l1: LoginFirstMessage<CS>,
         rng: &mut R,
     ) -> Result<ServerLoginStartResult<CS>, ProtocolError> {

src/tests/opaque_ke_test.rs

@@ -8,7 +8,7 @@ use crate::{
     errors::*,
     group::Group,
     key_exchange::tripledh::{TripleDH, NONCE_LEN},
-    keypair::{Key, KeyPair, X25519KeyPair},
+    keypair::{Key, KeyPair, SizedBytes, X25519KeyPair},
     opaque::*,
     slow_hash::NoOpHash,
     tests::mock_rng::CycleRng,
@@ -220,7 +220,18 @@ fn stringify_test_vectors(p: &TestVectorParameters) -> String {
     s
 }
 
-fn generate_parameters<CS: CipherSuite>() -> TestVectorParameters {
+fn generate_parameters<CS: CipherSuite>() -> TestVectorParameters
+where
+    // Unsightly constraints due to the (required) use of the SizedBytes
+    // instance for KP in ServerRegistration::start. See also the impl
+    // Tryfrom<&[u8]> for ServerRegistration (those are the same constraints).
+    <<CS::KeyFormat as KeyPair>::Repr as SizedBytes>::Len:
+        std::ops::Add<<<CS::KeyFormat as KeyPair>::Repr as SizedBytes>::Len>,
+    generic_array::typenum::Sum<
+        <<CS::KeyFormat as KeyPair>::Repr as SizedBytes>::Len,
+        <<CS::KeyFormat as KeyPair>::Repr as SizedBytes>::Len,
+    >: generic_array::ArrayLength<u8>,
+{
     let mut rng = OsRng;
 
     // Inputs
@@ -260,7 +271,7 @@ fn generate_parameters<CS: CipherSuite>() -> TestVectorParameters {
     let server_registration_state = server_registration.to_bytes().to_vec();
 
     let mut client_s_sk_and_nonce: Vec<u8> = Vec::new();
-    client_s_sk_and_nonce.extend_from_slice(&client_s_kp.private());
+    client_s_sk_and_nonce.extend_from_slice(&client_s_kp.private().to_arr());
     client_s_sk_and_nonce.extend_from_slice(&envelope_nonce);
 
     let mut finish_registration_rng = CycleRng::new(client_s_sk_and_nonce);
@@ -274,7 +285,7 @@ fn generate_parameters<CS: CipherSuite>() -> TestVectorParameters {
 
     let mut client_login_start: Vec<u8> = Vec::new();
     client_login_start.extend_from_slice(&blinding_factor_raw);
-    client_login_start.extend_from_slice(&client_e_kp.private());
+    client_login_start.extend_from_slice(&client_e_kp.private().to_arr());
     client_login_start.extend_from_slice(&client_nonce);
 
     let mut client_login_start_rng = CycleRng::new(client_login_start);
@@ -283,7 +294,7 @@ fn generate_parameters<CS: CipherSuite>() -> TestVectorParameters {
     let l1_bytes = l1.to_bytes().to_vec();
     let client_login_state = client_login.to_bytes().to_vec();
 
-    let mut server_e_sk_rng = CycleRng::new(server_e_kp.private().to_vec());
+    let mut server_e_sk_rng = CycleRng::new(server_e_kp.private().to_arr().to_vec());
     let (l2, server_login) = ServerLogin::<CS>::start(
         password_file,
         server_s_kp.private(),
@@ -294,21 +305,21 @@ fn generate_parameters<CS: CipherSuite>() -> TestVectorParameters {
     let l2_bytes = l2.to_bytes().to_vec();
     let server_login_state = server_login.to_bytes().to_vec();
 
-    let mut client_e_sk_rng = CycleRng::new(client_e_kp.private().to_vec());
+    let mut client_e_sk_rng = CycleRng::new(client_e_kp.private().to_arr().to_vec());
     let (l3, client_shared_secret, _export_key_login) = client_login
         .finish(l2, server_s_kp.public(), &mut client_e_sk_rng)
         .unwrap();
     let l3_bytes = l3.to_bytes().to_vec();
 
     TestVectorParameters {
-        client_s_pk: client_s_kp.public().to_vec(),
-        client_s_sk: client_s_kp.private().to_vec(),
-        client_e_pk: client_e_kp.public().to_vec(),
-        client_e_sk: client_e_kp.private().to_vec(),
-        server_s_pk: server_s_kp.public().to_vec(),
-        server_s_sk: server_s_kp.private().to_vec(),
-        server_e_pk: server_e_kp.public().to_vec(),
-        server_e_sk: server_e_kp.private().to_vec(),
+        client_s_pk: client_s_kp.public().to_arr().to_vec(),
+        client_s_sk: client_s_kp.private().to_arr().to_vec(),
+        client_e_pk: client_e_kp.public().to_arr().to_vec(),
+        client_e_sk: client_e_kp.private().to_arr().to_vec(),
+        server_s_pk: server_s_kp.public().to_arr().to_vec(),
+        server_s_sk: server_s_kp.private().to_arr().to_vec(),
+        server_e_pk: server_e_kp.public().to_arr().to_vec(),
+        server_e_sk: server_e_kp.private().to_arr().to_vec(),
         password: password.to_vec(),
         blinding_factor_raw: blinding_factor_raw.to_vec(),
         blinding_factor: blinding_factor_bytes.to_vec(),