1: /*
2: * Copyright (C) 2009-2010 Martin Willi
3: * Copyright (C) 2016-2019 Andreas Steffen
4: * HSR Hochschule fuer Technik Rapperswil
5: * Copyright (C) 2010 revosec AG
6: *
7: * This program is free software; you can redistribute it and/or modify it
8: * under the terms of the GNU General Public License as published by the
9: * Free Software Foundation; either version 2 of the License, or (at your
10: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
11: *
12: * This program is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15: * for more details.
16: */
17:
18: #ifdef HAVE_DLADDR
19: # define _GNU_SOURCE
20: # include <dlfcn.h>
21: #endif
22: #include <time.h>
23:
24: #include "crypto_tester.h"
25:
26: #include <utils/debug.h>
27: #include <collections/linked_list.h>
28: #include <crypto/rngs/rng_tester.h>
29:
30: typedef struct private_crypto_tester_t private_crypto_tester_t;
31:
32: /**
33: * Private data of an crypto_tester_t object.
34: */
35: struct private_crypto_tester_t {
36:
37: /**
38: * Public crypto_tester_t interface.
39: */
40: crypto_tester_t public;
41:
42: /**
43: * List of crypter test vectors
44: */
45: linked_list_t *crypter;
46:
47: /**
48: * List of aead test vectors
49: */
50: linked_list_t *aead;
51:
52: /**
53: * List of signer test vectors
54: */
55: linked_list_t *signer;
56:
57: /**
58: * List of hasher test vectors
59: */
60: linked_list_t *hasher;
61:
62: /**
63: * List of PRF test vectors
64: */
65: linked_list_t *prf;
66:
67: /**
68: * List of XOF test vectors
69: */
70: linked_list_t *xof;
71:
72: /**
73: * List of DRBG test vectors
74: */
75: linked_list_t *drbg;
76:
77: /**
78: * List of RNG test vectors
79: */
80: linked_list_t *rng;
81:
82: /**
83: * List of Diffie-Hellman test vectors
84: */
85: linked_list_t *dh;
86:
87: /**
88: * Is a test vector required to pass a test?
89: */
90: bool required;
91:
92: /**
93: * should we run RNG_TRUE tests? Enough entropy?
94: */
95: bool rng_true;
96:
97: /**
98: * time we test each algorithm
99: */
100: int bench_time;
101:
102: /**
103: * size of buffer we use for benchmarking
104: */
105: int bench_size;
106: };
107:
108: /**
109: * Get the name of a test vector, if available
110: */
111: static const char* get_name(void *sym)
112: {
113: #ifdef HAVE_DLADDR
114: Dl_info dli;
115:
116: if (dladdr(sym, &dli))
117: {
118: return dli.dli_sname;
119: }
120: #endif
121: return "unknown";
122: }
123:
124: #if defined(CLOCK_THREAD_CPUTIME_ID) && defined(HAVE_CLOCK_GETTIME)
125:
126: /**
127: * Start a benchmark timer
128: */
129: static void start_timing(struct timespec *start)
130: {
131: clock_gettime(CLOCK_THREAD_CPUTIME_ID, start);
132: }
133:
134: /**
135: * End a benchmark timer, return ms
136: */
137: static u_int end_timing(struct timespec *start)
138: {
139: struct timespec end;
140:
141: clock_gettime(CLOCK_THREAD_CPUTIME_ID, &end);
142: return (end.tv_nsec - start->tv_nsec) / 1000000 +
143: (end.tv_sec - start->tv_sec) * 1000;
144: }
145:
146: #else /* CLOCK_THREAD_CPUTIME_ID */
147:
148: /* Make benchmarking a no-op if CLOCK_THREAD_CPUTIME_ID is not available */
149: #define start_timing(start) ((start)->tv_sec = 0, (start)->tv_nsec = 0)
150: #define end_timing(...) (this->bench_time)
151:
152: #endif /* CLOCK_THREAD_CPUTIME_ID */
153:
154: /**
155: * Benchmark a crypter
156: */
157: static u_int bench_crypter(private_crypto_tester_t *this,
158: encryption_algorithm_t alg, crypter_constructor_t create, size_t key_size)
159: {
160: crypter_t *crypter;
161:
162: crypter = create(alg, key_size);
163: if (crypter)
164: {
165: char iv[crypter->get_iv_size(crypter)];
166: char key[crypter->get_key_size(crypter)];
167: chunk_t buf;
168: struct timespec start;
169: u_int runs;
170:
171: memset(iv, 0x56, sizeof(iv));
172: memset(key, 0x12, sizeof(key));
173: if (!crypter->set_key(crypter, chunk_from_thing(key)))
174: {
175: return 0;
176: }
177:
178: buf = chunk_alloc(this->bench_size);
179: memset(buf.ptr, 0x34, buf.len);
180:
181: runs = 0;
182: start_timing(&start);
183: while (end_timing(&start) < this->bench_time)
184: {
185: if (crypter->encrypt(crypter, buf, chunk_from_thing(iv), NULL))
186: {
187: runs++;
188: }
189: if (crypter->decrypt(crypter, buf, chunk_from_thing(iv), NULL))
190: {
191: runs++;
192: }
193: }
194: free(buf.ptr);
195: crypter->destroy(crypter);
196:
197: return runs;
198: }
199: return 0;
200: }
201:
202: METHOD(crypto_tester_t, test_crypter, bool,
203: private_crypto_tester_t *this, encryption_algorithm_t alg, size_t key_size,
204: crypter_constructor_t create, u_int *speed, const char *plugin_name)
205: {
206: enumerator_t *enumerator;
207: crypter_test_vector_t *vector;
208: bool failed = FALSE;
209: u_int tested = 0;
210:
211: enumerator = this->crypter->create_enumerator(this->crypter);
212: while (enumerator->enumerate(enumerator, &vector))
213: {
214: crypter_t *crypter;
215: chunk_t key, iv, plain = chunk_empty, cipher = chunk_empty;
216:
217: if (vector->alg != alg)
218: {
219: continue;
220: }
221: if (key_size && key_size != vector->key_size)
222: { /* test only vectors with a specific key size, if key size given */
223: continue;
224: }
225:
226: crypter = create(alg, vector->key_size);
227: if (!crypter)
228: { /* key size not supported */
229: continue;
230: }
231: tested++;
232: failed = TRUE;
233:
234: key = chunk_create(vector->key, crypter->get_key_size(crypter));
235: if (!crypter->set_key(crypter, key))
236: {
237: goto failure;
238: }
239: iv = chunk_create(vector->iv, crypter->get_iv_size(crypter));
240:
241: /* allocated encryption */
242: plain = chunk_create(vector->plain, vector->len);
243: if (!crypter->encrypt(crypter, plain, iv, &cipher))
244: {
245: goto failure;
246: }
247: if (!memeq(vector->cipher, cipher.ptr, cipher.len))
248: {
249: goto failure;
250: }
251: /* inline decryption */
252: if (!crypter->decrypt(crypter, cipher, iv, NULL))
253: {
254: goto failure;
255: }
256: if (!memeq(vector->plain, cipher.ptr, cipher.len))
257: {
258: goto failure;
259: }
260: /* allocated decryption */
261: if (!crypter->decrypt(crypter,
262: chunk_create(vector->cipher, vector->len), iv, &plain))
263: {
264: goto failure;
265: }
266: if (!memeq(vector->plain, plain.ptr, plain.len))
267: {
268: goto failure;
269: }
270: /* inline encryption */
271: if (!crypter->encrypt(crypter, plain, iv, NULL))
272: {
273: goto failure;
274: }
275: if (!memeq(vector->cipher, plain.ptr, plain.len))
276: {
277: goto failure;
278: }
279:
280: failed = FALSE;
281: failure:
282: crypter->destroy(crypter);
283: chunk_free(&cipher);
284: if (plain.ptr != vector->plain)
285: {
286: chunk_free(&plain);
287: }
288: if (failed)
289: {
290: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
291: encryption_algorithm_names, alg, plugin_name, get_name(vector));
292: break;
293: }
294: }
295: enumerator->destroy(enumerator);
296: if (!tested)
297: {
298: if (failed)
299: {
300: DBG1(DBG_LIB,"disable %N[%s]: %zd byte key size not supported",
301: encryption_algorithm_names, alg, plugin_name, key_size);
302: return FALSE;
303: }
304: else
305: {
306: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
307: this->required ? "disabled" : "enabled ",
308: encryption_algorithm_names, alg, plugin_name);
309: return !this->required;
310: }
311: }
312: if (!failed)
313: {
314: if (speed)
315: {
316: *speed = bench_crypter(this, alg, create, key_size);
317: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points "
318: "(%zd bit key)", encryption_algorithm_names, alg,
319: plugin_name, tested, *speed, key_size * 8);
320: }
321: else
322: {
323: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
324: encryption_algorithm_names, alg, plugin_name, tested);
325: }
326: }
327: return !failed;
328: }
329:
330: /**
331: * Benchmark an aead transform
332: */
333: static u_int bench_aead(private_crypto_tester_t *this,
334: encryption_algorithm_t alg, aead_constructor_t create, size_t key_size)
335: {
336: aead_t *aead;
337:
338: aead = create(alg, key_size, 0);
339: if (aead)
340: {
341: char iv[aead->get_iv_size(aead)];
342: char key[aead->get_key_size(aead)];
343: char assoc[4];
344: chunk_t buf;
345: struct timespec start;
346: u_int runs;
347: size_t icv;
348:
349: memset(iv, 0x56, sizeof(iv));
350: memset(key, 0x12, sizeof(key));
351: memset(assoc, 0x78, sizeof(assoc));
352: if (!aead->set_key(aead, chunk_from_thing(key)))
353: {
354: return 0;
355: }
356: icv = aead->get_icv_size(aead);
357:
358: buf = chunk_alloc(this->bench_size + icv);
359: memset(buf.ptr, 0x34, buf.len);
360: buf.len -= icv;
361:
362: runs = 0;
363: start_timing(&start);
364: while (end_timing(&start) < this->bench_time)
365: {
366: if (aead->encrypt(aead, buf, chunk_from_thing(assoc),
367: chunk_from_thing(iv), NULL))
368: {
369: runs += 2;
370: }
371: if (aead->decrypt(aead, chunk_create(buf.ptr, buf.len + icv),
372: chunk_from_thing(assoc), chunk_from_thing(iv), NULL))
373: {
374: runs += 2;
375: }
376: }
377: free(buf.ptr);
378: aead->destroy(aead);
379:
380: return runs;
381: }
382: return 0;
383: }
384:
385: METHOD(crypto_tester_t, test_aead, bool,
386: private_crypto_tester_t *this, encryption_algorithm_t alg, size_t key_size,
387: size_t salt_size, aead_constructor_t create,
388: u_int *speed, const char *plugin_name)
389: {
390: enumerator_t *enumerator;
391: aead_test_vector_t *vector;
392: bool failed = FALSE;
393: u_int tested = 0;
394:
395: enumerator = this->aead->create_enumerator(this->aead);
396: while (enumerator->enumerate(enumerator, &vector))
397: {
398: aead_t *aead;
399: chunk_t key, iv, assoc, plain = chunk_empty, cipher = chunk_empty;
400: size_t icv;
401:
402: if (vector->alg != alg)
403: {
404: continue;
405: }
406: if (key_size && key_size != vector->key_size)
407: { /* test only vectors with a specific key size, if key size given */
408: continue;
409: }
410: if (salt_size && salt_size != vector->salt_size)
411: {
412: continue;
413: }
414:
415: tested++;
416: failed = TRUE;
417: aead = create(alg, vector->key_size, vector->salt_size);
418: if (!aead)
419: {
420: DBG1(DBG_LIB, "%N[%s]: %u bit key size not supported",
421: encryption_algorithm_names, alg, plugin_name,
422: BITS_PER_BYTE * vector->key_size);
423: continue;
424: }
425:
426: key = chunk_create(vector->key, aead->get_key_size(aead));
427: if (!aead->set_key(aead, key))
428: {
429: goto failure;
430: }
431: iv = chunk_create(vector->iv, aead->get_iv_size(aead));
432: assoc = chunk_create(vector->adata, vector->alen);
433: icv = aead->get_icv_size(aead);
434:
435: /* allocated encryption */
436: plain = chunk_create(vector->plain, vector->len);
437: if (!aead->encrypt(aead, plain, assoc, iv, &cipher))
438: {
439: goto failure;
440: }
441: if (!memeq(vector->cipher, cipher.ptr, cipher.len))
442: {
443: goto failure;
444: }
445: /* inline decryption */
446: if (!aead->decrypt(aead, cipher, assoc, iv, NULL))
447: {
448: goto failure;
449: }
450: if (!memeq(vector->plain, cipher.ptr, cipher.len - icv))
451: {
452: goto failure;
453: }
454: /* allocated decryption */
455: if (!aead->decrypt(aead, chunk_create(vector->cipher, vector->len + icv),
456: assoc, iv, &plain))
457: {
458: goto failure;
459: }
460: if (!memeq(vector->plain, plain.ptr, plain.len))
461: {
462: goto failure;
463: }
464: plain.ptr = realloc(plain.ptr, plain.len + icv);
465: /* inline encryption */
466: if (!aead->encrypt(aead, plain, assoc, iv, NULL))
467: {
468: goto failure;
469: }
470: if (!memeq(vector->cipher, plain.ptr, plain.len + icv))
471: {
472: goto failure;
473: }
474:
475: failed = FALSE;
476: failure:
477: aead->destroy(aead);
478: chunk_free(&cipher);
479: if (plain.ptr != vector->plain)
480: {
481: chunk_free(&plain);
482: }
483: if (failed)
484: {
485: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
486: encryption_algorithm_names, alg, plugin_name, get_name(vector));
487: break;
488: }
489: }
490: enumerator->destroy(enumerator);
491: if (!tested)
492: {
493: if (failed)
494: {
495: DBG1(DBG_LIB,"disable %N[%s]: %zd byte key size not supported",
496: encryption_algorithm_names, alg, plugin_name, key_size);
497: return FALSE;
498: }
499: else
500: {
501: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
502: this->required ? "disabled" : "enabled ",
503: encryption_algorithm_names, alg, plugin_name);
504: return !this->required;
505: }
506: }
507: if (!failed)
508: {
509: if (speed)
510: {
511: *speed = bench_aead(this, alg, create, key_size);
512: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points "
513: "(%zd bit key)", encryption_algorithm_names, alg,
514: plugin_name, tested, *speed, key_size * 8);
515: }
516: else
517: {
518: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
519: encryption_algorithm_names, alg, plugin_name, tested);
520: }
521: }
522: return !failed;
523: }
524:
525: /**
526: * Benchmark a signer
527: */
528: static u_int bench_signer(private_crypto_tester_t *this,
529: integrity_algorithm_t alg, signer_constructor_t create)
530: {
531: signer_t *signer;
532:
533: signer = create(alg);
534: if (signer)
535: {
536: char key[signer->get_key_size(signer)];
537: char mac[signer->get_block_size(signer)];
538: chunk_t buf;
539: struct timespec start;
540: u_int runs;
541:
542: memset(key, 0x12, sizeof(key));
543: if (!signer->set_key(signer, chunk_from_thing(key)))
544: {
545: return 0;
546: }
547:
548: buf = chunk_alloc(this->bench_size);
549: memset(buf.ptr, 0x34, buf.len);
550:
551: runs = 0;
552: start_timing(&start);
553: while (end_timing(&start) < this->bench_time)
554: {
555: if (signer->get_signature(signer, buf, mac))
556: {
557: runs++;
558: }
559: if (signer->verify_signature(signer, buf, chunk_from_thing(mac)))
560: {
561: runs++;
562: }
563: }
564: free(buf.ptr);
565: signer->destroy(signer);
566:
567: return runs;
568: }
569: return 0;
570: }
571:
572: METHOD(crypto_tester_t, test_signer, bool,
573: private_crypto_tester_t *this, integrity_algorithm_t alg,
574: signer_constructor_t create, u_int *speed, const char *plugin_name)
575: {
576: enumerator_t *enumerator;
577: signer_test_vector_t *vector;
578: bool failed = FALSE;
579: u_int tested = 0;
580:
581: enumerator = this->signer->create_enumerator(this->signer);
582: while (enumerator->enumerate(enumerator, &vector))
583: {
584: signer_t *signer;
585: chunk_t key, data, mac = chunk_empty;
586:
587: if (vector->alg != alg)
588: {
589: continue;
590: }
591:
592: tested++;
593: failed = TRUE;
594: signer = create(alg);
595: if (!signer)
596: {
597: DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
598: integrity_algorithm_names, alg, plugin_name);
599: break;
600: }
601:
602: data = chunk_create(vector->data, vector->len);
603: key = chunk_create(vector->key, signer->get_key_size(signer));
604: if (!signer->set_key(signer, key))
605: {
606: goto failure;
607: }
608: /* do partial append mode and check if key gets set correctly */
609: if (!signer->get_signature(signer, data, NULL))
610: {
611: goto failure;
612: }
613: if (!signer->set_key(signer, key))
614: {
615: goto failure;
616: }
617: /* allocated signature */
618: if (!signer->allocate_signature(signer, data, &mac))
619: {
620: goto failure;
621: }
622: if (mac.len != signer->get_block_size(signer))
623: {
624: goto failure;
625: }
626: if (!memeq(vector->mac, mac.ptr, mac.len))
627: {
628: goto failure;
629: }
630: /* signature to existing buffer */
631: memset(mac.ptr, 0, mac.len);
632: if (!signer->get_signature(signer, data, mac.ptr))
633: {
634: goto failure;
635: }
636: if (!memeq(vector->mac, mac.ptr, mac.len))
637: {
638: goto failure;
639: }
640: /* signature verification, good case */
641: if (!signer->verify_signature(signer, data, mac))
642: {
643: goto failure;
644: }
645: /* signature verification, bad case */
646: *(mac.ptr + mac.len - 1) += 1;
647: if (signer->verify_signature(signer, data, mac))
648: {
649: goto failure;
650: }
651: /* signature to existing buffer, using append mode */
652: if (data.len > 2)
653: {
654: if (!signer->allocate_signature(signer,
655: chunk_create(data.ptr, 1), NULL))
656: {
657: goto failure;
658: }
659: if (!signer->get_signature(signer,
660: chunk_create(data.ptr + 1, 1), NULL))
661: {
662: goto failure;
663: }
664: if (!signer->verify_signature(signer, chunk_skip(data, 2),
665: chunk_create(vector->mac, mac.len)))
666: {
667: goto failure;
668: }
669: }
670:
671: failed = FALSE;
672: failure:
673: signer->destroy(signer);
674: chunk_free(&mac);
675: if (failed)
676: {
677: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
678: integrity_algorithm_names, alg, plugin_name, get_name(vector));
679: break;
680: }
681: }
682: enumerator->destroy(enumerator);
683: if (!tested)
684: {
685: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
686: this->required ? "disabled" : "enabled ",
687: integrity_algorithm_names, alg, plugin_name);
688: return !this->required;
689: }
690: if (!failed)
691: {
692: if (speed)
693: {
694: *speed = bench_signer(this, alg, create);
695: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
696: integrity_algorithm_names, alg, plugin_name, tested, *speed);
697: }
698: else
699: {
700: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
701: integrity_algorithm_names, alg, plugin_name, tested);
702: }
703: }
704: return !failed;
705: }
706:
707: /**
708: * Benchmark a hasher
709: */
710: static u_int bench_hasher(private_crypto_tester_t *this,
711: hash_algorithm_t alg, hasher_constructor_t create)
712: {
713: hasher_t *hasher;
714:
715: hasher = create(alg);
716: if (hasher)
717: {
718: char hash[hasher->get_hash_size(hasher)];
719: chunk_t buf;
720: struct timespec start;
721: u_int runs;
722:
723: buf = chunk_alloc(this->bench_size);
724: memset(buf.ptr, 0x34, buf.len);
725:
726: runs = 0;
727: start_timing(&start);
728: while (end_timing(&start) < this->bench_time)
729: {
730: if (hasher->get_hash(hasher, buf, hash))
731: {
732: runs++;
733: }
734: }
735: free(buf.ptr);
736: hasher->destroy(hasher);
737:
738: return runs;
739: }
740: return 0;
741: }
742:
743: METHOD(crypto_tester_t, test_hasher, bool,
744: private_crypto_tester_t *this, hash_algorithm_t alg,
745: hasher_constructor_t create, u_int *speed, const char *plugin_name)
746: {
747: enumerator_t *enumerator;
748: hasher_test_vector_t *vector;
749: bool failed = FALSE;
750: u_int tested = 0;
751:
752: enumerator = this->hasher->create_enumerator(this->hasher);
753: while (enumerator->enumerate(enumerator, &vector))
754: {
755: hasher_t *hasher;
756: chunk_t data, hash;
757:
758: if (vector->alg != alg)
759: {
760: continue;
761: }
762:
763: tested++;
764: failed = TRUE;
765: hasher = create(alg);
766: if (!hasher)
767: {
768: DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
769: hash_algorithm_names, alg, plugin_name);
770: break;
771: }
772:
773: /* allocated hash */
774: data = chunk_create(vector->data, vector->len);
775: if (!hasher->allocate_hash(hasher, data, &hash))
776: {
777: goto failure;
778: }
779: if (hash.len != hasher->get_hash_size(hasher))
780: {
781: goto failure;
782: }
783: if (!memeq(vector->hash, hash.ptr, hash.len))
784: {
785: goto failure;
786: }
787: /* hash to existing buffer, with a reset */
788: memset(hash.ptr, 0, hash.len);
789: if (!hasher->get_hash(hasher, data, NULL))
790: {
791: goto failure;
792: }
793: if (!hasher->reset(hasher))
794: {
795: goto failure;
796: }
797: if (!hasher->get_hash(hasher, data, hash.ptr))
798: {
799: goto failure;
800: }
801: if (!memeq(vector->hash, hash.ptr, hash.len))
802: {
803: goto failure;
804: }
805: /* hasher to existing buffer, using append mode */
806: if (data.len > 2)
807: {
808: memset(hash.ptr, 0, hash.len);
809: if (!hasher->allocate_hash(hasher, chunk_create(data.ptr, 1), NULL))
810: {
811: goto failure;
812: }
813: if (!hasher->get_hash(hasher, chunk_create(data.ptr + 1, 1), NULL))
814: {
815: goto failure;
816: }
817: if (!hasher->get_hash(hasher, chunk_skip(data, 2), hash.ptr))
818: {
819: goto failure;
820: }
821: if (!memeq(vector->hash, hash.ptr, hash.len))
822: {
823: goto failure;
824: }
825: }
826:
827: failed = FALSE;
828: failure:
829: hasher->destroy(hasher);
830: chunk_free(&hash);
831: if (failed)
832: {
833: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
834: hash_algorithm_names, alg, plugin_name, get_name(vector));
835: break;
836: }
837: }
838: enumerator->destroy(enumerator);
839: if (!tested)
840: {
841: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
842: this->required ? "disabled" : "enabled ",
843: hash_algorithm_names, alg, plugin_name);
844: return !this->required;
845: }
846: if (!failed)
847: {
848: if (speed)
849: {
850: *speed = bench_hasher(this, alg, create);
851: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
852: hash_algorithm_names, alg, plugin_name, tested, *speed);
853: }
854: else
855: {
856: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
857: hash_algorithm_names, alg, plugin_name, tested);
858: }
859: }
860: return !failed;
861: }
862:
863: /**
864: * Benchmark a PRF
865: */
866: static u_int bench_prf(private_crypto_tester_t *this,
867: pseudo_random_function_t alg, prf_constructor_t create)
868: {
869: prf_t *prf;
870:
871: prf = create(alg);
872: if (prf)
873: {
874: char bytes[prf->get_block_size(prf)], key[prf->get_block_size(prf)];
875: chunk_t buf;
876: struct timespec start;
877: u_int runs;
878:
879: memset(key, 0x56, prf->get_block_size(prf));
880: if (!prf->set_key(prf, chunk_create(key, prf->get_block_size(prf))))
881: {
882: prf->destroy(prf);
883: return 0;
884: }
885:
886: buf = chunk_alloc(this->bench_size);
887: memset(buf.ptr, 0x34, buf.len);
888:
889: runs = 0;
890: start_timing(&start);
891: while (end_timing(&start) < this->bench_time)
892: {
893: if (prf->get_bytes(prf, buf, bytes))
894: {
895: runs++;
896: }
897: }
898: free(buf.ptr);
899: prf->destroy(prf);
900:
901: return runs;
902: }
903: return 0;
904: }
905:
906: METHOD(crypto_tester_t, test_prf, bool,
907: private_crypto_tester_t *this, pseudo_random_function_t alg,
908: prf_constructor_t create, u_int *speed, const char *plugin_name)
909: {
910: enumerator_t *enumerator;
911: prf_test_vector_t *vector;
912: bool failed = FALSE;
913: u_int tested = 0;
914:
915: enumerator = this->prf->create_enumerator(this->prf);
916: while (enumerator->enumerate(enumerator, &vector))
917: {
918: prf_t *prf;
919: chunk_t key, seed, out = chunk_empty;
920:
921: if (vector->alg != alg)
922: {
923: continue;
924: }
925:
926: tested++;
927: failed = TRUE;
928: prf = create(alg);
929: if (!prf)
930: {
931: DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
932: pseudo_random_function_names, alg, plugin_name);
933: break;
934: }
935:
936: seed = chunk_create(vector->seed, vector->len);
937: key = chunk_create(vector->key, vector->key_size);
938: if (!prf->set_key(prf, key))
939: {
940: goto failure;
941: }
942: if (alg != PRF_FIPS_SHA1_160)
943: {
944: /* do partial append mode and check if key gets set correctly */
945: if (!prf->get_bytes(prf, seed, NULL))
946: {
947: goto failure;
948: }
949: if (!prf->set_key(prf, key))
950: {
951: goto failure;
952: }
953: }
954: /* allocated bytes */
955: if (!prf->allocate_bytes(prf, seed, &out))
956: {
957: goto failure;
958: }
959: if (out.len != prf->get_block_size(prf))
960: {
961: goto failure;
962: }
963: if (!memeq(vector->out, out.ptr, out.len))
964: {
965: goto failure;
966: }
967: /* bytes to existing buffer */
968: memset(out.ptr, 0, out.len);
969: if (vector->stateful)
970: {
971: if (!prf->set_key(prf, key))
972: {
973: goto failure;
974: }
975: }
976: if (!prf->get_bytes(prf, seed, out.ptr))
977: {
978: goto failure;
979: }
980: if (!memeq(vector->out, out.ptr, out.len))
981: {
982: goto failure;
983: }
984: /* bytes to existing buffer, using append mode */
985: if (alg != PRF_FIPS_SHA1_160 && seed.len > 2)
986: {
987: memset(out.ptr, 0, out.len);
988: if (vector->stateful)
989: {
990: if (!prf->set_key(prf, key))
991: {
992: goto failure;
993: }
994: }
995: if (!prf->allocate_bytes(prf, chunk_create(seed.ptr, 1), NULL))
996: {
997: goto failure;
998: }
999: if (!prf->get_bytes(prf, chunk_create(seed.ptr + 1, 1), NULL))
1000: {
1001: goto failure;
1002: }
1003: if (!prf->get_bytes(prf, chunk_skip(seed, 2), out.ptr))
1004: {
1005: goto failure;
1006: }
1007: if (!memeq(vector->out, out.ptr, out.len))
1008: {
1009: goto failure;
1010: }
1011: }
1012:
1013: failed = FALSE;
1014: failure:
1015: prf->destroy(prf);
1016: chunk_free(&out);
1017: if (failed)
1018: {
1019: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
1020: pseudo_random_function_names, alg, plugin_name, get_name(vector));
1021: break;
1022: }
1023: }
1024: enumerator->destroy(enumerator);
1025: if (!tested)
1026: {
1027: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
1028: this->required ? "disabled" : "enabled ",
1029: pseudo_random_function_names, alg, plugin_name);
1030: return !this->required;
1031: }
1032: if (!failed)
1033: {
1034: if (speed)
1035: {
1036: *speed = bench_prf(this, alg, create);
1037: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
1038: pseudo_random_function_names, alg, plugin_name, tested, *speed);
1039: }
1040: else
1041: {
1042: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
1043: pseudo_random_function_names, alg, plugin_name, tested);
1044: }
1045: }
1046: return !failed;
1047: }
1048:
1049: /**
1050: * Benchmark an XOF
1051: */
1052: static u_int bench_xof(private_crypto_tester_t *this,
1053: ext_out_function_t alg, xof_constructor_t create)
1054: {
1055: xof_t *xof;
1056:
1057: xof = create(alg);
1058: if (xof)
1059: {
1060: char seed[xof->get_seed_size(xof)];
1061: char bytes[xof->get_block_size(xof)];
1062: struct timespec start;
1063: u_int runs;
1064:
1065: memset(seed, 0x56, xof->get_seed_size(xof));
1066: if (!xof->set_seed(xof, chunk_create(seed, xof->get_seed_size(xof))))
1067: {
1068: xof->destroy(xof);
1069: return 0;
1070: }
1071:
1072: runs = 0;
1073: start_timing(&start);
1074: while (end_timing(&start) < this->bench_time)
1075: {
1076: if (xof->get_bytes(xof, xof->get_block_size(xof), bytes))
1077: {
1078: runs++;
1079: }
1080: }
1081: xof->destroy(xof);
1082:
1083: return runs;
1084: }
1085: return 0;
1086: }
1087:
1088: METHOD(crypto_tester_t, test_xof, bool,
1089: private_crypto_tester_t *this, ext_out_function_t alg,
1090: xof_constructor_t create, u_int *speed, const char *plugin_name)
1091: {
1092: enumerator_t *enumerator;
1093: xof_test_vector_t *vector;
1094: bool failed = FALSE;
1095: u_int tested = 0;
1096:
1097: enumerator = this->xof->create_enumerator(this->xof);
1098: while (enumerator->enumerate(enumerator, &vector))
1099: {
1100: xof_t *xof;
1101: chunk_t seed, out = chunk_empty;
1102:
1103: if (vector->alg != alg)
1104: {
1105: continue;
1106: }
1107:
1108: tested++;
1109: failed = TRUE;
1110: xof = create(alg);
1111: if (!xof)
1112: {
1113: DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
1114: ext_out_function_names, alg, plugin_name);
1115: break;
1116: }
1117:
1118: seed = chunk_create(vector->seed, vector->len);
1119: if (!xof->set_seed(xof, seed))
1120: {
1121: goto failure;
1122: }
1123: /* allocated bytes */
1124: if (!xof->allocate_bytes(xof, vector->out_len, &out))
1125: {
1126: goto failure;
1127: }
1128: if (out.len != vector->out_len)
1129: {
1130: goto failure;
1131: }
1132: if (!memeq(vector->out, out.ptr, out.len))
1133: {
1134: goto failure;
1135: }
1136: /* bytes to existing buffer */
1137: memset(out.ptr, 0, out.len);
1138: if (!xof->set_seed(xof, seed))
1139: {
1140: goto failure;
1141: }
1142: if (!xof->get_bytes(xof, vector->out_len, out.ptr))
1143: {
1144: goto failure;
1145: }
1146: if (!memeq(vector->out, out.ptr, vector->out_len))
1147: {
1148: goto failure;
1149: }
1150: /* bytes to existing buffer, using append mode */
1151: /* TODO */
1152:
1153: failed = FALSE;
1154: failure:
1155: xof->destroy(xof);
1156: chunk_free(&out);
1157: if (failed)
1158: {
1159: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
1160: ext_out_function_names, alg, plugin_name, get_name(vector));
1161: break;
1162: }
1163: }
1164: enumerator->destroy(enumerator);
1165: if (!tested)
1166: {
1167: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
1168: this->required ? "disabled" : "enabled ",
1169: ext_out_function_names, alg, plugin_name);
1170: return !this->required;
1171: }
1172: if (!failed)
1173: {
1174: if (speed)
1175: {
1176: *speed = bench_xof(this, alg, create);
1177: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
1178: ext_out_function_names, alg, plugin_name, tested, *speed);
1179: }
1180: else
1181: {
1182: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
1183: ext_out_function_names, alg, plugin_name, tested);
1184: }
1185: }
1186: return !failed;
1187: }
1188:
1189: /**
1190: * Benchmark a DRBG
1191: */
1192: static u_int bench_drbg(private_crypto_tester_t *this,
1193: drbg_type_t type, drbg_constructor_t create)
1194: {
1195: drbg_t *drbg;
1196: rng_t *entropy;
1197: uint32_t strength = 128;
1198: chunk_t seed = chunk_alloca(48);
1199:
1200: memset(seed.ptr, 0x81, seed.len);
1201: entropy = rng_tester_create(seed);
1202:
1203: drbg = create(type, strength, entropy, chunk_empty);
1204: if (drbg)
1205: {
1206: struct timespec start;
1207: u_int runs = 0;
1208: size_t out_len = 128;
1209: char out_buf[out_len];
1210:
1211: start_timing(&start);
1212: while (end_timing(&start) < this->bench_time)
1213: {
1214: if (drbg->generate(drbg, out_len, out_buf))
1215: {
1216: runs++;
1217: }
1218: }
1219: drbg->destroy(drbg);
1220:
1221: return runs;
1222: }
1223: return 0;
1224: }
1225:
1226: METHOD(crypto_tester_t, test_drbg, bool,
1227: private_crypto_tester_t *this, drbg_type_t type,
1228: drbg_constructor_t create, u_int *speed, const char *plugin_name)
1229: {
1230: enumerator_t *enumerator;
1231: drbg_test_vector_t *vector;
1232: bool failed = FALSE;
1233: u_int tested = 0;
1234:
1235: enumerator = this->drbg->create_enumerator(this->drbg);
1236: while (enumerator->enumerate(enumerator, &vector))
1237: {
1238: drbg_t *drbg;
1239: rng_t *entropy;
1240: chunk_t out = chunk_empty;
1241:
1242: if (vector->type != type)
1243: {
1244: continue;
1245: }
1246: tested++;
1247: failed = TRUE;
1248:
1249: entropy = rng_tester_create(vector->entropy);
1250: out = chunk_alloc(vector->out.len);
1251:
1252: drbg = create(type, vector->strength, entropy,
1253: vector->personalization_str);
1254: if (!drbg)
1255: {
1256: DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
1257: drbg_type_names, type, plugin_name);
1258: entropy->destroy(entropy);
1259: chunk_free(&out);
1260: break;
1261: }
1262: if (!drbg->reseed(drbg))
1263: {
1264: goto failure;
1265: }
1266: if (!drbg->generate(drbg, out.len, out.ptr))
1267: {
1268: goto failure;
1269: }
1270: if (!drbg->generate(drbg, out.len, out.ptr))
1271: {
1272: goto failure;
1273: }
1274: if (!chunk_equals(out, vector->out))
1275: {
1276: goto failure;
1277: }
1278: failed = FALSE;
1279:
1280: failure:
1281: drbg->destroy(drbg);
1282: chunk_free(&out);
1283: if (failed)
1284: {
1285: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
1286: drbg_type_names, type, plugin_name, get_name(vector));
1287: break;
1288: }
1289: }
1290: enumerator->destroy(enumerator);
1291: if (!tested)
1292: {
1293: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
1294: this->required ? "disabled" : "enabled ",
1295: drbg_type_names, type, plugin_name);
1296: return !this->required;
1297: }
1298: if (!failed)
1299: {
1300: if (speed)
1301: {
1302: *speed = bench_drbg(this, type, create);
1303: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
1304: drbg_type_names, type, plugin_name, tested, *speed);
1305: }
1306: else
1307: {
1308: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
1309: drbg_type_names, type, plugin_name, tested);
1310: }
1311: }
1312: return !failed;
1313: }
1314:
1315: /**
1316: * Benchmark a RNG
1317: */
1318: static u_int bench_rng(private_crypto_tester_t *this,
1319: rng_quality_t quality, rng_constructor_t create)
1320: {
1321: rng_t *rng;
1322:
1323: rng = create(quality);
1324: if (rng)
1325: {
1326: struct timespec start;
1327: chunk_t buf;
1328: u_int runs;
1329:
1330: runs = 0;
1331: buf = chunk_alloc(this->bench_size);
1332: start_timing(&start);
1333: while (end_timing(&start) < this->bench_time)
1334: {
1335: if (!rng->get_bytes(rng, buf.len, buf.ptr))
1336: {
1337: runs = 0;
1338: break;
1339: }
1340: runs++;
1341: }
1342: free(buf.ptr);
1343: rng->destroy(rng);
1344:
1345: return runs;
1346: }
1347: return 0;
1348: }
1349:
1350: METHOD(crypto_tester_t, test_rng, bool,
1351: private_crypto_tester_t *this, rng_quality_t quality,
1352: rng_constructor_t create, u_int *speed, const char *plugin_name)
1353: {
1354: enumerator_t *enumerator;
1355: rng_test_vector_t *vector;
1356: bool failed = FALSE;
1357: u_int tested = 0;
1358:
1359: if (!this->rng_true && quality == RNG_TRUE)
1360: {
1361: DBG1(DBG_LIB, "enabled %N[%s]: skipping test (disabled by config)",
1362: rng_quality_names, quality, plugin_name);
1363: return TRUE;
1364: }
1365:
1366: enumerator = this->rng->create_enumerator(this->rng);
1367: while (enumerator->enumerate(enumerator, &vector))
1368: {
1369: chunk_t data = chunk_empty;
1370: rng_t *rng;
1371:
1372: if (vector->quality != quality)
1373: {
1374: continue;
1375: }
1376:
1377: tested++;
1378: failed = TRUE;
1379: rng = create(quality);
1380: if (!rng)
1381: {
1382: DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
1383: rng_quality_names, quality, plugin_name);
1384: break;
1385: }
1386:
1387: /* allocated bytes */
1388: if (!rng->allocate_bytes(rng, vector->len, &data) ||
1389: data.len != vector->len ||
1390: !vector->test(vector->user, data))
1391: {
1392: goto failure;
1393: }
1394: /* write bytes into existing buffer */
1395: memset(data.ptr, 0, data.len);
1396: if (!rng->get_bytes(rng, vector->len, data.ptr))
1397: {
1398: goto failure;
1399: }
1400: if (!vector->test(vector->user, data))
1401: {
1402: goto failure;
1403: }
1404:
1405: failed = FALSE;
1406: failure:
1407: rng->destroy(rng);
1408: chunk_free(&data);
1409: if (failed)
1410: {
1411: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
1412: rng_quality_names, quality, plugin_name, get_name(vector));
1413: break;
1414: }
1415: }
1416: enumerator->destroy(enumerator);
1417: if (!tested)
1418: {
1419: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
1420: this->required ? ", disabled" : "enabled ",
1421: rng_quality_names, quality, plugin_name);
1422: return !this->required;
1423: }
1424: if (!failed)
1425: {
1426: if (speed)
1427: {
1428: *speed = bench_rng(this, quality, create);
1429: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
1430: rng_quality_names, quality, plugin_name, tested, *speed);
1431: }
1432: else
1433: {
1434: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
1435: rng_quality_names, quality, plugin_name, tested);
1436: }
1437: }
1438: return !failed;
1439: }
1440:
1441: /**
1442: * Benchmark a DH backend
1443: */
1444: static u_int bench_dh(private_crypto_tester_t *this,
1445: diffie_hellman_group_t group, dh_constructor_t create)
1446: {
1447: chunk_t pub = chunk_empty, shared = chunk_empty;
1448: diffie_hellman_t *dh;
1449: struct timespec start;
1450: u_int runs;
1451:
1452: runs = 0;
1453: start_timing(&start);
1454: while (end_timing(&start) < this->bench_time)
1455: {
1456: dh = create(group);
1457: if (!dh)
1458: {
1459: return 0;
1460: }
1461: if (dh->get_my_public_value(dh, &pub) &&
1462: dh->set_other_public_value(dh, pub) &&
1463: dh->get_shared_secret(dh, &shared))
1464: {
1465: runs++;
1466: }
1467: chunk_free(&pub);
1468: chunk_free(&shared);
1469: dh->destroy(dh);
1470: }
1471: return runs;
1472: }
1473:
1474: METHOD(crypto_tester_t, test_dh, bool,
1475: private_crypto_tester_t *this, diffie_hellman_group_t group,
1476: dh_constructor_t create, u_int *speed, const char *plugin_name)
1477: {
1478: enumerator_t *enumerator;
1479: dh_test_vector_t *v;
1480: bool failed = FALSE;
1481: u_int tested = 0;
1482:
1483: enumerator = this->dh->create_enumerator(this->dh);
1484: while (enumerator->enumerate(enumerator, &v))
1485: {
1486: diffie_hellman_t *a, *b;
1487: chunk_t apub, bpub, asec, bsec;
1488:
1489: if (v->group != group)
1490: {
1491: continue;
1492: }
1493:
1494: a = create(group);
1495: b = create(group);
1496: if (!a || !b)
1497: {
1498: DESTROY_IF(a);
1499: DESTROY_IF(b);
1500: failed = TRUE;
1501: tested++;
1502: DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
1503: diffie_hellman_group_names, group, plugin_name);
1504: break;
1505: }
1506:
1507: if (!a->set_private_value || !b->set_private_value)
1508: { /* does not support testing */
1509: a->destroy(a);
1510: b->destroy(b);
1511: continue;
1512: }
1513: failed = TRUE;
1514: tested++;
1515:
1516: apub = bpub = asec = bsec = chunk_empty;
1517:
1518: if (!a->set_private_value(a, chunk_create(v->priv_a, v->priv_len)) ||
1519: !b->set_private_value(b, chunk_create(v->priv_b, v->priv_len)))
1520: {
1521: goto failure;
1522: }
1523: if (!a->get_my_public_value(a, &apub) ||
1524: !chunk_equals(apub, chunk_create(v->pub_a, v->pub_len)))
1525: {
1526: goto failure;
1527: }
1528: if (!b->get_my_public_value(b, &bpub) ||
1529: !chunk_equals(bpub, chunk_create(v->pub_b, v->pub_len)))
1530: {
1531: goto failure;
1532: }
1533: if (!a->set_other_public_value(a, bpub) ||
1534: !b->set_other_public_value(b, apub))
1535: {
1536: goto failure;
1537: }
1538: if (!a->get_shared_secret(a, &asec) ||
1539: !chunk_equals(asec, chunk_create(v->shared, v->shared_len)))
1540: {
1541: goto failure;
1542: }
1543: if (!b->get_shared_secret(b, &bsec) ||
1544: !chunk_equals(bsec, chunk_create(v->shared, v->shared_len)))
1545: {
1546: goto failure;
1547: }
1548:
1549: failed = FALSE;
1550: failure:
1551: a->destroy(a);
1552: b->destroy(b);
1553: chunk_free(&apub);
1554: chunk_free(&bpub);
1555: chunk_free(&asec);
1556: chunk_free(&bsec);
1557: if (failed)
1558: {
1559: DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
1560: diffie_hellman_group_names, group, plugin_name, get_name(v));
1561: break;
1562: }
1563: }
1564: enumerator->destroy(enumerator);
1565: if (!tested)
1566: {
1567: DBG1(DBG_LIB, "%s %N[%s]: no test vectors found / untestable",
1568: this->required ? "disabled" : "enabled ",
1569: diffie_hellman_group_names, group, plugin_name);
1570: return !this->required;
1571: }
1572: if (!failed)
1573: {
1574: if (speed)
1575: {
1576: *speed = bench_dh(this, group, create);
1577: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
1578: diffie_hellman_group_names, group, plugin_name, tested, *speed);
1579: }
1580: else
1581: {
1582: DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
1583: diffie_hellman_group_names, group, plugin_name, tested);
1584: }
1585: }
1586: return !failed;
1587: }
1588:
1589: METHOD(crypto_tester_t, add_crypter_vector, void,
1590: private_crypto_tester_t *this, crypter_test_vector_t *vector)
1591: {
1592: this->crypter->insert_last(this->crypter, vector);
1593: }
1594:
1595: METHOD(crypto_tester_t, add_aead_vector, void,
1596: private_crypto_tester_t *this, aead_test_vector_t *vector)
1597: {
1598: this->aead->insert_last(this->aead, vector);
1599: }
1600:
1601: METHOD(crypto_tester_t, add_signer_vector, void,
1602: private_crypto_tester_t *this, signer_test_vector_t *vector)
1603: {
1604: this->signer->insert_last(this->signer, vector);
1605: }
1606:
1607: METHOD(crypto_tester_t, add_hasher_vector, void,
1608: private_crypto_tester_t *this, hasher_test_vector_t *vector)
1609: {
1610: this->hasher->insert_last(this->hasher, vector);
1611: }
1612:
1613: METHOD(crypto_tester_t, add_prf_vector, void,
1614: private_crypto_tester_t *this, prf_test_vector_t *vector)
1615: {
1616: this->prf->insert_last(this->prf, vector);
1617: }
1618:
1619: METHOD(crypto_tester_t, add_xof_vector, void,
1620: private_crypto_tester_t *this, xof_test_vector_t *vector)
1621: {
1622: this->xof->insert_last(this->xof, vector);
1623: }
1624:
1625: METHOD(crypto_tester_t, add_drbg_vector, void,
1626: private_crypto_tester_t *this, drbg_test_vector_t *vector)
1627: {
1628: this->drbg->insert_last(this->drbg, vector);
1629: }
1630:
1631: METHOD(crypto_tester_t, add_rng_vector, void,
1632: private_crypto_tester_t *this, rng_test_vector_t *vector)
1633: {
1634: this->rng->insert_last(this->rng, vector);
1635: }
1636:
1637: METHOD(crypto_tester_t, add_dh_vector, void,
1638: private_crypto_tester_t *this, dh_test_vector_t *vector)
1639: {
1640: this->dh->insert_last(this->dh, vector);
1641: }
1642:
1643: METHOD(crypto_tester_t, destroy, void,
1644: private_crypto_tester_t *this)
1645: {
1646: this->crypter->destroy(this->crypter);
1647: this->aead->destroy(this->aead);
1648: this->signer->destroy(this->signer);
1649: this->hasher->destroy(this->hasher);
1650: this->prf->destroy(this->prf);
1651: this->xof->destroy(this->xof);
1652: this->drbg->destroy(this->drbg);
1653: this->rng->destroy(this->rng);
1654: this->dh->destroy(this->dh);
1655: free(this);
1656: }
1657:
1658: /**
1659: * See header
1660: */
1661: crypto_tester_t *crypto_tester_create()
1662: {
1663: private_crypto_tester_t *this;
1664:
1665: INIT(this,
1666: .public = {
1667: .test_crypter = _test_crypter,
1668: .test_aead = _test_aead,
1669: .test_signer = _test_signer,
1670: .test_hasher = _test_hasher,
1671: .test_prf = _test_prf,
1672: .test_xof = _test_xof,
1673: .test_drbg = _test_drbg,
1674: .test_rng = _test_rng,
1675: .test_dh = _test_dh,
1676: .add_crypter_vector = _add_crypter_vector,
1677: .add_aead_vector = _add_aead_vector,
1678: .add_signer_vector = _add_signer_vector,
1679: .add_hasher_vector = _add_hasher_vector,
1680: .add_prf_vector = _add_prf_vector,
1681: .add_xof_vector = _add_xof_vector,
1682: .add_drbg_vector = _add_drbg_vector,
1683: .add_rng_vector = _add_rng_vector,
1684: .add_dh_vector = _add_dh_vector,
1685: .destroy = _destroy,
1686: },
1687: .crypter = linked_list_create(),
1688: .aead = linked_list_create(),
1689: .signer = linked_list_create(),
1690: .hasher = linked_list_create(),
1691: .prf = linked_list_create(),
1692: .xof = linked_list_create(),
1693: .drbg = linked_list_create(),
1694: .rng = linked_list_create(),
1695: .dh = linked_list_create(),
1696:
1697: .required = lib->settings->get_bool(lib->settings,
1698: "%s.crypto_test.required", FALSE, lib->ns),
1699: .rng_true = lib->settings->get_bool(lib->settings,
1700: "%s.crypto_test.rng_true", FALSE, lib->ns),
1701: .bench_time = lib->settings->get_int(lib->settings,
1702: "%s.crypto_test.bench_time", 50, lib->ns),
1703: .bench_size = lib->settings->get_int(lib->settings,
1704: "%s.crypto_test.bench_size", 1024, lib->ns),
1705: );
1706:
1707: /* enforce a block size of 16, should be fine for all algorithms */
1708: this->bench_size = this->bench_size / 16 * 16;
1709:
1710: return &this->public;
1711: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to crypto_tester.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / crypto