test.c

来自「文件驱动加密,功能强大,可产生加密分区,支持AES,MD2,MD4,MD5MD2」· C语言 代码 · 共 1,898 行 · 第 1/4 页

       kr_make_key (*kr, &prng, find_prng ("yarrow"), ECC_KEY, 20, "ecckey",
            "[e-mail]", "ecckey one")) != CRYPT_OK) {
    printf ("Make key error: %s\n", error_to_string (errnum));
    exit (-1);
  }

  /* make a RSA key */
  printf ("KR: Making RSA key...\n");
  if ((errnum =
       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 (errnum));
    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 ((errnum = kr_export (kr, kr->ID, kr->key_type, buf, &len)) != CRYPT_OK) {
      printf ("Error exporting key %d, %s\n", i, error_to_string (errnum));
      exit (-1);
    }
    printf ("Exported key was: %lu bytes\n", len);
    if ((errnum = kr_del (&kr, kr->ID)) != CRYPT_OK) {
      printf ("Error deleting key %d, %s\n", i, error_to_string (errnum));
      exit (-1);
    }
    kr_display (kr);
    if ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) {
      printf ("Error importing key %d, %s\n", i, error_to_string (errnum));
      exit (-1);
    }
    kr_display (kr);
  }

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

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


/* TEST output to file */
#ifndef NO_FILE

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

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

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

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

  if ((errnum = kr_clear (&kr)) != CRYPT_OK) {
    printf ("clear error: %s\n", error_to_string (errnum));
    exit (-1);
  }
#endif

/* test the packet encryption/sign stuff */
  for (i = 0; i < 32; 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 ((errnum =
     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 (errnum));
      exit (-1);
    }
    len = sizeof (buf3);
    if ((errnum = kr_decrypt_key (kr, buf2, buf3, &len)) != CRYPT_OK) {
      printf ("decrypt error, %d, %s\n", i, error_to_string (errnum));
      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 ((errnum =
     kr_sign_hash (kr, _kr->ID, buf, 32, buf2, &len, &prng,
               find_prng ("yarrow"))) != CRYPT_OK) {
      printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum));
      exit (-1);
    }
    printf ("kr_sign_hash: ");
    if ((errnum = kr_verify_hash (kr, buf2, buf, 32, &stat)) != CRYPT_OK) {
      printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum));
      exit (-1);
    }
    printf ("%s, ", stat ? "passed" : "failed");
    buf[15] ^= 1;
    if ((errnum = kr_verify_hash (kr, buf2, buf, 32, &stat)) != CRYPT_OK) {
      printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum));
      exit (-1);
    }
    printf ("%s\n", (!stat) ? "passed" : "failed");
    buf[15] ^= 1;

    len = sizeof (buf);
    if ((errnum =
     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 ((errnum = kr_export (kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) {
    printf ("Error exporting key %d, %s\n", i, error_to_string (errnum));
    exit (-1);
  }

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

  len = sizeof (buf2);
  if ((errnum = kr_export (kr, kr->ID, PK_PRIVATE, buf2, &len)) != CRYPT_OK) {
    printf ("Error exporting key  %s\n", error_to_string (errnum));
    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 ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) {
    printf ("Error importing key %s\n", error_to_string (errnum));
    exit (-1);
  }
  kr_display (kr);

  /* now encrypt a buffer */
  for (i = 0; i < 16; i++)
    buf[i] = i;
  len = sizeof (buf3);
  if ((errnum =
       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 (errnum));
    exit (-1);
  }

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

  /* now decrypt */
  len = sizeof (buf2);
  if ((errnum = kr_decrypt_key (kr, buf3, buf2, &len)) != CRYPT_OK) {
    printf ("decrypt error, %s\n", error_to_string (errnum));
    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);
}
#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);
}




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

  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 ();

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

  rng_tests ();
  test_prime();

#ifdef KR
  kr_test ();
#endif
  dsa_tests();
  rsa_test ();
  pad_test ();
  ecc_tests ();
  dh_tests ();


  gf_tests ();
  base64_test ();

  time_ecb ();
  time_hash ();

#ifdef SONY_PS2
  TIMER_Shutdown ();
#endif

  return 0;
}