test.c

最新版本的加密解密算法库

  if (memcmp (buf[0], buf[1], x)) {
    printf ("ecc Shared keys not same contents.\n");
    exit (-1);
  }

  /* now export userb */
  y = 4096;
  if ((errnum = ecc_export (buf[1], &y, PK_PUBLIC, &userb)) != CRYPT_OK) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }
  ecc_free (&userb);
  printf ("ECC-192 export took %ld bytes\n", y);

  /* import and make the shared secret again */
  if ((errnum = ecc_import (buf[1], y, &userb)) != CRYPT_OK) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }

  z = 4096;
  if ((errnum = ecc_shared_secret (&usera, &userb, buf[2], &z)) != CRYPT_OK) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }

  printf ("ecc routines: ");
  if (z != x) {
    printf ("failed.  Size don't match?\n");
    exit (-1);
  }
  if (memcmp (buf[0], buf[2], x)) {
    printf ("Failed.  Content didn't match.\n");
    exit (-1);
  }
  printf ("Passed\n");
  ecc_free (&usera);
  ecc_free (&userb);

/* time stuff */
  {
    static int sizes[] = { 20, 24, 28, 32, 48, 65 };
    int     ii, tt;

    for (ii = 0; ii < (int) (sizeof (sizes) / sizeof (sizes[0])); ii++) {
      t1 = XCLOCK ();
      for (tt = 0; tt < 10; tt++) {
    if ((errnum =
         ecc_make_key (&prng, find_prng ("yarrow"), sizes[ii],
               &usera)) != CRYPT_OK) {
      printf ("Error: %s\n", error_to_string (errnum));
      exit (-1);
    }
    ecc_free (&usera);
      }
      t1 = XCLOCK () - t1;
      printf ("Make ECC-%d key took %f msec\n", sizes[ii] * 8,
          1000.0 * (((double) t1 / 10.0) / (double) XCLOCKS_PER_SEC));
    }
  }

/* test encrypt_key */
  ecc_make_key (&prng, find_prng ("yarrow"), 20, &usera);
  for (x = 0; x < 32; x++)
    buf[0][x] = x;
  y = sizeof (buf[1]);
  if ((errnum =
       ecc_encrypt_key (buf[0], 32, buf[1], &y, &prng, find_prng ("yarrow"),
            find_hash ("sha256"), &usera)) != CRYPT_OK) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }
  zeromem (buf[0], sizeof (buf[0]));
  x = sizeof (buf[0]);
  if ((errnum = ecc_decrypt_key (buf[1], y, buf[0], &x, &usera)) != CRYPT_OK) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }
  printf ("ECC en/de crypt key routines: ");
  if (x != 32) {
    printf ("Failed (length)\n");
    exit (-1);
  }
  for (x = 0; x < 32; x++)
    if (buf[0][x] != x) {
      printf ("Failed (contents)\n");
      exit (-1);
    }
  printf ("Passed (size: %lu)\n", y);
/* test sign_hash */
  for (x = 0; x < 16; x++)
    buf[0][x] = x;
  x = sizeof (buf[1]);
  if ((errnum =
       ecc_sign_hash (buf[0], 16, buf[1], &x, &prng, find_prng ("yarrow"),
              &usera)) != CRYPT_OK) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }
  printf("Signature size: %lu\n", x);
  if (ecc_verify_hash (buf[1], x, buf[0], 16, &stat, &usera)) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }
  buf[0][0] ^= 1;
  if (ecc_verify_hash (buf[1], x, buf[0], 16, &stat2, &usera)) {
    printf ("Error: %s\n", error_to_string (errnum));
    exit (-1);
  }
  printf ("ecc_sign/verify_hash: %s (%d,%d)\n",
      ((stat == 1) && (stat2 == 0)) ? "passed" : "failed", stat, stat2);
  ecc_free (&usera);
}
#else
void
ecc_tests (void)
{
  printf ("MECC not compiled in\n");
}
#endif

