Simplify opaque types

model/src/opaque.rs

@@ -95,16 +95,17 @@ pub mod client {
     /// Methods to register a new user, from the client side.
     pub mod registration {
         pub use super::*;
-        pub use opaque_ke::{
-            ClientRegistration, ClientRegistrationFinishParameters, ClientRegistrationFinishResult,
-            ClientRegistrationStartResult, RegistrationResponse,
-        };
+        pub type ClientRegistration = opaque_ke::ClientRegistration<DefaultSuite>;
+        pub type ClientRegistrationStartResult = opaque_ke::ClientRegistrationStartResult<DefaultSuite>;
+        pub type ClientRegistrationFinishResult = opaque_ke::ClientRegistrationFinishResult<DefaultSuite>;
+        pub type RegistrationResponse = opaque_ke::RegistrationResponse<DefaultSuite>;
+        pub use opaque_ke::ClientRegistrationFinishParameters;
         /// Initiate the registration negotiation.
         pub fn start_registration<R: RngCore + CryptoRng>(
             password: &str,
             rng: &mut R,
-        ) -> AuthenticationResult<ClientRegistrationStartResult<DefaultSuite>> {
-            Ok(ClientRegistration::<DefaultSuite>::start(
+        ) -> AuthenticationResult<ClientRegistrationStartResult> {
+            Ok(ClientRegistration::start(
                 rng,
                 password.as_bytes(),
             )?)
@@ -112,10 +113,10 @@ pub mod client {
 
         /// Finalize the registration negotiation.
         pub fn finish_registration<R: RngCore + CryptoRng>(
-            registration_start: ClientRegistration<DefaultSuite>,
-            registration_response: RegistrationResponse<DefaultSuite>,
+            registration_start: ClientRegistration,
+            registration_response: RegistrationResponse,
             rng: &mut R,
-        ) -> AuthenticationResult<ClientRegistrationFinishResult<DefaultSuite>> {
+        ) -> AuthenticationResult<ClientRegistrationFinishResult> {
             Ok(registration_start.finish(
                 rng,
                 registration_response,
@@ -127,17 +128,21 @@ pub mod client {
     /// Methods to login, from the client side.
     pub mod login {
         pub use super::*;
+        pub type ClientLogin = opaque_ke::ClientLogin<DefaultSuite>;
+        pub type ClientLoginFinishResult = opaque_ke::ClientLoginFinishResult<DefaultSuite>;
+        pub type ClientLoginStartResult = opaque_ke::ClientLoginStartResult<DefaultSuite>;
+        pub type CredentialResponse = opaque_ke::CredentialResponse<DefaultSuite>;
         pub use opaque_ke::{
-            ClientLogin, ClientLoginFinishParameters, ClientLoginFinishResult,
-            ClientLoginStartParameters, ClientLoginStartResult, CredentialResponse,
+            ClientLoginFinishParameters,
+            ClientLoginStartParameters,
         };
 
         /// Initiate the login negotiation.
         pub fn start_login<R: RngCore + CryptoRng>(
             password: &str,
             rng: &mut R,
-        ) -> AuthenticationResult<ClientLoginStartResult<DefaultSuite>> {
-            Ok(ClientLogin::<DefaultSuite>::start(
+        ) -> AuthenticationResult<ClientLoginStartResult> {
+            Ok(ClientLogin::start(
                 rng,
                 password.as_bytes(),
                 ClientLoginStartParameters::default(),
@@ -146,9 +151,9 @@ pub mod client {
 
         /// Finalize the client login negotiation.
         pub fn finish_login(
-            login_start: ClientLogin<DefaultSuite>,
-            login_response: CredentialResponse<DefaultSuite>,
-        ) -> AuthenticationResult<ClientLoginFinishResult<DefaultSuite>> {
+            login_start: ClientLogin,
+            login_response: CredentialResponse,
+        ) -> AuthenticationResult<ClientLoginFinishResult> {
             Ok(login_start.finish(login_response, ClientLoginFinishParameters::default())?)
         }
     }
@@ -159,20 +164,22 @@ pub mod client {
 #[cfg(feature = "opaque_server")]
 pub mod server {
     pub use super::*;
-    pub use opaque_ke::ServerRegistration;
+    pub type ServerRegistration = opaque_ke::ServerRegistration<DefaultSuite>;
     /// Methods to register a new user, from the server side.
     pub mod registration {
         pub use super::*;
-        pub use opaque_ke::{RegistrationRequest, RegistrationUpload, ServerRegistrationStartResult};
+        pub type RegistrationRequest = opaque_ke::RegistrationRequest<DefaultSuite>;
+        pub type RegistrationUpload = opaque_ke::RegistrationUpload<DefaultSuite>;
+        pub type ServerRegistrationStartResult = opaque_ke::ServerRegistrationStartResult<DefaultSuite>;
         /// Start a registration process, from a request sent by the client.
         ///
         /// The result must be kept for the next step.
         pub fn start_registration<R: RngCore + CryptoRng>(
             rng: &mut R,
-            registration_request: RegistrationRequest<DefaultSuite>,
+            registration_request: RegistrationRequest,
             server_public_key: PublicKey<'_>,
-        ) -> AuthenticationResult<ServerRegistrationStartResult<DefaultSuite>> {
-            Ok(ServerRegistration::<DefaultSuite>::start(
+        ) -> AuthenticationResult<ServerRegistrationStartResult> {
+            Ok(ServerRegistration::start(
                 rng,
                 registration_request,
                 *server_public_key,
@@ -181,9 +188,9 @@ pub mod server {
 
         /// Finish to register a new user, and get the data to store in the database.
         pub fn get_password_file(
-            registration_start: ServerRegistration<DefaultSuite>,
-            registration_upload: RegistrationUpload<DefaultSuite>,
-        ) -> AuthenticationResult<ServerRegistration<DefaultSuite>> {
+            registration_start: ServerRegistration,
+            registration_upload: RegistrationUpload,
+        ) -> AuthenticationResult<ServerRegistration> {
             Ok(registration_start.finish(registration_upload)?)
         }
     }
@@ -191,20 +198,22 @@ pub mod server {
     /// Methods to handle user login, from the server-side.
     pub mod login {
         pub use super::*;
-        pub use opaque_ke::{
-            CredentialFinalization, CredentialRequest, ServerLogin, ServerLoginFinishResult,
-            ServerLoginStartParameters, ServerLoginStartResult,
-        };
+        pub type CredentialFinalization = opaque_ke::CredentialFinalization<DefaultSuite>;
+        pub type CredentialRequest = opaque_ke::CredentialRequest<DefaultSuite>;
+        pub type ServerLogin = opaque_ke::ServerLogin<DefaultSuite>;
+        pub type ServerLoginStartResult = opaque_ke::ServerLoginStartResult<DefaultSuite>;
+        pub type ServerLoginFinishResult = opaque_ke::ServerLoginFinishResult<DefaultSuite>;
+        pub use opaque_ke::ServerLoginStartParameters;
 
         /// Start a login process, from a request sent by the client.
         ///
         /// The result must be kept for the next step.
         pub fn start_login<R: RngCore + CryptoRng>(
             rng: &mut R,
-            password_file: ServerRegistration<DefaultSuite>,
+            password_file: ServerRegistration,
             server_private_key: PrivateKey<'_>,
-            credential_request: CredentialRequest<DefaultSuite>,
-        ) -> AuthenticationResult<ServerLoginStartResult<DefaultSuite>> {
+            credential_request: CredentialRequest,
+        ) -> AuthenticationResult<ServerLoginStartResult> {
             Ok(ServerLogin::start(
                 rng,
                 password_file,
@@ -215,9 +224,9 @@ pub mod server {
         }
 
         /// Finish to authorize a new user, and get the session key to decrypt associated data.
-        pub fn finalize_login(
-            login_start: ServerLogin<DefaultSuite>,
-            credential_finalization: CredentialFinalization<DefaultSuite>,
+        pub fn finish_login(
+            login_start: ServerLogin,
+            credential_finalization: CredentialFinalization,
         ) -> AuthenticationResult<ServerLoginFinishResult> {
             Ok(login_start.finish(credential_finalization)?)
         }