wolfcrypt-wrapper 1.2.0

Rust wrapper for wolfssl C library cryptographic functionality
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

#![cfg(all(curve25519, random))]

use wolfcrypt_wrapper::curve25519::*;
use wolfcrypt_wrapper::random::RNG;

#[test]
fn test_check_pub() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::generate_priv(&mut rng, &mut private_buffer)
        .expect("Error with generate_priv()");
    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::make_pub(&private_buffer, &mut public_buffer).expect("Error with make_pub()");
    Curve25519Key::check_public(&public_buffer, false).expect("Error with check_public()");
}

#[test]
fn test_generate_priv() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::generate_priv(&mut rng, &mut private_buffer)
        .expect("Error with generate_priv()");
}

#[test]
fn test_import_export_private() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut curve25519key = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    curve25519key
        .export_private_raw(&mut private_buffer)
        .expect("Error with export_private_raw()");
    Curve25519Key::import_private(&private_buffer).expect("Error with import_private()");
}

#[test]
fn test_import_export_private_ex() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut curve25519key = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    curve25519key
        .export_private_raw_ex(&mut private_buffer, false)
        .expect("Error with export_private_raw_ex()");
    Curve25519Key::import_private_ex(&private_buffer, false)
        .expect("Error with import_private_ex()");
}

#[test]
fn test_import_export_raw() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut curve25519key = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    curve25519key
        .export_key_raw(&mut private_buffer, &mut public_buffer)
        .expect("Error with export_key_raw()");
    Curve25519Key::import_private_raw(&private_buffer, &public_buffer)
        .expect("Error with import_private_raw()");
}

#[test]
fn test_import_export_raw_ex() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut curve25519key = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    curve25519key
        .export_key_raw_ex(&mut private_buffer, &mut public_buffer, false)
        .expect("Error with export_key_raw_ex()");
    Curve25519Key::import_private_raw_ex(&private_buffer, &public_buffer, false)
        .expect("Error with import_private_raw_ex()");
}

#[test]
fn test_import_export_public() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut curve25519key = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    curve25519key
        .export_public(&mut public_buffer)
        .expect("Error with export_public()");
    Curve25519Key::import_public(&public_buffer).expect("Error with import_public()");
}

#[test]
fn test_import_export_public_ex() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut curve25519key = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    curve25519key
        .export_public_ex(&mut public_buffer, false)
        .expect("Error with export_public_ex()");
    Curve25519Key::import_public_ex(&public_buffer, false).expect("Error with import_public_ex()");
}

#[test]
fn test_make_pub() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::generate_priv(&mut rng, &mut private_buffer)
        .expect("Error with generate_priv()");
    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::make_pub(&private_buffer, &mut public_buffer).expect("Error with make_pub()");
}

#[test]
#[cfg(curve25519_blinding)]
fn test_make_pub_blind() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut private_buffer = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::generate_priv(&mut rng, &mut private_buffer)
        .expect("Error with generate_priv()");
    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::make_pub_blind(&private_buffer, &mut public_buffer, &mut rng)
        .expect("Error with make_pub_blind()");
}

#[test]
fn test_shared_secret() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut key1 = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut key2 = Curve25519Key::generate(&mut rng).expect("Error with generate()");

    #[cfg(curve25519_blinding)]
    key1.set_rng(&mut rng).expect("Error with set_rng()");
    #[cfg(curve25519_blinding)]
    key2.set_rng(&mut rng).expect("Error with set_rng()");

    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    key1.export_public(&mut public_buffer)
        .expect("Error with export_public()");
    let mut key1public =
        Curve25519Key::import_public(&public_buffer).expect("Error with import_public()");
    key2.export_public(&mut public_buffer)
        .expect("Error with export_public()");
    let mut key2public =
        Curve25519Key::import_public(&public_buffer).expect("Error with import_public()");

    let mut ss1 = [0u8; Curve25519Key::KEYSIZE];
    let mut ss2 = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::shared_secret(&mut key1, &mut key2public, &mut ss1)
        .expect("Error with shared_secret()");
    Curve25519Key::shared_secret(&mut key2, &mut key1public, &mut ss2)
        .expect("Error with shared_secret()");

    assert_eq!(ss1, ss2);
}

#[test]
fn test_shared_secret_ex() {
    let mut rng = RNG::new().expect("Error with new()");
    let mut key1 = Curve25519Key::generate(&mut rng).expect("Error with generate()");
    let mut key2 = Curve25519Key::generate(&mut rng).expect("Error with generate()");

    #[cfg(curve25519_blinding)]
    key1.set_rng(&mut rng).expect("Error with set_rng()");
    #[cfg(curve25519_blinding)]
    key2.set_rng(&mut rng).expect("Error with set_rng()");

    let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
    key1.export_public(&mut public_buffer)
        .expect("Error with export_public()");
    let mut key1public =
        Curve25519Key::import_public(&public_buffer).expect("Error with import_public()");
    key2.export_public(&mut public_buffer)
        .expect("Error with export_public()");
    let mut key2public =
        Curve25519Key::import_public(&public_buffer).expect("Error with import_public()");

    let mut ss1 = [0u8; Curve25519Key::KEYSIZE];
    let mut ss2 = [0u8; Curve25519Key::KEYSIZE];
    Curve25519Key::shared_secret_ex(&mut key1, &mut key2public, &mut ss1, false)
        .expect("Error with shared_secret()");
    Curve25519Key::shared_secret_ex(&mut key2, &mut key1public, &mut ss2, false)
        .expect("Error with shared_secret()");

    assert_eq!(ss1, ss2);
}