lib/crypto: run all aes_gcm_128 testcases
[gd/samba-autobuild/.git] / lib / crypto / aes_gcm_128_test.c
1 /*
2    AES-GCM-128 tests
3
4    Copyright (C) Stefan Metzmacher 2014
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19 #include "replace.h"
20 #include "../lib/util/samba_util.h"
21 #include "../lib/crypto/crypto.h"
22
23 struct torture_context;
24 bool torture_local_crypto_aes_gcm_128(struct torture_context *torture);
25
26 /*
27  This uses the test values from ...
28 */
29 bool torture_local_crypto_aes_gcm_128(struct torture_context *torture)
30 {
31         bool ret = true;
32         uint32_t i;
33         struct {
34                 DATA_BLOB K;
35                 DATA_BLOB IV;
36                 DATA_BLOB A;
37                 DATA_BLOB P;
38                 DATA_BLOB C;
39                 DATA_BLOB T;
40         } testarray[5];
41
42         TALLOC_CTX *tctx = talloc_new(torture);
43         if (!tctx) { return false; };
44
45         ZERO_STRUCT(testarray);
46
47         testarray[0].K = strhex_to_data_blob(tctx,
48                                 "00000000000000000000000000000000");
49         testarray[0].IV = strhex_to_data_blob(tctx,
50                                 "000000000000000000000000");
51         testarray[0].A = data_blob_null;
52         testarray[0].P = data_blob_null;
53         testarray[0].C = data_blob_null;
54         testarray[0].T = strhex_to_data_blob(tctx,
55                                 "58e2fccefa7e3061367f1d57a4e7455a");
56
57         testarray[1].K = strhex_to_data_blob(tctx,
58                                 "00000000000000000000000000000000");
59         testarray[1].IV = strhex_to_data_blob(tctx,
60                                 "000000000000000000000000");
61         testarray[1].A = data_blob_null;
62         testarray[1].P = strhex_to_data_blob(tctx,
63                                 "00000000000000000000000000000000");
64         testarray[1].C = strhex_to_data_blob(tctx,
65                                 "0388dace60b6a392f328c2b971b2fe78");
66         testarray[1].T = strhex_to_data_blob(tctx,
67                                 "ab6e47d42cec13bdf53a67b21257bddf");
68
69         testarray[2].K = strhex_to_data_blob(tctx,
70                                 "feffe9928665731c6d6a8f9467308308");
71         testarray[2].IV = strhex_to_data_blob(tctx,
72                                 "cafebabefacedbaddecaf888");
73         testarray[2].A = data_blob_null;
74         testarray[2].P = strhex_to_data_blob(tctx,
75                                 "d9313225f88406e5a55909c5aff5269a"
76                                 "86a7a9531534f7da2e4c303d8a318a72"
77                                 "1c3c0c95956809532fcf0e2449a6b525"
78                                 "b16aedf5aa0de657ba637b391aafd255");
79         testarray[2].C = strhex_to_data_blob(tctx,
80                                 "42831ec2217774244b7221b784d0d49c"
81                                 "e3aa212f2c02a4e035c17e2329aca12e"
82                                 "21d514b25466931c7d8f6a5aac84aa05"
83                                 "1ba30b396a0aac973d58e091473f5985");
84         testarray[2].T = strhex_to_data_blob(tctx,
85                                 "4d5c2af327cd64a62cf35abd2ba6fab4");
86
87         testarray[3].K = strhex_to_data_blob(tctx,
88                                 "feffe9928665731c6d6a8f9467308308");
89         testarray[3].IV = strhex_to_data_blob(tctx,
90                                 "cafebabefacedbaddecaf888");
91         testarray[3].A = strhex_to_data_blob(tctx,
92                                 "feedfacedeadbeeffeedfacedeadbeef"
93                                 "abaddad2");
94         testarray[3].P = strhex_to_data_blob(tctx,
95                                 "d9313225f88406e5a55909c5aff5269a"
96                                 "86a7a9531534f7da2e4c303d8a318a72"
97                                 "1c3c0c95956809532fcf0e2449a6b525"
98                                 "b16aedf5aa0de657ba637b39");
99         testarray[3].C = strhex_to_data_blob(tctx,
100                                 "42831ec2217774244b7221b784d0d49c"
101                                 "e3aa212f2c02a4e035c17e2329aca12e"
102                                 "21d514b25466931c7d8f6a5aac84aa05"
103                                 "1ba30b396a0aac973d58e091");
104         testarray[3].T = strhex_to_data_blob(tctx,
105                                 "5bc94fbc3221a5db94fae95ae7121a47");
106
107         for (i=0; testarray[i].T.length != 0; i++) {
108                 struct aes_gcm_128_context ctx;
109                 uint8_t T[AES_BLOCK_SIZE];
110                 DATA_BLOB C;
111                 int e;
112
113                 C = data_blob_dup_talloc(tctx, testarray[i].P);
114
115                 aes_gcm_128_init(&ctx, testarray[i].K.data, testarray[i].IV.data);
116                 aes_gcm_128_updateA(&ctx,
117                                     testarray[i].A.data,
118                                     testarray[i].A.length);
119                 aes_gcm_128_crypt(&ctx, C.data, C.length);
120                 aes_gcm_128_updateC(&ctx, C.data, C.length);
121                 aes_gcm_128_digest(&ctx, T);
122
123                 e = memcmp(testarray[i].T.data, T, sizeof(T));
124                 if (e != 0) {
125                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
126                         printf("K\n");
127                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
128                         printf("IV\n");
129                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
130                         printf("A\n");
131                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
132                         printf("P\n");
133                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
134                         printf("C1\n");
135                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
136                         printf("C2\n");
137                         dump_data(0, C.data, C.length);
138                         printf("T1\n");
139                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
140                         printf("T2\n");
141                         dump_data(0, T, sizeof(T));
142                         ret = false;
143                         goto fail;
144                 }
145
146                 e = memcmp(testarray[i].C.data, C.data, C.length);
147                 if (e != 0) {
148                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
149                         printf("K\n");
150                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
151                         printf("IV\n");
152                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
153                         printf("A\n");
154                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
155                         printf("P\n");
156                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
157                         printf("C1\n");
158                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
159                         printf("C2\n");
160                         dump_data(0, C.data, C.length);
161                         printf("T1\n");
162                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
163                         printf("T2\n");
164                         dump_data(0, T, sizeof(T));
165                         ret = false;
166                         goto fail;
167                 }
168         }
169
170         for (i=0; testarray[i].T.length != 0; i++) {
171                 struct aes_gcm_128_context ctx;
172                 uint8_t T[AES_BLOCK_SIZE];
173                 DATA_BLOB C;
174                 int e;
175                 size_t j;
176
177                 C = data_blob_dup_talloc(tctx, testarray[i].P);
178
179                 aes_gcm_128_init(&ctx, testarray[i].K.data, testarray[i].IV.data);
180                 for (j=0; j < testarray[i].A.length; j++) {
181                         aes_gcm_128_updateA(&ctx, &testarray[i].A.data[j], 1);
182                 }
183                 for (j=0; j < C.length; j++) {
184                         aes_gcm_128_crypt(&ctx, &C.data[j], 1);
185                         aes_gcm_128_updateC(&ctx, &C.data[j], 1);
186                 }
187                 aes_gcm_128_digest(&ctx, T);
188
189                 e = memcmp(testarray[i].T.data, T, sizeof(T));
190                 if (e != 0) {
191                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
192                         printf("K\n");
193                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
194                         printf("IV\n");
195                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
196                         printf("A\n");
197                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
198                         printf("P\n");
199                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
200                         printf("C1\n");
201                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
202                         printf("C2\n");
203                         dump_data(0, C.data, C.length);
204                         printf("T1\n");
205                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
206                         printf("T2\n");
207                         dump_data(0, T, sizeof(T));
208                         ret = false;
209                         goto fail;
210                 }
211
212                 e = memcmp(testarray[i].C.data, C.data, C.length);
213                 if (e != 0) {
214                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
215                         printf("K\n");
216                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
217                         printf("IV\n");
218                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
219                         printf("A\n");
220                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
221                         printf("P\n");
222                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
223                         printf("C1\n");
224                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
225                         printf("C2\n");
226                         dump_data(0, C.data, C.length);
227                         printf("T1\n");
228                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
229                         printf("T2\n");
230                         dump_data(0, T, sizeof(T));
231                         ret = false;
232                         goto fail;
233                 }
234         }
235
236         for (i=0; testarray[i].T.length != 0; i++) {
237                 struct aes_gcm_128_context ctx;
238                 uint8_t T[AES_BLOCK_SIZE];
239                 DATA_BLOB P;
240                 int e;
241                 size_t j;
242
243                 P = data_blob_dup_talloc(tctx, testarray[i].C);
244
245                 aes_gcm_128_init(&ctx, testarray[i].K.data, testarray[i].IV.data);
246                 for (j=0; j < testarray[i].A.length; j++) {
247                         aes_gcm_128_updateA(&ctx, &testarray[i].A.data[j], 1);
248                 }
249                 for (j=0; j < P.length; j++) {
250                         aes_gcm_128_updateC(&ctx, &P.data[j], 1);
251                         aes_gcm_128_crypt(&ctx, &P.data[j], 1);
252                 }
253                 aes_gcm_128_digest(&ctx, T);
254
255                 e = memcmp(testarray[i].T.data, T, sizeof(T));
256                 if (e != 0) {
257                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
258                         printf("K\n");
259                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
260                         printf("IV\n");
261                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
262                         printf("A\n");
263                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
264                         printf("P1\n");
265                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
266                         printf("P2\n");
267                         dump_data(0, P.data, P.length);
268                         printf("C\n");
269                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
270                         printf("T1\n");
271                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
272                         printf("T2\n");
273                         dump_data(0, T, sizeof(T));
274                         ret = false;
275                         goto fail;
276                 }
277
278                 e = memcmp(testarray[i].P.data, P.data, P.length);
279                 if (e != 0) {
280                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
281                         printf("K\n");
282                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
283                         printf("IV\n");
284                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
285                         printf("A\n");
286                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
287                         printf("P1\n");
288                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
289                         printf("P2\n");
290                         dump_data(0, P.data, P.length);
291                         printf("C\n");
292                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
293                         printf("T1\n");
294                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
295                         printf("T2\n");
296                         dump_data(0, T, sizeof(T));
297                         ret = false;
298                         goto fail;
299                 }
300         }
301
302         for (i=0; testarray[i].T.length != 0; i++) {
303                 struct aes_gcm_128_context ctx;
304                 uint8_t T[AES_BLOCK_SIZE];
305                 DATA_BLOB P;
306                 int e;
307
308                 P = data_blob_dup_talloc(tctx, testarray[i].C);
309
310                 aes_gcm_128_init(&ctx, testarray[i].K.data, testarray[i].IV.data);
311                 aes_gcm_128_updateA(&ctx, testarray[i].A.data, testarray[i].A.length);
312                 aes_gcm_128_updateC(&ctx, P.data, P.length);
313                 aes_gcm_128_crypt(&ctx, P.data, P.length);
314                 aes_gcm_128_digest(&ctx, T);
315
316                 e = memcmp(testarray[i].T.data, T, sizeof(T));
317                 if (e != 0) {
318                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
319                         printf("K\n");
320                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
321                         printf("IV\n");
322                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
323                         printf("A\n");
324                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
325                         printf("P1\n");
326                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
327                         printf("P2\n");
328                         dump_data(0, P.data, P.length);
329                         printf("C\n");
330                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
331                         printf("T1\n");
332                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
333                         printf("T2\n");
334                         dump_data(0, T, sizeof(T));
335                         ret = false;
336                         goto fail;
337                 }
338
339                 e = memcmp(testarray[i].P.data, P.data, P.length);
340                 if (e != 0) {
341                         printf("%s: aes_gcm_128 test[%u]: failed\n", __location__, i);
342                         printf("K\n");
343                         dump_data(0, testarray[i].K.data, testarray[i].K.length);
344                         printf("IV\n");
345                         dump_data(0, testarray[i].IV.data, testarray[i].IV.length);
346                         printf("A\n");
347                         dump_data(0, testarray[i].A.data, testarray[i].A.length);
348                         printf("P1\n");
349                         dump_data(0, testarray[i].P.data, testarray[i].P.length);
350                         printf("P2\n");
351                         dump_data(0, P.data, P.length);
352                         printf("C\n");
353                         dump_data(0, testarray[i].C.data, testarray[i].C.length);
354                         printf("T1\n");
355                         dump_data(0, testarray[i].T.data, testarray[i].T.length);
356                         printf("T2\n");
357                         dump_data(0, T, sizeof(T));
358                         ret = false;
359                         goto fail;
360                 }
361         }
362
363  fail:
364         talloc_free(tctx);
365         return ret;
366 }