dtls 0.17.1

A pure Rust implementation of DTLS
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use super::*;

#[test]
fn test_parse_signature_schemes() -> Result<()> {
    let tests = vec![
        (
            "Translate",
            vec![
                SignatureScheme::EcdsaWithP256AndSha256 as u16,
                SignatureScheme::EcdsaWithP384AndSha384 as u16,
                SignatureScheme::EcdsaWithP521AndSha512 as u16,
                SignatureScheme::Pkcs1WithSha256 as u16,
                SignatureScheme::Pkcs1WithSha384 as u16,
                SignatureScheme::Pkcs1WithSha512 as u16,
            ],
            vec![
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha256,
                    signature: SignatureAlgorithm::Ecdsa,
                },
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha384,
                    signature: SignatureAlgorithm::Ecdsa,
                },
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha512,
                    signature: SignatureAlgorithm::Ecdsa,
                },
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha256,
                    signature: SignatureAlgorithm::Rsa,
                },
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha384,
                    signature: SignatureAlgorithm::Rsa,
                },
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha512,
                    signature: SignatureAlgorithm::Rsa,
                },
            ],
            false,
            None,
        ),
        (
            "InvalidSignatureAlgorithm",
            vec![
                SignatureScheme::EcdsaWithP256AndSha256 as u16, // Valid
                0x04FF, // Invalid: unknown signature with SHA-256
            ],
            vec![],
            false,
            Some(Error::ErrInvalidSignatureAlgorithm),
        ),
        (
            "InvalidHashAlgorithm",
            vec![
                SignatureScheme::EcdsaWithP256AndSha256 as u16, // Valid
                0x0003,                                         // Invalid: ECDSA with MD2
            ],
            vec![],
            false,
            Some(Error::ErrInvalidHashAlgorithm),
        ),
        (
            "InsecureHashAlgorithmDenied",
            vec![
                SignatureScheme::EcdsaWithP256AndSha256 as u16, // Valid
                SignatureScheme::EcdsaWithSha1 as u16,          // Insecure
            ],
            vec![SignatureHashAlgorithm {
                hash: HashAlgorithm::Sha256,
                signature: SignatureAlgorithm::Ecdsa,
            }],
            false,
            None,
        ),
        (
            "InsecureHashAlgorithmAllowed",
            vec![
                SignatureScheme::EcdsaWithP256AndSha256 as u16, // Valid
                SignatureScheme::EcdsaWithSha1 as u16,          // Insecure
            ],
            vec![
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha256,
                    signature: SignatureAlgorithm::Ecdsa,
                },
                SignatureHashAlgorithm {
                    hash: HashAlgorithm::Sha1,
                    signature: SignatureAlgorithm::Ecdsa,
                },
            ],
            true,
            None,
        ),
        (
            "OnlyInsecureHashAlgorithm",
            vec![
                SignatureScheme::EcdsaWithSha1 as u16, // Insecure
            ],
            vec![],
            false,
            Some(Error::ErrNoAvailableSignatureSchemes),
        ),
        (
            "Translate",
            vec![SignatureScheme::Ed25519 as u16],
            vec![SignatureHashAlgorithm {
                hash: HashAlgorithm::Ed25519,
                signature: SignatureAlgorithm::Ed25519,
            }],
            false,
            None,
        ),
    ];

    for (name, inputs, expected, insecure_hashes, want_err) in tests {
        let output = parse_signature_schemes(&inputs, insecure_hashes);
        if let Some(err) = want_err {
            if let Err(output_err) = output {
                assert_eq!(
                    err.to_string(),
                    output_err.to_string(),
                    "Expected error: {err:?}, got: {output_err:?}"
                );
            } else {
                panic!("expect err, but got non-err for {name}");
            }
        } else if let Ok(output_val) = output {
            assert_eq!(
                expected, output_val,
                "Expected signatureHashAlgorithm:\n{expected:?}\ngot:\n{output_val:?}",
            );
        } else {
            panic!("expect non-err, but got err for {name}");
        }
    }

    Ok(())
}