summaryrefslogtreecommitdiffhomepage
path: root/libtomcrypt/testprof
diff options
context:
space:
mode:
Diffstat (limited to 'libtomcrypt/testprof')
-rw-r--r--libtomcrypt/testprof/base64_test.c24
-rw-r--r--libtomcrypt/testprof/cipher_hash_test.c45
-rw-r--r--libtomcrypt/testprof/der_tests.c370
-rw-r--r--libtomcrypt/testprof/dh_tests.c103
-rw-r--r--libtomcrypt/testprof/dsa_test.c68
-rw-r--r--libtomcrypt/testprof/ecc_test.c137
-rw-r--r--libtomcrypt/testprof/mac_test.c35
-rw-r--r--libtomcrypt/testprof/makefile15
-rw-r--r--libtomcrypt/testprof/makefile.icc15
-rw-r--r--libtomcrypt/testprof/makefile.msvc10
-rw-r--r--libtomcrypt/testprof/makefile.shared15
-rw-r--r--libtomcrypt/testprof/modes_test.c120
-rw-r--r--libtomcrypt/testprof/pkcs_1_test.c96
-rw-r--r--libtomcrypt/testprof/rsa_test.c338
-rw-r--r--libtomcrypt/testprof/store_test.c78
-rw-r--r--libtomcrypt/testprof/test.c13
-rw-r--r--libtomcrypt/testprof/test.key15
-rw-r--r--libtomcrypt/testprof/tomcrypt_test.h77
-rw-r--r--libtomcrypt/testprof/x86_prof.c1050
19 files changed, 2624 insertions, 0 deletions
diff --git a/libtomcrypt/testprof/base64_test.c b/libtomcrypt/testprof/base64_test.c
new file mode 100644
index 0000000..af20a67
--- /dev/null
+++ b/libtomcrypt/testprof/base64_test.c
@@ -0,0 +1,24 @@
+#include <tomcrypt_test.h>
+
+int base64_test(void)
+{
+ unsigned char in[64], out[256], tmp[64];
+ unsigned long x, l1, l2;
+
+ for (x = 0; x < 64; x++) {
+ yarrow_read(in, x, &yarrow_prng);
+ l1 = sizeof(out);
+ DO(base64_encode(in, x, out, &l1));
+ l2 = sizeof(tmp);
+ DO(base64_decode(out, l1, tmp, &l2));
+ if (l2 != x || memcmp(tmp, in, x)) {
+ fprintf(stderr, "base64 failed %lu %lu %lu", x, l1, l2);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/base64_test.c,v $ */
+/* $Revision: 1.5 $ */
+/* $Date: 2005/05/21 12:51:25 $ */
diff --git a/libtomcrypt/testprof/cipher_hash_test.c b/libtomcrypt/testprof/cipher_hash_test.c
new file mode 100644
index 0000000..27232e2
--- /dev/null
+++ b/libtomcrypt/testprof/cipher_hash_test.c
@@ -0,0 +1,45 @@
+/* test the ciphers and hashes using their built-in self-tests */
+
+#include <tomcrypt_test.h>
+
+int cipher_hash_test(void)
+{
+ int x;
+ unsigned char buf[4096];
+ unsigned long n;
+ prng_state nprng;
+
+ /* test ciphers */
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ DO(cipher_descriptor[x].test());
+ }
+
+ /* test hashes */
+ for (x = 0; hash_descriptor[x].name != NULL; x++) {
+ DO(hash_descriptor[x].test());
+ }
+
+ /* test prngs (test, import/export */
+ for (x = 0; prng_descriptor[x].name != NULL; x++) {
+ DO(prng_descriptor[x].test());
+ DO(prng_descriptor[x].start(&nprng));
+ DO(prng_descriptor[x].add_entropy((unsigned char *)"helloworld12", 12, &nprng));
+ DO(prng_descriptor[x].ready(&nprng));
+ n = sizeof(buf);
+ DO(prng_descriptor[x].pexport(buf, &n, &nprng));
+ prng_descriptor[x].done(&nprng);
+ DO(prng_descriptor[x].pimport(buf, n, &nprng));
+ DO(prng_descriptor[x].ready(&nprng));
+ if (prng_descriptor[x].read(buf, 100, &nprng) != 100) {
+ fprintf(stderr, "Error reading from imported PRNG!\n");
+ exit(EXIT_FAILURE);
+ }
+ prng_descriptor[x].done(&nprng);
+ }
+
+ return 0;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/cipher_hash_test.c,v $ */
+/* $Revision: 1.3 $ */
+/* $Date: 2005/05/05 14:35:59 $ */
diff --git a/libtomcrypt/testprof/der_tests.c b/libtomcrypt/testprof/der_tests.c
new file mode 100644
index 0000000..8119351
--- /dev/null
+++ b/libtomcrypt/testprof/der_tests.c
@@ -0,0 +1,370 @@
+#include <tomcrypt_test.h>
+
+#ifndef LTC_DER
+
+int der_tests(void)
+{
+ fprintf(stderr, "NOP");
+ return 0;
+}
+
+#else
+
+static int der_choice_test(void)
+{
+ ltc_asn1_list types[7], host[1];
+ unsigned char bitbuf[10], octetbuf[10], ia5buf[10], printbuf[10], outbuf[256];
+ unsigned long integer, oidbuf[10], outlen, inlen, x, y;
+ mp_int mpinteger;
+ ltc_utctime utctime = { 91, 5, 6, 16, 45, 40, 1, 7, 0 };
+
+ /* setup variables */
+ for (x = 0; x < sizeof(bitbuf); x++) { bitbuf[x] = x & 1; }
+ for (x = 0; x < sizeof(octetbuf); x++) { octetbuf[x] = x; }
+ for (x = 0; x < sizeof(ia5buf); x++) { ia5buf[x] = 'a'; }
+ for (x = 0; x < sizeof(printbuf); x++) { printbuf[x] = 'a'; }
+ integer = 1;
+ for (x = 0; x < sizeof(oidbuf)/sizeof(oidbuf[0]); x++) { oidbuf[x] = x + 1; }
+ DO(mpi_to_ltc_error(mp_init(&mpinteger)));
+
+ for (x = 0; x < 14; x++) {
+ /* setup list */
+ LTC_SET_ASN1(types, 0, LTC_ASN1_PRINTABLE_STRING, printbuf, sizeof(printbuf));
+ LTC_SET_ASN1(types, 1, LTC_ASN1_BIT_STRING, bitbuf, sizeof(bitbuf));
+ LTC_SET_ASN1(types, 2, LTC_ASN1_OCTET_STRING, octetbuf, sizeof(octetbuf));
+ LTC_SET_ASN1(types, 3, LTC_ASN1_IA5_STRING, ia5buf, sizeof(ia5buf));
+ if (x > 7) {
+ LTC_SET_ASN1(types, 4, LTC_ASN1_SHORT_INTEGER, &integer, 1);
+ } else {
+ LTC_SET_ASN1(types, 4, LTC_ASN1_INTEGER, &mpinteger, 1);
+ }
+ LTC_SET_ASN1(types, 5, LTC_ASN1_OBJECT_IDENTIFIER, oidbuf, sizeof(oidbuf)/sizeof(oidbuf[0]));
+ LTC_SET_ASN1(types, 6, LTC_ASN1_UTCTIME, &utctime, 1);
+
+ LTC_SET_ASN1(host, 0, LTC_ASN1_CHOICE, types, 7);
+
+
+ /* encode */
+ outlen = sizeof(outbuf);
+ DO(der_encode_sequence(&types[x>6?x-7:x], 1, outbuf, &outlen));
+
+ /* decode it */
+ inlen = outlen;
+ DO(der_decode_sequence(outbuf, inlen, &host, 1));
+
+ for (y = 0; y < 7; y++) {
+ if (types[y].used && y != (x>6?x-7:x)) {
+ fprintf(stderr, "CHOICE, flag %lu in trial %lu was incorrectly set to one\n", y, x);
+ return 1;
+ }
+ if (!types[y].used && y == (x>6?x-7:x)) {
+ fprintf(stderr, "CHOICE, flag %lu in trial %lu was incorrectly set to zero\n", y, x);
+ return 1;
+ }
+ }
+ }
+ mp_clear(&mpinteger);
+ return 0;
+}
+
+
+int der_tests(void)
+{
+ unsigned long x, y, z, zz, oid[2][32];
+ unsigned char buf[3][2048];
+ mp_int a, b, c, d, e, f, g;
+
+ static const unsigned char rsa_oid_der[] = { 0x06, 0x06, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d };
+ static const unsigned long rsa_oid[] = { 1, 2, 840, 113549 };
+
+ static const unsigned char rsa_ia5[] = "test1@rsa.com";
+ static const unsigned char rsa_ia5_der[] = { 0x16, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x31,
+ 0x40, 0x72, 0x73, 0x61, 0x2e, 0x63, 0x6f, 0x6d };
+
+ static const unsigned char rsa_printable[] = "Test User 1";
+ static const unsigned char rsa_printable_der[] = { 0x13, 0x0b, 0x54, 0x65, 0x73, 0x74, 0x20, 0x55,
+ 0x73, 0x65, 0x72, 0x20, 0x31 };
+
+ static const ltc_utctime rsa_time1 = { 91, 5, 6, 16, 45, 40, 1, 7, 0 };
+ static const ltc_utctime rsa_time2 = { 91, 5, 6, 23, 45, 40, 0, 0, 0 };
+ ltc_utctime tmp_time;
+
+ static const unsigned char rsa_time1_der[] = { 0x17, 0x11, 0x39, 0x31, 0x30, 0x35, 0x30, 0x36, 0x31, 0x36, 0x34, 0x35, 0x34, 0x30, 0x2D, 0x30, 0x37, 0x30, 0x30 };
+ static const unsigned char rsa_time2_der[] = { 0x17, 0x0d, 0x39, 0x31, 0x30, 0x35, 0x30, 0x36, 0x32, 0x33, 0x34, 0x35, 0x34, 0x30, 0x5a };
+
+ DO(mpi_to_ltc_error(mp_init_multi(&a, &b, &c, &d, &e, &f, &g, NULL)));
+ for (zz = 0; zz < 16; zz++) {
+ for (z = 0; z < 1024; z++) {
+ if (yarrow_read(buf[0], z, &yarrow_prng) != z) {
+ fprintf(stderr, "Failed to read %lu bytes from yarrow\n", z);
+ return 1;
+ }
+ DO(mpi_to_ltc_error(mp_read_unsigned_bin(&a, buf[0], z)));
+ if (mp_iszero(&a) == MP_NO) { a.sign = buf[0][0] & 1 ? MP_ZPOS : MP_NEG; }
+ x = sizeof(buf[0]);
+ DO(der_encode_integer(&a, buf[0], &x));
+ DO(der_length_integer(&a, &y));
+ if (y != x) { fprintf(stderr, "DER INTEGER size mismatch\n"); return 1; }
+ mp_zero(&b);
+ DO(der_decode_integer(buf[0], y, &b));
+ if (y != x || mp_cmp(&a, &b) != MP_EQ) {
+ fprintf(stderr, "%lu: %lu vs %lu\n", z, x, y);
+#ifdef BN_MP_TORADIX_C
+ mp_todecimal(&a, buf[0]);
+ mp_todecimal(&b, buf[1]);
+ fprintf(stderr, "a == %s\nb == %s\n", buf[0], buf[1]);
+#endif
+ mp_clear_multi(&a, &b, &c, &d, &e, &f, &g, NULL);
+ return 1;
+ }
+ }
+ }
+
+/* test short integer */
+ for (zz = 0; zz < 256; zz++) {
+ for (z = 1; z < 4; z++) {
+ if (yarrow_read(buf[0], z, &yarrow_prng) != z) {
+ fprintf(stderr, "Failed to read %lu bytes from yarrow\n", z);
+ return 1;
+ }
+ /* encode with normal */
+ DO(mpi_to_ltc_error(mp_read_unsigned_bin(&a, buf[0], z)));
+
+ x = sizeof(buf[0]);
+ DO(der_encode_integer(&a, buf[0], &x));
+
+ /* encode with short */
+ y = sizeof(buf[1]);
+ DO(der_encode_short_integer(mp_get_int(&a), buf[1], &y));
+ if (x != y || memcmp(buf[0], buf[1], x)) {
+ fprintf(stderr, "DER INTEGER short encoding failed, %lu, %lu\n", x, y);
+ for (z = 0; z < x; z++) fprintf(stderr, "%02x ", buf[0][z]); fprintf(stderr, "\n");
+ for (z = 0; z < y; z++) fprintf(stderr, "%02x ", buf[1][z]); fprintf(stderr, "\n");
+ mp_clear_multi(&a, &b, &c, &d, &e, &f, &g, NULL);
+ return 1;
+ }
+
+ /* decode it */
+ x = 0;
+ DO(der_decode_short_integer(buf[1], y, &x));
+ if (x != mp_get_int(&a)) {
+ fprintf(stderr, "DER INTEGER short decoding failed, %lu, %lu\n", x, mp_get_int(&a));
+ mp_clear_multi(&a, &b, &c, &d, &e, &f, &g, NULL);
+ return 1;
+ }
+ }
+ }
+ mp_clear_multi(&a, &b, &c, &d, &e, &f, &g, NULL);
+
+
+/* Test bit string */
+ for (zz = 1; zz < 1536; zz++) {
+ yarrow_read(buf[0], zz, &yarrow_prng);
+ for (z = 0; z < zz; z++) {
+ buf[0][z] &= 0x01;
+ }
+ x = sizeof(buf[1]);
+ DO(der_encode_bit_string(buf[0], zz, buf[1], &x));
+ DO(der_length_bit_string(zz, &y));
+ if (y != x) {
+ fprintf(stderr, "\nDER BIT STRING length of encoded not match expected : %lu, %lu, %lu\n", z, x, y);
+ return 1;
+ }
+
+ y = sizeof(buf[2]);
+ DO(der_decode_bit_string(buf[1], x, buf[2], &y));
+ if (y != zz || memcmp(buf[0], buf[2], zz)) {
+ fprintf(stderr, "%lu, %lu, %d\n", y, zz, memcmp(buf[0], buf[2], zz));
+ return 1;
+ }
+ }
+
+/* Test octet string */
+ for (zz = 1; zz < 1536; zz++) {
+ yarrow_read(buf[0], zz, &yarrow_prng);
+ x = sizeof(buf[1]);
+ DO(der_encode_octet_string(buf[0], zz, buf[1], &x));
+ DO(der_length_octet_string(zz, &y));
+ if (y != x) {
+ fprintf(stderr, "\nDER OCTET STRING length of encoded not match expected : %lu, %lu, %lu\n", z, x, y);
+ return 1;
+ }
+ y = sizeof(buf[2]);
+ DO(der_decode_octet_string(buf[1], x, buf[2], &y));
+ if (y != zz || memcmp(buf[0], buf[2], zz)) {
+ fprintf(stderr, "%lu, %lu, %d\n", y, zz, memcmp(buf[0], buf[2], zz));
+ return 1;
+ }
+ }
+
+/* test OID */
+ x = sizeof(buf[0]);
+ DO(der_encode_object_identifier(rsa_oid, sizeof(rsa_oid)/sizeof(rsa_oid[0]), buf[0], &x));
+ if (x != sizeof(rsa_oid_der) || memcmp(rsa_oid_der, buf[0], x)) {
+ fprintf(stderr, "rsa_oid_der encode failed to match, %lu, ", x);
+ for (y = 0; y < x; y++) fprintf(stderr, "%02x ", buf[0][y]);
+ fprintf(stderr, "\n");
+ return 1;
+ }
+
+ y = sizeof(oid[0])/sizeof(oid[0][0]);
+ DO(der_decode_object_identifier(buf[0], x, oid[0], &y));
+ if (y != sizeof(rsa_oid)/sizeof(rsa_oid[0]) || memcmp(rsa_oid, oid[0], sizeof(rsa_oid))) {
+ fprintf(stderr, "rsa_oid_der decode failed to match, %lu, ", y);
+ for (z = 0; z < y; z++) fprintf(stderr, "%lu ", oid[0][z]);
+ fprintf(stderr, "\n");
+ return 1;
+ }
+
+ /* do random strings */
+ for (zz = 0; zz < 5000; zz++) {
+ /* pick a random number of words */
+ yarrow_read(buf[0], 4, &yarrow_prng);
+ LOAD32L(z, buf[0]);
+ z = 2 + (z % ((sizeof(oid[0])/sizeof(oid[0][0])) - 2));
+
+ /* fill them in */
+ oid[0][0] = buf[0][0] % 3;
+ oid[0][1] = buf[0][1] % 40;
+
+ for (y = 2; y < z; y++) {
+ yarrow_read(buf[0], 4, &yarrow_prng);
+ LOAD32L(oid[0][y], buf[0]);
+ }
+
+ /* encode it */
+ x = sizeof(buf[0]);
+ DO(der_encode_object_identifier(oid[0], z, buf[0], &x));
+ DO(der_length_object_identifier(oid[0], z, &y));
+ if (x != y) {
+ fprintf(stderr, "Random OID %lu test failed, length mismatch: %lu, %lu\n", z, x, y);
+ for (x = 0; x < z; x++) fprintf(stderr, "%lu\n", oid[0][x]);
+ return 1;
+ }
+
+ /* decode it */
+ y = sizeof(oid[0])/sizeof(oid[0][0]);
+ DO(der_decode_object_identifier(buf[0], x, oid[1], &y));
+ if (y != z) {
+ fprintf(stderr, "Random OID %lu test failed, decode length mismatch: %lu, %lu\n", z, x, y);
+ return 1;
+ }
+ if (memcmp(oid[0], oid[1], sizeof(oid[0][0]) * z)) {
+ fprintf(stderr, "Random OID %lu test failed, decoded values wrong\n", z);
+ for (x = 0; x < z; x++) fprintf(stderr, "%lu\n", oid[0][x]); fprintf(stderr, "\n\n Got \n\n");
+ for (x = 0; x < z; x++) fprintf(stderr, "%lu\n", oid[1][x]);
+ return 1;
+ }
+ }
+
+/* IA5 string */
+ x = sizeof(buf[0]);
+ DO(der_encode_ia5_string(rsa_ia5, strlen(rsa_ia5), buf[0], &x));
+ if (x != sizeof(rsa_ia5_der) || memcmp(buf[0], rsa_ia5_der, x)) {
+ fprintf(stderr, "IA5 encode failed: %lu, %lu\n", x, (unsigned long)sizeof(rsa_ia5_der));
+ return 1;
+ }
+ DO(der_length_ia5_string(rsa_ia5, strlen(rsa_ia5), &y));
+ if (y != x) {
+ fprintf(stderr, "IA5 length failed to match: %lu, %lu\n", x, y);
+ return 1;
+ }
+ y = sizeof(buf[1]);
+ DO(der_decode_ia5_string(buf[0], x, buf[1], &y));
+ if (y != strlen(rsa_ia5) || memcmp(buf[1], rsa_ia5, strlen(rsa_ia5))) {
+ fprintf(stderr, "DER IA5 failed test vector\n");
+ return 1;
+ }
+
+/* Printable string */
+ x = sizeof(buf[0]);
+ DO(der_encode_printable_string(rsa_printable, strlen(rsa_printable), buf[0], &x));
+ if (x != sizeof(rsa_printable_der) || memcmp(buf[0], rsa_printable_der, x)) {
+ fprintf(stderr, "PRINTABLE encode failed: %lu, %lu\n", x, (unsigned long)sizeof(rsa_printable_der));
+ return 1;
+ }
+ DO(der_length_printable_string(rsa_printable, strlen(rsa_printable), &y));
+ if (y != x) {
+ fprintf(stderr, "printable length failed to match: %lu, %lu\n", x, y);
+ return 1;
+ }
+ y = sizeof(buf[1]);
+ DO(der_decode_printable_string(buf[0], x, buf[1], &y));
+ if (y != strlen(rsa_printable) || memcmp(buf[1], rsa_printable, strlen(rsa_printable))) {
+ fprintf(stderr, "DER printable failed test vector\n");
+ return 1;
+ }
+
+/* Test UTC time */
+ x = sizeof(buf[0]);
+ DO(der_encode_utctime(&rsa_time1, buf[0], &x));
+ if (x != sizeof(rsa_time1_der) || memcmp(buf[0], rsa_time1_der, x)) {
+ fprintf(stderr, "UTCTIME encode of rsa_time1 failed: %lu, %lu\n", x, (unsigned long)sizeof(rsa_time1_der));
+fprintf(stderr, "\n\n");
+for (y = 0; y < x; y++) fprintf(stderr, "%02x ", buf[0][y]); printf("\n");
+
+ return 1;
+ }
+ DO(der_length_utctime(&rsa_time1, &y));
+ if (y != x) {
+ fprintf(stderr, "UTCTIME length failed to match for rsa_time1: %lu, %lu\n", x, y);
+ return 1;
+ }
+ DO(der_decode_utctime(buf[0], &y, &tmp_time));
+ if (y != x || memcmp(&rsa_time1, &tmp_time, sizeof(ltc_utctime))) {
+ fprintf(stderr, "UTCTIME decode failed for rsa_time1: %lu %lu\n", x, y);
+fprintf(stderr, "\n\n%u %u %u %u %u %u %u %u %u\n\n",
+tmp_time.YY,
+tmp_time.MM,
+tmp_time.DD,
+tmp_time.hh,
+tmp_time.mm,
+tmp_time.ss,
+tmp_time.off_dir,
+tmp_time.off_mm,
+tmp_time.off_hh);
+ return 1;
+ }
+
+ x = sizeof(buf[0]);
+ DO(der_encode_utctime(&rsa_time2, buf[0], &x));
+ if (x != sizeof(rsa_time2_der) || memcmp(buf[0], rsa_time2_der, x)) {
+ fprintf(stderr, "UTCTIME encode of rsa_time2 failed: %lu, %lu\n", x, (unsigned long)sizeof(rsa_time1_der));
+fprintf(stderr, "\n\n");
+for (y = 0; y < x; y++) fprintf(stderr, "%02x ", buf[0][y]); printf("\n");
+
+ return 1;
+ }
+ DO(der_length_utctime(&rsa_time2, &y));
+ if (y != x) {
+ fprintf(stderr, "UTCTIME length failed to match for rsa_time2: %lu, %lu\n", x, y);
+ return 1;
+ }
+ DO(der_decode_utctime(buf[0], &y, &tmp_time));
+ if (y != x || memcmp(&rsa_time2, &tmp_time, sizeof(ltc_utctime))) {
+ fprintf(stderr, "UTCTIME decode failed for rsa_time2: %lu %lu\n", x, y);
+fprintf(stderr, "\n\n%u %u %u %u %u %u %u %u %u\n\n",
+tmp_time.YY,
+tmp_time.MM,
+tmp_time.DD,
+tmp_time.hh,
+tmp_time.mm,
+tmp_time.ss,
+tmp_time.off_dir,
+tmp_time.off_mm,
+tmp_time.off_hh);
+
+
+ return 1;
+ }
+
+
+
+ return der_choice_test();
+}
+
+#endif
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/der_tests.c,v $ */
+/* $Revision: 1.25 $ */
+/* $Date: 2005/06/20 20:37:45 $ */
diff --git a/libtomcrypt/testprof/dh_tests.c b/libtomcrypt/testprof/dh_tests.c
new file mode 100644
index 0000000..3852e47
--- /dev/null
+++ b/libtomcrypt/testprof/dh_tests.c
@@ -0,0 +1,103 @@
+#include <tomcrypt_test.h>
+
+#ifdef MDH
+
+int dh_tests (void)
+{
+ unsigned char buf[3][4096];
+ unsigned long x, y, z;
+ int stat, stat2;
+ dh_key usera, userb;
+
+ DO(dh_test());
+
+ /* make up two keys */
+ DO(dh_make_key (&yarrow_prng, find_prng ("yarrow"), 512, &usera));
+ DO(dh_make_key (&yarrow_prng, find_prng ("yarrow"), 512, &userb));
+
+ /* make the shared secret */
+ x = 4096;
+ DO(dh_shared_secret (&usera, &userb, buf[0], &x));
+
+ y = 4096;
+ DO(dh_shared_secret (&userb, &usera, buf[1], &y));
+ if (y != x) {
+ fprintf(stderr, "DH Shared keys are not same size.\n");
+ return 1;
+ }
+ if (memcmp (buf[0], buf[1], x)) {
+ fprintf(stderr, "DH Shared keys not same contents.\n");
+ return 1;
+ }
+
+ /* now export userb */
+ y = 4096;
+ DO(dh_export (buf[1], &y, PK_PUBLIC, &userb));
+ dh_free (&userb);
+
+ /* import and make the shared secret again */
+ DO(dh_import (buf[1], y, &userb));
+ z = 4096;
+ DO(dh_shared_secret (&usera, &userb, buf[2], &z));
+
+ if (z != x) {
+ fprintf(stderr, "failed. Size don't match?\n");
+ return 1;
+ }
+ if (memcmp (buf[0], buf[2], x)) {
+ fprintf(stderr, "Failed. Content didn't match.\n");
+ return 1;
+ }
+ dh_free (&usera);
+ dh_free (&userb);
+
+/* test encrypt_key */
+ dh_make_key (&yarrow_prng, find_prng ("yarrow"), 512, &usera);
+ for (x = 0; x < 16; x++) {
+ buf[0][x] = x;
+ }
+ y = sizeof (buf[1]);
+ DO(dh_encrypt_key (buf[0], 16, buf[1], &y, &yarrow_prng, find_prng ("yarrow"), find_hash ("md5"), &usera));
+ zeromem (buf[0], sizeof (buf[0]));
+ x = sizeof (buf[0]);
+ DO(dh_decrypt_key (buf[1], y, buf[0], &x, &usera));
+ if (x != 16) {
+ fprintf(stderr, "Failed (length)\n");
+ return 1;
+ }
+ for (x = 0; x < 16; x++)
+ if (buf[0][x] != x) {
+ fprintf(stderr, "Failed (contents)\n");
+ return 1;
+ }
+
+/* test sign_hash */
+ for (x = 0; x < 16; x++) {
+ buf[0][x] = x;
+ }
+ x = sizeof (buf[1]);
+ DO(dh_sign_hash (buf[0], 16, buf[1], &x, &yarrow_prng , find_prng ("yarrow"), &usera));
+ DO(dh_verify_hash (buf[1], x, buf[0], 16, &stat, &usera));
+ buf[0][0] ^= 1;
+ DO(dh_verify_hash (buf[1], x, buf[0], 16, &stat2, &usera));
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "dh_sign/verify_hash %d %d", stat, stat2);
+ return 1;
+ }
+ dh_free (&usera);
+ return 0;
+}
+
+#else
+
+int dh_tests(void)
+{
+ fprintf(stderr, "NOP");
+ return 0;
+}
+
+#endif
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/dh_tests.c,v $ */
+/* $Revision: 1.5 $ */
+/* $Date: 2005/05/21 12:51:25 $ */
diff --git a/libtomcrypt/testprof/dsa_test.c b/libtomcrypt/testprof/dsa_test.c
new file mode 100644
index 0000000..aa4988c
--- /dev/null
+++ b/libtomcrypt/testprof/dsa_test.c
@@ -0,0 +1,68 @@
+#include <tomcrypt_test.h>
+
+#ifdef MDSA
+
+int dsa_test(void)
+{
+ unsigned char msg[16], out[1024], out2[1024];
+ unsigned long x;
+ int stat1, stat2;
+ dsa_key key, key2;
+
+ /* make a random key */
+ DO(dsa_make_key(&yarrow_prng, find_prng("yarrow"), 20, 128, &key));
+
+ /* verify it */
+ DO(dsa_verify_key(&key, &stat1));
+ if (stat1 == 0) { fprintf(stderr, "dsa_verify_key "); return 1; }
+
+ /* sign the message */
+ x = sizeof(out);
+ DO(dsa_sign_hash(msg, sizeof(msg), out, &x, &yarrow_prng, find_prng("yarrow"), &key));
+
+ /* verify it once */
+ DO(dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key));
+
+ /* Modify and verify again */
+ msg[0] ^= 1;
+ DO(dsa_verify_hash(out, x, msg, sizeof(msg), &stat2, &key));
+ msg[0] ^= 1;
+ if (!(stat1 == 1 && stat2 == 0)) { fprintf(stderr, "dsa_verify %d %d", stat1, stat2); return 1; }
+
+ /* test exporting it */
+ x = sizeof(out2);
+ DO(dsa_export(out2, &x, PK_PRIVATE, &key));
+ DO(dsa_import(out2, x, &key2));
+
+ /* verify a signature with it */
+ DO(dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2));
+ if (stat1 == 0) { fprintf(stderr, "dsa_verify (import private) %d ", stat1); return 1; }
+ dsa_free(&key2);
+
+ /* export as public now */
+ x = sizeof(out2);
+ DO(dsa_export(out2, &x, PK_PUBLIC, &key));
+
+ DO(dsa_import(out2, x, &key2));
+ /* verify a signature with it */
+ DO(dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2));
+ if (stat1 == 0) { fprintf(stderr, "dsa_verify (import public) %d ", stat1); return 1; }
+ dsa_free(&key2);
+ dsa_free(&key);
+
+ return 0;
+}
+
+#else
+
+int dsa_test(void)
+{
+ fprintf(stderr, "NOP");
+ return 0;
+}
+
+#endif
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/dsa_test.c,v $ */
+/* $Revision: 1.8 $ */
+/* $Date: 2005/06/03 19:24:32 $ */
diff --git a/libtomcrypt/testprof/ecc_test.c b/libtomcrypt/testprof/ecc_test.c
new file mode 100644
index 0000000..d5f88ab
--- /dev/null
+++ b/libtomcrypt/testprof/ecc_test.c
@@ -0,0 +1,137 @@
+#include <tomcrypt_test.h>
+
+#ifdef MECC
+
+static int sizes[] = {
+#ifdef ECC192
+24,
+#endif
+#ifdef ECC224
+28,
+#endif
+#ifdef ECC256
+32,
+#endif
+#ifdef ECC384
+48,
+#endif
+#ifdef ECC512
+65
+#endif
+};
+
+int ecc_tests (void)
+{
+ unsigned char buf[4][4096];
+ unsigned long x, y, z, s;
+ int stat, stat2;
+ ecc_key usera, userb, pubKey, privKey;
+
+ DO(ecc_test ());
+
+ for (s = 0; s < (int)(sizeof(sizes)/sizeof(sizes[0])); s++) {
+ /* make up two keys */
+ DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &usera));
+ DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &userb));
+
+ /* make the shared secret */
+ x = 4096;
+ DO(ecc_shared_secret (&usera, &userb, buf[0], &x));
+
+ y = 4096;
+ DO(ecc_shared_secret (&userb, &usera, buf[1], &y));
+
+ if (y != x) {
+ fprintf(stderr, "ecc Shared keys are not same size.");
+ return 1;
+ }
+
+ if (memcmp (buf[0], buf[1], x)) {
+ fprintf(stderr, "ecc Shared keys not same contents.");
+ return 1;
+ }
+
+ /* now export userb */
+ y = 4096;
+ DO(ecc_export (buf[1], &y, PK_PUBLIC, &userb));
+ ecc_free (&userb);
+
+ /* import and make the shared secret again */
+ DO(ecc_import (buf[1], y, &userb));
+
+ z = 4096;
+ DO(ecc_shared_secret (&usera, &userb, buf[2], &z));
+
+ if (z != x) {
+ fprintf(stderr, "failed. Size don't match?");
+ return 1;
+ }
+ if (memcmp (buf[0], buf[2], x)) {
+ fprintf(stderr, "Failed. Contents didn't match.");
+ return 1;
+ }
+ ecc_free (&usera);
+ ecc_free (&userb);
+
+ /* test encrypt_key */
+ DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &usera));
+
+ /* export key */
+ x = sizeof(buf[0]);
+ DO(ecc_export(buf[0], &x, PK_PUBLIC, &usera));
+ DO(ecc_import(buf[0], x, &pubKey));
+ x = sizeof(buf[0]);
+ DO(ecc_export(buf[0], &x, PK_PRIVATE, &usera));
+ DO(ecc_import(buf[0], x, &privKey));
+
+ for (x = 0; x < 32; x++) {
+ buf[0][x] = x;
+ }
+ y = sizeof (buf[1]);
+ DO(ecc_encrypt_key (buf[0], 32, buf[1], &y, &yarrow_prng, find_prng ("yarrow"), find_hash ("sha256"), &pubKey));
+ zeromem (buf[0], sizeof (buf[0]));
+ x = sizeof (buf[0]);
+ DO(ecc_decrypt_key (buf[1], y, buf[0], &x, &privKey));
+ if (x != 32) {
+ fprintf(stderr, "Failed (length)");
+ return 1;
+ }
+ for (x = 0; x < 32; x++) {
+ if (buf[0][x] != x) {
+ fprintf(stderr, "Failed (contents)");
+ return 1;
+ }
+ }
+ /* test sign_hash */
+ for (x = 0; x < 16; x++) {
+ buf[0][x] = x;
+ }
+ x = sizeof (buf[1]);
+ DO(ecc_sign_hash (buf[0], 16, buf[1], &x, &yarrow_prng, find_prng ("yarrow"), &privKey));
+ DO(ecc_verify_hash (buf[1], x, buf[0], 16, &stat, &pubKey));
+ buf[0][0] ^= 1;
+ DO(ecc_verify_hash (buf[1], x, buf[0], 16, &stat2, &privKey));
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "ecc_verify_hash failed %d, %d, ", stat, stat2);
+ return 1;
+ }
+ ecc_free (&usera);
+ ecc_free (&pubKey);
+ ecc_free (&privKey);
+ }
+ return 0;
+}
+
+#else
+
+int ecc_tests(void)
+{
+ fprintf(stderr, "NOP");
+ return 0;
+}
+
+#endif
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/ecc_test.c,v $ */
+/* $Revision: 1.9 $ */
+/* $Date: 2005/06/14 19:43:29 $ */
diff --git a/libtomcrypt/testprof/mac_test.c b/libtomcrypt/testprof/mac_test.c
new file mode 100644
index 0000000..3c9e902
--- /dev/null
+++ b/libtomcrypt/testprof/mac_test.c
@@ -0,0 +1,35 @@
+/* test pmac/omac/hmac */
+#include <tomcrypt_test.h>
+
+int mac_test(void)
+{
+#ifdef HMAC
+ DO(hmac_test());
+#endif
+#ifdef PMAC
+ DO(pmac_test());
+#endif
+#ifdef OMAC
+ DO(omac_test());
+#endif
+#ifdef EAX_MODE
+ DO(eax_test());
+#endif
+#ifdef OCB_MODE
+ DO(ocb_test());
+#endif
+#ifdef CCM_MODE
+ DO(ccm_test());
+#endif
+#ifdef GCM_MODE
+ DO(gcm_test());
+#endif
+#ifdef PELICAN
+ DO(pelican_test());
+#endif
+ return 0;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/mac_test.c,v $ */
+/* $Revision: 1.3 $ */
+/* $Date: 2005/05/05 14:35:59 $ */
diff --git a/libtomcrypt/testprof/makefile b/libtomcrypt/testprof/makefile
new file mode 100644
index 0000000..f4be577
--- /dev/null
+++ b/libtomcrypt/testprof/makefile
@@ -0,0 +1,15 @@
+CFLAGS += -I../src/headers -I./ -Wall -W
+
+OBJECTS = base64_test.o cipher_hash_test.o der_tests.o dh_tests.o \
+dsa_test.o ecc_test.o mac_test.o modes_test.o pkcs_1_test.o rsa_test.o \
+store_test.o test.o x86_prof.o
+
+default: libtomcrypt_prof.a
+
+libtomcrypt_prof.a: $(OBJECTS)
+ $(AR) $(ARFLAGS) libtomcrypt_prof.a $(OBJECTS)
+ ranlib libtomcrypt_prof.a
+
+clean:
+ rm -f *.o *.a
+
diff --git a/libtomcrypt/testprof/makefile.icc b/libtomcrypt/testprof/makefile.icc
new file mode 100644
index 0000000..ff87660
--- /dev/null
+++ b/libtomcrypt/testprof/makefile.icc
@@ -0,0 +1,15 @@
+CFLAGS += -I../src/headers -I./
+CC=icc
+
+OBJECTS = base64_test.o cipher_hash_test.o der_tests.o dh_tests.o \
+dsa_test.o ecc_test.o mac_test.o modes_test.o pkcs_1_test.o rsa_test.o \
+store_test.o test.o x86_prof.o
+
+default: libtomcrypt_prof.a
+
+libtomcrypt_prof.a: $(OBJECTS)
+ $(AR) $(ARFLAGS) libtomcrypt_prof.a $(OBJECTS)
+
+clean:
+ rm -f *.o *.a
+
diff --git a/libtomcrypt/testprof/makefile.msvc b/libtomcrypt/testprof/makefile.msvc
new file mode 100644
index 0000000..6e15ffb
--- /dev/null
+++ b/libtomcrypt/testprof/makefile.msvc
@@ -0,0 +1,10 @@
+CFLAGS = /I../src/headers/ /I./ /Ox /DWIN32 /W3 /Fo$@
+
+OBJECTS=base64_test.obj cipher_hash_test.obj der_tests.obj dh_tests.obj \
+dsa_test.obj ecc_test.obj mac_test.obj modes_test.obj pkcs_1_test.obj \
+rsa_test.obj store_test.obj test.obj x86_prof.obj
+
+tomcrypt_prof.lib: $(OBJECTS)
+ lib /out:tomcrypt_prof.lib $(OBJECTS)
+
+
diff --git a/libtomcrypt/testprof/makefile.shared b/libtomcrypt/testprof/makefile.shared
new file mode 100644
index 0000000..b4219f0
--- /dev/null
+++ b/libtomcrypt/testprof/makefile.shared
@@ -0,0 +1,15 @@
+CC=libtool --mode=compile gcc
+
+CFLAGS += -I../src/headers -I./ -O3 -fomit-frame-pointer -funroll-loops -Wall -W
+
+OBJECTS = base64_test.o cipher_hash_test.o der_tests.o dh_tests.o \
+dsa_test.o ecc_test.o mac_test.o modes_test.o pkcs_1_test.o rsa_test.o \
+store_test.o test.o x86_prof.o
+
+default: $(LIBNAME)
+
+$(LIBNAME): $(OBJECTS)
+ libtool --silent --mode=link gcc $(CFLAGS) `find . -type f | grep "[.]lo" | xargs` -o libtomcrypt_prof.la -rpath $(LIBPATH) -version-info $(VERSION)
+ libtool --silent --mode=link gcc $(CFLAGS) `find . -type f | grep "[.]o" | xargs` -o libtomcrypt_prof.a
+ ranlib libtomcrypt_prof.a
+ libtool --silent --mode=install install -c libtomcrypt_prof.la $(LIBPATH)/libtomcrypt_prof.la
diff --git a/libtomcrypt/testprof/modes_test.c b/libtomcrypt/testprof/modes_test.c
new file mode 100644
index 0000000..d394267
--- /dev/null
+++ b/libtomcrypt/testprof/modes_test.c
@@ -0,0 +1,120 @@
+/* test CFB/OFB/CBC modes */
+#include <tomcrypt_test.h>
+
+int modes_test(void)
+{
+ unsigned char pt[64], ct[64], tmp[64], key[16], iv[16], iv2[16];
+ int cipher_idx;
+ symmetric_CBC cbc;
+ symmetric_CFB cfb;
+ symmetric_OFB ofb;
+ symmetric_CTR ctr;
+ unsigned long l;
+
+ /* make a random pt, key and iv */
+ yarrow_read(pt, 64, &yarrow_prng);
+ yarrow_read(key, 16, &yarrow_prng);
+ yarrow_read(iv, 16, &yarrow_prng);
+
+ /* get idx of AES handy */
+ cipher_idx = find_cipher("aes");
+ if (cipher_idx == -1) {
+ fprintf(stderr, "test requires AES");
+ return 1;
+ }
+
+#ifdef CBC
+ /* test CBC mode */
+ /* encode the block */
+ DO(cbc_start(cipher_idx, iv, key, 16, 0, &cbc));
+ l = sizeof(iv2);
+ DO(cbc_getiv(iv2, &l, &cbc));
+ if (l != 16 || memcmp(iv2, iv, 16)) {
+ fprintf(stderr, "cbc_getiv failed");
+ return 1;
+ }
+ DO(cbc_encrypt(pt, ct, 64, &cbc));
+
+ /* decode the block */
+ DO(cbc_setiv(iv2, l, &cbc));
+ zeromem(tmp, sizeof(tmp));
+ DO(cbc_decrypt(ct, tmp, 64, &cbc));
+ if (memcmp(tmp, pt, 64) != 0) {
+ fprintf(stderr, "CBC failed");
+ return 1;
+ }
+#endif
+
+#ifdef CFB
+ /* test CFB mode */
+ /* encode the block */
+ DO(cfb_start(cipher_idx, iv, key, 16, 0, &cfb));
+ l = sizeof(iv2);
+ DO(cfb_getiv(iv2, &l, &cfb));
+ /* note we don't memcmp iv2/iv since cfb_start processes the IV for the first block */
+ if (l != 16) {
+ fprintf(stderr, "cfb_getiv failed");
+ return 1;
+ }
+ DO(cfb_encrypt(pt, ct, 64, &cfb));
+
+ /* decode the block */
+ DO(cfb_setiv(iv, l, &cfb));
+ zeromem(tmp, sizeof(tmp));
+ DO(cfb_decrypt(ct, tmp, 64, &cfb));
+ if (memcmp(tmp, pt, 64) != 0) {
+ fprintf(stderr, "CFB failed");
+ return 1;
+ }
+#endif
+
+#ifdef OFB
+ /* test OFB mode */
+ /* encode the block */
+ DO(ofb_start(cipher_idx, iv, key, 16, 0, &ofb));
+ l = sizeof(iv2);
+ DO(ofb_getiv(iv2, &l, &ofb));
+ if (l != 16 || memcmp(iv2, iv, 16)) {
+ fprintf(stderr, "ofb_getiv failed");
+ return 1;
+ }
+ DO(ofb_encrypt(pt, ct, 64, &ofb));
+
+ /* decode the block */
+ DO(ofb_setiv(iv2, l, &ofb));
+ zeromem(tmp, sizeof(tmp));
+ DO(ofb_decrypt(ct, tmp, 64, &ofb));
+ if (memcmp(tmp, pt, 64) != 0) {
+ fprintf(stderr, "OFB failed");
+ return 1;
+ }
+#endif
+
+#ifdef CTR
+ /* test CTR mode */
+ /* encode the block */
+ DO(ctr_start(cipher_idx, iv, key, 16, 0, CTR_COUNTER_LITTLE_ENDIAN, &ctr));
+ l = sizeof(iv2);
+ DO(ctr_getiv(iv2, &l, &ctr));
+ if (l != 16 || memcmp(iv2, iv, 16)) {
+ fprintf(stderr, "ctr_getiv failed");
+ return 1;
+ }
+ DO(ctr_encrypt(pt, ct, 57, &ctr));
+
+ /* decode the block */
+ DO(ctr_setiv(iv2, l, &ctr));
+ zeromem(tmp, sizeof(tmp));
+ DO(ctr_decrypt(ct, tmp, 57, &ctr));
+ if (memcmp(tmp, pt, 57) != 0) {
+ fprintf(stderr, "CTR failed");
+ return 1;
+ }
+#endif
+
+ return 0;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/modes_test.c,v $ */
+/* $Revision: 1.6 $ */
+/* $Date: 2005/05/21 12:51:25 $ */
diff --git a/libtomcrypt/testprof/pkcs_1_test.c b/libtomcrypt/testprof/pkcs_1_test.c
new file mode 100644
index 0000000..1a47d85
--- /dev/null
+++ b/libtomcrypt/testprof/pkcs_1_test.c
@@ -0,0 +1,96 @@
+#include <tomcrypt_test.h>
+
+#ifdef PKCS_1
+
+int pkcs_1_test(void)
+{
+ unsigned char buf[3][128];
+ int res1, res2, res3, prng_idx, hash_idx;
+ unsigned long x, y, l1, l2, l3, i1, i2, lparamlen, saltlen, modlen;
+ static const unsigned char lparam[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
+
+ /* get hash/prng */
+ hash_idx = find_hash("sha1");
+ prng_idx = find_prng("yarrow");
+
+ if (hash_idx == -1 || prng_idx == -1) {
+ fprintf(stderr, "pkcs_1 tests require sha1/yarrow");
+ return 1;
+ }
+
+ /* do many tests */
+ for (x = 0; x < 100; x++) {
+ zeromem(buf, sizeof(buf));
+
+ /* make a dummy message (of random length) */
+ l3 = (rand() & 31) + 8;
+ for (y = 0; y < l3; y++) buf[0][y] = rand() & 255;
+
+ /* random modulus len (v1.5 must be multiple of 8 though arbitrary sizes seem to work) */
+ modlen = 800 + 8 * (abs(rand()) % 28);
+
+ /* pick a random lparam len [0..16] */
+ lparamlen = abs(rand()) % 17;
+
+ /* pick a random saltlen 0..16 */
+ saltlen = abs(rand()) % 17;
+
+ /* PKCS #1 v2.0 supports modlens not multiple of 8 */
+ modlen = 800 + (abs(rand()) % 224);
+
+ /* encode it */
+ l1 = sizeof(buf[1]);
+ DO(pkcs_1_oaep_encode(buf[0], l3, lparam, lparamlen, modlen, &yarrow_prng, prng_idx, hash_idx, buf[1], &l1));
+
+ /* decode it */
+ l2 = sizeof(buf[2]);
+ DO(pkcs_1_oaep_decode(buf[1], l1, lparam, lparamlen, modlen, hash_idx, buf[2], &l2, &res1));
+
+ if (res1 != 1 || l2 != l3 || memcmp(buf[2], buf[0], l3) != 0) {
+ fprintf(stderr, "Outsize == %lu, should have been %lu, res1 = %d, lparamlen = %lu, msg contents follow.\n", l2, l3, res1, lparamlen);
+ fprintf(stderr, "ORIGINAL:\n");
+ for (x = 0; x < l3; x++) {
+ fprintf(stderr, "%02x ", buf[0][x]);
+ }
+ fprintf(stderr, "\nRESULT:\n");
+ for (x = 0; x < l2; x++) {
+ fprintf(stderr, "%02x ", buf[2][x]);
+ }
+ fprintf(stderr, "\n\n");
+ return 1;
+ }
+
+ /* test PSS */
+ l1 = sizeof(buf[1]);
+ DO(pkcs_1_pss_encode(buf[0], l3, saltlen, &yarrow_prng, prng_idx, hash_idx, modlen, buf[1], &l1));
+ DO(pkcs_1_pss_decode(buf[0], l3, buf[1], l1, saltlen, hash_idx, modlen, &res1));
+
+ buf[0][i1 = abs(rand()) % l3] ^= 1;
+ DO(pkcs_1_pss_decode(buf[0], l3, buf[1], l1, saltlen, hash_idx, modlen, &res2));
+
+ buf[0][i1] ^= 1;
+ buf[1][i2 = abs(rand()) % l1] ^= 1;
+ DO(pkcs_1_pss_decode(buf[0], l3, buf[1], l1, saltlen, hash_idx, modlen, &res3));
+
+ if (!(res1 == 1 && res2 == 0 && res3 == 0)) {
+ fprintf(stderr, "PSS failed: %d, %d, %d, %lu, %lu\n", res1, res2, res3, l3, saltlen);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+#else
+
+int pkcs_1_test(void)
+{
+ fprintf(stderr, "NOP");
+ return 0;
+}
+
+#endif
+
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/pkcs_1_test.c,v $ */
+/* $Revision: 1.6 $ */
+/* $Date: 2005/05/21 12:51:25 $ */
diff --git a/libtomcrypt/testprof/rsa_test.c b/libtomcrypt/testprof/rsa_test.c
new file mode 100644
index 0000000..4facdcd
--- /dev/null
+++ b/libtomcrypt/testprof/rsa_test.c
@@ -0,0 +1,338 @@
+#include <tomcrypt_test.h>
+
+#ifdef MRSA
+
+#define RSA_MSGSIZE 78
+
+/* These are test keys [see file test.key] that I use to test my import/export against */
+static const unsigned char openssl_private_rsa[] = {
+ 0x30, 0x82, 0x02, 0x5e, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xcf, 0x9a, 0xde, 0x64, 0x8a,
+ 0xda, 0xc8, 0x33, 0x20, 0xa9, 0xd7, 0x83, 0x31, 0x19, 0x54, 0xb2, 0x9a, 0x85, 0xa7, 0xa1, 0xb7,
+ 0x75, 0x33, 0xb6, 0xa9, 0xac, 0x84, 0x24, 0xb3, 0xde, 0xdb, 0x7d, 0x85, 0x2d, 0x96, 0x65, 0xe5,
+ 0x3f, 0x72, 0x95, 0x24, 0x9f, 0x28, 0x68, 0xca, 0x4f, 0xdb, 0x44, 0x1c, 0x3e, 0x60, 0x12, 0x8a,
+ 0xdd, 0x26, 0xa5, 0xeb, 0xff, 0x0b, 0x5e, 0xd4, 0x88, 0x38, 0x49, 0x2a, 0x6e, 0x5b, 0xbf, 0x12,
+ 0x37, 0x47, 0xbd, 0x05, 0x6b, 0xbc, 0xdb, 0xf3, 0xee, 0xe4, 0x11, 0x8e, 0x41, 0x68, 0x7c, 0x61,
+ 0x13, 0xd7, 0x42, 0xc8, 0x80, 0xbe, 0x36, 0x8f, 0xdc, 0x08, 0x8b, 0x4f, 0xac, 0xa4, 0xe2, 0x76,
+ 0x0c, 0xc9, 0x63, 0x6c, 0x49, 0x58, 0x93, 0xed, 0xcc, 0xaa, 0xdc, 0x25, 0x3b, 0x0a, 0x60, 0x3f,
+ 0x8b, 0x54, 0x3a, 0xc3, 0x4d, 0x31, 0xe7, 0x94, 0xa4, 0x44, 0xfd, 0x02, 0x03, 0x01, 0x00, 0x01,
+ 0x02, 0x81, 0x81, 0x00, 0xc8, 0x62, 0xb9, 0xea, 0xde, 0x44, 0x53, 0x1d, 0x56, 0x97, 0xd9, 0x97,
+ 0x9e, 0x1a, 0xcf, 0x30, 0x1e, 0x0a, 0x88, 0x45, 0x86, 0x29, 0x30, 0xa3, 0x4d, 0x9f, 0x61, 0x65,
+ 0x73, 0xe0, 0xd6, 0x87, 0x8f, 0xb6, 0xf3, 0x06, 0xa3, 0x82, 0xdc, 0x7c, 0xac, 0xfe, 0x9b, 0x28,
+ 0x9a, 0xae, 0xfd, 0xfb, 0xfe, 0x2f, 0x0e, 0xd8, 0x97, 0x04, 0xe3, 0xbb, 0x1f, 0xd1, 0xec, 0x0d,
+ 0xba, 0xa3, 0x49, 0x7f, 0x47, 0xac, 0x8a, 0x44, 0x04, 0x7e, 0x86, 0xb7, 0x39, 0x42, 0x3f, 0xad,
+ 0x1e, 0xb7, 0x0e, 0xa5, 0x51, 0xf4, 0x40, 0x63, 0x1e, 0xfd, 0xbd, 0xea, 0x9f, 0x41, 0x9f, 0xa8,
+ 0x90, 0x1d, 0x6f, 0x0a, 0x5a, 0x95, 0x13, 0x11, 0x0d, 0x80, 0xaf, 0x5f, 0x64, 0x98, 0x8a, 0x2c,
+ 0x78, 0x68, 0x65, 0xb0, 0x2b, 0x8b, 0xa2, 0x53, 0x87, 0xca, 0xf1, 0x64, 0x04, 0xab, 0xf2, 0x7b,
+ 0xdb, 0x83, 0xc8, 0x81, 0x02, 0x41, 0x00, 0xf7, 0xbe, 0x5e, 0x23, 0xc3, 0x32, 0x3f, 0xbf, 0x8b,
+ 0x8e, 0x3a, 0xee, 0xfc, 0xfc, 0xcb, 0xe5, 0xf7, 0xf1, 0x0b, 0xbc, 0x42, 0x82, 0xae, 0xd5, 0x7a,
+ 0x3e, 0xca, 0xf7, 0xd5, 0x69, 0x3f, 0x64, 0x25, 0xa2, 0x1f, 0xb7, 0x75, 0x75, 0x05, 0x92, 0x42,
+ 0xeb, 0xb8, 0xf1, 0xf3, 0x0a, 0x05, 0xe3, 0x94, 0xd1, 0x55, 0x78, 0x35, 0xa0, 0x36, 0xa0, 0x9b,
+ 0x7c, 0x92, 0x84, 0x6c, 0xdd, 0xdc, 0x4d, 0x02, 0x41, 0x00, 0xd6, 0x86, 0x0e, 0x85, 0x42, 0x0b,
+ 0x04, 0x08, 0x84, 0x21, 0x60, 0xf0, 0x0e, 0x0d, 0x88, 0xfd, 0x1e, 0x36, 0x10, 0x65, 0x4f, 0x1e,
+ 0x53, 0xb4, 0x08, 0x72, 0x80, 0x5c, 0x3f, 0x59, 0x66, 0x17, 0xe6, 0x98, 0xf2, 0xe9, 0x6c, 0x7a,
+ 0x06, 0x4c, 0xac, 0x76, 0x3d, 0xed, 0x8c, 0xa1, 0xce, 0xad, 0x1b, 0xbd, 0xb4, 0x7d, 0x28, 0xbc,
+ 0xe3, 0x0e, 0x38, 0x8d, 0x99, 0xd8, 0x05, 0xb5, 0xa3, 0x71, 0x02, 0x40, 0x6d, 0xeb, 0xc3, 0x2d,
+ 0x2e, 0xf0, 0x5e, 0xa4, 0x88, 0x31, 0x05, 0x29, 0x00, 0x8a, 0xd1, 0x95, 0x29, 0x9b, 0x83, 0xcf,
+ 0x75, 0xdb, 0x31, 0xe3, 0x7a, 0x27, 0xde, 0x3a, 0x74, 0x30, 0x0c, 0x76, 0x4c, 0xd4, 0x50, 0x2a,
+ 0x40, 0x2d, 0x39, 0xd9, 0x99, 0x63, 0xa9, 0x5d, 0x80, 0xae, 0x53, 0xca, 0x94, 0x3f, 0x05, 0x23,
+ 0x1e, 0xf8, 0x05, 0x04, 0xe1, 0xb8, 0x35, 0xf2, 0x17, 0xb3, 0xa0, 0x89, 0x02, 0x41, 0x00, 0xab,
+ 0x90, 0x88, 0xfa, 0x60, 0x08, 0x29, 0x50, 0x9a, 0x43, 0x8b, 0xa0, 0x50, 0xcc, 0xd8, 0x5a, 0xfe,
+ 0x97, 0x64, 0x63, 0x71, 0x74, 0x22, 0xa3, 0x20, 0x02, 0x5a, 0xcf, 0xeb, 0xc6, 0x16, 0x95, 0x54,
+ 0xd1, 0xcb, 0xab, 0x8d, 0x1a, 0xc6, 0x00, 0xfa, 0x08, 0x92, 0x9c, 0x71, 0xd5, 0x52, 0x52, 0x35,
+ 0x96, 0x71, 0x4b, 0x8b, 0x92, 0x0c, 0xd0, 0xe9, 0xbf, 0xad, 0x63, 0x0b, 0xa5, 0xe9, 0xb1, 0x02,
+ 0x41, 0x00, 0xdc, 0xcc, 0x27, 0xc8, 0xe4, 0xdc, 0x62, 0x48, 0xd5, 0x9b, 0xaf, 0xf5, 0xab, 0x60,
+ 0xf6, 0x21, 0xfd, 0x53, 0xe2, 0xb7, 0x5d, 0x09, 0xc9, 0x1a, 0xa1, 0x04, 0xa9, 0xfc, 0x61, 0x2c,
+ 0x5d, 0x04, 0x58, 0x3a, 0x5a, 0x39, 0xf1, 0x4a, 0x21, 0x56, 0x67, 0xfd, 0xcc, 0x20, 0xa3, 0x8f,
+ 0x78, 0x18, 0x5a, 0x79, 0x3d, 0x2e, 0x8e, 0x7e, 0x86, 0x0a, 0xe6, 0xa8, 0x33, 0xc1, 0x04, 0x17,
+ 0x4a, 0x9f, };
+
+
+/*** NOTE: OpenSSL seems to have more to their public key format. I've stripped the extra headers... */
+static const unsigned char openssl_public_rsa[] = {
+ 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xcf, 0x9a, 0xde,
+ 0x64, 0x8a, 0xda, 0xc8, 0x33, 0x20, 0xa9, 0xd7, 0x83, 0x31, 0x19, 0x54, 0xb2, 0x9a, 0x85, 0xa7,
+ 0xa1, 0xb7, 0x75, 0x33, 0xb6, 0xa9, 0xac, 0x84, 0x24, 0xb3, 0xde, 0xdb, 0x7d, 0x85, 0x2d, 0x96,
+ 0x65, 0xe5, 0x3f, 0x72, 0x95, 0x24, 0x9f, 0x28, 0x68, 0xca, 0x4f, 0xdb, 0x44, 0x1c, 0x3e, 0x60,
+ 0x12, 0x8a, 0xdd, 0x26, 0xa5, 0xeb, 0xff, 0x0b, 0x5e, 0xd4, 0x88, 0x38, 0x49, 0x2a, 0x6e, 0x5b,
+ 0xbf, 0x12, 0x37, 0x47, 0xbd, 0x05, 0x6b, 0xbc, 0xdb, 0xf3, 0xee, 0xe4, 0x11, 0x8e, 0x41, 0x68,
+ 0x7c, 0x61, 0x13, 0xd7, 0x42, 0xc8, 0x80, 0xbe, 0x36, 0x8f, 0xdc, 0x08, 0x8b, 0x4f, 0xac, 0xa4,
+ 0xe2, 0x76, 0x0c, 0xc9, 0x63, 0x6c, 0x49, 0x58, 0x93, 0xed, 0xcc, 0xaa, 0xdc, 0x25, 0x3b, 0x0a,
+ 0x60, 0x3f, 0x8b, 0x54, 0x3a, 0xc3, 0x4d, 0x31, 0xe7, 0x94, 0xa4, 0x44, 0xfd, 0x02, 0x03, 0x01,
+ 0x00, 0x01, };
+
+static int rsa_compat_test(void)
+{
+ rsa_key key;
+ unsigned char buf[1024];
+ unsigned long len;
+
+ /* try reading the key */
+ DO(rsa_import(openssl_private_rsa, sizeof(openssl_private_rsa), &key));
+
+ /* now try to export private/public and compare */
+ len = sizeof(buf);
+ DO(rsa_export(buf, &len, PK_PRIVATE, &key));
+ if (len != sizeof(openssl_private_rsa) || memcmp(buf, openssl_private_rsa, len)) {
+ fprintf(stderr, "RSA private export failed to match OpenSSL output, %lu, %lu\n", len, sizeof(openssl_private_rsa));
+
+
+{
+int x;
+printf("\n\n");
+for (x = 0; x < len; ) { if (buf[x] == openssl_private_rsa[x]) printf("-- "); else printf("%02x ", buf[x]^openssl_private_rsa[x]); if (!(++x & 15)) printf("\n"); }
+}
+printf("\n\n");
+
+ return 1;
+ }
+
+ len = sizeof(buf);
+ DO(rsa_export(buf, &len, PK_PUBLIC, &key));
+ if (len != sizeof(openssl_public_rsa) || memcmp(buf, openssl_public_rsa, len)) {
+ fprintf(stderr, "RSA(private) public export failed to match OpenSSL output\n");
+ return 1;
+ }
+ rsa_free(&key);
+
+ /* try reading the public key */
+ DO(rsa_import(openssl_public_rsa, sizeof(openssl_public_rsa), &key));
+ len = sizeof(buf);
+ DO(rsa_export(buf, &len, PK_PUBLIC, &key));
+ if (len != sizeof(openssl_public_rsa) || memcmp(buf, openssl_public_rsa, len)) {
+ fprintf(stderr, "RSA(public) public export failed to match OpenSSL output\n");
+ return 1;
+ }
+ rsa_free(&key);
+
+ return 0;
+}
+
+int rsa_test(void)
+{
+ unsigned char in[1024], out[1024], tmp[1024];
+ rsa_key key, privKey, pubKey;
+ int hash_idx, prng_idx, stat, stat2;
+ unsigned long rsa_msgsize, len, len2, cnt;
+ static unsigned char lparam[] = { 0x01, 0x02, 0x03, 0x04 };
+
+ if (rsa_compat_test() != 0) {
+ return 1;
+ }
+
+ hash_idx = find_hash("sha1");
+ prng_idx = find_prng("yarrow");
+ if (hash_idx == -1 || prng_idx == -1) {
+ fprintf(stderr, "rsa_test requires SHA1 and yarrow");
+ return 1;
+ }
+
+ /* make 10 random key */
+ for (cnt = 0; cnt < 10; cnt++) {
+ DO(rsa_make_key(&yarrow_prng, prng_idx, 1024/8, 65537, &key));
+ if (mp_count_bits(&key.N) != 1024) {
+ fprintf(stderr, "rsa_1024 key modulus has %d bits\n", mp_count_bits(&key.N));
+
+len = mp_unsigned_bin_size(&key.N);
+mp_to_unsigned_bin(&key.N, tmp);
+ fprintf(stderr, "N == \n");
+for (cnt = 0; cnt < len; ) {
+ fprintf(stderr, "%02x ", tmp[cnt]);
+ if (!(++cnt & 15)) fprintf(stderr, "\n");
+}
+
+len = mp_unsigned_bin_size(&key.p);
+mp_to_unsigned_bin(&key.p, tmp);
+ fprintf(stderr, "p == \n");
+for (cnt = 0; cnt < len; ) {
+ fprintf(stderr, "%02x ", tmp[cnt]);
+ if (!(++cnt & 15)) fprintf(stderr, "\n");
+}
+
+len = mp_unsigned_bin_size(&key.q);
+mp_to_unsigned_bin(&key.q, tmp);
+ fprintf(stderr, "\nq == \n");
+for (cnt = 0; cnt < len; ) {
+ fprintf(stderr, "%02x ", tmp[cnt]);
+ if (!(++cnt & 15)) fprintf(stderr, "\n");
+}
+ fprintf(stderr, "\n");
+
+
+ return 1;
+ }
+ if (cnt != 9) {
+ rsa_free(&key);
+ }
+ }
+
+ /* encrypt the key (without lparam) */
+ for (cnt = 0; cnt < 4; cnt++) {
+ for (rsa_msgsize = 1; rsa_msgsize <= 86; rsa_msgsize++) {
+ /* make a random key/msg */
+ yarrow_read(in, rsa_msgsize, &yarrow_prng);
+
+ len = sizeof(out);
+ len2 = rsa_msgsize;
+
+ DO(rsa_encrypt_key(in, rsa_msgsize, out, &len, NULL, 0, &yarrow_prng, prng_idx, hash_idx, &key));
+ /* change a byte */
+ out[8] ^= 1;
+ DO(rsa_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat2, &key));
+ /* change a byte back */
+ out[8] ^= 1;
+ if (len2 != rsa_msgsize) {
+ fprintf(stderr, "\nrsa_decrypt_key mismatch len %lu (first decrypt)", len2);
+ return 1;
+ }
+
+ len2 = rsa_msgsize;
+ DO(rsa_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat, &key));
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "rsa_decrypt_key failed");
+ return 1;
+ }
+ if (len2 != rsa_msgsize || memcmp(tmp, in, rsa_msgsize)) {
+ unsigned long x;
+ fprintf(stderr, "\nrsa_decrypt_key mismatch, len %lu (second decrypt)\n", len2);
+ fprintf(stderr, "Original contents: \n");
+ for (x = 0; x < rsa_msgsize; ) {
+ fprintf(stderr, "%02x ", in[x]);
+ if (!(++x % 16)) {
+ fprintf(stderr, "\n");
+ }
+ }
+ fprintf(stderr, "\n");
+ fprintf(stderr, "Output contents: \n");
+ for (x = 0; x < rsa_msgsize; ) {
+ fprintf(stderr, "%02x ", out[x]);
+ if (!(++x % 16)) {
+ fprintf(stderr, "\n");
+ }
+ }
+ fprintf(stderr, "\n");
+ return 1;
+ }
+ }
+ }
+
+ /* encrypt the key (with lparam) */
+ for (rsa_msgsize = 1; rsa_msgsize <= 86; rsa_msgsize++) {
+ len = sizeof(out);
+ len2 = rsa_msgsize;
+ DO(rsa_encrypt_key(in, rsa_msgsize, out, &len, lparam, sizeof(lparam), &yarrow_prng, prng_idx, hash_idx, &key));
+ /* change a byte */
+ out[8] ^= 1;
+ DO(rsa_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat2, &key));
+ if (len2 != rsa_msgsize) {
+ fprintf(stderr, "\nrsa_decrypt_key mismatch len %lu (first decrypt)", len2);
+ return 1;
+ }
+ /* change a byte back */
+ out[8] ^= 1;
+
+ len2 = rsa_msgsize;
+ DO(rsa_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat, &key));
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "rsa_decrypt_key failed");
+ return 1;
+ }
+ if (len2 != rsa_msgsize || memcmp(tmp, in, rsa_msgsize)) {
+ fprintf(stderr, "rsa_decrypt_key mismatch len %lu", len2);
+ return 1;
+ }
+ }
+
+ /* sign a message (unsalted, lower cholestorol and Atkins approved) now */
+ len = sizeof(out);
+ DO(rsa_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 0, &key));
+
+/* export key and import as both private and public */
+ len2 = sizeof(tmp);
+ DO(rsa_export(tmp, &len2, PK_PRIVATE, &key));
+ DO(rsa_import(tmp, len2, &privKey));
+ len2 = sizeof(tmp);
+ DO(rsa_export(tmp, &len2, PK_PUBLIC, &key));
+ DO(rsa_import(tmp, len2, &pubKey));
+
+ /* verify with original */
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &key));
+ /* change a byte */
+ in[0] ^= 1;
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &key));
+
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "rsa_verify_hash (unsalted, origKey) failed, %d, %d", stat, stat2);
+ rsa_free(&key);
+ rsa_free(&pubKey);
+ rsa_free(&privKey);
+ return 1;
+ }
+
+ /* verify with privKey */
+ /* change a byte */
+ in[0] ^= 1;
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &privKey));
+ /* change a byte */
+ in[0] ^= 1;
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &privKey));
+
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "rsa_verify_hash (unsalted, privKey) failed, %d, %d", stat, stat2);
+ rsa_free(&key);
+ rsa_free(&pubKey);
+ rsa_free(&privKey);
+ return 1;
+ }
+
+ /* verify with pubKey */
+ /* change a byte */
+ in[0] ^= 1;
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &pubKey));
+ /* change a byte */
+ in[0] ^= 1;
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &pubKey));
+
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "rsa_verify_hash (unsalted, pubkey) failed, %d, %d", stat, stat2);
+ rsa_free(&key);
+ rsa_free(&pubKey);
+ rsa_free(&privKey);
+ return 1;
+ }
+
+ /* sign a message (salted) now (use privKey to make, pubKey to verify) */
+ len = sizeof(out);
+ DO(rsa_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 8, &privKey));
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 8, &stat, &pubKey));
+ /* change a byte */
+ in[0] ^= 1;
+ DO(rsa_verify_hash(out, len, in, 20, hash_idx, 8, &stat2, &pubKey));
+
+ if (!(stat == 1 && stat2 == 0)) {
+ fprintf(stderr, "rsa_verify_hash (salted) failed, %d, %d", stat, stat2);
+ rsa_free(&key);
+ rsa_free(&pubKey);
+ rsa_free(&privKey);
+ return 1;
+ }
+
+ /* free the key and return */
+ rsa_free(&key);
+ rsa_free(&pubKey);
+ rsa_free(&privKey);
+ return 0;
+}
+
+#else
+
+int rsa_test(void)
+{
+ fprintf(stderr, "NOP");
+ return 0;
+}
+
+#endif
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/rsa_test.c,v $ */
+/* $Revision: 1.10 $ */
+/* $Date: 2005/06/03 19:18:33 $ */
diff --git a/libtomcrypt/testprof/store_test.c b/libtomcrypt/testprof/store_test.c
new file mode 100644
index 0000000..5a38d65
--- /dev/null
+++ b/libtomcrypt/testprof/store_test.c
@@ -0,0 +1,78 @@
+#include <tomcrypt_test.h>
+
+/* Test store/load macros with offsets */
+int store_test(void)
+{
+ unsigned char buf[256];
+ int y;
+ ulong32 L, L1;
+ ulong64 LL, LL1;
+#ifdef LTC_FAST
+ int x, z;
+#endif
+
+ for (y = 0; y < 4; y++) {
+ L = 0x12345678UL;
+ L1 = 0;
+ STORE32L(L, buf + y);
+ LOAD32L(L1, buf + y);
+ if (L1 != L) {
+ fprintf(stderr, "\n32L failed at offset %d\n", y);
+ return 1;
+ }
+ STORE32H(L, buf + y);
+ LOAD32H(L1, buf + y);
+ if (L1 != L) {
+ fprintf(stderr, "\n32H failed at offset %d\n", y);
+ return 1;
+ }
+ }
+
+ for (y = 0; y < 8; y++) {
+ LL = CONST64 (0x01020304050607);
+ LL1 = 0;
+ STORE64L(LL, buf + y);
+ LOAD64L(LL1, buf + y);
+ if (LL1 != LL) {
+ fprintf(stderr, "\n64L failed at offset %d\n", y);
+ return 1;
+ }
+ STORE64H(LL, buf + y);
+ LOAD64H(LL1, buf + y);
+ if (LL1 != LL) {
+ fprintf(stderr, "\n64H failed at offset %d\n", y);
+ return 1;
+ }
+ }
+
+/* test LTC_FAST */
+#ifdef LTC_FAST
+ y = 16;
+
+ for (z = 0; z < y; z++) {
+ /* fill y bytes with random */
+ yarrow_read(buf+z, y, &yarrow_prng);
+ yarrow_read(buf+z+y, y, &yarrow_prng);
+
+ /* now XOR it byte for byte */
+ for (x = 0; x < y; x++) {
+ buf[2*y+z+x] = buf[z+x] ^ buf[z+y+x];
+ }
+
+ /* now XOR it word for word */
+ for (x = 0; x < y; x += sizeof(LTC_FAST_TYPE)) {
+ *((LTC_FAST_TYPE*)(&buf[3*y+z+x])) = *((LTC_FAST_TYPE*)(&buf[z+x])) ^ *((LTC_FAST_TYPE*)(&buf[z+y+x]));
+ }
+
+ if (memcmp(&buf[2*y+z], &buf[3*y+z], y)) {
+ fprintf(stderr, "\nLTC_FAST failed at offset %d\n", z);
+ return 1;
+ }
+ }
+#endif
+ return 0;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/store_test.c,v $ */
+/* $Revision: 1.6 $ */
+/* $Date: 2005/05/05 14:35:59 $ */
diff --git a/libtomcrypt/testprof/test.c b/libtomcrypt/testprof/test.c
new file mode 100644
index 0000000..5a38421
--- /dev/null
+++ b/libtomcrypt/testprof/test.c
@@ -0,0 +1,13 @@
+#include <tomcrypt_test.h>
+
+void run_cmd(int res, int line, char *file, char *cmd)
+{
+ if (res != CRYPT_OK) {
+ fprintf(stderr, "%s (%d)\n%s:%d:%s\n", error_to_string(res), res, file, line, cmd);
+ exit(EXIT_FAILURE);
+ }
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/test.c,v $ */
+/* $Revision: 1.6 $ */
+/* $Date: 2005/05/05 14:35:59 $ */
diff --git a/libtomcrypt/testprof/test.key b/libtomcrypt/testprof/test.key
new file mode 100644
index 0000000..e4996c3
--- /dev/null
+++ b/libtomcrypt/testprof/test.key
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQDPmt5kitrIMyCp14MxGVSymoWnobd1M7aprIQks97bfYUtlmXl
+P3KVJJ8oaMpP20QcPmASit0mpev/C17UiDhJKm5bvxI3R70Fa7zb8+7kEY5BaHxh
+E9dCyIC+No/cCItPrKTidgzJY2xJWJPtzKrcJTsKYD+LVDrDTTHnlKRE/QIDAQAB
+AoGBAMhiuereRFMdVpfZl54azzAeCohFhikwo02fYWVz4NaHj7bzBqOC3Hys/pso
+mq79+/4vDtiXBOO7H9HsDbqjSX9HrIpEBH6GtzlCP60etw6lUfRAYx79veqfQZ+o
+kB1vClqVExENgK9fZJiKLHhoZbAri6JTh8rxZASr8nvbg8iBAkEA975eI8MyP7+L
+jjru/PzL5ffxC7xCgq7Vej7K99VpP2Qloh+3dXUFkkLruPHzCgXjlNFVeDWgNqCb
+fJKEbN3cTQJBANaGDoVCCwQIhCFg8A4NiP0eNhBlTx5TtAhygFw/WWYX5pjy6Wx6
+Bkysdj3tjKHOrRu9tH0ovOMOOI2Z2AW1o3ECQG3rwy0u8F6kiDEFKQCK0ZUpm4PP
+ddsx43on3jp0MAx2TNRQKkAtOdmZY6ldgK5TypQ/BSMe+AUE4bg18hezoIkCQQCr
+kIj6YAgpUJpDi6BQzNha/pdkY3F0IqMgAlrP68YWlVTRy6uNGsYA+giSnHHVUlI1
+lnFLi5IM0Om/rWMLpemxAkEA3MwnyOTcYkjVm6/1q2D2If1T4rddCckaoQSp/GEs
+XQRYOlo58UohVmf9zCCjj3gYWnk9Lo5+hgrmqDPBBBdKnw==
+-----END RSA PRIVATE KEY-----
diff --git a/libtomcrypt/testprof/tomcrypt_test.h b/libtomcrypt/testprof/tomcrypt_test.h
new file mode 100644
index 0000000..2c66bad
--- /dev/null
+++ b/libtomcrypt/testprof/tomcrypt_test.h
@@ -0,0 +1,77 @@
+
+#ifndef __TEST_H_
+#define __TEST_H_
+
+#include <tomcrypt.h>
+
+/* enable stack testing */
+// #define STACK_TEST
+
+/* stack testing, define this if stack usage goes downwards [e.g. x86] */
+#define STACK_DOWN
+
+typedef struct {
+ char *name, *prov, *req;
+ int (*entry)(void);
+} test_entry;
+
+extern prng_state yarrow_prng;
+
+void run_cmd(int res, int line, char *file, char *cmd);
+#define DO(x) { run_cmd((x), __LINE__, __FILE__, #x); }
+
+/* TESTS */
+int cipher_hash_test(void);
+int modes_test(void);
+int mac_test(void);
+int pkcs_1_test(void);
+int store_test(void);
+int rsa_test(void);
+int ecc_tests(void);
+int dsa_test(void);
+int dh_tests(void);
+int der_tests(void);
+
+/* timing */
+#define KTIMES 25
+#define TIMES 100000
+
+extern struct list {
+ int id;
+ unsigned long spd1, spd2, avg;
+} results[];
+
+extern int no_results;
+
+int sorter(const void *a, const void *b);
+void tally_results(int type);
+ulong64 rdtsc (void);
+
+void t_start(void);
+ulong64 t_read(void);
+void init_timer(void);
+
+/* register default algs */
+void reg_algs(void);
+int time_keysched(void);
+int time_cipher(void);
+int time_cipher2(void);
+int time_cipher3(void);
+int time_hash(void);
+void time_mult(void);
+void time_sqr(void);
+void time_prng(void);
+void time_rsa(void);
+void time_ecc(void);
+void time_dh(void);
+void time_macs_(unsigned long MAC_SIZE);
+void time_macs(void);
+void time_encmacs(void);
+
+
+
+#endif
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/tomcrypt_test.h,v $ */
+/* $Revision: 1.8 $ */
+/* $Date: 2005/05/05 14:35:59 $ */
diff --git a/libtomcrypt/testprof/x86_prof.c b/libtomcrypt/testprof/x86_prof.c
new file mode 100644
index 0000000..997180c
--- /dev/null
+++ b/libtomcrypt/testprof/x86_prof.c
@@ -0,0 +1,1050 @@
+#include <tomcrypt_test.h>
+
+prng_state yarrow_prng;
+
+struct list results[100];
+int no_results;
+int sorter(const void *a, const void *b)
+{
+ const struct list *A, *B;
+ A = a;
+ B = b;
+ if (A->avg < B->avg) return -1;
+ if (A->avg > B->avg) return 1;
+ return 0;
+}
+
+void tally_results(int type)
+{
+ int x;
+
+ // qsort the results
+ qsort(results, no_results, sizeof(struct list), &sorter);
+
+ fprintf(stderr, "\n");
+ if (type == 0) {
+ for (x = 0; x < no_results; x++) {
+ fprintf(stderr, "%-20s: Schedule at %6lu\n", cipher_descriptor[results[x].id].name, (unsigned long)results[x].spd1);
+ }
+ } else if (type == 1) {
+ for (x = 0; x < no_results; x++) {
+ printf
+ ("%-20s[%3d]: Encrypt at %5lu, Decrypt at %5lu\n", cipher_descriptor[results[x].id].name, cipher_descriptor[results[x].id].ID, results[x].spd1, results[x].spd2);
+ }
+ } else {
+ for (x = 0; x < no_results; x++) {
+ printf
+ ("%-20s: Process at %5lu\n", hash_descriptor[results[x].id].name, results[x].spd1 / 1000);
+ }
+ }
+}
+
+/* RDTSC from Scott Duplichan */
+ulong64 rdtsc (void)
+ {
+ #if defined __GNUC__ && !defined(LTC_NO_ASM)
+ #ifdef INTEL_CC
+ ulong64 a;
+ asm ( " rdtsc ":"=A"(a));
+ return a;
+ #elif defined(__i386__) || defined(__x86_64__)
+ ulong64 a;
+ asm __volatile__ ("rdtsc\nmovl %%eax,(%0)\nmovl %%edx,4(%0)\n"::"r"(&a):"%eax","%edx");
+ return a;
+ #elif defined(__ia64__) /* gcc-IA64 version */
+ unsigned long result;
+ __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
+ while (__builtin_expect ((int) result == -1, 0))
+ __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
+ return result;
+ #else
+ return XCLOCK();
+ #endif
+
+ // Microsoft and Intel Windows compilers
+ #elif defined _M_IX86 && !defined(LTC_NO_ASM)
+ __asm rdtsc
+ #elif defined _M_AMD64 && !defined(LTC_NO_ASM)
+ return __rdtsc ();
+ #elif defined _M_IA64 && !defined(LTC_NO_ASM)
+ #if defined __INTEL_COMPILER
+ #include <ia64intrin.h>
+ #endif
+ return __getReg (3116);
+ #else
+ return XCLOCK();
+ #endif
+ }
+
+static ulong64 timer, skew = 0;
+
+void t_start(void)
+{
+ timer = rdtsc();
+}
+
+ulong64 t_read(void)
+{
+ return rdtsc() - timer;
+}
+
+void init_timer(void)
+{
+ ulong64 c1, c2, t1, t2, t3;
+ unsigned long y1;
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < TIMES*100; y1++) {
+ t_start();
+ t1 = t_read();
+ t3 = t_read();
+ t2 = (t_read() - t1)>>1;
+
+ c1 = (t1 > c1) ? t1 : c1;
+ c2 = (t2 > c2) ? t2 : c2;
+ }
+ skew = c2 - c1;
+ fprintf(stderr, "Clock Skew: %lu\n", (unsigned long)skew);
+}
+
+void reg_algs(void)
+{
+ int err;
+#ifdef RIJNDAEL
+ register_cipher (&aes_desc);
+#endif
+#ifdef BLOWFISH
+ register_cipher (&blowfish_desc);
+#endif
+#ifdef XTEA
+ register_cipher (&xtea_desc);
+#endif
+#ifdef RC5
+ register_cipher (&rc5_desc);
+#endif
+#ifdef RC6
+ register_cipher (&rc6_desc);
+#endif
+#ifdef SAFERP
+ register_cipher (&saferp_desc);
+#endif
+#ifdef TWOFISH
+ register_cipher (&twofish_desc);
+#endif
+#ifdef SAFER
+ register_cipher (&safer_k64_desc);
+ register_cipher (&safer_sk64_desc);
+ register_cipher (&safer_k128_desc);
+ register_cipher (&safer_sk128_desc);
+#endif
+#ifdef RC2
+ register_cipher (&rc2_desc);
+#endif
+#ifdef DES
+ register_cipher (&des_desc);
+ register_cipher (&des3_desc);
+#endif
+#ifdef CAST5
+ register_cipher (&cast5_desc);
+#endif
+#ifdef NOEKEON
+ register_cipher (&noekeon_desc);
+#endif
+#ifdef SKIPJACK
+ register_cipher (&skipjack_desc);
+#endif
+#ifdef KHAZAD
+ register_cipher (&khazad_desc);
+#endif
+#ifdef ANUBIS
+ register_cipher (&anubis_desc);
+#endif
+
+#ifdef TIGER
+ register_hash (&tiger_desc);
+#endif
+#ifdef MD2
+ register_hash (&md2_desc);
+#endif
+#ifdef MD4
+ register_hash (&md4_desc);
+#endif
+#ifdef MD5
+ register_hash (&md5_desc);
+#endif
+#ifdef SHA1
+ register_hash (&sha1_desc);
+#endif
+#ifdef SHA224
+ register_hash (&sha224_desc);
+#endif
+#ifdef SHA256
+ register_hash (&sha256_desc);
+#endif
+#ifdef SHA384
+ register_hash (&sha384_desc);
+#endif
+#ifdef SHA512
+ register_hash (&sha512_desc);
+#endif
+#ifdef RIPEMD128
+ register_hash (&rmd128_desc);
+#endif
+#ifdef RIPEMD160
+ register_hash (&rmd160_desc);
+#endif
+#ifdef WHIRLPOOL
+ register_hash (&whirlpool_desc);
+#endif
+#ifdef CHC_HASH
+ register_hash(&chc_desc);
+ if ((err = chc_register(register_cipher(&aes_desc))) != CRYPT_OK) {
+ fprintf(stderr, "chc_register error: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+#endif
+
+
+#ifndef YARROW
+ #error This demo requires Yarrow.
+#endif
+register_prng(&yarrow_desc);
+#ifdef FORTUNA
+register_prng(&fortuna_desc);
+#endif
+#ifdef RC4
+register_prng(&rc4_desc);
+#endif
+#ifdef SOBER128
+register_prng(&sober128_desc);
+#endif
+
+rng_make_prng(128, find_prng("yarrow"), &yarrow_prng, NULL);
+}
+
+int time_keysched(void)
+{
+ unsigned long x, y1;
+ ulong64 t1, c1;
+ symmetric_key skey;
+ int kl;
+ int (*func) (const unsigned char *, int , int , symmetric_key *);
+ unsigned char key[MAXBLOCKSIZE];
+
+ fprintf(stderr, "\n\nKey Schedule Time Trials for the Symmetric Ciphers:\n(Times are cycles per key)\n");
+ no_results = 0;
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+#define DO1(k) func(k, kl, 0, &skey);
+
+ func = cipher_descriptor[x].setup;
+ kl = cipher_descriptor[x].min_key_length;
+ c1 = (ulong64)-1;
+ for (y1 = 0; y1 < KTIMES; y1++) {
+ yarrow_read(key, kl, &yarrow_prng);
+ t_start();
+ DO1(key);
+ t1 = t_read();
+ c1 = (t1 > c1) ? c1 : t1;
+ }
+ t1 = c1 - skew;
+ results[no_results].spd1 = results[no_results].avg = t1;
+ results[no_results++].id = x;
+ fprintf(stderr, "."); fflush(stdout);
+
+#undef DO1
+ }
+ tally_results(0);
+
+ return 0;
+}
+
+int time_cipher(void)
+{
+ unsigned long x, y1;
+ ulong64 t1, t2, c1, c2, a1, a2;
+ symmetric_ECB ecb;
+ unsigned char key[MAXBLOCKSIZE], pt[4096];
+ int err;
+
+ fprintf(stderr, "\n\nECB Time Trials for the Symmetric Ciphers:\n");
+ no_results = 0;
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ ecb_start(x, key, cipher_descriptor[x].min_key_length, 0, &ecb);
+
+ /* sanity check on cipher */
+ if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
+ fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+
+#define DO1 ecb_encrypt(pt, pt, sizeof(pt), &ecb);
+#define DO2 DO1 DO1
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < 100; y1++) {
+ t_start();
+ DO1;
+ t1 = t_read();
+ DO2;
+ t2 = t_read();
+ t2 -= t1;
+
+ c1 = (t1 > c1 ? c1 : t1);
+ c2 = (t2 > c2 ? c2 : t2);
+ }
+ a1 = c2 - c1 - skew;
+
+#undef DO1
+#undef DO2
+#define DO1 ecb_decrypt(pt, pt, sizeof(pt), &ecb);
+#define DO2 DO1 DO1
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < 100; y1++) {
+ t_start();
+ DO1;
+ t1 = t_read();
+ DO2;
+ t2 = t_read();
+ t2 -= t1;
+
+ c1 = (t1 > c1 ? c1 : t1);
+ c2 = (t2 > c2 ? c2 : t2);
+ }
+ a2 = c2 - c1 - skew;
+
+ results[no_results].id = x;
+ results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
+ results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
+ results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
+ ++no_results;
+ fprintf(stderr, "."); fflush(stdout);
+
+#undef DO2
+#undef DO1
+ }
+ tally_results(1);
+
+ return 0;
+}
+
+#ifdef CBC
+int time_cipher2(void)
+{
+ unsigned long x, y1;
+ ulong64 t1, t2, c1, c2, a1, a2;
+ symmetric_CBC cbc;
+ unsigned char key[MAXBLOCKSIZE], pt[4096];
+ int err;
+
+ fprintf(stderr, "\n\nCBC Time Trials for the Symmetric Ciphers:\n");
+ no_results = 0;
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ cbc_start(x, pt, key, cipher_descriptor[x].min_key_length, 0, &cbc);
+
+ /* sanity check on cipher */
+ if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
+ fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+
+#define DO1 cbc_encrypt(pt, pt, sizeof(pt), &cbc);
+#define DO2 DO1 DO1
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < 100; y1++) {
+ t_start();
+ DO1;
+ t1 = t_read();
+ DO2;
+ t2 = t_read();
+ t2 -= t1;
+
+ c1 = (t1 > c1 ? c1 : t1);
+ c2 = (t2 > c2 ? c2 : t2);
+ }
+ a1 = c2 - c1 - skew;
+
+#undef DO1
+#undef DO2
+#define DO1 cbc_decrypt(pt, pt, sizeof(pt), &cbc);
+#define DO2 DO1 DO1
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < 100; y1++) {
+ t_start();
+ DO1;
+ t1 = t_read();
+ DO2;
+ t2 = t_read();
+ t2 -= t1;
+
+ c1 = (t1 > c1 ? c1 : t1);
+ c2 = (t2 > c2 ? c2 : t2);
+ }
+ a2 = c2 - c1 - skew;
+
+ results[no_results].id = x;
+ results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
+ results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
+ results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
+ ++no_results;
+ fprintf(stderr, "."); fflush(stdout);
+
+#undef DO2
+#undef DO1
+ }
+ tally_results(1);
+
+ return 0;
+}
+#else
+int time_cipher2(void) { fprintf(stderr, "NO CBC\n"); return 0; }
+#endif
+
+#ifdef CTR
+int time_cipher3(void)
+{
+ unsigned long x, y1;
+ ulong64 t1, t2, c1, c2, a1, a2;
+ symmetric_CTR ctr;
+ unsigned char key[MAXBLOCKSIZE], pt[4096];
+ int err;
+
+ fprintf(stderr, "\n\nCTR Time Trials for the Symmetric Ciphers:\n");
+ no_results = 0;
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ ctr_start(x, pt, key, cipher_descriptor[x].min_key_length, 0, CTR_COUNTER_LITTLE_ENDIAN, &ctr);
+
+ /* sanity check on cipher */
+ if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
+ fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+
+#define DO1 ctr_encrypt(pt, pt, sizeof(pt), &ctr);
+#define DO2 DO1 DO1
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < 100; y1++) {
+ t_start();
+ DO1;
+ t1 = t_read();
+ DO2;
+ t2 = t_read();
+ t2 -= t1;
+
+ c1 = (t1 > c1 ? c1 : t1);
+ c2 = (t2 > c2 ? c2 : t2);
+ }
+ a1 = c2 - c1 - skew;
+
+#undef DO1
+#undef DO2
+#define DO1 ctr_decrypt(pt, pt, sizeof(pt), &ctr);
+#define DO2 DO1 DO1
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < 100; y1++) {
+ t_start();
+ DO1;
+ t1 = t_read();
+ DO2;
+ t2 = t_read();
+ t2 -= t1;
+
+ c1 = (t1 > c1 ? c1 : t1);
+ c2 = (t2 > c2 ? c2 : t2);
+ }
+ a2 = c2 - c1 - skew;
+
+ results[no_results].id = x;
+ results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
+ results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
+ results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
+ ++no_results;
+ fprintf(stderr, "."); fflush(stdout);
+
+#undef DO2
+#undef DO1
+ }
+ tally_results(1);
+
+ return 0;
+}
+#else
+int time_cipher3(void) { fprintf(stderr, "NO CTR\n"); return 0; }
+#endif
+
+int time_hash(void)
+{
+ unsigned long x, y1, len;
+ ulong64 t1, t2, c1, c2;
+ hash_state md;
+ int (*func)(hash_state *, const unsigned char *, unsigned long), err;
+ unsigned char pt[MAXBLOCKSIZE];
+
+
+ fprintf(stderr, "\n\nHASH Time Trials for:\n");
+ no_results = 0;
+ for (x = 0; hash_descriptor[x].name != NULL; x++) {
+
+ /* sanity check on hash */
+ if ((err = hash_descriptor[x].test()) != CRYPT_OK) {
+ fprintf(stderr, "\n\nERROR: Hash %s failed self-test %s\n", hash_descriptor[x].name, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+
+ hash_descriptor[x].init(&md);
+
+#define DO1 func(&md,pt,len);
+#define DO2 DO1 DO1
+
+ func = hash_descriptor[x].process;
+ len = hash_descriptor[x].blocksize;
+
+ c1 = c2 = (ulong64)-1;
+ for (y1 = 0; y1 < TIMES; y1++) {
+ t_start();
+ DO1;
+ t1 = t_read();
+ DO2;
+ t2 = t_read() - t1;
+ c1 = (t1 > c1) ? c1 : t1;
+ c2 = (t2 > c2) ? c2 : t2;
+ }
+ t1 = c2 - c1 - skew;
+ t1 = ((t1 * CONST64(1000))) / ((ulong64)hash_descriptor[x].blocksize);
+ results[no_results].id = x;
+ results[no_results].spd1 = results[no_results].avg = t1;
+ ++no_results;
+ fprintf(stderr, "."); fflush(stdout);
+#undef DO2
+#undef DO1
+ }
+ tally_results(2);
+
+ return 0;
+}
+
+#ifdef MPI
+void time_mult(void)
+{
+ ulong64 t1, t2;
+ unsigned long x, y;
+ mp_int a, b, c;
+
+ fprintf(stderr, "Timing Multiplying:\n");
+ mp_init_multi(&a,&b,&c,NULL);
+ for (x = 128/DIGIT_BIT; x <= 1536/DIGIT_BIT; x += 128/DIGIT_BIT) {
+ mp_rand(&a, x);
+ mp_rand(&b, x);
+
+#define DO1 mp_mul(&a, &b, &c);
+#define DO2 DO1; DO1;
+
+ t2 = -1;
+ for (y = 0; y < TIMES; y++) {
+ t_start();
+ t1 = t_read();
+ DO2;
+ t1 = (t_read() - t1)>>1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "%4lu bits: %9llu cycles\n", x*DIGIT_BIT, t2);
+ }
+ mp_clear_multi(&a,&b,&c,NULL);
+
+#undef DO1
+#undef DO2
+}
+
+void time_sqr(void)
+{
+ ulong64 t1, t2;
+ unsigned long x, y;
+ mp_int a, b;
+
+ fprintf(stderr, "Timing Squaring:\n");
+ mp_init_multi(&a,&b,NULL);
+ for (x = 128/DIGIT_BIT; x <= 1536/DIGIT_BIT; x += 128/DIGIT_BIT) {
+ mp_rand(&a, x);
+
+#define DO1 mp_sqr(&a, &b);
+#define DO2 DO1; DO1;
+
+ t2 = -1;
+ for (y = 0; y < TIMES; y++) {
+ t_start();
+ t1 = t_read();
+ DO2;
+ t1 = (t_read() - t1)>>1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "%4lu bits: %9llu cycles\n", x*DIGIT_BIT, t2);
+ }
+ mp_clear_multi(&a,&b,NULL);
+
+#undef DO1
+#undef DO2
+}
+#else
+void time_mult(void) { fprintf(stderr, "NO MULT\n"); }
+void time_sqr(void) { fprintf(stderr, "NO SQR\n"); }
+#endif
+
+void time_prng(void)
+{
+ ulong64 t1, t2;
+ unsigned char buf[4096];
+ prng_state tprng;
+ unsigned long x, y;
+ int err;
+
+ fprintf(stderr, "Timing PRNGs (cycles/byte output, cycles add_entropy (32 bytes) :\n");
+ for (x = 0; prng_descriptor[x].name != NULL; x++) {
+
+ /* sanity check on prng */
+ if ((err = prng_descriptor[x].test()) != CRYPT_OK) {
+ fprintf(stderr, "\n\nERROR: PRNG %s failed self-test %s\n", prng_descriptor[x].name, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+
+ prng_descriptor[x].start(&tprng);
+ zeromem(buf, 256);
+ prng_descriptor[x].add_entropy(buf, 256, &tprng);
+ prng_descriptor[x].ready(&tprng);
+ t2 = -1;
+
+#define DO1 if (prng_descriptor[x].read(buf, 4096, &tprng) != 4096) { fprintf(stderr, "\n\nERROR READ != 4096\n\n"); exit(EXIT_FAILURE); }
+#define DO2 DO1 DO1
+ for (y = 0; y < 10000; y++) {
+ t_start();
+ t1 = t_read();
+ DO2;
+ t1 = (t_read() - t1)>>1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "%20s: %5llu ", prng_descriptor[x].name, t2>>12);
+#undef DO2
+#undef DO1
+
+#define DO1 prng_descriptor[x].start(&tprng); prng_descriptor[x].add_entropy(buf, 32, &tprng); prng_descriptor[x].ready(&tprng); prng_descriptor[x].done(&tprng);
+#define DO2 DO1 DO1
+ for (y = 0; y < 10000; y++) {
+ t_start();
+ t1 = t_read();
+ DO2;
+ t1 = (t_read() - t1)>>1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "%5llu\n", t2);
+#undef DO2
+#undef DO1
+
+ }
+}
+
+#ifdef MRSA
+/* time various RSA operations */
+void time_rsa(void)
+{
+ rsa_key key;
+ ulong64 t1, t2;
+ unsigned char buf[2][4096];
+ unsigned long x, y, z, zzz;
+ int err, zz;
+
+ for (x = 1024; x <= 2048; x += 512) {
+ t2 = 0;
+ for (y = 0; y < 16; y++) {
+ t_start();
+ t1 = t_read();
+ if ((err = rsa_make_key(&yarrow_prng, find_prng("yarrow"), x/8, 65537, &key)) != CRYPT_OK) {
+ fprintf(stderr, "\n\nrsa_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ t2 += t1;
+
+ if (y < 15) {
+ rsa_free(&key);
+ }
+ }
+ t2 >>= 4;
+ fprintf(stderr, "RSA-%lu make_key took %15llu cycles\n", x, t2);
+
+ t2 = 0;
+ for (y = 0; y < 16; y++) {
+ t_start();
+ t1 = t_read();
+ z = sizeof(buf[1]);
+ if ((err = rsa_encrypt_key(buf[0], 32, buf[1], &z, "testprog", 8, &yarrow_prng,
+ find_prng("yarrow"), find_hash("sha1"),
+ &key)) != CRYPT_OK) {
+ fprintf(stderr, "\n\nrsa_encrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ t2 += t1;
+ }
+ t2 >>= 4;
+ fprintf(stderr, "RSA-%lu encrypt_key took %15llu cycles\n", x, t2);
+
+ t2 = 0;
+ for (y = 0; y < 16; y++) {
+ t_start();
+ t1 = t_read();
+ zzz = sizeof(buf[0]);
+ if ((err = rsa_decrypt_key(buf[1], z, buf[0], &zzz, "testprog", 8, find_hash("sha1"),
+ &zz, &key)) != CRYPT_OK) {
+ fprintf(stderr, "\n\nrsa_decrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ t2 += t1;
+ }
+ t2 >>= 4;
+ fprintf(stderr, "RSA-%lu decrypt_key took %15llu cycles\n", x, t2);
+
+
+ rsa_free(&key);
+ }
+}
+#else
+void time_rsa(void) { fprintf(stderr, "NO RSA\n"); }
+#endif
+
+#ifdef MECC
+/* time various ECC operations */
+void time_ecc(void)
+{
+ ecc_key key;
+ ulong64 t1, t2;
+ unsigned char buf[2][4096];
+ unsigned long i, x, y, z;
+ int err;
+ static unsigned long sizes[] = {192/8, 256/8, 384/8, 521/8, 100000};
+
+ for (x = sizes[i=0]; x < 100000; x = sizes[++i]) {
+ t2 = 0;
+ for (y = 0; y < 16; y++) {
+ t_start();
+ t1 = t_read();
+ if ((err = ecc_make_key(&yarrow_prng, find_prng("yarrow"), x, &key)) != CRYPT_OK) {
+ fprintf(stderr, "\n\necc_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ t2 += t1;
+
+ if (y < 15) {
+ ecc_free(&key);
+ }
+ }
+ t2 >>= 4;
+ fprintf(stderr, "ECC-%lu make_key took %15llu cycles\n", x*8, t2);
+
+ t2 = 0;
+ for (y = 0; y < 16; y++) {
+ t_start();
+ t1 = t_read();
+ z = sizeof(buf[1]);
+ if ((err = ecc_encrypt_key(buf[0], 20, buf[1], &z, &yarrow_prng, find_prng("yarrow"), find_hash("sha1"),
+ &key)) != CRYPT_OK) {
+ fprintf(stderr, "\n\necc_encrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ t2 += t1;
+ }
+ t2 >>= 4;
+ fprintf(stderr, "ECC-%lu encrypt_key took %15llu cycles\n", x*8, t2);
+ ecc_free(&key);
+ }
+}
+#else
+void time_ecc(void) { fprintf(stderr, "NO ECC\n"); }
+#endif
+
+#ifdef MDH
+/* time various DH operations */
+void time_dh(void)
+{
+ dh_key key;
+ ulong64 t1, t2;
+ unsigned char buf[2][4096];
+ unsigned long i, x, y, z;
+ int err;
+ static unsigned long sizes[] = {768/8, 1024/8, 1536/8, 2048/8, 3072/8, 4096/8, 100000};
+
+ for (x = sizes[i=0]; x < 100000; x = sizes[++i]) {
+ t2 = 0;
+ for (y = 0; y < 16; y++) {
+ t_start();
+ t1 = t_read();
+ if ((err = dh_make_key(&yarrow_prng, find_prng("yarrow"), x, &key)) != CRYPT_OK) {
+ fprintf(stderr, "\n\ndh_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ t2 += t1;
+
+ if (y < 15) {
+ dh_free(&key);
+ }
+ }
+ t2 >>= 4;
+ fprintf(stderr, "DH-%4lu make_key took %15llu cycles\n", x*8, t2);
+
+ t2 = 0;
+ for (y = 0; y < 16; y++) {
+ t_start();
+ t1 = t_read();
+ z = sizeof(buf[1]);
+ if ((err = dh_encrypt_key(buf[0], 20, buf[1], &z, &yarrow_prng, find_prng("yarrow"), find_hash("sha1"),
+ &key)) != CRYPT_OK) {
+ fprintf(stderr, "\n\ndh_encrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ t2 += t1;
+ }
+ t2 >>= 4;
+ fprintf(stderr, "DH-%4lu encrypt_key took %15llu cycles\n", x*8, t2);
+ dh_free(&key);
+ }
+}
+#else
+void time_dh(void) { fprintf(stderr, "NO DH\n"); }
+#endif
+
+void time_macs_(unsigned long MAC_SIZE)
+{
+ unsigned char *buf, key[16], tag[16];
+ ulong64 t1, t2;
+ unsigned long x, z;
+ int err, cipher_idx, hash_idx;
+
+ fprintf(stderr, "\nMAC Timings (cycles/byte on %luKB blocks):\n", MAC_SIZE);
+
+ buf = XMALLOC(MAC_SIZE*1024);
+ if (buf == NULL) {
+ fprintf(stderr, "\n\nout of heap yo\n\n");
+ exit(EXIT_FAILURE);
+ }
+
+ cipher_idx = find_cipher("aes");
+ hash_idx = find_hash("md5");
+
+ yarrow_read(buf, MAC_SIZE*1024, &yarrow_prng);
+ yarrow_read(key, 16, &yarrow_prng);
+
+#ifdef OMAC
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = omac_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
+ fprintf(stderr, "\n\nomac error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "OMAC-AES\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+#endif
+
+#ifdef PMAC
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = pmac_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
+ fprintf(stderr, "\n\npmac error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "PMAC-AES\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+#endif
+
+#ifdef PELICAN
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = pelican_memory(key, 16, buf, MAC_SIZE*1024, tag)) != CRYPT_OK) {
+ fprintf(stderr, "\n\npelican error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "PELICAN \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+#endif
+
+#ifdef HMAC
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = hmac_memory(hash_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
+ fprintf(stderr, "\n\nhmac error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "HMAC-MD5\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+#endif
+
+ XFREE(buf);
+}
+
+void time_macs(void)
+{
+ time_macs_(1);
+ time_macs_(4);
+ time_macs_(32);
+}
+
+void time_encmacs_(unsigned long MAC_SIZE)
+{
+ unsigned char *buf, IV[16], key[16], tag[16];
+ ulong64 t1, t2;
+ unsigned long x, z;
+ int err, cipher_idx;
+
+ fprintf(stderr, "\nENC+MAC Timings (zero byte AAD, 16 byte IV, cycles/byte on %luKB blocks):\n", MAC_SIZE);
+
+ buf = XMALLOC(MAC_SIZE*1024);
+ if (buf == NULL) {
+ fprintf(stderr, "\n\nout of heap yo\n\n");
+ exit(EXIT_FAILURE);
+ }
+
+ cipher_idx = find_cipher("aes");
+
+ yarrow_read(buf, MAC_SIZE*1024, &yarrow_prng);
+ yarrow_read(key, 16, &yarrow_prng);
+ yarrow_read(IV, 16, &yarrow_prng);
+
+#ifdef EAX_MODE
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = eax_encrypt_authenticate_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z)) != CRYPT_OK) {
+ fprintf(stderr, "\nEAX error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "EAX \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+#endif
+
+#ifdef OCB_MODE
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = ocb_encrypt_authenticate_memory(cipher_idx, key, 16, IV, buf, MAC_SIZE*1024, buf, tag, &z)) != CRYPT_OK) {
+ fprintf(stderr, "\nOCB error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "OCB \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+#endif
+
+#ifdef CCM_MODE
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = ccm_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z, CCM_ENCRYPT)) != CRYPT_OK) {
+ fprintf(stderr, "\nCCM error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "CCM \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+#endif
+
+#ifdef GCM_MODE
+ t2 = -1;
+ for (x = 0; x < 100; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = gcm_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z, GCM_ENCRYPT)) != CRYPT_OK) {
+ fprintf(stderr, "\nGCM error... %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "GCM (no-precomp)\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+
+ {
+ gcm_state gcm;
+
+ if ((err = gcm_init(&gcm, cipher_idx, key, 16)) != CRYPT_OK) { fprintf(stderr, "gcm_init: %s\n", error_to_string(err)); exit(EXIT_FAILURE); }
+ t2 = -1;
+ for (x = 0; x < 10000; x++) {
+ t_start();
+ t1 = t_read();
+ z = 16;
+ if ((err = gcm_reset(&gcm)) != CRYPT_OK) {
+ fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ if ((err = gcm_add_iv(&gcm, IV, 16)) != CRYPT_OK) {
+ fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ if ((err = gcm_add_aad(&gcm, NULL, 0)) != CRYPT_OK) {
+ fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ if ((err = gcm_process(&gcm, buf, MAC_SIZE*1024, buf, GCM_ENCRYPT)) != CRYPT_OK) {
+ fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+
+ if ((err = gcm_done(&gcm, tag, &z)) != CRYPT_OK) {
+ fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ t1 = t_read() - t1;
+ if (t1 < t2) t2 = t1;
+ }
+ fprintf(stderr, "GCM (precomp)\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
+ }
+
+#endif
+
+}
+
+void time_encmacs(void)
+{
+ time_encmacs_(1);
+ time_encmacs_(4);
+ time_encmacs_(32);
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/testprof/x86_prof.c,v $ */
+/* $Revision: 1.16 $ */
+/* $Date: 2005/06/14 20:44:23 $ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 18:10:53 +0000