Mercurial > dropbear

comparison demos/tv_gen.c @ 3:7faae8f46238 libtomcrypt-orig

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Branch renaming
author Matt Johnston <matt@ucc.asn.au>
date Mon, 31 May 2004 18:25:41 +0000
parents
children 5d99163f7e32
comparison
equal deleted inserted replaced
-1:000000000000 3:7faae8f46238
1 #include <mycrypt.h>
2
3 void reg_algs(void)
4 {
5 #ifdef RIJNDAEL
6 register_cipher (&aes_desc);
7 #endif
8 #ifdef BLOWFISH
9 register_cipher (&blowfish_desc);
10 #endif
11 #ifdef XTEA
12 register_cipher (&xtea_desc);
13 #endif
14 #ifdef RC5
15 register_cipher (&rc5_desc);
16 #endif
17 #ifdef RC6
18 register_cipher (&rc6_desc);
19 #endif
20 #ifdef SAFERP
21 register_cipher (&saferp_desc);
22 #endif
23 #ifdef TWOFISH
24 register_cipher (&twofish_desc);
25 #endif
26 #ifdef SAFER
27 register_cipher (&safer_k64_desc);
28 register_cipher (&safer_sk64_desc);
29 register_cipher (&safer_k128_desc);
30 register_cipher (&safer_sk128_desc);
31 #endif
32 #ifdef RC2
33 register_cipher (&rc2_desc);
34 #endif
35 #ifdef DES
36 register_cipher (&des_desc);
37 register_cipher (&des3_desc);
38 #endif
39 #ifdef CAST5
40 register_cipher (&cast5_desc);
41 #endif
42 #ifdef NOEKEON
43 register_cipher (&noekeon_desc);
44 #endif
45 #ifdef SKIPJACK
46 register_cipher (&skipjack_desc);
47 #endif
48
49 #ifdef TIGER
50 register_hash (&tiger_desc);
51 #endif
52 #ifdef MD2
53 register_hash (&md2_desc);
54 #endif
55 #ifdef MD4
56 register_hash (&md4_desc);
57 #endif
58 #ifdef MD5
59 register_hash (&md5_desc);
60 #endif
61 #ifdef SHA1
62 register_hash (&sha1_desc);
63 #endif
64 #ifdef SHA224
65 register_hash (&sha224_desc);
66 #endif
67 #ifdef SHA256
68 register_hash (&sha256_desc);
69 #endif
70 #ifdef SHA384
71 register_hash (&sha384_desc);
72 #endif
73 #ifdef SHA512
74 register_hash (&sha512_desc);
75 #endif
76 #ifdef RIPEMD128
77 register_hash (&rmd128_desc);
78 #endif
79 #ifdef RIPEMD160
80 register_hash (&rmd160_desc);
81 #endif
82 #ifdef WHIRLPOOL
83 register_hash (&whirlpool_desc);
84 #endif
85 }
86
87 void hash_gen(void)
88 {
89 unsigned char md[MAXBLOCKSIZE], buf[MAXBLOCKSIZE*2+2];
90 unsigned long outlen, x, y, z;
91 FILE *out;
92
93 out = fopen("hash_tv.txt", "w");
94
95 fprintf(out, "Hash Test Vectors:\n\nThese are the hashes of nn bytes '00 01 02 03 .. (nn-1)'\n\n");
96 for (x = 0; hash_descriptor[x].name != NULL; x++) {
97 fprintf(out, "Hash: %s\n", hash_descriptor[x].name);
98
99 for (y = 0; y <= (hash_descriptor[x].blocksize * 2); y++) {
100 for (z = 0; z < y; z++) {
101 buf[z] = (unsigned char)(z & 255);
102 }
103 outlen = sizeof(md);
104 hash_memory(x, buf, y, md, &outlen);
105 fprintf(out, "%3lu: ", y);
106 for (z = 0; z < outlen; z++) {
107 fprintf(out, "%02X", md[z]);
108 }
109 fprintf(out, "\n");
110 }
111 fprintf(out, "\n");
112 }
113 fclose(out);
114 }
115
116 void cipher_gen(void)
117 {
118 unsigned char key[MAXBLOCKSIZE], pt[MAXBLOCKSIZE];
119 unsigned long x, y, z, w;
120 int kl, lastkl;
121 FILE *out;
122 symmetric_key skey;
123
124 out = fopen("cipher_tv.txt", "w");
125
126 fprintf(out,
127 "Cipher Test Vectors\n\nThese are test encryptions with key of nn bytes '00 01 02 03 .. (nn-1)' and original PT of the same style.\n"
128 "The output of step N is used as the key and plaintext for step N+1 (key bytes repeated as required to fill the key)\n\n");
129
130 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
131 fprintf(out, "Cipher: %s\n", cipher_descriptor[x].name);
132
133 /* three modes, smallest, medium, large keys */
134 lastkl = 10000;
135 for (y = 0; y < 3; y++) {
136 switch (y) {
137 case 0: kl = cipher_descriptor[x].min_key_length; break;
138 case 1: kl = (cipher_descriptor[x].min_key_length + cipher_descriptor[x].max_key_length)/2; break;
139 case 2: kl = cipher_descriptor[x].max_key_length; break;
140 }
141 cipher_descriptor[x].keysize(&kl);
142 if (kl == lastkl) break;
143 lastkl = kl;
144 fprintf(out, "Key Size: %d bytes\n", kl);
145
146 for (z = 0; (int)z < kl; z++) {
147 key[z] = (unsigned char)z;
148 }
149 cipher_descriptor[x].setup(key, kl, 0, &skey);
150
151 for (z = 0; (int)z < cipher_descriptor[x].block_length; z++) {
152 pt[z] = (unsigned char)z;
153 }
154 for (w = 0; w < 50; w++) {
155 cipher_descriptor[x].ecb_encrypt(pt, pt, &skey);
156 fprintf(out, "%2lu: ", w);
157 for (z = 0; (int)z < cipher_descriptor[x].block_length; z++) {
158 fprintf(out, "%02X", pt[z]);
159 }
160 fprintf(out, "\n");
161
162 /* reschedule a new key */
163 for (z = 0; z < (unsigned long)kl; z++) {
164 key[z] = pt[z % cipher_descriptor[x].block_length];
165 }
166 cipher_descriptor[x].setup(key, kl, 0, &skey);
167 }
168 fprintf(out, "\n");
169 }
170 fprintf(out, "\n");
171 }
172 fclose(out);
173 }
174
175 void hmac_gen(void)
176 {
177 unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], input[MAXBLOCKSIZE*2+2];
178 int x, y, z, kl, err;
179 FILE *out;
180 unsigned long len;
181
182 out = fopen("hmac_tv.txt", "w");
183
184 fprintf(out,
185 "HMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are HMACed. The initial key is\n"
186 "of the same format (the same length as the HASH output size). The HMAC key in step N+1 is the HMAC output of\n"
187 "step N.\n\n");
188
189 for (x = 0; hash_descriptor[x].name != NULL; x++) {
190 fprintf(out, "HMAC-%s\n", hash_descriptor[x].name);
191
192 /* initial key */
193 for (y = 0; y < (int)hash_descriptor[x].hashsize; y++) {
194 key[y] = (y&255);
195 }
196
197 for (y = 0; y <= (int)(hash_descriptor[x].blocksize * 2); y++) {
198 for (z = 0; z < y; z++) {
199 input[z] = (unsigned char)(z & 255);
200 }
201 len = sizeof(output);
202 if ((err = hmac_memory(x, key, hash_descriptor[x].hashsize, input, y, output, &len)) != CRYPT_OK) {
203 printf("Error hmacing: %s\n", error_to_string(err));
204 exit(EXIT_FAILURE);
205 }
206 fprintf(out, "%3d: ", y);
207 for (z = 0; z <(int) len; z++) {
208 fprintf(out, "%02X", output[z]);
209 }
210 fprintf(out, "\n");
211
212 /* forward the key */
213 memcpy(key, output, hash_descriptor[x].hashsize);
214 }
215 fprintf(out, "\n");
216 }
217 fclose(out);
218 }
219
220 void omac_gen(void)
221 {
222 unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], input[MAXBLOCKSIZE*2+2];
223 int err, x, y, z, kl;
224 FILE *out;
225 unsigned long len;
226
227 out = fopen("omac_tv.txt", "w");
228
229 fprintf(out,
230 "OMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are OMAC'ed. The initial key is\n"
231 "of the same format (length specified per cipher). The OMAC key in step N+1 is the OMAC output of\n"
232 "step N (repeated as required to fill the array).\n\n");
233
234 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
235 kl = cipher_descriptor[x].block_length;
236
237 /* skip ciphers which do not have 64 or 128 bit block sizes */
238 if (kl != 8 && kl != 16) continue;
239
240 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
241 kl = cipher_descriptor[x].max_key_length;
242 }
243 fprintf(out, "OMAC-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
244
245 /* initial key/block */
246 for (y = 0; y < kl; y++) {
247 key[y] = (y & 255);
248 }
249
250 for (y = 0; y <= (int)(cipher_descriptor[x].block_length*2); y++) {
251 for (z = 0; z < y; z++) {
252 input[z] = (unsigned char)(z & 255);
253 }
254 len = sizeof(output);
255 if ((err = omac_memory(x, key, kl, input, y, output, &len)) != CRYPT_OK) {
256 printf("Error omacing: %s\n", error_to_string(err));
257 exit(EXIT_FAILURE);
258 }
259 fprintf(out, "%3d: ", y);
260 for (z = 0; z <(int)len; z++) {
261 fprintf(out, "%02X", output[z]);
262 }
263 fprintf(out, "\n");
264
265 /* forward the key */
266 for (z = 0; z < kl; z++) {
267 key[z] = output[z % len];
268 }
269 }
270 fprintf(out, "\n");
271 }
272 fclose(out);
273 }
274
275 void pmac_gen(void)
276 {
277 unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], input[MAXBLOCKSIZE*2+2];
278 int err, x, y, z, kl;
279 FILE *out;
280 unsigned long len;
281
282 out = fopen("pmac_tv.txt", "w");
283
284 fprintf(out,
285 "PMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are OMAC'ed. The initial key is\n"
286 "of the same format (length specified per cipher). The OMAC key in step N+1 is the OMAC output of\n"
287 "step N (repeated as required to fill the array).\n\n");
288
289 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
290 kl = cipher_descriptor[x].block_length;
291
292 /* skip ciphers which do not have 64 or 128 bit block sizes */
293 if (kl != 8 && kl != 16) continue;
294
295 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
296 kl = cipher_descriptor[x].max_key_length;
297 }
298 fprintf(out, "PMAC-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
299
300 /* initial key/block */
301 for (y = 0; y < kl; y++) {
302 key[y] = (y & 255);
303 }
304
305 for (y = 0; y <= (int)(cipher_descriptor[x].block_length*2); y++) {
306 for (z = 0; z < y; z++) {
307 input[z] = (unsigned char)(z & 255);
308 }
309 len = sizeof(output);
310 if ((err = pmac_memory(x, key, kl, input, y, output, &len)) != CRYPT_OK) {
311 printf("Error omacing: %s\n", error_to_string(err));
312 exit(EXIT_FAILURE);
313 }
314 fprintf(out, "%3d: ", y);
315 for (z = 0; z <(int)len; z++) {
316 fprintf(out, "%02X", output[z]);
317 }
318 fprintf(out, "\n");
319
320 /* forward the key */
321 for (z = 0; z < kl; z++) {
322 key[z] = output[z % len];
323 }
324 }
325 fprintf(out, "\n");
326 }
327 fclose(out);
328 }
329
330 void eax_gen(void)
331 {
332 int err, kl, x, y1, z;
333 FILE *out;
334 unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2], header[MAXBLOCKSIZE*2],
335 plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
336 unsigned long len;
337
338 out = fopen("eax_tv.txt", "w");
339 fprintf(out, "EAX Test Vectors. Uses the 00010203...NN-1 pattern for header/nonce/plaintext/key. The outputs\n"
340 "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
341 "step repeated sufficiently.\n\n");
342
343 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
344 kl = cipher_descriptor[x].block_length;
345
346 /* skip ciphers which do not have 64 or 128 bit block sizes */
347 if (kl != 8 && kl != 16) continue;
348
349 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
350 kl = cipher_descriptor[x].max_key_length;
351 }
352 fprintf(out, "EAX-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
353
354 /* the key */
355 for (z = 0; z < kl; z++) {
356 key[z] = (z & 255);
357 }
358
359 for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
360 for (z = 0; z < y1; z++) {
361 plaintext[z] = (unsigned char)(z & 255);
362 nonce[z] = (unsigned char)(z & 255);
363 header[z] = (unsigned char)(z & 255);
364 }
365 len = sizeof(tag);
366 if ((err = eax_encrypt_authenticate_memory(x, key, kl, nonce, y1, header, y1, plaintext, y1, plaintext, tag, &len)) != CRYPT_OK) {
367 printf("Error EAX'ing: %s\n", error_to_string(err));
368 exit(EXIT_FAILURE);
369 }
370 fprintf(out, "%3d: ", y1);
371 for (z = 0; z < y1; z++) {
372 fprintf(out, "%02X", plaintext[z]);
373 }
374 fprintf(out, ", ");
375 for (z = 0; z <(int)len; z++) {
376 fprintf(out, "%02X", tag[z]);
377 }
378 fprintf(out, "\n");
379
380 /* forward the key */
381 for (z = 0; z < kl; z++) {
382 key[z] = tag[z % len];
383 }
384 }
385 fprintf(out, "\n");
386 }
387 fclose(out);
388 }
389
390 void ocb_gen(void)
391 {
392 int err, kl, x, y1, z;
393 FILE *out;
394 unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2],
395 plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
396 unsigned long len;
397
398 out = fopen("ocb_tv.txt", "w");
399 fprintf(out, "OCB Test Vectors. Uses the 00010203...NN-1 pattern for nonce/plaintext/key. The outputs\n"
400 "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
401 "step repeated sufficiently. The nonce is fixed throughout.\n\n");
402
403 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
404 kl = cipher_descriptor[x].block_length;
405
406 /* skip ciphers which do not have 64 or 128 bit block sizes */
407 if (kl != 8 && kl != 16) continue;
408
409 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
410 kl = cipher_descriptor[x].max_key_length;
411 }
412 fprintf(out, "OCB-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
413
414 /* the key */
415 for (z = 0; z < kl; z++) {
416 key[z] = (z & 255);
417 }
418
419 /* fixed nonce */
420 for (z = 0; z < cipher_descriptor[x].block_length; z++) {
421 nonce[z] = z;
422 }
423
424 for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
425 for (z = 0; z < y1; z++) {
426 plaintext[z] = (unsigned char)(z & 255);
427 }
428 len = sizeof(tag);
429 if ((err = ocb_encrypt_authenticate_memory(x, key, kl, nonce, plaintext, y1, plaintext, tag, &len)) != CRYPT_OK) {
430 printf("Error OCB'ing: %s\n", error_to_string(err));
431 exit(EXIT_FAILURE);
432 }
433 fprintf(out, "%3d: ", y1);
434 for (z = 0; z < y1; z++) {
435 fprintf(out, "%02X", plaintext[z]);
436 }
437 fprintf(out, ", ");
438 for (z = 0; z <(int)len; z++) {
439 fprintf(out, "%02X", tag[z]);
440 }
441 fprintf(out, "\n");
442
443 /* forward the key */
444 for (z = 0; z < kl; z++) {
445 key[z] = tag[z % len];
446 }
447 }
448 fprintf(out, "\n");
449 }
450 fclose(out);
451 }
452
453 void base64_gen(void)
454 {
455 FILE *out;
456 unsigned char dst[256], src[32];
457 unsigned long x, y, len;
458
459 out = fopen("base64_tv.txt", "w");
460 fprintf(out, "Base64 vectors. These are the base64 encodings of the strings 00,01,02...NN-1\n\n");
461 for (x = 0; x <= 32; x++) {
462 for (y = 0; y < x; y++) {
463 src[y] = y;
464 }
465 len = sizeof(dst);
466 base64_encode(src, x, dst, &len);
467 fprintf(out, "%2lu: %s\n", x, dst);
468 }
469 fclose(out);
470 }
471
472 int main(void)
473 {
474 reg_algs();
475 printf("Generating hash vectors..."); fflush(stdout); hash_gen(); printf("done\n");
476 printf("Generating cipher vectors..."); fflush(stdout); cipher_gen(); printf("done\n");
477 printf("Generating HMAC vectors..."); fflush(stdout); hmac_gen(); printf("done\n");
478 printf("Generating OMAC vectors..."); fflush(stdout); omac_gen(); printf("done\n");
479 printf("Generating PMAC vectors..."); fflush(stdout); pmac_gen(); printf("done\n");
480 printf("Generating EAX vectors..."); fflush(stdout); eax_gen(); printf("done\n");
481 printf("Generating OCB vectors..."); fflush(stdout); ocb_gen(); printf("done\n");
482 printf("Generating BASE64 vectors..."); fflush(stdout); base64_gen(); printf("done\n");
483 return 0;
484 }
485
486
487
488
489
490
491
492