summaryrefslogtreecommitdiffhomepage
path: root/libtomcrypt/demos
diff options
context:
space:
mode:
Diffstat (limited to 'libtomcrypt/demos')
-rw-r--r--libtomcrypt/demos/encrypt.c241
-rw-r--r--libtomcrypt/demos/hashsum.c119
-rw-r--r--libtomcrypt/demos/multi.c110
-rw-r--r--libtomcrypt/demos/small.c14
-rw-r--r--libtomcrypt/demos/test.c24
-rw-r--r--libtomcrypt/demos/timing.c26
-rw-r--r--libtomcrypt/demos/tv_gen.c670
7 files changed, 1204 insertions, 0 deletions
diff --git a/libtomcrypt/demos/encrypt.c b/libtomcrypt/demos/encrypt.c
new file mode 100644
index 0000000..d8eb293
--- /dev/null
+++ b/libtomcrypt/demos/encrypt.c
@@ -0,0 +1,241 @@
+/* encrypt V1.1 Fri Oct 18 04:28:03 NZDT 2002 */
+/* File de/encryption, using libtomcrypt */
+/* Written by Daniel Richards <kyhwana@world-net.co.nz> */
+/* Help from Tom St Denis with various bits */
+/* This code is public domain, no rights reserved. */
+/* Encrypts by default, -d flag enables decryption */
+/* ie: ./encrypt blowfish story.txt story.ct */
+/* ./encrypt -d blowfish story.ct story.pt */
+
+#include <tomcrypt.h>
+
+int errno;
+
+int usage(char *name)
+{
+ int x;
+
+ printf("Usage: %s [-d](ecrypt) cipher infile outfile\nCiphers:\n", name);
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ printf("%s\n",cipher_descriptor[x].name);
+ }
+ exit(1);
+}
+
+void register_algs(void)
+{
+ int x;
+
+#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
+
+ if (register_hash(&sha256_desc) == -1) {
+ printf("Error registering SHA256\n");
+ exit(-1);
+ }
+
+ if (register_prng(&yarrow_desc) == -1) {
+ printf("Error registering yarrow PRNG\n");
+ exit(-1);
+ }
+
+ if (register_prng(&sprng_desc) == -1) {
+ printf("Error registering sprng PRNG\n");
+ exit(-1);
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ unsigned char plaintext[512],ciphertext[512];
+ unsigned char tmpkey[512], key[MAXBLOCKSIZE], IV[MAXBLOCKSIZE];
+ unsigned char inbuf[512]; /* i/o block size */
+ unsigned long outlen, y, ivsize, x, decrypt;
+ symmetric_CTR ctr;
+ int cipher_idx, hash_idx, ks;
+ char *infile, *outfile, *cipher;
+ prng_state prng;
+ FILE *fdin, *fdout;
+
+ /* register algs, so they can be printed */
+ register_algs();
+
+ if (argc < 4) {
+ return usage(argv[0]);
+ }
+
+ if (!strcmp(argv[1], "-d")) {
+ decrypt = 1;
+ cipher = argv[2];
+ infile = argv[3];
+ outfile = argv[4];
+ } else {
+ decrypt = 0;
+ cipher = argv[1];
+ infile = argv[2];
+ outfile = argv[3];
+ }
+
+ /* file handles setup */
+ fdin = fopen(infile,"rb");
+ if (fdin == NULL) {
+ perror("Can't open input for reading");
+ exit(-1);
+ }
+
+ fdout = fopen(outfile,"wb");
+ if (fdout == NULL) {
+ perror("Can't open output for writing");
+ exit(-1);
+ }
+
+ cipher_idx = find_cipher(cipher);
+ if (cipher_idx == -1) {
+ printf("Invalid cipher entered on command line.\n");
+ exit(-1);
+ }
+
+ hash_idx = find_hash("sha256");
+ if (hash_idx == -1) {
+ printf("SHA256 not found...?\n");
+ exit(-1);
+ }
+
+ ivsize = cipher_descriptor[cipher_idx].block_length;
+ ks = hash_descriptor[hash_idx].hashsize;
+ if (cipher_descriptor[cipher_idx].keysize(&ks) != CRYPT_OK) {
+ printf("Invalid keysize???\n");
+ exit(-1);
+ }
+
+ printf("\nEnter key: ");
+ fgets((char *)tmpkey,sizeof(tmpkey), stdin);
+ outlen = sizeof(key);
+ if ((errno = hash_memory(hash_idx,tmpkey,strlen((char *)tmpkey),key,&outlen)) != CRYPT_OK) {
+ printf("Error hashing key: %s\n", error_to_string(errno));
+ exit(-1);
+ }
+
+ if (decrypt) {
+ /* Need to read in IV */
+ if (fread(IV,1,ivsize,fdin) != ivsize) {
+ printf("Error reading IV from input.\n");
+ exit(-1);
+ }
+
+ if ((errno = ctr_start(cipher_idx,IV,key,ks,0,&ctr)) != CRYPT_OK) {
+ printf("ctr_start error: %s\n",error_to_string(errno));
+ exit(-1);
+ }
+
+ /* IV done */
+ do {
+ y = fread(inbuf,1,sizeof(inbuf),fdin);
+
+ if ((errno = ctr_decrypt(inbuf,plaintext,y,&ctr)) != CRYPT_OK) {
+ printf("ctr_decrypt error: %s\n", error_to_string(errno));
+ exit(-1);
+ }
+
+ if (fwrite(plaintext,1,y,fdout) != y) {
+ printf("Error writing to file.\n");
+ exit(-1);
+ }
+ } while (y == sizeof(inbuf));
+ fclose(fdin);
+ fclose(fdout);
+
+ } else { /* encrypt */
+ /* Setup yarrow for random bytes for IV */
+
+ if ((errno = rng_make_prng(128, find_prng("yarrow"), &prng, NULL)) != CRYPT_OK) {
+ printf("Error setting up PRNG, %s\n", error_to_string(errno));
+ }
+
+ /* You can use rng_get_bytes on platforms that support it */
+ /* x = rng_get_bytes(IV,ivsize,NULL);*/
+ x = yarrow_read(IV,ivsize,&prng);
+ if (x != ivsize) {
+ printf("Error reading PRNG for IV required.\n");
+ exit(-1);
+ }
+
+ if (fwrite(IV,1,ivsize,fdout) != ivsize) {
+ printf("Error writing IV to output.\n");
+ exit(-1);
+ }
+
+ if ((errno = ctr_start(cipher_idx,IV,key,ks,0,&ctr)) != CRYPT_OK) {
+ printf("ctr_start error: %s\n",error_to_string(errno));
+ exit(-1);
+ }
+
+ do {
+ y = fread(inbuf,1,sizeof(inbuf),fdin);
+
+ if ((errno = ctr_encrypt(inbuf,ciphertext,y,&ctr)) != CRYPT_OK) {
+ printf("ctr_encrypt error: %s\n", error_to_string(errno));
+ exit(-1);
+ }
+
+ if (fwrite(ciphertext,1,y,fdout) != y) {
+ printf("Error writing to output.\n");
+ exit(-1);
+ }
+ } while (y == sizeof(inbuf));
+ fclose(fdout);
+ fclose(fdin);
+ }
+ return 0;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/demos/encrypt.c,v $ */
+/* $Revision: 1.2 $ */
+/* $Date: 2005/05/05 14:35:56 $ */
diff --git a/libtomcrypt/demos/hashsum.c b/libtomcrypt/demos/hashsum.c
new file mode 100644
index 0000000..653b6ef
--- /dev/null
+++ b/libtomcrypt/demos/hashsum.c
@@ -0,0 +1,119 @@
+/*
+ * Written by Daniel Richards <kyhwana@world-net.co.nz> 6/7/2002
+ * hash.c: This app uses libtomcrypt to hash either stdin or a file
+ * This file is Public Domain. No rights are reserved.
+ * Compile with 'gcc hashsum.c -o hashsum -ltomcrypt'
+ * This example isn't really big enough to warrent splitting into
+ * more functions ;)
+*/
+
+#include <tomcrypt.h>
+
+int errno;
+
+void register_algs();
+
+int main(int argc, char **argv)
+{
+ int idx, x, z;
+ unsigned long w;
+ unsigned char hash_buffer[MAXBLOCKSIZE];
+ hash_state md;
+
+ /* You need to register algorithms before using them */
+ register_algs();
+ if (argc < 2) {
+ printf("usage: ./hash algorithm file [file ...]\n");
+ printf("Algorithms:\n");
+ for (x = 0; hash_descriptor[x].name != NULL; x++) {
+ printf(" %s (%d)\n", hash_descriptor[x].name, hash_descriptor[x].ID);
+ }
+ exit(EXIT_SUCCESS);
+ }
+
+ idx = find_hash(argv[1]);
+ if (idx == -1) {
+ fprintf(stderr, "\nInvalid hash specified on command line.\n");
+ return -1;
+ }
+
+ if (argc == 2) {
+ hash_descriptor[idx].init(&md);
+ do {
+ x = fread(hash_buffer, 1, sizeof(hash_buffer), stdin);
+ hash_descriptor[idx].process(&md, hash_buffer, x);
+ } while (x == sizeof(hash_buffer));
+ hash_descriptor[idx].done(&md, hash_buffer);
+ for (x = 0; x < (int)hash_descriptor[idx].hashsize; x++) {
+ printf("%02x",hash_buffer[x]);
+ }
+ printf(" (stdin)\n");
+ } else {
+ for (z = 2; z < argc; z++) {
+ w = sizeof(hash_buffer);
+ if ((errno = hash_file(idx,argv[z],hash_buffer,&w)) != CRYPT_OK) {
+ printf("File hash error: %s\n", error_to_string(errno));
+ } else {
+ for (x = 0; x < (int)hash_descriptor[idx].hashsize; x++) {
+ printf("%02x",hash_buffer[x]);
+ }
+ printf(" %s\n", argv[z]);
+ }
+ }
+ }
+ return EXIT_SUCCESS;
+}
+
+void register_algs(void)
+{
+ int err;
+
+#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_enc_desc))) != CRYPT_OK) {
+ printf("chc_register error: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+#endif
+
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/demos/hashsum.c,v $ */
+/* $Revision: 1.2 $ */
+/* $Date: 2005/05/05 14:35:56 $ */
diff --git a/libtomcrypt/demos/multi.c b/libtomcrypt/demos/multi.c
new file mode 100644
index 0000000..af4d6b6
--- /dev/null
+++ b/libtomcrypt/demos/multi.c
@@ -0,0 +1,110 @@
+/* test the multi helpers... */
+#include <tomcrypt.h>
+
+int main(void)
+{
+ unsigned char key[16], buf[2][MAXBLOCKSIZE];
+ unsigned long len, len2;
+
+
+/* register algos */
+ register_hash(&sha256_desc);
+ register_cipher(&aes_desc);
+
+/* HASH testing */
+ len = sizeof(buf[0]);
+ hash_memory(find_hash("sha256"), "hello", 5, buf[0], &len);
+ len2 = sizeof(buf[0]);
+ hash_memory_multi(find_hash("sha256"), buf[1], &len2, "hello", 5, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ hash_memory_multi(find_hash("sha256"), buf[1], &len2, "he", 2, "llo", 3, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ hash_memory_multi(find_hash("sha256"), buf[1], &len2, "h", 1, "e", 1, "l", 1, "l", 1, "o", 1, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+
+/* HMAC */
+ len = sizeof(buf[0]);
+ hmac_memory(find_hash("sha256"), key, 16, "hello", 5, buf[0], &len);
+ len2 = sizeof(buf[0]);
+ hmac_memory_multi(find_hash("sha256"), key, 16, buf[1], &len2, "hello", 5, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ hmac_memory_multi(find_hash("sha256"), key, 16, buf[1], &len2, "he", 2, "llo", 3, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ hmac_memory_multi(find_hash("sha256"), key, 16, buf[1], &len2, "h", 1, "e", 1, "l", 1, "l", 1, "o", 1, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+
+/* OMAC */
+ len = sizeof(buf[0]);
+ omac_memory(find_cipher("aes"), key, 16, "hello", 5, buf[0], &len);
+ len2 = sizeof(buf[0]);
+ omac_memory_multi(find_cipher("aes"), key, 16, buf[1], &len2, "hello", 5, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ omac_memory_multi(find_cipher("aes"), key, 16, buf[1], &len2, "he", 2, "llo", 3, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ omac_memory_multi(find_cipher("aes"), key, 16, buf[1], &len2, "h", 1, "e", 1, "l", 1, "l", 1, "o", 1, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+
+/* PMAC */
+ len = sizeof(buf[0]);
+ pmac_memory(find_cipher("aes"), key, 16, "hello", 5, buf[0], &len);
+ len2 = sizeof(buf[0]);
+ pmac_memory_multi(find_cipher("aes"), key, 16, buf[1], &len2, "hello", 5, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ pmac_memory_multi(find_cipher("aes"), key, 16, buf[1], &len2, "he", 2, "llo", 3, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+ len2 = sizeof(buf[0]);
+ pmac_memory_multi(find_cipher("aes"), key, 16, buf[1], &len2, "h", 1, "e", 1, "l", 1, "l", 1, "o", 1, NULL);
+ if (len != len2 || memcmp(buf[0], buf[1], len)) {
+ printf("Failed: %d %lu %lu\n", __LINE__, len, len2);
+ return EXIT_FAILURE;
+ }
+
+
+ printf("All passed\n");
+ return EXIT_SUCCESS;
+}
+
+
+/* $Source: /cvs/libtom/libtomcrypt/demos/multi.c,v $ */
+/* $Revision: 1.2 $ */
+/* $Date: 2005/05/05 14:35:56 $ */
diff --git a/libtomcrypt/demos/small.c b/libtomcrypt/demos/small.c
new file mode 100644
index 0000000..6bdd842
--- /dev/null
+++ b/libtomcrypt/demos/small.c
@@ -0,0 +1,14 @@
+// small demo app that just includes a cipher/hash/prng
+#include <tomcrypt.h>
+
+int main(void)
+{
+ register_cipher(&rijndael_enc_desc);
+ register_prng(&yarrow_desc);
+ register_hash(&sha256_desc);
+ return 0;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/demos/small.c,v $ */
+/* $Revision: 1.2 $ */
+/* $Date: 2005/05/05 14:35:56 $ */
diff --git a/libtomcrypt/demos/test.c b/libtomcrypt/demos/test.c
new file mode 100644
index 0000000..f6c7170
--- /dev/null
+++ b/libtomcrypt/demos/test.c
@@ -0,0 +1,24 @@
+#include <tomcrypt_test.h>
+
+int main(void)
+{
+ int x;
+ reg_algs();
+ printf("build == \n%s\n", crypt_build_settings);
+ printf("\nstore_test...."); fflush(stdout); x = store_test(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\ncipher_test..."); fflush(stdout); x = cipher_hash_test(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\nmodes_test...."); fflush(stdout); x = modes_test(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\nder_test......"); fflush(stdout); x = der_tests(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\nmac_test......"); fflush(stdout); x = mac_test(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\npkcs_1_test..."); fflush(stdout); x = pkcs_1_test(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\nrsa_test......"); fflush(stdout); x = rsa_test(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\necc_test......"); fflush(stdout); x = ecc_tests(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\ndsa_test......"); fflush(stdout); x = dsa_test(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\ndh_test......."); fflush(stdout); x = dh_tests(); printf(x ? "failed" : "passed");if (x) exit(EXIT_FAILURE);
+ printf("\n");
+ return EXIT_SUCCESS;
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/demos/test.c,v $ */
+/* $Revision: 1.12 $ */
+/* $Date: 2005/06/19 12:06:58 $ */
diff --git a/libtomcrypt/demos/timing.c b/libtomcrypt/demos/timing.c
new file mode 100644
index 0000000..368d6e4
--- /dev/null
+++ b/libtomcrypt/demos/timing.c
@@ -0,0 +1,26 @@
+#include <tomcrypt_test.h>
+
+int main(void)
+{
+init_timer();
+reg_algs();
+time_keysched();
+time_cipher();
+time_cipher2();
+time_cipher3();
+time_hash();
+time_macs();
+time_encmacs();
+time_prng();
+time_mult();
+time_sqr();
+time_rsa();
+time_ecc();
+time_dh();
+return EXIT_SUCCESS;
+
+}
+
+/* $Source: /cvs/libtom/libtomcrypt/demos/timing.c,v $ */
+/* $Revision: 1.17 $ */
+/* $Date: 2005/06/23 02:16:26 $ */
diff --git a/libtomcrypt/demos/tv_gen.c b/libtomcrypt/demos/tv_gen.c
new file mode 100644
index 0000000..edaae3e
--- /dev/null
+++ b/libtomcrypt/demos/tv_gen.c
@@ -0,0 +1,670 @@
+#include <tomcrypt.h>
+
+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 ANUBIS
+ register_cipher (&anubis_desc);
+#endif
+#ifdef KHAZAD
+ register_cipher (&khazad_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) {
+ printf("chc_register error: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+#endif
+
+}
+
+void hash_gen(void)
+{
+ unsigned char md[MAXBLOCKSIZE], *buf;
+ unsigned long outlen, x, y, z;
+ FILE *out;
+ int err;
+
+ out = fopen("hash_tv.txt", "w");
+ if (out == NULL) {
+ perror("can't open hash_tv");
+ }
+
+ fprintf(out, "Hash Test Vectors:\n\nThese are the hashes of nn bytes '00 01 02 03 .. (nn-1)'\n\n");
+ for (x = 0; hash_descriptor[x].name != NULL; x++) {
+ buf = XMALLOC(2 * hash_descriptor[x].blocksize + 1);
+ if (buf == NULL) {
+ perror("can't alloc mem");
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "Hash: %s\n", hash_descriptor[x].name);
+ for (y = 0; y <= (hash_descriptor[x].blocksize * 2); y++) {
+ for (z = 0; z < y; z++) {
+ buf[z] = (unsigned char)(z & 255);
+ }
+ outlen = sizeof(md);
+ if ((err = hash_memory(x, buf, y, md, &outlen)) != CRYPT_OK) {
+ printf("hash_memory error: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3lu: ", y);
+ for (z = 0; z < outlen; z++) {
+ fprintf(out, "%02X", md[z]);
+ }
+ fprintf(out, "\n");
+ }
+ fprintf(out, "\n");
+ XFREE(buf);
+ }
+ fclose(out);
+}
+
+void cipher_gen(void)
+{
+ unsigned char *key, pt[MAXBLOCKSIZE];
+ unsigned long x, y, z, w;
+ int err, kl, lastkl;
+ FILE *out;
+ symmetric_key skey;
+
+ out = fopen("cipher_tv.txt", "w");
+
+ fprintf(out,
+"Cipher Test Vectors\n\nThese are test encryptions with key of nn bytes '00 01 02 03 .. (nn-1)' and original PT of the same style.\n"
+"The output of step N is used as the key and plaintext for step N+1 (key bytes repeated as required to fill the key)\n\n");
+
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ fprintf(out, "Cipher: %s\n", cipher_descriptor[x].name);
+
+ /* three modes, smallest, medium, large keys */
+ lastkl = 10000;
+ for (y = 0; y < 3; y++) {
+ switch (y) {
+ case 0: kl = cipher_descriptor[x].min_key_length; break;
+ case 1: kl = (cipher_descriptor[x].min_key_length + cipher_descriptor[x].max_key_length)/2; break;
+ case 2: kl = cipher_descriptor[x].max_key_length; break;
+ }
+ if ((err = cipher_descriptor[x].keysize(&kl)) != CRYPT_OK) {
+ printf("keysize error: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ if (kl == lastkl) break;
+ lastkl = kl;
+ fprintf(out, "Key Size: %d bytes\n", kl);
+
+ key = XMALLOC(kl);
+ if (key == NULL) {
+ perror("can't malloc memory");
+ exit(EXIT_FAILURE);
+ }
+
+ for (z = 0; (int)z < kl; z++) {
+ key[z] = (unsigned char)z;
+ }
+ if ((err = cipher_descriptor[x].setup(key, kl, 0, &skey)) != CRYPT_OK) {
+ printf("setup error: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+
+ for (z = 0; (int)z < cipher_descriptor[x].block_length; z++) {
+ pt[z] = (unsigned char)z;
+ }
+ for (w = 0; w < 50; w++) {
+ cipher_descriptor[x].ecb_encrypt(pt, pt, &skey);
+ fprintf(out, "%2lu: ", w);
+ for (z = 0; (int)z < cipher_descriptor[x].block_length; z++) {
+ fprintf(out, "%02X", pt[z]);
+ }
+ fprintf(out, "\n");
+
+ /* reschedule a new key */
+ for (z = 0; z < (unsigned long)kl; z++) {
+ key[z] = pt[z % cipher_descriptor[x].block_length];
+ }
+ if ((err = cipher_descriptor[x].setup(key, kl, 0, &skey)) != CRYPT_OK) {
+ printf("cipher setup2 error: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ }
+ fprintf(out, "\n");
+ XFREE(key);
+ }
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+void hmac_gen(void)
+{
+ unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], *input;
+ int x, y, z, err;
+ FILE *out;
+ unsigned long len;
+
+ out = fopen("hmac_tv.txt", "w");
+
+ fprintf(out,
+"HMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are HMACed. The initial key is\n"
+"of the same format (the same length as the HASH output size). The HMAC key in step N+1 is the HMAC output of\n"
+"step N.\n\n");
+
+ for (x = 0; hash_descriptor[x].name != NULL; x++) {
+ fprintf(out, "HMAC-%s\n", hash_descriptor[x].name);
+
+ /* initial key */
+ for (y = 0; y < (int)hash_descriptor[x].hashsize; y++) {
+ key[y] = (y&255);
+ }
+
+ input = XMALLOC(hash_descriptor[x].blocksize * 2 + 1);
+ if (input == NULL) {
+ perror("Can't malloc memory");
+ exit(EXIT_FAILURE);
+ }
+
+ for (y = 0; y <= (int)(hash_descriptor[x].blocksize * 2); y++) {
+ for (z = 0; z < y; z++) {
+ input[z] = (unsigned char)(z & 255);
+ }
+ len = sizeof(output);
+ if ((err = hmac_memory(x, key, hash_descriptor[x].hashsize, input, y, output, &len)) != CRYPT_OK) {
+ printf("Error hmacing: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3d: ", y);
+ for (z = 0; z <(int) len; z++) {
+ fprintf(out, "%02X", output[z]);
+ }
+ fprintf(out, "\n");
+
+ /* forward the key */
+ memcpy(key, output, hash_descriptor[x].hashsize);
+ }
+ XFREE(input);
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+void omac_gen(void)
+{
+ unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], input[MAXBLOCKSIZE*2+2];
+ int err, x, y, z, kl;
+ FILE *out;
+ unsigned long len;
+
+ out = fopen("omac_tv.txt", "w");
+
+ fprintf(out,
+"OMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are OMAC'ed. The initial key is\n"
+"of the same format (length specified per cipher). The OMAC key in step N+1 is the OMAC output of\n"
+"step N (repeated as required to fill the array).\n\n");
+
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ kl = cipher_descriptor[x].block_length;
+
+ /* skip ciphers which do not have 64 or 128 bit block sizes */
+ if (kl != 8 && kl != 16) continue;
+
+ if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
+ kl = cipher_descriptor[x].max_key_length;
+ }
+ fprintf(out, "OMAC-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
+
+ /* initial key/block */
+ for (y = 0; y < kl; y++) {
+ key[y] = (y & 255);
+ }
+
+ for (y = 0; y <= (int)(cipher_descriptor[x].block_length*2); y++) {
+ for (z = 0; z < y; z++) {
+ input[z] = (unsigned char)(z & 255);
+ }
+ len = sizeof(output);
+ if ((err = omac_memory(x, key, kl, input, y, output, &len)) != CRYPT_OK) {
+ printf("Error omacing: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3d: ", y);
+ for (z = 0; z <(int)len; z++) {
+ fprintf(out, "%02X", output[z]);
+ }
+ fprintf(out, "\n");
+
+ /* forward the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = output[z % len];
+ }
+ }
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+void pmac_gen(void)
+{
+ unsigned char key[MAXBLOCKSIZE], output[MAXBLOCKSIZE], input[MAXBLOCKSIZE*2+2];
+ int err, x, y, z, kl;
+ FILE *out;
+ unsigned long len;
+
+ out = fopen("pmac_tv.txt", "w");
+
+ fprintf(out,
+"PMAC Tests. In these tests messages of N bytes long (00,01,02,...,NN-1) are OMAC'ed. The initial key is\n"
+"of the same format (length specified per cipher). The OMAC key in step N+1 is the OMAC output of\n"
+"step N (repeated as required to fill the array).\n\n");
+
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ kl = cipher_descriptor[x].block_length;
+
+ /* skip ciphers which do not have 64 or 128 bit block sizes */
+ if (kl != 8 && kl != 16) continue;
+
+ if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
+ kl = cipher_descriptor[x].max_key_length;
+ }
+ fprintf(out, "PMAC-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
+
+ /* initial key/block */
+ for (y = 0; y < kl; y++) {
+ key[y] = (y & 255);
+ }
+
+ for (y = 0; y <= (int)(cipher_descriptor[x].block_length*2); y++) {
+ for (z = 0; z < y; z++) {
+ input[z] = (unsigned char)(z & 255);
+ }
+ len = sizeof(output);
+ if ((err = pmac_memory(x, key, kl, input, y, output, &len)) != CRYPT_OK) {
+ printf("Error omacing: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3d: ", y);
+ for (z = 0; z <(int)len; z++) {
+ fprintf(out, "%02X", output[z]);
+ }
+ fprintf(out, "\n");
+
+ /* forward the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = output[z % len];
+ }
+ }
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+void eax_gen(void)
+{
+ int err, kl, x, y1, z;
+ FILE *out;
+ unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2], header[MAXBLOCKSIZE*2],
+ plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
+ unsigned long len;
+
+ out = fopen("eax_tv.txt", "w");
+ fprintf(out, "EAX Test Vectors. Uses the 00010203...NN-1 pattern for header/nonce/plaintext/key. The outputs\n"
+ "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
+ "step repeated sufficiently.\n\n");
+
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ kl = cipher_descriptor[x].block_length;
+
+ /* skip ciphers which do not have 64 or 128 bit block sizes */
+ if (kl != 8 && kl != 16) continue;
+
+ if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
+ kl = cipher_descriptor[x].max_key_length;
+ }
+ fprintf(out, "EAX-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
+
+ /* the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = (z & 255);
+ }
+
+ for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
+ for (z = 0; z < y1; z++) {
+ plaintext[z] = (unsigned char)(z & 255);
+ nonce[z] = (unsigned char)(z & 255);
+ header[z] = (unsigned char)(z & 255);
+ }
+ len = sizeof(tag);
+ if ((err = eax_encrypt_authenticate_memory(x, key, kl, nonce, y1, header, y1, plaintext, y1, plaintext, tag, &len)) != CRYPT_OK) {
+ printf("Error EAX'ing: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3d: ", y1);
+ for (z = 0; z < y1; z++) {
+ fprintf(out, "%02X", plaintext[z]);
+ }
+ fprintf(out, ", ");
+ for (z = 0; z <(int)len; z++) {
+ fprintf(out, "%02X", tag[z]);
+ }
+ fprintf(out, "\n");
+
+ /* forward the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = tag[z % len];
+ }
+ }
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+void ocb_gen(void)
+{
+ int err, kl, x, y1, z;
+ FILE *out;
+ unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2],
+ plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
+ unsigned long len;
+
+ out = fopen("ocb_tv.txt", "w");
+ fprintf(out, "OCB Test Vectors. Uses the 00010203...NN-1 pattern for nonce/plaintext/key. The outputs\n"
+ "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
+ "step repeated sufficiently. The nonce is fixed throughout.\n\n");
+
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ kl = cipher_descriptor[x].block_length;
+
+ /* skip ciphers which do not have 64 or 128 bit block sizes */
+ if (kl != 8 && kl != 16) continue;
+
+ if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
+ kl = cipher_descriptor[x].max_key_length;
+ }
+ fprintf(out, "OCB-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
+
+ /* the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = (z & 255);
+ }
+
+ /* fixed nonce */
+ for (z = 0; z < cipher_descriptor[x].block_length; z++) {
+ nonce[z] = z;
+ }
+
+ for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
+ for (z = 0; z < y1; z++) {
+ plaintext[z] = (unsigned char)(z & 255);
+ }
+ len = sizeof(tag);
+ if ((err = ocb_encrypt_authenticate_memory(x, key, kl, nonce, plaintext, y1, plaintext, tag, &len)) != CRYPT_OK) {
+ printf("Error OCB'ing: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3d: ", y1);
+ for (z = 0; z < y1; z++) {
+ fprintf(out, "%02X", plaintext[z]);
+ }
+ fprintf(out, ", ");
+ for (z = 0; z <(int)len; z++) {
+ fprintf(out, "%02X", tag[z]);
+ }
+ fprintf(out, "\n");
+
+ /* forward the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = tag[z % len];
+ }
+ }
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+
+void ccm_gen(void)
+{
+ int err, kl, x, y1, z;
+ FILE *out;
+ unsigned char key[MAXBLOCKSIZE], nonce[MAXBLOCKSIZE*2],
+ plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
+ unsigned long len;
+
+ out = fopen("ccm_tv.txt", "w");
+ fprintf(out, "CCM Test Vectors. Uses the 00010203...NN-1 pattern for nonce/header/plaintext/key. The outputs\n"
+ "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
+ "step repeated sufficiently. The nonce is fixed throughout at 13 bytes 000102...\n\n");
+
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ kl = cipher_descriptor[x].block_length;
+
+ /* skip ciphers which do not have 128 bit block sizes */
+ if (kl != 16) continue;
+
+ if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
+ kl = cipher_descriptor[x].max_key_length;
+ }
+ fprintf(out, "CCM-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
+
+ /* the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = (z & 255);
+ }
+
+ /* fixed nonce */
+ for (z = 0; z < cipher_descriptor[x].block_length; z++) {
+ nonce[z] = z;
+ }
+
+ for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
+ for (z = 0; z < y1; z++) {
+ plaintext[z] = (unsigned char)(z & 255);
+ }
+ len = sizeof(tag);
+ if ((err = ccm_memory(x, key, kl, nonce, 13, plaintext, y1, plaintext, y1, plaintext, tag, &len, CCM_ENCRYPT)) != CRYPT_OK) {
+ printf("Error CCM'ing: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3d: ", y1);
+ for (z = 0; z < y1; z++) {
+ fprintf(out, "%02X", plaintext[z]);
+ }
+ fprintf(out, ", ");
+ for (z = 0; z <(int)len; z++) {
+ fprintf(out, "%02X", tag[z]);
+ }
+ fprintf(out, "\n");
+
+ /* forward the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = tag[z % len];
+ }
+ }
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+void gcm_gen(void)
+{
+ int err, kl, x, y1, z;
+ FILE *out;
+ unsigned char key[MAXBLOCKSIZE], plaintext[MAXBLOCKSIZE*2], tag[MAXBLOCKSIZE];
+ unsigned long len;
+
+ out = fopen("gcm_tv.txt", "w");
+ fprintf(out, "GCM Test Vectors. Uses the 00010203...NN-1 pattern for nonce/header/plaintext/key. The outputs\n"
+ "are of the form ciphertext,tag for a given NN. The key for step N>1 is the tag of the previous\n"
+ "step repeated sufficiently. The nonce is fixed throughout at 13 bytes 000102...\n\n");
+
+ for (x = 0; cipher_descriptor[x].name != NULL; x++) {
+ kl = cipher_descriptor[x].block_length;
+
+ /* skip ciphers which do not have 128 bit block sizes */
+ if (kl != 16) continue;
+
+ if (cipher_descriptor[x].keysize(&kl) != CRYPT_OK) {
+ kl = cipher_descriptor[x].max_key_length;
+ }
+ fprintf(out, "GCM-%s (%d byte key)\n", cipher_descriptor[x].name, kl);
+
+ /* the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = (z & 255);
+ }
+
+ for (y1 = 0; y1 <= (int)(cipher_descriptor[x].block_length*2); y1++){
+ for (z = 0; z < y1; z++) {
+ plaintext[z] = (unsigned char)(z & 255);
+ }
+ len = sizeof(tag);
+ if ((err = gcm_memory(x, key, kl, plaintext, y1, plaintext, y1, plaintext, y1, plaintext, tag, &len, GCM_ENCRYPT)) != CRYPT_OK) {
+ printf("Error GCM'ing: %s\n", error_to_string(err));
+ exit(EXIT_FAILURE);
+ }
+ fprintf(out, "%3d: ", y1);
+ for (z = 0; z < y1; z++) {
+ fprintf(out, "%02X", plaintext[z]);
+ }
+ fprintf(out, ", ");
+ for (z = 0; z <(int)len; z++) {
+ fprintf(out, "%02X", tag[z]);
+ }
+ fprintf(out, "\n");
+
+ /* forward the key */
+ for (z = 0; z < kl; z++) {
+ key[z] = tag[z % len];
+ }
+ }
+ fprintf(out, "\n");
+ }
+ fclose(out);
+}
+
+void base64_gen(void)
+{
+ FILE *out;
+ unsigned char dst[256], src[32];
+ unsigned long x, y, len;
+
+ out = fopen("base64_tv.txt", "w");
+ fprintf(out, "Base64 vectors. These are the base64 encodings of the strings 00,01,02...NN-1\n\n");
+ for (x = 0; x <= 32; x++) {
+ for (y = 0; y < x; y++) {
+ src[y] = y;
+ }
+ len = sizeof(dst);
+ base64_encode(src, x, dst, &len);
+ fprintf(out, "%2lu: %s\n", x, dst);
+ }
+ fclose(out);
+}
+
+int main(void)
+{
+ reg_algs();
+ printf("Generating hash vectors..."); fflush(stdout); hash_gen(); printf("done\n");
+ printf("Generating cipher vectors..."); fflush(stdout); cipher_gen(); printf("done\n");
+ printf("Generating HMAC vectors..."); fflush(stdout); hmac_gen(); printf("done\n");
+ printf("Generating OMAC vectors..."); fflush(stdout); omac_gen(); printf("done\n");
+ printf("Generating PMAC vectors..."); fflush(stdout); pmac_gen(); printf("done\n");
+ printf("Generating EAX vectors..."); fflush(stdout); eax_gen(); printf("done\n");
+ printf("Generating OCB vectors..."); fflush(stdout); ocb_gen(); printf("done\n");
+ printf("Generating CCM vectors..."); fflush(stdout); ccm_gen(); printf("done\n");
+ printf("Generating GCM vectors..."); fflush(stdout); gcm_gen(); printf("done\n");
+ printf("Generating BASE64 vectors..."); fflush(stdout); base64_gen(); printf("done\n");
+ return 0;
+}
+
+
+
+
+
+
+
+
+
+/* $Source: /cvs/libtom/libtomcrypt/demos/tv_gen.c,v $ */
+/* $Revision: 1.4 $ */
+/* $Date: 2005/05/05 14:35:56 $ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 04:28:20 +0000