demos/tv_gen.c - third_party/dropbear - Git at Google

 #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

 #ifdef USE_LTM
    ltc_mp = ltm_desc;
 #elif defined(USE_TFM)
    ltc_mp = tfm_desc;
 #elif defined(USE_GMP)
    ltc_mp = gmp_desc;
 #else
    extern ltc_math_descriptor EXT_MATH_LIB;
    ltc_mp = EXT_MATH_LIB;
 #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, NULL, 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);
 }

 void math_gen(void)
 {
 }

 void ecc_gen(void)
 {
    FILE         *out;
    unsigned char str[512];
    void          *k, *order, *modulus;
    ecc_point    *G, *R;
    int           x;

    out = fopen("ecc_tv.txt", "w");
    fprintf(out, "ecc vectors.  These are for kG for k=1,3,9,27,...,3**n until k > order of the curve outputs are <k,x,y> triplets\n\n");
    G = ltc_ecc_new_point();
    R = ltc_ecc_new_point();
    mp_init(&k);
    mp_init(&order);
    mp_init(&modulus);

    for (x = 0; ltc_ecc_sets[x].size != 0; x++) {
         fprintf(out, "ECC-%d\n", ltc_ecc_sets[x].size*8);
         mp_set(k, 1);

         mp_read_radix(order,   (char *)ltc_ecc_sets[x].order, 16);
         mp_read_radix(modulus, (char *)ltc_ecc_sets[x].prime, 16);
         mp_read_radix(G->x,    (char *)ltc_ecc_sets[x].Gx,    16);
         mp_read_radix(G->y,    (char *)ltc_ecc_sets[x].Gy,    16);
         mp_set(G->z, 1);

         while (mp_cmp(k, order) == LTC_MP_LT) {
             ltc_mp.ecc_ptmul(k, G, R, modulus, 1);
             mp_tohex(k,    (char*)str); fprintf(out, "%s, ", (char*)str);
             mp_tohex(R->x, (char*)str); fprintf(out, "%s, ", (char*)str);
             mp_tohex(R->y, (char*)str); fprintf(out, "%s\n", (char*)str);
             mp_mul_d(k, 3, k);
         }
    }
    mp_clear_multi(k, order, modulus, NULL);
    ltc_ecc_del_point(G);
    ltc_ecc_del_point(R);
    fclose(out);
 }

 void lrw_gen(void)
 {
    FILE *out;
    unsigned char tweak[16], key[16], iv[16], buf[1024];
    int x, y, err;
    symmetric_LRW lrw;

    /* initialize default key and tweak */
    for (x = 0; x < 16; x++) {
       tweak[x] = key[x] = iv[x] = x;
    }

    out = fopen("lrw_tv.txt", "w");
    for (x = 16; x < (int)(sizeof(buf)); x += 16) {
        if ((err = lrw_start(find_cipher("aes"), iv, key, 16, tweak, 0, &lrw)) != CRYPT_OK) {
           fprintf(stderr, "Error starting LRW-AES: %s\n", error_to_string(err));
           exit(EXIT_FAILURE);
        }

        /* encrypt incremental */
        for (y = 0; y < x; y++) {
            buf[y] = y & 255;
        }

        if ((err = lrw_encrypt(buf, buf, x, &lrw)) != CRYPT_OK) {
           fprintf(stderr, "Error encrypting with LRW-AES: %s\n", error_to_string(err));
           exit(EXIT_FAILURE);
        }

        /* display it */
        fprintf(out, "%d:", x);
        for (y = 0; y < x; y++) {
           fprintf(out, "%02x", buf[y]);
        }
        fprintf(out, "\n");

        /* reset IV */
        if ((err = lrw_setiv(iv, 16, &lrw)) != CRYPT_OK) {
           fprintf(stderr, "Error setting IV: %s\n", error_to_string(err));
           exit(EXIT_FAILURE);
        }

        /* copy new tweak, iv and key */
        for (y = 0; y < 16; y++) {
           key[y]   = buf[y];
           iv[y]    = buf[(y+16)%x];
           tweak[y] = buf[(y+32)%x];
        }

        if ((err = lrw_decrypt(buf, buf, x, &lrw)) != CRYPT_OK) {
           fprintf(stderr, "Error decrypting with LRW-AES: %s\n", error_to_string(err));
           exit(EXIT_FAILURE);
        }

        /* display it */
        fprintf(out, "%d:", x);
        for (y = 0; y < x; y++) {
           fprintf(out, "%02x", buf[y]);
        }
        fprintf(out, "\n");
        lrw_done(&lrw);
    }
    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");
    printf("Generating MATH   vectors..."); fflush(stdout); math_gen();   printf("done\n");
    printf("Generating ECC    vectors..."); fflush(stdout); ecc_gen();    printf("done\n");
    printf("Generating LRW    vectors..."); fflush(stdout); lrw_gen();    printf("done\n");
    return 0;
 }

 /* $Source: /cvs/libtom/libtomcrypt/demos/tv_gen.c,v $ */
 /* $Revision: 1.15 $ */
 /* $Date: 2006/06/09 22:10:27 $ */
	#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

	#ifdef USE_LTM
	ltc_mp = ltm_desc;
	#elif defined(USE_TFM)
	ltc_mp = tfm_desc;
	#elif defined(USE_GMP)
	ltc_mp = gmp_desc;
	#else
	extern ltc_math_descriptor EXT_MATH_LIB;
	ltc_mp = EXT_MATH_LIB;
	#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[MAXBLOCKSIZE2], header[MAXBLOCKSIZE2],
	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, NULL, 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);
	}

	void math_gen(void)
	{
	}

	void ecc_gen(void)
	{
	FILE *out;
	unsigned char str[512];
	void k, order, *modulus;
	ecc_point G, R;
	int x;

	out = fopen("ecc_tv.txt", "w");
	fprintf(out, "ecc vectors. These are for kG for k=1,3,9,27,...,3**n until k > order of the curve outputs are <k,x,y> triplets\n\n");
	G = ltc_ecc_new_point();
	R = ltc_ecc_new_point();
	mp_init(&k);
	mp_init(&order);
	mp_init(&modulus);

	for (x = 0; ltc_ecc_sets[x].size != 0; x++) {
	fprintf(out, "ECC-%d\n", ltc_ecc_sets[x].size*8);
	mp_set(k, 1);

	mp_read_radix(order, (char *)ltc_ecc_sets[x].order, 16);
	mp_read_radix(modulus, (char *)ltc_ecc_sets[x].prime, 16);
	mp_read_radix(G->x, (char *)ltc_ecc_sets[x].Gx, 16);
	mp_read_radix(G->y, (char *)ltc_ecc_sets[x].Gy, 16);
	mp_set(G->z, 1);

	while (mp_cmp(k, order) == LTC_MP_LT) {
	ltc_mp.ecc_ptmul(k, G, R, modulus, 1);
	mp_tohex(k, (char)str); fprintf(out, "%s, ", (char)str);
	mp_tohex(R->x, (char)str); fprintf(out, "%s, ", (char)str);
	mp_tohex(R->y, (char)str); fprintf(out, "%s\n", (char)str);
	mp_mul_d(k, 3, k);
	}
	}
	mp_clear_multi(k, order, modulus, NULL);
	ltc_ecc_del_point(G);
	ltc_ecc_del_point(R);
	fclose(out);
	}

	void lrw_gen(void)
	{
	FILE *out;
	unsigned char tweak[16], key[16], iv[16], buf[1024];
	int x, y, err;
	symmetric_LRW lrw;

	/* initialize default key and tweak */
	for (x = 0; x < 16; x++) {
	tweak[x] = key[x] = iv[x] = x;
	}

	out = fopen("lrw_tv.txt", "w");
	for (x = 16; x < (int)(sizeof(buf)); x += 16) {
	if ((err = lrw_start(find_cipher("aes"), iv, key, 16, tweak, 0, &lrw)) != CRYPT_OK) {
	fprintf(stderr, "Error starting LRW-AES: %s\n", error_to_string(err));
	exit(EXIT_FAILURE);
	}

	/* encrypt incremental */
	for (y = 0; y < x; y++) {
	buf[y] = y & 255;
	}

	if ((err = lrw_encrypt(buf, buf, x, &lrw)) != CRYPT_OK) {
	fprintf(stderr, "Error encrypting with LRW-AES: %s\n", error_to_string(err));
	exit(EXIT_FAILURE);
	}

	/* display it */
	fprintf(out, "%d:", x);
	for (y = 0; y < x; y++) {
	fprintf(out, "%02x", buf[y]);
	}
	fprintf(out, "\n");

	/* reset IV */
	if ((err = lrw_setiv(iv, 16, &lrw)) != CRYPT_OK) {
	fprintf(stderr, "Error setting IV: %s\n", error_to_string(err));
	exit(EXIT_FAILURE);
	}

	/* copy new tweak, iv and key */
	for (y = 0; y < 16; y++) {
	key[y] = buf[y];
	iv[y] = buf[(y+16)%x];
	tweak[y] = buf[(y+32)%x];
	}

	if ((err = lrw_decrypt(buf, buf, x, &lrw)) != CRYPT_OK) {
	fprintf(stderr, "Error decrypting with LRW-AES: %s\n", error_to_string(err));
	exit(EXIT_FAILURE);
	}

	/* display it */
	fprintf(out, "%d:", x);
	for (y = 0; y < x; y++) {
	fprintf(out, "%02x", buf[y]);
	}
	fprintf(out, "\n");
	lrw_done(&lrw);
	}
	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");
	printf("Generating MATH vectors..."); fflush(stdout); math_gen(); printf("done\n");
	printf("Generating ECC vectors..."); fflush(stdout); ecc_gen(); printf("done\n");
	printf("Generating LRW vectors..."); fflush(stdout); lrw_gen(); printf("done\n");
	return 0;
	}

	/* $Source: /cvs/libtom/libtomcrypt/demos/tv_gen.c,v $ */
	/* $Revision: 1.15 $ */
	/* $Date: 2006/06/09 22:10:27 $ */