#ifdef MPI
void
test_prime (void)
{
  char buf[1024];
  mp_int  a;
  int     x;

  /* make a 1024 bit prime */
  mp_init (&a);
  rand_prime (&a, 128*8, &prng, find_prng ("yarrow"));

  /* dump it */
  mp_todecimal (&a, buf);
  printf ("1024-bit prime:\n");
  for (x = 0; x < (int) strlen (buf);) {
    printf ("%c", buf[x]);
    if (!(++x % 60))
      printf ("\\ \n");
  }
  printf ("\n\n");

  mp_clear (&a);
}
#else
void
test_prime (void)
{
  printf ("MPI not compiled in\n");
}
#endif

void
register_all_algs (void)
{
#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
  register_cipher (&null_desc);

#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 SHA256
  register_hash (&sha256_desc);
#endif
#ifdef SHA224
  register_hash (&sha224_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 YARROW
  register_prng (&yarrow_desc);
#endif
#ifdef SPRNG
  register_prng (&sprng_desc);
#endif
}

void
test_errs (void)
{
#define ERR(x)  printf("%25s => %s\n", #x, error_to_string(x));

  ERR (CRYPT_OK);
  ERR (CRYPT_ERROR);

  ERR (CRYPT_INVALID_KEYSIZE);
  ERR (CRYPT_INVALID_ROUNDS);
  ERR (CRYPT_FAIL_TESTVECTOR);

  ERR (CRYPT_BUFFER_OVERFLOW);
  ERR (CRYPT_INVALID_PACKET);

  ERR (CRYPT_INVALID_PRNGSIZE);
  ERR (CRYPT_ERROR_READPRNG);

  ERR (CRYPT_INVALID_CIPHER);
  ERR (CRYPT_INVALID_HASH);
  ERR (CRYPT_INVALID_PRNG);

  ERR (CRYPT_MEM);

  ERR (CRYPT_PK_TYPE_MISMATCH);
  ERR (CRYPT_PK_NOT_PRIVATE);

  ERR (CRYPT_INVALID_ARG);
  ERR (CRYPT_FILE_NOTFOUND);

  ERR (CRYPT_PK_INVALID_TYPE);
  ERR (CRYPT_PK_INVALID_SYSTEM);
  ERR (CRYPT_PK_DUP);
  ERR (CRYPT_PK_NOT_FOUND);
  ERR (CRYPT_PK_INVALID_SIZE);

  ERR (CRYPT_INVALID_PRIME_SIZE);
}


void dsa_tests(void)
{
   unsigned char msg[16], out[1024], out2[1024];
   unsigned long x, y;
   int err, stat1, stat2;
   dsa_key key, key2;

   /* make a random key */
   if ((err = dsa_make_key(&prng, find_prng("yarrow"), 20, 128, &key)) != CRYPT_OK) {
      printf("Error making DSA key: %s\n", error_to_string(err));
      exit(-1);
   }
   printf("DSA Key Made\n");

   /* verify it */
   if ((err = dsa_verify_key(&key, &stat1)) != CRYPT_OK) {
      printf("Error verifying DSA key: %s\n", error_to_string(err));
      exit(-1);
   }
   printf("DSA key verification: %s\n", stat1 == 1 ? "passed" : "failed");
   if (stat1 == 0) exit(-1);     

   /* sign the message */
   x = sizeof(out);
   if ((err = dsa_sign_hash(msg, sizeof(msg), out, &x, &prng, find_prng("yarrow"), &key)) != CRYPT_OK) {
      printf("Error signing with DSA key: %s\n", error_to_string(err));
      exit(-1);
   }
   printf("DSA 160/1024 signature is %lu bytes long\n", x);

   /* verify it once */
   if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key)) != CRYPT_OK) {
      printf("Error verifying with DSA key 1: %s\n", error_to_string(err));
      exit(-1);
   }

   /* Modify and verify again */
   msg[0] ^= 1;
   if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat2, &key)) != CRYPT_OK) {
      printf("Error verifying with DSA key 2: %s\n", error_to_string(err));
      exit(-1);
   }
   msg[0] ^= 1;
   printf("DSA Verification: %d, %d, %s\n", stat1, stat2, (stat1 == 1 && stat2 == 0) ? "passed" : "failed");
   if (!(stat1 == 1 && stat2 == 0)) exit(-1);

   /* test exporting it */
   x = sizeof(out2);
   if ((err = dsa_export(out2, &x, PK_PRIVATE, &key)) != CRYPT_OK) {
      printf("Error export PK_PRIVATE DSA key: %s\n", error_to_string(err));
      exit(-1);
   }
   printf("Exported PK_PRIVATE DSA key in %lu bytes\n", x);
   if ((err = dsa_import(out2, x, &key2)) != CRYPT_OK) {
      printf("Error importing PK_PRIVATE DSA key: %s\n", error_to_string(err));
      exit(-1);
   }
   /* verify a signature with it */
   if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2)) != CRYPT_OK) {
      printf("Error verifying with DSA key 3: %s\n", error_to_string(err));
      exit(-1);
   }
   printf("PRIVATE Import Test: %s\n", stat1 == 1 ? "passed" : "failed");
   if (stat1 == 0) exit(-1);
   dsa_free(&key2);

   /* export as public now */
   x = sizeof(out2);
   if ((err = dsa_export(out2, &x, PK_PUBLIC, &key)) != CRYPT_OK) {
      printf("Error export PK_PUBLIC DSA key: %s\n", error_to_string(err));
      exit(-1);
   }
   printf("Exported PK_PUBLIC DSA key in %lu bytes\n", x);
   if ((err = dsa_import(out2, x, &key2)) != CRYPT_OK) {
      printf("Error importing PK_PUBLIC DSA key: %s\n", error_to_string(err));
      exit(-1);
   }
   /* verify a signature with it */
   if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2)) != CRYPT_OK) {
      printf("Error verifying with DSA key 4: %s\n", error_to_string(err));
      exit(-1);
   }
   printf("PUBLIC Import Test: %s\n", stat1 == 1 ? "passed" : "failed");
   if (stat1 == 0) exit(-1);

   dsa_free(&key2);
   dsa_free(&key);
}

