Debian Codegraph @

crypto/aes/rt+test.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use bytes;
5 use crypto::cipher;
6
7 @test fn rt_finish() void = {
8 const key: [16]u8 = [
9 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
10 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
11 ];
12
13 const zero: [CT64_EXPKEYSZ]u8 = [0...];
14
15 let block = aes();
16 init(&block, key);
17 cipher::finish(&block);
18
19 assert(len(block.expkey) == len(zero));
20 assert(bytes::equal(zero, block.expkey));
21 };
22
23 @test fn rt_encrypt_128() void = {
24 const key: [16]u8 = [
25 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
26 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
27 ];
28
29 const plain: [16]u8 = [
30 0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d,
31 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34,
32 ];
33
34 const cipher: [16]u8 = [
35 0x39, 0x25, 0x84, 0x1d, 0x02, 0xdc, 0x09, 0xfb,
36 0xdc, 0x11, 0x85, 0x97, 0x19, 0x6a, 0x0b, 0x32,
37 ];
38
39 let result: [16]u8 = [0...];
40
41 let block = aes();
42 init(&block, key);
43 defer cipher::finish(&block);
44 cipher::encrypt(&block, result[..], plain[..]);
45
46 assert(bytes::equal(cipher, result));
47 };
48
49 @test fn rt_encrypt_128_multiple_blocks() void = {
50 const key: [16]u8 = [
51 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
52 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
53 ];
54
55 const plain: [_]u8 = [
56 0xdb, 0x3a, 0x36, 0x50, 0x85, 0x60, 0x4c, 0x65,
57 0xc0, 0x22, 0x5a, 0x0d, 0x68, 0x2f, 0x19, 0xc2,
58 0x16, 0x27, 0xdd, 0xae, 0xd7, 0x28, 0x29, 0x23,
59 0xfa, 0x97, 0x28, 0xb0, 0x9a, 0x90, 0xfe, 0xb3,
60 0xde, 0x57, 0xbc, 0x15, 0x15, 0x8d, 0xb6, 0x29,
61 0x61, 0x40, 0x76, 0x51, 0x32, 0xc2, 0x3d, 0x1e,
62 0xdf, 0x97, 0x6a, 0x5e, 0x0a, 0x6b, 0xf6, 0x40,
63 0xb4, 0x08, 0x7e, 0xde, 0x17, 0xa4, 0x58, 0x98
64 ];
65
66 const cipher: [_]u8 = [
67 0xdd, 0xf4, 0x53, 0x55, 0x18, 0x7a, 0xf0, 0x65,
68 0x59, 0xd6, 0xdc, 0x4e, 0xc2, 0x89, 0xff, 0x7b,
69 0x54, 0x41, 0x6a, 0xda, 0xa0, 0xad, 0x85, 0xbd,
70 0x75, 0x1e, 0x59, 0x15, 0x6d, 0x30, 0xa8, 0xa8,
71 0xa8, 0x54, 0x6e, 0xab, 0x9c, 0x47, 0x84, 0xd,
72 0x6e, 0xb5, 0x5e, 0xba, 0xb0, 0xd9, 0x47, 0xfa,
73 0x53, 0x6b, 0xff, 0x31, 0x47, 0x86, 0xf8, 0x4c,
74 0x6b, 0x65, 0xaa, 0xa2, 0xd2, 0xd7, 0xc1, 0xdf
75 ];
76
77
78 let block = aes();
79 init(&block, key[..]);
80 defer cipher::finish(&block);
81
82 // test from 1 to 4 parallel blocks
83 for (let i = 0z; i < 4; i += 1) {
84 let result: [64]u8 = [0...];
85
86 let sz = (i + 1) * 16;
87 cipher::encrypt(&block, result[0..sz], plain[0..sz]);
88
89 assert(bytes::equal(cipher[0..sz], result[0..sz]));
90 };
91 };
92
93 @test fn rt_decrypt_128_multiple_blocks() void = {
94 const key: [16]u8 = [
95 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
96 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
97 ];
98
99 const plain: [_]u8 = [
100 0xdb, 0x3a, 0x36, 0x50, 0x85, 0x60, 0x4c, 0x65,
101 0xc0, 0x22, 0x5a, 0x0d, 0x68, 0x2f, 0x19, 0xc2,
102 0x16, 0x27, 0xdd, 0xae, 0xd7, 0x28, 0x29, 0x23,
103 0xfa, 0x97, 0x28, 0xb0, 0x9a, 0x90, 0xfe, 0xb3,
104 0xde, 0x57, 0xbc, 0x15, 0x15, 0x8d, 0xb6, 0x29,
105 0x61, 0x40, 0x76, 0x51, 0x32, 0xc2, 0x3d, 0x1e,
106 0xdf, 0x97, 0x6a, 0x5e, 0x0a, 0x6b, 0xf6, 0x40,
107 0xb4, 0x08, 0x7e, 0xde, 0x17, 0xa4, 0x58, 0x98
108 ];
109
110 const cipher: [_]u8 = [
111 0xdd, 0xf4, 0x53, 0x55, 0x18, 0x7a, 0xf0, 0x65,
112 0x59, 0xd6, 0xdc, 0x4e, 0xc2, 0x89, 0xff, 0x7b,
113 0x54, 0x41, 0x6a, 0xda, 0xa0, 0xad, 0x85, 0xbd,
114 0x75, 0x1e, 0x59, 0x15, 0x6d, 0x30, 0xa8, 0xa8,
115 0xa8, 0x54, 0x6e, 0xab, 0x9c, 0x47, 0x84, 0xd,
116 0x6e, 0xb5, 0x5e, 0xba, 0xb0, 0xd9, 0x47, 0xfa,
117 0x53, 0x6b, 0xff, 0x31, 0x47, 0x86, 0xf8, 0x4c,
118 0x6b, 0x65, 0xaa, 0xa2, 0xd2, 0xd7, 0xc1, 0xdf
119 ];
120
121
122 let block = aes();
123 init(&block, key[..]);
124 defer cipher::finish(&block);
125
126 // test from 1 to 4 parallel blocks
127 for (let i = 0z; i < 4; i += 1) {
128 let result: [64]u8 = [0...];
129
130 let sz = (i + 1) * 16;
131 cipher::decrypt(&block, result[0..sz], cipher[0..sz]);
132
133 assert(bytes::equal(plain[0..sz], result[0..sz]));
134 };
135 };
136
137 @test fn rt_decrypt_128() void = {
138 const key: []u8 = [
139 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
140 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
141 ];
142
143 const plain: [16]u8 = [
144 0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d,
145 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34,
146 ];
147
148 const cipher: [16]u8 = [
149 0x39, 0x25, 0x84, 0x1d, 0x02, 0xdc, 0x09, 0xfb,
150 0xdc, 0x11, 0x85, 0x97, 0x19, 0x6a, 0x0b, 0x32,
151 ];
152
153 let result: [16]u8 = [0...];
154
155 let block = aes();
156 init(&block, key[..]);
157 defer cipher::finish(&block);
158
159 cipher::decrypt(&block, result[..], cipher[..]);
160
161 assert(bytes::equal(plain, result));
162 };
163
164 // fips-197.pdf Appendix C.1
165 @test fn rt_example_vector1() void = {
166 const key: [_]u8 = [
167 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
168 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
169 ];
170
171 const plain: [_]u8 = [
172 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
173 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
174 ];
175
176 const cipher: [_]u8 = [
177 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
178 0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a,
179 ];
180
181 let result: [16]u8 = [0...];
182
183 let block = aes();
184 init(&block, key[..]);
185 defer cipher::finish(&block);
186
187 cipher::encrypt(&block, result[..], plain[..]);
188 assert(bytes::equal(cipher, result));
189
190 cipher::decrypt(&block, result[..], cipher[..]);
191 assert(bytes::equal(plain, result));
192 };
193
194 @test fn rt_example_vector1_in_place() void = {
195 const key: [_]u8 = [
196 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
197 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
198 ];
199
200 const plain: [_]u8 = [
201 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
202 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
203 ];
204
205 const cipher: [_]u8 = [
206 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
207 0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a,
208 ];
209
210 let result: [16]u8 = plain;
211
212 let block = aes();
213 init(&block, key[..]);
214 defer cipher::finish(&block);
215
216 cipher::encrypt(&block, result[..], result[..]);
217 assert(bytes::equal(cipher, result));
218
219 cipher::decrypt(&block, result[..], result[..]);
220 assert(bytes::equal(plain, result));
221 };
222
223 // fips-197.pdf Appendix C.2
224 @test fn rt_example_vector2() void = {
225 const key: [_]u8 = [
226 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
227 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
228 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
229 ];
230
231 const plain: [_]u8 = [
232 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
233 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
234 ];
235
236 const cipher: [_]u8 = [
237 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0,
238 0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91,
239 ];
240
241 let result: [16]u8 = [0...];
242 let block = aes();
243 init(&block, key[..]);
244 defer cipher::finish(&block);
245
246 cipher::encrypt(&block, result[..], plain[..]);
247 assert(bytes::equal(cipher, result));
248
249 cipher::decrypt(&block, result[..], cipher[..]);
250 assert(bytes::equal(plain, result));
251 };
252
253 // fips-197.pdf Appendix C.3
254 @test fn rt_example_vector3() void = {
255 const key: []u8 = [
256 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
257 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
258 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
259 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
260 ];
261
262 const plain: []u8 = [
263 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
264 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
265 ];
266
267 const cipher: []u8 = [
268 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf,
269 0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89,
270 ];
271
272 let result: [16]u8 = [0...];
273 let block = aes();
274 init(&block, key[..]);
275 defer cipher::finish(&block);
276
277 cipher::encrypt(&block, result[..], plain[..]);
278 assert(bytes::equal(cipher, result));
279
280 cipher::decrypt(&block, result[..], cipher[..]);
281 assert(bytes::equal(plain, result));
282 };