srp: Client* and Server* type aliases (#245)

tarcieri · web-flow · commit 52ef2be6bb39 · 2026-01-13T11:26:15.000-07:00
Adds type aliases (still parameterized by a generic `D`) which are
already configured with the appropriate SRP groups, e.g `ClientG2048`,
`ServerG2048`.
diff --git a/srp/src/client.rs b/srp/src/client.rs
@@ -1,17 +1,21 @@
-use crate::{
-    Group,
-    errors::AuthError,
-    utils::{
-        compute_hash, compute_k, compute_m1_legacy, compute_m1_rfc5054, compute_m2, compute_u,
-        monty_form,
-    },
-};
+use crate::{errors::AuthError, groups::*, utils::*};
 use alloc::vec::Vec;
 use core::marker::PhantomData;
 use crypto_bigint::{BoxedUint, ConcatenatingMul, Odd, Resize, modular::BoxedMontyForm};
 use digest::{Digest, Output};
 use subtle::ConstantTimeEq;
 
+/// SRP client configured with a standard 1024-bit group.
+pub type ClientG1024<D> = Client<G1024, D>;
+/// SRP client configured with a standard 1536-bit group.
+pub type ClientG1536<D> = Client<G1536, D>;
+/// SRP client configured with a standard 2048-bit group.
+pub type ClientG2048<D> = Client<G2048, D>;
+/// SRP client configured with a standard 3072-bit group.
+pub type ClientG3072<D> = Client<G3072, D>;
+/// SRP client configured with a standard 4096-bit group.
+pub type ClientG4096<D> = Client<G4096, D>;
+
 /// SRP client implementation.
 ///
 /// # Usage
@@ -22,17 +26,16 @@ use subtle::ConstantTimeEq;
 /// password hashing algorithm instead (e.g. PBKDF2, argon2 or scrypt).
 ///
 /// ```rust
-/// use srp::{G2048, Client};
 /// use sha2::Sha256;
 ///
-/// let client = Client::<G2048, Sha256>::new();
+/// let client = srp::ClientG2048::<Sha256>::new();
 /// ```
 ///
 /// Next send handshake data (username and `a_pub`) to the server and receive
 /// `salt` and `b_pub`:
 ///
 /// ```rust
-/// # let client = srp::Client::<srp::G2048, sha2::Sha256>::new();
+/// # let client = srp::ClientG2048::<sha2::Sha256>::new();
 /// # fn server_response()-> (Vec<u8>, Vec<u8>) { (vec![], vec![]) }
 ///
 /// let mut a = [0u8; 64];
@@ -45,7 +48,7 @@ use subtle::ConstantTimeEq;
 /// `process_reply` can return error in case of malicious `b_pub`.
 ///
 /// ```rust
-/// # let client = srp::Client::<srp::G2048, sha2::Sha256>::new();
+/// # let client = srp::ClientG2048::<sha2::Sha256>::new();
 /// # let a = [0u8; 64];
 /// # let username = b"username";
 /// # let password = b"password";
@@ -61,7 +64,7 @@ use subtle::ConstantTimeEq;
 /// `verify_server` method will return error in case of incorrect server reply.
 ///
 /// ```ignore
-/// # let client = srp::Client::<srp::G2048, sha2::Sha256>::new();
+/// # let client = srp::ClientG2048::<sha2::Sha256>::new();
 /// # let verifier = client.process_reply(b"", b"", b"", b"", b"1").unwrap();
 /// # fn send_proof(_: &[u8]) -> Vec<u8> { vec![173, 202, 13, 26, 207, 73, 0, 46, 121, 238, 48, 170, 96, 146, 60, 49, 88, 76, 12, 184, 152, 76, 207, 220, 140, 205, 190, 189, 117, 6, 131, 63]   }
 ///
@@ -73,7 +76,7 @@ use subtle::ConstantTimeEq;
 /// `key` contains shared secret key between user and the server. You can extract shared secret
 /// key using `key()` method.
 /// ```rust
-/// # let client = srp::Client::<srp::G2048, sha2::Sha256>::new();
+/// # let client = srp::ClientG2048::<sha2::Sha256>::new();
 /// # let verifier = client.process_reply_legacy(b"", b"", b"", b"", b"1").unwrap();
 ///
 /// verifier.key();
@@ -86,7 +89,7 @@ use subtle::ConstantTimeEq;
 /// key in case of correct server data.
 ///
 /// ```ignore
-/// # let client = srp::Client::<srp::G2048, sha2::Sha256>::new();
+/// # let client = srp::ClientG2048::<sha2::Sha256>::new();
 /// # let verifier = client.process_reply_rfc5054(b"", b"", b"", b"", b"1").unwrap();
 /// # fn send_proof(_: &[u8]) -> Vec<u8> { vec![10, 215, 214, 40, 136, 200, 122, 121, 68, 160, 38, 32, 85, 82, 128, 30, 199, 194, 126, 222, 61, 55, 2, 28, 120, 181, 155, 102, 141, 65, 17, 64]   }
 ///
@@ -102,7 +105,7 @@ use subtle::ConstantTimeEq;
 /// Man-in-the-middle (MITM) attack for registration.
 ///
 /// ```rust
-/// # let client = srp::Client::<srp::G2048, sha2::Sha256>::new();
+/// # let client = srp::ClientG2048::<sha2::Sha256>::new();
 /// # let username = b"username";
 /// # let password = b"password";
 /// # let salt = b"salt";
diff --git a/srp/src/groups.rs b/srp/src/groups.rs
@@ -1,7 +1,7 @@
-//! Groups from [RFC 5054](https://tools.ietf.org/html/rfc5054)
+//! Groups from [RFC5054](https://tools.ietf.org/html/rfc5054)
 //!
 //! It is strongly recommended to use them instead of custom generated
-//! groups. Additionally, it is not recommended to use `G1024` and `G_1536`,
+//! groups. Additionally, it is not recommended to use `G1024` and `G1536`,
 //! they are provided only for compatibility with the legacy software.
 
 use core::{
diff --git a/srp/src/lib.rs b/srp/src/lib.rs
@@ -34,7 +34,8 @@
 //! (`N = 2q + 1`, where `q` is prime).
 //!
 //! Additionally, `g` MUST be a generator modulo `N`. It's STRONGLY recommended to use SRP
-//! parameters provided by this crate as [`G1024`], [`G1536`], [`G2048`], [`G3072`] and [`G4096`].
+//! parameters provided by this crate under the [`groups`] module, and available as various
+//! type aliases e.g. [`ClientG2048`] and [`ServerG2048`].
 //!
 //! |       Client           |   Data transfer   |      Server                     |
 //! |------------------------|-------------------|---------------------------------|
@@ -69,17 +70,22 @@
 #[macro_use]
 extern crate alloc;
 
+pub mod groups;
+#[doc(hidden)]
+pub mod utils;
+
 mod client;
 mod errors;
-mod groups;
 mod server;
-#[doc(hidden)]
-pub mod utils;
 
-pub use client::{Client, ClientVerifier};
+pub use client::{
+    Client, ClientG1024, ClientG1536, ClientG2048, ClientG3072, ClientG4096, ClientVerifier,
+};
 pub use errors::AuthError;
-pub use groups::*;
-pub use server::{Server, ServerVerifier};
+pub use groups::Group;
+pub use server::{
+    Server, ServerG1024, ServerG1536, ServerG2048, ServerG3072, ServerG4096, ServerVerifier,
+};
 
 #[allow(deprecated)]
 pub use {client::LegacyClientVerifier, server::LegacyServerVerifier};
diff --git a/srp/src/server.rs b/srp/src/server.rs
@@ -1,17 +1,21 @@
-use crate::{
-    Group,
-    errors::AuthError,
-    utils::{
-        compute_hash, compute_k, compute_m1_legacy, compute_m1_rfc5054, compute_m2, compute_u,
-        monty_form,
-    },
-};
+use crate::{errors::AuthError, groups::*, utils::*};
 use alloc::vec::Vec;
 use core::marker::PhantomData;
 use crypto_bigint::{BoxedUint, Odd, Resize, modular::BoxedMontyForm};
 use digest::{Digest, Output};
 use subtle::ConstantTimeEq;
 
+/// SRP server configured with a standard [`G1024`] group.
+pub type ServerG1024<D> = Server<G1024, D>;
+/// SRP server configured with a standard [`G1536`] group.
+pub type ServerG1536<D> = Server<G1536, D>;
+/// SRP server configured with a standard [`G2048`] group.
+pub type ServerG2048<D> = Server<G2048, D>;
+/// SRP server configured with a standard [`G3072`] group.
+pub type ServerG3072<D> = Server<G3072, D>;
+/// SRP server configured with a standard [`G4096`] group.
+pub type ServerG4096<D> = Server<G4096, D>;
+
 /// SRP server implementation.
 ///
 /// # Usage
@@ -20,12 +24,11 @@ use subtle::ConstantTimeEq;
 ///
 ///
 /// ```rust
-/// use srp::{G2048, Server};
 /// use sha2::Sha256;
 /// # fn get_client_request()-> (Vec<u8>, Vec<u8>) { (vec![], vec![])}
 /// # fn get_user(_: &[u8])-> (Vec<u8>, Vec<u8>) { (vec![], vec![])}
 ///
-/// let server = Server::<G2048, Sha256>::new();
+/// let server = srp::ServerG2048::<Sha256>::new();
 /// let (username, a_pub) = get_client_request();
 /// let (salt, v) = get_user(&username);
 /// let mut b = [0u8; 64];
@@ -38,7 +41,7 @@ use subtle::ConstantTimeEq;
 /// Next process the user response:
 ///
 /// ```rust
-/// # let server = srp::Server::<srp::G2048, sha2::Sha256>::new();
+/// # let server = srp::ServerG2048::<sha2::Sha256>::new();
 /// # fn get_client_response() -> Vec<u8> { vec![1] }
 /// # let b = [0u8; 64];
 /// # let v = b"";
@@ -52,7 +55,7 @@ use subtle::ConstantTimeEq;
 /// reply:
 ///
 /// ```rust
-/// # let server = srp::Server::<srp::G2048, sha2::Sha256>::new();
+/// # let server = srp::ServerG2048::<sha2::Sha256>::new();
 /// # let verifier = server.process_reply_legacy(b"", b"", b"1").unwrap();
 /// # fn get_client_proof()-> Vec<u8> { vec![26, 80, 8, 243, 111, 162, 238, 171, 208, 237, 207, 46, 46, 137, 44, 213, 105, 208, 84, 224, 244, 216, 103, 145, 14, 103, 182, 56, 242, 4, 179, 57] };
 /// # fn send_proof(_: &[u8]) { };
@@ -66,7 +69,7 @@ use subtle::ConstantTimeEq;
 /// `key` contains shared secret key between user and the server. You can extract shared secret
 /// key using `key()` method.
 /// ```rust
-/// # let server = srp::Server::<srp::G2048, sha2::Sha256>::new();
+/// # let server = srp::ServerG2048::<sha2::Sha256>::new();
 /// # let verifier = server.process_reply_legacy(b"", b"", b"1").unwrap();
 ///
 /// verifier.key();
@@ -80,7 +83,7 @@ use subtle::ConstantTimeEq;
 /// key in case of correct server data.
 ///
 /// ```ident
-/// # let server = srp::Server::<srp::G2048, sha2::Sha256>::new();
+/// # let server = srp::ServerG2048::<sha2::Sha256>::new();
 /// # let verifier = server.process_reply_rfc5054(b"", b"", b"", b"", b"1").unwrap();
 /// # fn get_client_proof()-> Vec<u8> { vec![53, 91, 252, 129, 223, 201, 97, 145, 208, 243, 229, 232, 20, 118, 108, 126, 244, 68, 237, 38, 121, 24, 181, 53, 155, 103, 134, 44, 107, 204, 56, 50] };
 /// # fn send_proof(_: &[u8]) { };
diff --git a/srp/tests/bad_public.rs b/srp/tests/bad_public.rs
@@ -1,6 +1,6 @@
 use crypto_bigint::BoxedUint;
 use sha1::Sha1;
-use srp::{Client, G1024, Server};
+use srp::{Client, Server, groups::G1024};
 
 #[test]
 #[should_panic]
diff --git a/srp/tests/rfc5054.rs b/srp/tests/rfc5054.rs
@@ -2,7 +2,7 @@ use crypto_bigint::BoxedUint;
 use hex_literal::hex;
 use sha1::Sha1;
 use srp::utils::{compute_k, compute_u};
-use srp::{Client, G1024, Group, Server};
+use srp::{Client, Group, Server, groups::G1024};
 
 #[test]
 #[allow(clippy::many_single_char_names)]
diff --git a/srp/tests/srp.rs b/srp/tests/srp.rs
@@ -3,7 +3,7 @@ use getrandom::{
     rand_core::{RngCore, TryRngCore},
 };
 use sha2::Sha256;
-use srp::{Client, G2048, Server};
+use srp::{Client, Server, groups::G2048};
 
 fn auth_test_rfc5054(true_pwd: &[u8], auth_pwd: &[u8]) {
     let mut rng = SysRng.unwrap_err();