#ifdef PKCS_1
void pkcs1_test(void)
{
   unsigned char buf[3][128];
   int err, res1, res2, res3, prng_idx, hash_idx;
   unsigned long x, y, l1, l2, l3, i1, i2;

   /* get hash/prng  */
   hash_idx = find_hash("sha1");
   prng_idx = find_prng("yarrow");

   /* do many tests */
   for (x = 0; x < 10000; 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;

      /* encode it */
      l1 = sizeof(buf[1]);
      if ((err = pkcs_1_oaep_encode(buf[0], l3, NULL, 0, 1024, hash_idx, prng_idx, &prng, buf[1], &l1)) != CRYPT_OK) {
         printf("OAEP encode: %s\n", error_to_string(err));
         exit(-1);
      }

      /* decode it */
      l2 = sizeof(buf[2]);
      if ((err = pkcs_1_oaep_decode(buf[1], l1, NULL, 0, 1024, hash_idx, buf[2], &l2, &res1)) != CRYPT_OK) {
         printf("OAEP decode: %s\n", error_to_string(err));
         exit(-1);
      }

      if (res1 != 1 || l2 != l3 || memcmp(buf[2], buf[0], l3) != 0) {
         printf("res == %d, Outsize == %lu, should have been %lu, msg contents follow.\n", res1, l2, l3);
         printf("ORIGINAL:\n");
         for (x = 0; x < l3; x++) {
             printf("%02x ", buf[0][x]);
         }
         printf("\nRESULT:\n");
         for (x = 0; x < l2; x++) {
             printf("%02x ", buf[2][x]);
         }
         printf("\n\n");
         exit(-1);
      }

      /* test PSS */
      l1 = sizeof(buf[1]);
      if ((err = pkcs_1_pss_encode(buf[0], l3, l3>>2, hash_idx, prng_idx, &prng, 1024, buf[1], &l1)) != CRYPT_OK) {
         printf("PSS encode: %s\n", error_to_string(err));
         exit(-1); 
      }
      
      if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res1)) != CRYPT_OK) {
         printf("PSS decode1: %s\n", error_to_string(err));
         exit(-1); 
      }
      
      buf[0][i1 = abs(rand()) % l3] ^= 1;
      if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res2)) != CRYPT_OK) {
         printf("PSS decode2: %s\n", error_to_string(err));
         exit(-1); 
      }

      buf[0][i1] ^= 1;
      buf[1][i2 = abs(rand()) % l1] ^= 1;
      if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res3)) != CRYPT_OK) {
         printf("PSS decode3: %s\n", error_to_string(err));
         exit(-1); 
      }

      if (!(res1 == 1 && res2 == 0 && res3 == 0)) {
         printf("PSS failed: %d, %d, %d, %lu\n", res1, res2, res3, l3);
         exit(-1);
      }
   }
   printf("PKCS #1: Passed\n");
}

