test.c

NIST推荐的素域上的椭圆曲线

 ecc_free(&usera);
}
#else
void ecc_tests(void) { printf("MECC not compiled in\n"); }
#endif

#ifdef GF
void gf_tests(void)
{
   gf_int a, b, c, d;
   int n;
   unsigned char buf[1024];

   printf("GF tests\n");
   gf_zero(a);gf_zero(b);gf_zero(c);gf_zero(d);

   /* a == 0x18000000b */
   a[1] = 1;
   a[0] = 0x8000000bUL;

   /* b == 0x012345678 */
   b[0] = 0x012345678UL;

   /* find 1/b mod a */
   gf_invmod(b,a,c);

   /* find 1/1/b mod a */
   gf_invmod(c,a,d);

   /* display them */
   printf("  %08lx %08lx\n", c[0], d[0]);

   /* store as binary string */
   n = gf_size(a);
   printf("  a takes %d bytes\n", n);
   gf_toraw(a, buf);
   gf_readraw(a, buf, n);
   printf("  a == %08lx%08lx\n", a[1], a[0]);

   /* primality testing */
   gf_zero(a);
   a[0] = 0x169;
   printf("  GF prime: %s, ", gf_is_prime(a)?"passed":"failed");
   a[0] = 0x168;
   printf("  %s\n", gf_is_prime(a)?"failed":"passed");

   /* test sqrt code */
   gf_zero(a);
   a[1] = 0x00000001;
   a[0] = 0x8000000bUL;
   gf_zero(b);
   b[0] = 0x12345678UL;

   gf_sqrt(b, a, c);
   gf_mulmod(c, c, a, b);
   printf("  (%08lx)^2 = %08lx (mod %08lx%08lx) \n", c[0], b[0], a[1], a[0]);
}
#else
void gf_tests(void) { printf("GF not compiled in\n"); }
#endif

