srp6a 0.1.0

Implementation of SRP 6a (Secure Remote Password) according to RFC 5054 (https://datatracker.ietf.org/doc/html/rfc5054)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use num_bigint::BigUint;
use sha1::Sha1;

use crate::server::Server;
use crate::tests::test_utils::*;

#[test]
fn test_compute_k() {
    let server: Server<Sha1> = Server::<Sha1>::new(create_test_group_1024());

    let expected_k = create_test_k();

    assert_eq!(server.k, expected_k);
}

#[test]
fn test_generate_keypair_from_private_key() {
    let server = Server::<Sha1>::new(create_test_group_1024());

    let verifier = create_test_verifier();

    let (private_key, expected_public_key) = create_test_server_keypair();

    let (_, public_key) = server
        .generate_keypair_from_private_key(&private_key.to_bytes_be(), &verifier)
        .unwrap();

    assert_eq!(public_key, expected_public_key);
}

#[test]
fn test_generate_keypair() {
    let server = Server::<Sha1>::new(create_test_group_1024());

    let verifier = create_test_verifier();

    let result = server.generate_keypair(128, &verifier);
    assert!(result.is_ok());

    let (private, public) = result.unwrap();
    assert!(private > BigUint::from(0u32));
    assert!(public > BigUint::from(0u32));
    assert!(public < server.group.n);
}

#[test]
fn test_generate_keypair_invalid_length() {
    let server = Server::<Sha1>::new(create_test_group_1024());

    let verifier = create_test_verifier();

    // Zero length
    let result = server.generate_keypair(0, &verifier);
    assert!(matches!(
        result,
        Err(crate::server::ServerError::InvalidKeyLength(_))
    ));

    // Non-multiple of 8
    let result = server.generate_keypair(127, &verifier);
    assert!(matches!(
        result,
        Err(crate::server::ServerError::InvalidKeyLength(_))
    ));

    // Length exceeds maximum
    let result = server.generate_keypair(2048, &verifier);
    assert!(matches!(
        result,
        Err(crate::server::ServerError::InvalidKeyLength(_))
    ));
}

#[test]
fn test_compute_premaster_key() {
    let server = Server::<Sha1>::new(create_test_group_1024());

    let verifier = create_test_verifier();

    let (_, public_client_key) = create_test_client_keypair();

    let (private_server_key, public_server_key) = create_test_server_keypair();

    let premaster_key = server
        .compute_premaster_key(
            &public_client_key,
            &verifier,
            &private_server_key,
            &public_server_key,
        )
        .unwrap();

    let expected_premaster_key = create_test_premaster_key();

    assert_eq!(premaster_key, expected_premaster_key);
}