#endif /* PKCS_1 */

int
main (void)
{
#ifdef SONY_PS2
  TIMER_Init ();
#endif
  srand(time(NULL));

  register_all_algs ();
   
  if ((errnum = yarrow_start (&prng)) != CRYPT_OK) {
    printf ("yarrow_start: %s\n", error_to_string (errnum));
  }
  if ((errnum = yarrow_add_entropy ((unsigned char *)"hello", 5, &prng)) != CRYPT_OK) {
    printf ("yarrow_add_entropy: %s\n", error_to_string (errnum));
  }
  if ((errnum = yarrow_ready (&prng)) != CRYPT_OK) {
    printf ("yarrow_ready: %s\n", error_to_string (errnum));
  }

  printf (crypt_build_settings);
  test_errs ();

#ifdef HMAC
  printf ("HMAC: %s\n", hmac_test () == CRYPT_OK ? "passed" : "failed");
  if (hmac_test() != CRYPT_OK) exit(EXIT_FAILURE);
#endif

#ifdef OMAC
  printf ("OMAC: %s\n", omac_test () == CRYPT_OK ? "passed" : "failed");
  if (omac_test() != CRYPT_OK) exit(EXIT_FAILURE);
#endif

#ifdef PMAC
  printf ("PMAC: %s\n", pmac_test () == CRYPT_OK ? "passed" : "failed");
  if (pmac_test() != CRYPT_OK) exit(EXIT_FAILURE);
#endif

#ifdef EAX_MODE
  printf ("EAX : %s\n", eax_test () == CRYPT_OK ? "passed" : "failed");
  if (eax_test() != CRYPT_OK) exit(EXIT_FAILURE);
#endif

#ifdef OCB_MODE
  printf ("OCB : %s\n", ocb_test () == CRYPT_OK ? "passed" : "failed");
  if (ocb_test() != CRYPT_OK) exit(EXIT_FAILURE);
#endif

  store_tests ();
  cipher_tests ();
  hash_tests ();

#ifdef PKCS_1
  pkcs1_test();
#endif

  ecb_tests ();
  cbc_tests ();
  ctr_tests ();
  ofb_tests ();
  cfb_tests ();

  rng_tests ();
  test_prime();

  dsa_tests();
  rsa_test ();
  pad_test ();
  ecc_tests ();
  dh_tests ();

  base64_test ();

  time_ecb ();
  time_hash ();

#ifdef SONY_PS2
  TIMER_Shutdown ();
#endif

  return 0;
}