#ifdef MPI
void test_prime(void)
{
   unsigned char buf[1024];
   mp_int a;
   int x;
  
   /* make a 1024 bit prime */
   mp_init(&a);
   rand_prime(&a, 128, &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 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 SERPENT
   register_cipher(&serpent_desc);
#endif
#ifdef RIJNDAEL
   register_cipher(&rijndael_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 TWOFISH
   register_cipher(&twofish_desc);
#endif
#ifdef RC2
   register_cipher(&rc2_desc);
#endif
#ifdef CAST5
   register_cipher(&cast5_desc);
#endif
#ifdef DES
   register_cipher(&des_desc);
   register_cipher(&des3_desc);
#endif

   register_cipher(&null_desc);

#ifdef SHA256
   register_hash(&sha256_desc);
#endif
#ifdef TIGER
   register_hash(&tiger_desc);
#endif
#ifdef SHA1
   register_hash(&sha1_desc);
#endif
#ifdef MD5
   register_hash(&md5_desc);
#endif
#ifdef SHA384
   register_hash(&sha384_desc);
#endif
#ifdef SHA512
   register_hash(&sha512_desc);
#endif
#ifdef MD4
   register_hash(&md4_desc);
#endif
#ifdef MD2
   register_hash(&md2_desc);
#endif

#ifdef YARROW
   register_prng(&yarrow_desc);
#endif
#ifdef SPRNG
   register_prng(&sprng_desc);
#endif
}

void kr_display(pk_key *kr)
{
   static const char *system[] = { "NON-KEY", "RSA", "DH", "ECC" };
   static const char *type[]   = { "PRIVATE", "PUBLIC", "PRIVATE_OPTIMIZED" };

   while (kr->system != NON_KEY) {
       printf("CRC [%08lx], System [%10s], Type [%20s], %s, %s, %s\n", kr->ID, system[kr->system], type[kr->key_type], kr->name, kr->email, kr->description);
       kr = kr->next;
   }
   printf("\n");
}

void kr_test_makekeys(pk_key **kr)
{
   if ((errno = kr_init(kr)) != CRYPT_OK) {
      printf("KR init error %s\n", error_to_string(errno));
      exit(-1);
   }

   /* make a ECC key */
   printf("KR: Making ECC key...\n");
   if ((errno = kr_make_key(*kr, &prng, find_prng("yarrow"), ECC_KEY, 24, "ecckey", "[e-mail]", "ecckey one")) != CRYPT_OK) {
      printf("Make key error: %s\n", error_to_string(errno));
      exit(-1);
   }

   /* make a RSA key */
   printf("KR: Making RSA key...\n");
   if ((errno = kr_make_key(*kr, &prng, find_prng("yarrow"), RSA_KEY, 128, "rsakey", "[e-mail]", "rsakey one")) != CRYPT_OK) {
      printf("Make key error: %s\n", error_to_string(errno));
      exit(-1);
   }

   /* make a DH key */
   printf("KR: Making DH key...\n");
   if ((errno = kr_make_key(*kr, &prng, find_prng("yarrow"), DH_KEY, 128, "dhkey", "[e-mail]", "dhkey one")) != CRYPT_OK) {
      printf("Make key error: %s\n", error_to_string(errno));
      exit(-1);
   }
}

void kr_test(void)
{
   pk_key *kr, *_kr;
   unsigned char buf[8192], buf2[8192], buf3[8192];
   unsigned long len;
   int i, j, stat;
#ifndef NO_FILE   
   FILE *f;
#endif

   kr_test_makekeys(&kr);

   printf("The original list:\n");
   kr_display(kr);

   for (i = 0; i < 3; i++) {
       len = sizeof(buf);
       if ((errno = kr_export(kr, kr->ID, kr->key_type, buf, &len)) != CRYPT_OK) {
          printf("Error exporting key %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       printf("Exported key was: %lu bytes\n", len);
       if ((errno = kr_del(&kr, kr->ID)) != CRYPT_OK) {
          printf("Error deleting key %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       kr_display(kr);
       if ((errno = kr_import(kr, buf)) != CRYPT_OK) {
          printf("Error importing key %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       kr_display(kr);
   }         

   for (i = 0; i < 3; i++) {
       len = sizeof(buf);
       if ((errno = kr_export(kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) {
          printf("Error exporting key %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       printf("Exported key was: %lu bytes\n", len);
       if ((errno = kr_del(&kr, kr->ID)) != CRYPT_OK) {
          printf("Error deleting key %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       kr_display(kr);
       if ((errno = kr_import(kr, buf)) != CRYPT_OK) {
          printf("Error importing key %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       kr_display(kr);
   }

   if ((errno = kr_clear(&kr)) != CRYPT_OK) {
      printf("Error clearing ring: %s\n", error_to_string(errno));
      exit(-1);
   }


/* TEST output to file */
#ifndef NO_FILE

   if ((errno = kr_init(&kr)) != CRYPT_OK) {
      printf("KR init error %s\n", error_to_string(errno));
      exit(-1);
   }
   kr_test_makekeys(&kr);

   /* save to file */
   f = fopen("ring.dat", "wb");
   if ((errno = kr_save(kr, f, NULL)) != CRYPT_OK) {
      printf("kr_save error %s\n", error_to_string(errno));
      exit(-1);
   }
   fclose(f);

   /* delete and load */
   if ((errno = kr_clear(&kr)) != CRYPT_OK) {
      printf("clear error: %s\n", error_to_string(errno));
      exit(-1);
   }

   f = fopen("ring.dat", "rb");
   if ((errno = kr_load(&kr, f, NULL)) != CRYPT_OK) {
      printf("kr_load error %s\n", error_to_string(errno));
      exit(-1);
   }
   fclose(f);
   remove("ring.dat");
   printf("After load and save...\n");
   kr_display(kr);
  
   if ((errno = kr_clear(&kr)) != CRYPT_OK) {
      printf("clear error: %s\n", error_to_string(errno));
      exit(-1);
   }

#endif

/* test the packet encryption/sign stuff */
   for (i = 0; i < 16; i++) buf[i] = i;
   kr_test_makekeys(&kr);
   _kr = kr;
   for (i = 0; i < 3; i++) {
       printf("Testing a key with system %d, type %d:\t", _kr->system, _kr->key_type);
       len = sizeof(buf2);
       if ((errno = kr_encrypt_key(kr, _kr->ID, buf, 16, buf2, &len, &prng, find_prng("yarrow"), find_hash("md5"))) != CRYPT_OK) {
          printf("Encrypt error, %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       len = sizeof(buf3);
       if ((errno = kr_decrypt_key(kr, buf2, buf3, &len)) != CRYPT_OK) {
          printf("decrypt error, %d, %s\n", i, error_to_string(errno));
          exit(-1);
       }
       if (len != 16 || memcmp(buf3, buf, 16)) {
          printf("kr_decrypt_key failed, %i, %lu\n", i, len);
          exit(-1);
       }
       printf("kr_encrypt_key passed, ");

       len = sizeof(buf2);
       if ((errno = kr_sign_hash(kr, _kr->ID, buf, 16, buf2, &len, &prng, find_prng("yarrow"))) != CRYPT_OK) {
          printf("kr_sign_hash failed, %i, %lu\n", i, len);
          exit(-1);
       }
       printf("kr_sign_hash: ");
       if ((errno = kr_verify_hash(kr, buf2, buf, 16, &stat)) != CRYPT_OK) {
          printf("kr_sign_hash failed, %i, %lu\n", i, len);
          exit(-1);
       }
       printf("%s, ", stat?"passed":"failed");
       buf[15] ^= 1;
       if ((errno = kr_verify_hash(kr, buf2, buf, 16, &stat)) != CRYPT_OK) {
          printf("kr_sign_hash failed, %i, %lu\n", i, len);
          exit(-1);
       }
       printf("%s\n", (!stat)?"passed":"failed");
       buf[15] ^= 1;

       len = sizeof(buf);
       if ((errno = kr_fingerprint(kr, _kr->ID, find_hash("sha1"), buf, &len)) != CRYPT_OK) {
          printf("kr_fingerprint failed, %i, %lu\n", i, len);
          exit(-1);
       }
       printf("Fingerprint:  ");
       for (j = 0; j < 20; j++) {
           printf("%02x", buf[j]);
           if (j < 19) printf(":");
       }
       printf("\n\n");

       _kr = _kr->next;
    }

/* Test encrypting/decrypting to a public key */
/* first dump the other two keys */
   kr_del(&kr, kr->ID);
   kr_del(&kr, kr->ID);
   kr_display(kr);

   /* now export it as public and private */
   len = sizeof(buf);
   if ((errno = kr_export(kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) {
       printf("Error exporting key %d, %s\n", i, error_to_string(errno));
       exit(-1);
   }

   /* check boundaries */
   memset(buf+len, 0, sizeof(buf)-len);

   len = sizeof(buf2);
   if ((errno = kr_export(kr, kr->ID, PK_PRIVATE, buf2, &len)) != CRYPT_OK) {
       printf("Error exporting key  %s\n", error_to_string(errno));
       exit(-1);
   }

   /* check boundaries */
   memset(buf2+len, 0, sizeof(buf2)-len);

   /* delete the key and import the public */
   kr_clear(&kr);
   kr_init(&kr);
   kr_display(kr);
   if ((errno = kr_import(kr, buf)) != CRYPT_OK) {
      printf("Error importing key %s\n", error_to_string(errno));
      exit(-1);
   }
   kr_display(kr);
   
   /* now encrypt a buffer */
   for (i = 0; i < 16; i++) buf[i] = i;
   len = sizeof(buf3);
   if ((errno = kr_encrypt_key(kr, kr->ID, buf, 16, buf3, &len, &prng, find_prng("yarrow"), find_hash("md5"))) != CRYPT_OK) {
      printf("Encrypt error, %d, %s\n", i, error_to_string(errno));
      exit(-1);
   }

   /* now delete the key and import the private one */
   kr_clear(&kr);
   kr_init(&kr);
   kr_display(kr);
   if ((errno = kr_import(kr, buf2)) != CRYPT_OK) {
      printf("Error importing key %s\n", error_to_string(errno));
      exit(-1);
   }
   kr_display(kr);

   /* now decrypt */
   len = sizeof(buf2);
   if ((errno = kr_decrypt_key(kr, buf3, buf2, &len)) != CRYPT_OK) {
      printf("decrypt error, %s\n", error_to_string(errno));
      exit(-1);
   }

   printf("KR encrypt to public, decrypt with private: ");
   if (len == 16 && !memcmp(buf2, buf, 16)) {
      printf("passed\n"); 
   } else {
      printf("failed\n");
   }

   kr_clear(&kr);

}   

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_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);
}   



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

 register_all_algs();

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

 printf(crypt_build_settings);
 test_errs();


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

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

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

 rng_tests();
 //test_prime();

 kr_test();
 rsa_test();
 pad_test();
 ecc_tests();
 dh_tests();

 gf_tests();
 base64_test();

 time_ecb();
 time_hash();

#ifdef SONY_PS2
  TIMER_Shutdown();
#endif

 return 0;
}