Mercurial > dropbear

comparison demos/tv_gen.c @ 280:59400faa4b44 libtomcrypt-orig libtomcrypt-1.05

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Re-import libtomcrypt 1.05 for cleaner propagating. From crypt-1.05.tar.bz2, SHA1 of 88250202bb51570dc64f7e8f1c943cda9479258f
author Matt Johnston <matt@ucc.asn.au>
date Wed, 08 Mar 2006 12:58:00 +0000
parents
children d5faf4814ddb
comparison
equal deleted inserted replaced
-1:000000000000 280:59400faa4b44
1 #include <tomcrypt.h>
2
3 void reg_algs(void)
4 {
5 int err;
6
7 #ifdef RIJNDAEL
8 register_cipher (&aes_desc);
9 #endif
10 #ifdef BLOWFISH
11 register_cipher (&blowfish_desc);
12 #endif
13 #ifdef XTEA
14 register_cipher (&xtea_desc);
15 #endif
16 #ifdef RC5
17 register_cipher (&rc5_desc);
18 #endif
19 #ifdef RC6
20 register_cipher (&rc6_desc);
21 #endif
22 #ifdef SAFERP
23 register_cipher (&saferp_desc);
24 #endif
25 #ifdef TWOFISH
26 register_cipher (&twofish_desc);
27 #endif
28 #ifdef SAFER
29 register_cipher (&safer_k64_desc);
30 register_cipher (&safer_sk64_desc);
31 register_cipher (&safer_k128_desc);
32 register_cipher (&safer_sk128_desc);
33 #endif
34 #ifdef RC2
35 register_cipher (&rc2_desc);
36 #endif
37 #ifdef DES
38 register_cipher (&des_desc);
39 register_cipher (&des3_desc);
40 #endif
41 #ifdef CAST5
42 register_cipher (&cast5_desc);
43 #endif
44 #ifdef NOEKEON
45 register_cipher (&noekeon_desc);
46 #endif
47 #ifdef SKIPJACK
48 register_cipher (&skipjack_desc);
49 #endif
50 #ifdef ANUBIS
51 register_cipher (&anubis_desc);
52 #endif
53 #ifdef KHAZAD
54 register_cipher (&khazad_desc);
55 #endif
56
57 #ifdef TIGER
58 register_hash (&tiger_desc);
59 #endif
60 #ifdef MD2
61 register_hash (&md2_desc);
62 #endif
63 #ifdef MD4
64 register_hash (&md4_desc);
65 #endif
66 #ifdef MD5
67 register_hash (&md5_desc);
68 #endif
69 #ifdef SHA1
70 register_hash (&sha1_desc);
71 #endif
72 #ifdef SHA224
73 register_hash (&sha224_desc);
74 #endif
75 #ifdef SHA256
76 register_hash (&sha256_desc);
77 #endif
78 #ifdef SHA384
79 register_hash (&sha384_desc);
80 #endif
81 #ifdef SHA512
82 register_hash (&sha512_desc);
83 #endif
84 #ifdef RIPEMD128
85 register_hash (&rmd128_desc);
86 #endif
87 #ifdef RIPEMD160
88 register_hash (&rmd160_desc);
89 #endif
90 #ifdef WHIRLPOOL
91 register_hash (&whirlpool_desc);
92 #endif
93 #ifdef CHC_HASH
94 register_hash(&chc_desc);
95 if ((err = chc_register(register_cipher(&aes_desc))) != CRYPT_OK) {
96 printf("chc_register error: %s\n", error_to_string(err));
97 exit(EXIT_FAILURE);
98 }
99 #endif
100
101 }
102
103 void hash_gen(void)
104 {
105 unsigned char md[MAXBLOCKSIZE], *buf;
106 unsigned long outlen, x, y, z;
107 FILE *out;
108 int err;
109
110 out = fopen("hash_tv.txt", "w");
111 if (out == NULL) {
112 perror("can't open hash_tv");
113 }
114
115 fprintf(out, "Hash Test Vectors:\n\nThese are the hashes of nn bytes '00 01 02 03 .. (nn-1)'\n\n");
116 for (x = 0; hash_descriptor[x].name != NULL; x++) {
117 buf = XMALLOC(2 * hash_descriptor[x].blocksize + 1);
118 if (buf == NULL) {
119 perror("can't alloc mem");
120 exit(EXIT_FAILURE);
121 }
122 fprintf(out, "Hash: %s\n", hash_descriptor[x].name);
123 for (y = 0; y <= (hash_descriptor[x].blocksize * 2); y++) {
124 for (z = 0; z < y; z++) {
125 buf[z] = (unsigned char)(z & 255);
126 }
127 outlen = sizeof(md);
128 if ((err = hash_memory(x, buf, y, md, &outlen)) != CRYPT_OK) {
129 printf("hash_memory error: %s\n", error_to_string(err));
130 exit(EXIT_FAILURE);
131 }
132 fprintf(out, "%3lu: ", y);
133 for (z = 0; z < outlen; z++) {
134 fprintf(out, "%02X", md[z]);
135 }
136 fprintf(out, "\n");
137 }
138 fprintf(out, "\n");
139 XFREE(buf);
140 }
141 fclose(out);
142 }
143
144 void cipher_gen(void)
145 {
146 unsigned char *key, pt[MAXBLOCKSIZE];
147 unsigned long x, y, z, w;
148 int err, kl, lastkl;
149 FILE *out;
150 symmetric_key skey;
151
152 out = fopen("cipher_tv.txt", "w");
153
154 fprintf(out,
155 "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"
156 "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");
157
158 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
159 fprintf(out, "Cipher: %s\n", cipher_descriptor[x].name);
160
161 /* three modes, smallest, medium, large keys */
162 lastkl = 10000;
163 for (y = 0; y < 3; y++) {
164 switch (y) {
165 case 0: kl = cipher_descriptor[x].min_key_length; break;
166 case 1: kl = (cipher_descriptor[x].min_key_length + cipher_descriptor[x].max_key_length)/2; break;
167 case 2: kl = cipher_descriptor[x].max_key_length; break;
168 }
169 if ((err = cipher_descriptor[x].keysize(&kl)) != CRYPT_OK) {
170 printf("keysize error: %s\n", error_to_string(err));
171 exit(EXIT_FAILURE);
172 }
173 if (kl == lastkl) break;
174 lastkl = kl;
175 fprintf(out, "Key Size: %d bytes\n", kl);
176
177 key = XMALLOC(kl);
178 if (key == NULL) {
179 perror("can't malloc memory");
180 exit(EXIT_FAILURE);
181 }
182
183 for (z = 0; (int)z < kl; z++) {
184 key[z] = (unsigned char)z;
185 }
186 if ((err = cipher_descriptor[x].setup(key, kl, 0, &skey)) != CRYPT_OK) {
187 printf("setup error: %s\n", error_to_string(err));
188 exit(EXIT_FAILURE);
189 }
190
191 for (z = 0; (int)z < cipher_descriptor[x].block_length; z++) {
192 pt[z] = (unsigned char)z;
193 }
194 for (w = 0; w < 50; w++) {
195 cipher_descriptor[x].ecb_encrypt(pt, pt, &skey);
196 fprintf(out, "%2lu: ", w);
197 for (z = 0; (int)z < cipher_descriptor[x].block_length; z++) {
198 fprintf(out, "%02X", pt[z]);
199 }
200 fprintf(out, "\n");
201
202 /* reschedule a new key */
203 for (z = 0; z < (unsigned long)kl; z++) {
204 key[z] = pt[z % cipher_descriptor[x].block_length];
205 }
206 if ((err = cipher_descriptor[x].setup(key, kl, 0, &skey)) != CRYPT_OK) {
207 printf("cipher setup2 error: %s\n", error_to_string(err));
208 exit(EXIT_FAILURE);
209 }
210 }
211 fprintf(out, "\n");
212 XFREE(key);
213 }
214 fprintf(out, "\n");
215 }
216 fclose(out);
217 }
218
219 void hmac_gen(void)
220 {
221 unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], *input;
222 int x, y, z, err;
223 FILE *out;
224 unsigned long len;
225
226 out = fopen("hmac_tv.txt", "w");
227
228 fprintf(out,
229 "HMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are HMACed. The initial key is\n"
230 "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"
231 "step N.\n\n");
232
233 for (x = 0; hash_descriptor[x].name != NULL; x++) {
234 fprintf(out, "HMAC-%s\n", hash_descriptor[x].name);
235
236 /* initial key */
237 for (y = 0; y < (int)hash_descriptor[x].hashsize; y++) {
238 key[y] = (y&255);
239 }
240
241 input = XMALLOC(hash_descriptor[x].blocksize * 2 + 1);
242 if (input == NULL) {
243 perror("Can't malloc memory");
244 exit(EXIT_FAILURE);
245 }
246
247 for (y = 0; y <= (int)(hash_descriptor[x].blocksize * 2); y++) {
248 for (z = 0; z < y; z++) {
249 input[z] = (unsigned char)(z & 255);
250 }
251 len = sizeof(output);
252 if ((err = hmac_memory(x, key, hash_descriptor[x].hashsize, input, y, output, &len)) != CRYPT_OK) {
253 printf("Error hmacing: %s\n", error_to_string(err));
254 exit(EXIT_FAILURE);
255 }
256 fprintf(out, "%3d: ", y);
257 for (z = 0; z <(int) len; z++) {
258 fprintf(out, "%02X", output[z]);
259 }
260 fprintf(out, "\n");
261
262 /* forward the key */
263 memcpy(key, output, hash_descriptor[x].hashsize);
264 }
265 XFREE(input);
266 fprintf(out, "\n");
267 }
268 fclose(out);
269 }
270
271 void omac_gen(void)
272 {
273 unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], input[MAXBLOCKSIZE*2+2];
274 int err, x, y, z, kl;
275 FILE *out;
276 unsigned long len;
277
278 out = fopen("omac_tv.txt", "w");
279
280 fprintf(out,
281 "OMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are OMAC'ed. The initial key is\n"
282 "of the same format (length specified per cipher). The OMAC key in step N+1 is the OMAC output of\n"
283 "step N (repeated as required to fill the array).\n\n");
284
285 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
286 kl = cipher_descriptor[x].block_length;
287
288 /* skip ciphers which do not have 64 or 128 bit block sizes */
289 if (kl != 8 && kl != 16) continue;
290
291 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
292 kl = cipher_descriptor[x].max_key_length;
293 }
294 fprintf(out, "OMAC-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
295
296 /* initial key/block */
297 for (y = 0; y < kl; y++) {
298 key[y] = (y & 255);
299 }
300
301 for (y = 0; y <= (int)(cipher_descriptor[x].block_length*2); y++) {
302 for (z = 0; z < y; z++) {
303 input[z] = (unsigned char)(z & 255);
304 }
305 len = sizeof(output);
306 if ((err = omac_memory(x, key, kl, input, y, output, &len)) != CRYPT_OK) {
307 printf("Error omacing: %s\n", error_to_string(err));
308 exit(EXIT_FAILURE);
309 }
310 fprintf(out, "%3d: ", y);
311 for (z = 0; z <(int)len; z++) {
312 fprintf(out, "%02X", output[z]);
313 }
314 fprintf(out, "\n");
315
316 /* forward the key */
317 for (z = 0; z < kl; z++) {
318 key[z] = output[z % len];
319 }
320 }
321 fprintf(out, "\n");
322 }
323 fclose(out);
324 }
325
326 void pmac_gen(void)
327 {
328 unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], input[MAXBLOCKSIZE*2+2];
329 int err, x, y, z, kl;
330 FILE *out;
331 unsigned long len;
332
333 out = fopen("pmac_tv.txt", "w");
334
335 fprintf(out,
336 "PMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are OMAC'ed. The initial key is\n"
337 "of the same format (length specified per cipher). The OMAC key in step N+1 is the OMAC output of\n"
338 "step N (repeated as required to fill the array).\n\n");
339
340 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
341 kl = cipher_descriptor[x].block_length;
342
343 /* skip ciphers which do not have 64 or 128 bit block sizes */
344 if (kl != 8 && kl != 16) continue;
345
346 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
347 kl = cipher_descriptor[x].max_key_length;
348 }
349 fprintf(out, "PMAC-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
350
351 /* initial key/block */
352 for (y = 0; y < kl; y++) {
353 key[y] = (y & 255);
354 }
355
356 for (y = 0; y <= (int)(cipher_descriptor[x].block_length*2); y++) {
357 for (z = 0; z < y; z++) {
358 input[z] = (unsigned char)(z & 255);
359 }
360 len = sizeof(output);
361 if ((err = pmac_memory(x, key, kl, input, y, output, &len)) != CRYPT_OK) {
362 printf("Error omacing: %s\n", error_to_string(err));
363 exit(EXIT_FAILURE);
364 }
365 fprintf(out, "%3d: ", y);
366 for (z = 0; z <(int)len; z++) {
367 fprintf(out, "%02X", output[z]);
368 }
369 fprintf(out, "\n");
370
371 /* forward the key */
372 for (z = 0; z < kl; z++) {
373 key[z] = output[z % len];
374 }
375 }
376 fprintf(out, "\n");
377 }
378 fclose(out);
379 }
380
381 void eax_gen(void)
382 {
383 int err, kl, x, y1, z;
384 FILE *out;
385 unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2], header[MAXBLOCKSIZE*2],
386 plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
387 unsigned long len;
388
389 out = fopen("eax_tv.txt", "w");
390 fprintf(out, "EAX Test Vectors. Uses the 00010203...NN-1 pattern for header/nonce/plaintext/key. The outputs\n"
391 "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
392 "step repeated sufficiently.\n\n");
393
394 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
395 kl = cipher_descriptor[x].block_length;
396
397 /* skip ciphers which do not have 64 or 128 bit block sizes */
398 if (kl != 8 && kl != 16) continue;
399
400 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
401 kl = cipher_descriptor[x].max_key_length;
402 }
403 fprintf(out, "EAX-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
404
405 /* the key */
406 for (z = 0; z < kl; z++) {
407 key[z] = (z & 255);
408 }
409
410 for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
411 for (z = 0; z < y1; z++) {
412 plaintext[z] = (unsigned char)(z & 255);
413 nonce[z] = (unsigned char)(z & 255);
414 header[z] = (unsigned char)(z & 255);
415 }
416 len = sizeof(tag);
417 if ((err = eax_encrypt_authenticate_memory(x, key, kl, nonce, y1, header, y1, plaintext, y1, plaintext, tag, &len)) != CRYPT_OK) {
418 printf("Error EAX'ing: %s\n", error_to_string(err));
419 exit(EXIT_FAILURE);
420 }
421 fprintf(out, "%3d: ", y1);
422 for (z = 0; z < y1; z++) {
423 fprintf(out, "%02X", plaintext[z]);
424 }
425 fprintf(out, ", ");
426 for (z = 0; z <(int)len; z++) {
427 fprintf(out, "%02X", tag[z]);
428 }
429 fprintf(out, "\n");
430
431 /* forward the key */
432 for (z = 0; z < kl; z++) {
433 key[z] = tag[z % len];
434 }
435 }
436 fprintf(out, "\n");
437 }
438 fclose(out);
439 }
440
441 void ocb_gen(void)
442 {
443 int err, kl, x, y1, z;
444 FILE *out;
445 unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2],
446 plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
447 unsigned long len;
448
449 out = fopen("ocb_tv.txt", "w");
450 fprintf(out, "OCB Test Vectors. Uses the 00010203...NN-1 pattern for nonce/plaintext/key. The outputs\n"
451 "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
452 "step repeated sufficiently. The nonce is fixed throughout.\n\n");
453
454 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
455 kl = cipher_descriptor[x].block_length;
456
457 /* skip ciphers which do not have 64 or 128 bit block sizes */
458 if (kl != 8 && kl != 16) continue;
459
460 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
461 kl = cipher_descriptor[x].max_key_length;
462 }
463 fprintf(out, "OCB-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
464
465 /* the key */
466 for (z = 0; z < kl; z++) {
467 key[z] = (z & 255);
468 }
469
470 /* fixed nonce */
471 for (z = 0; z < cipher_descriptor[x].block_length; z++) {
472 nonce[z] = z;
473 }
474
475 for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
476 for (z = 0; z < y1; z++) {
477 plaintext[z] = (unsigned char)(z & 255);
478 }
479 len = sizeof(tag);
480 if ((err = ocb_encrypt_authenticate_memory(x, key, kl, nonce, plaintext, y1, plaintext, tag, &len)) != CRYPT_OK) {
481 printf("Error OCB'ing: %s\n", error_to_string(err));
482 exit(EXIT_FAILURE);
483 }
484 fprintf(out, "%3d: ", y1);
485 for (z = 0; z < y1; z++) {
486 fprintf(out, "%02X", plaintext[z]);
487 }
488 fprintf(out, ", ");
489 for (z = 0; z <(int)len; z++) {
490 fprintf(out, "%02X", tag[z]);
491 }
492 fprintf(out, "\n");
493
494 /* forward the key */
495 for (z = 0; z < kl; z++) {
496 key[z] = tag[z % len];
497 }
498 }
499 fprintf(out, "\n");
500 }
501 fclose(out);
502 }
503
504
505 void ccm_gen(void)
506 {
507 int err, kl, x, y1, z;
508 FILE *out;
509 unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2],
510 plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
511 unsigned long len;
512
513 out = fopen("ccm_tv.txt", "w");
514 fprintf(out, "CCM Test Vectors. Uses the 00010203...NN-1 pattern for nonce/header/plaintext/key. The outputs\n"
515 "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
516 "step repeated sufficiently. The nonce is fixed throughout at 13 bytes 000102...\n\n");
517
518 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
519 kl = cipher_descriptor[x].block_length;
520
521 /* skip ciphers which do not have 128 bit block sizes */
522 if (kl != 16) continue;
523
524 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
525 kl = cipher_descriptor[x].max_key_length;
526 }
527 fprintf(out, "CCM-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
528
529 /* the key */
530 for (z = 0; z < kl; z++) {
531 key[z] = (z & 255);
532 }
533
534 /* fixed nonce */
535 for (z = 0; z < cipher_descriptor[x].block_length; z++) {
536 nonce[z] = z;
537 }
538
539 for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
540 for (z = 0; z < y1; z++) {
541 plaintext[z] = (unsigned char)(z & 255);
542 }
543 len = sizeof(tag);
544 if ((err = ccm_memory(x, key, kl, nonce, 13, plaintext, y1, plaintext, y1, plaintext, tag, &len, CCM_ENCRYPT)) != CRYPT_OK) {
545 printf("Error CCM'ing: %s\n", error_to_string(err));
546 exit(EXIT_FAILURE);
547 }
548 fprintf(out, "%3d: ", y1);
549 for (z = 0; z < y1; z++) {
550 fprintf(out, "%02X", plaintext[z]);
551 }
552 fprintf(out, ", ");
553 for (z = 0; z <(int)len; z++) {
554 fprintf(out, "%02X", tag[z]);
555 }
556 fprintf(out, "\n");
557
558 /* forward the key */
559 for (z = 0; z < kl; z++) {
560 key[z] = tag[z % len];
561 }
562 }
563 fprintf(out, "\n");
564 }
565 fclose(out);
566 }
567
568 void gcm_gen(void)
569 {
570 int err, kl, x, y1, z;
571 FILE *out;
572 unsigned char key[MAXBLOCKSIZE], plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
573 unsigned long len;
574
575 out = fopen("gcm_tv.txt", "w");
576 fprintf(out, "GCM Test Vectors. Uses the 00010203...NN-1 pattern for nonce/header/plaintext/key. The outputs\n"
577 "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
578 "step repeated sufficiently. The nonce is fixed throughout at 13 bytes 000102...\n\n");
579
580 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
581 kl = cipher_descriptor[x].block_length;
582
583 /* skip ciphers which do not have 128 bit block sizes */
584 if (kl != 16) continue;
585
586 if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
587 kl = cipher_descriptor[x].max_key_length;
588 }
589 fprintf(out, "GCM-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
590
591 /* the key */
592 for (z = 0; z < kl; z++) {
593 key[z] = (z & 255);
594 }
595
596 for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
597 for (z = 0; z < y1; z++) {
598 plaintext[z] = (unsigned char)(z & 255);
599 }
600 len = sizeof(tag);
601 if ((err = gcm_memory(x, key, kl, plaintext, y1, plaintext, y1, plaintext, y1, plaintext, tag, &len, GCM_ENCRYPT)) != CRYPT_OK) {
602 printf("Error GCM'ing: %s\n", error_to_string(err));
603 exit(EXIT_FAILURE);
604 }
605 fprintf(out, "%3d: ", y1);
606 for (z = 0; z < y1; z++) {
607 fprintf(out, "%02X", plaintext[z]);
608 }
609 fprintf(out, ", ");
610 for (z = 0; z <(int)len; z++) {
611 fprintf(out, "%02X", tag[z]);
612 }
613 fprintf(out, "\n");
614
615 /* forward the key */
616 for (z = 0; z < kl; z++) {
617 key[z] = tag[z % len];
618 }
619 }
620 fprintf(out, "\n");
621 }
622 fclose(out);
623 }
624
625 void base64_gen(void)
626 {
627 FILE *out;
628 unsigned char dst[256], src[32];
629 unsigned long x, y, len;
630
631 out = fopen("base64_tv.txt", "w");
632 fprintf(out, "Base64 vectors. These are the base64 encodings of the strings 00,01,02...NN-1\n\n");
633 for (x = 0; x <= 32; x++) {
634 for (y = 0; y < x; y++) {
635 src[y] = y;
636 }
637 len = sizeof(dst);
638 base64_encode(src, x, dst, &len);
639 fprintf(out, "%2lu: %s\n", x, dst);
640 }
641 fclose(out);
642 }
643
644 int main(void)
645 {
646 reg_algs();
647 printf("Generating hash vectors..."); fflush(stdout); hash_gen(); printf("done\n");
648 printf("Generating cipher vectors..."); fflush(stdout); cipher_gen(); printf("done\n");
649 printf("Generating HMAC vectors..."); fflush(stdout); hmac_gen(); printf("done\n");
650 printf("Generating OMAC vectors..."); fflush(stdout); omac_gen(); printf("done\n");
651 printf("Generating PMAC vectors..."); fflush(stdout); pmac_gen(); printf("done\n");
652 printf("Generating EAX vectors..."); fflush(stdout); eax_gen(); printf("done\n");
653 printf("Generating OCB vectors..."); fflush(stdout); ocb_gen(); printf("done\n");
654 printf("Generating CCM vectors..."); fflush(stdout); ccm_gen(); printf("done\n");
655 printf("Generating GCM vectors..."); fflush(stdout); gcm_gen(); printf("done\n");
656 printf("Generating BASE64 vectors..."); fflush(stdout); base64_gen(); printf("done\n");
657 return 0;
658 }
659
660
661
662
663
664
665
666
667
668 /* $Source: /cvs/libtom/libtomcrypt/demos/tv_gen.c,v $ */
669 /* $Revision: 1.4 $ */
670 /* $Date: 2005/05/05 14:35:56 $ */