#include "smg_rsa.h"
#include "mpi.h"

#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <stdio.h>

extern void adainit(void);
extern void adafinal(void);

void err(char *msg)
{
  fprintf(stderr, "%s\n", msg);
  exit(1);
}

void time_entropy_source(int nruns, int noctets) {
	unsigned char buffer[noctets];
	int read, i;
	struct timespec tstart, tend;
	long int diff;

	clock_gettime(CLOCK_MONOTONIC, &tstart);
	for (i=0; i<nruns; i++) {
		read = get_random_octets(noctets,buffer);
		if (read != noctets)
			err("Failed reading from entropy source!");
	}
	clock_gettime(CLOCK_MONOTONIC, &tend);

	diff = tend.tv_sec-tstart.tv_sec;
	double kbps = (nruns*noctets) / (diff*1000.0);
	printf("ENTROPY source timing: %d kB in %ld seconds, at an average speed of %f kB/s over %d runs of %d octets each\n", nruns*noctets, diff, kbps, nruns, noctets);
}

void test_entropy_output(unsigned int noctets, char * filename) {
	FILE * out;
	int source;
	unsigned int nread, total_read, to_read;
	const int buffer_length = 1000;
	unsigned char buffer[buffer_length];

	source = open_entropy_source(ENTROPY_SOURCE);
	if (source <= 0)
		err("unable to access entropy source!");

	out = fopen(filename, "wb");
	if ( !out )
		err("unable to open output file for test_entropy_output!");

	printf("TEST_ENTROPY_SOURCE: reading %u octets from %s ", noctets, ENTROPY_SOURCE);
	total_read = 0;
	while (total_read < noctets) {
		to_read = noctets - total_read;
		if (to_read > buffer_length)
			to_read = buffer_length;

		nread = get_random_octets_from(to_read, buffer, source);
		if (nread > 0) {
			total_read = total_read + nread;
			fwrite(buffer, 1, nread, out);
			fflush(out);
			printf(".");
			fflush(stdout);
		}
	}
	printf("done.\n");

	fclose(out);
	close(source);
}

void test_is_composite(int nruns, char *hex_number, int expected) {
	int i;
	int output;
	int count_ok = 0;
	int source = open_entropy_source(ENTROPY_SOURCE);
	MPI p = mpi_alloc(0);

	mpi_fromstr(p, hex_number);
	printf("TEST is_composite on MPI(hex) ");
	mpi_print(stdout, p, 1);
	for (i=0; i < nruns; i++) {
		printf(".");
		fflush(stdout);
		output = is_composite(p, M_R_ITERATIONS, source);
		if (output == expected)
			count_ok = count_ok + 1;
	}
	printf("done, with %d out of %d correct runs for expected=%d: %s\n", count_ok, nruns, expected, count_ok==nruns? "PASS":"FAIL");
	mpi_free(p);
	close(source);
}

void time_mr(int nruns) {
	struct timespec tstart, tend;
	long int diff;
	int i;
	MPI prime;
	unsigned int noctets = KEY_LENGTH_OCTETS / 2;
	unsigned int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);

	int entropy_source = open_entropy_source(ENTROPY_SOURCE);
	if (entropy_source <= 0)
		err("can't open entropy source!");

	/* first generate a prime of half key length, to make sure M-R will run max number of iterations */
	printf("Generating a prime number of %d octets length for M-R timing test\n", noctets);
	prime = mpi_alloc(nlimbs);
	gen_random_prime(noctets, prime);

	printf("Running timing test for Miller-Rabin with %d repetitions and %d witnesses on prime number ", nruns, M_R_ITERATIONS);
	mpi_print(stdout, prime, 1);
	printf("\n");
	/* now do the actual runs and time it all */
	clock_gettime(CLOCK_MONOTONIC, &tstart);
	for (i=0; i<nruns; i++) {
		if (is_composite(prime, M_R_ITERATIONS, entropy_source))
			printf("FAIL");
		else printf(".");
		fflush(stdout);
	}
	clock_gettime(CLOCK_MONOTONIC, &tend);

	diff = tend.tv_sec-tstart.tv_sec;
	printf("\nTimings on prime number %d octets long, %d runs of MR with %d iterations (witnesses checked) each\n", \
		noctets, nruns, M_R_ITERATIONS);
	printf("Total time: %ld seconds\nTime per MR run: %f seconds\nTime per MR iteration: %f seconds\n",\
			 diff, diff / (1.0*nruns), diff / (1.0*nruns * M_R_ITERATIONS));

	mpi_free(prime);
	close(entropy_source);
}

void test_rpng(int nruns) {
	unsigned int noctets = KEY_LENGTH_OCTETS / 2;
	unsigned int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
	int entropy_source = open_entropy_source(ENTROPY_SOURCE);
	if (entropy_source <= 0)
		err("can't open entropy source!");

	MPI prime = mpi_alloc(nlimbs);
	int i;

	printf("TEST: random prime number generator with %d runs\n", nruns);
	for (i = 0;i < nruns; i++) {
		gen_random_prime(noctets, prime);
		printf("Run %d: ", i+1);
		mpi_print(stdout, prime, 1);
		if (is_composite(prime, M_R_ITERATIONS, entropy_source))
			printf("  **FAIL**\n");
		else
			printf("  **PASS**\n");
	}

	mpi_free(prime);
	close(entropy_source);
}

void time_rpng(int nruns) {
	struct timespec tstart, tend;
	long int diff;

	unsigned int noctets = KEY_LENGTH_OCTETS / 2;
	unsigned int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);

	int entropy_source = open_entropy_source(ENTROPY_SOURCE);
	if (entropy_source <= 0)
		err("can't open entropy source!");

	MPI prime = mpi_alloc(nlimbs);
	int i;

	printf("TIMING: random prime number generator with %d runs\n", nruns);
	clock_gettime(CLOCK_MONOTONIC, &tstart);
	for (i = 0;i < nruns; i++) {
		gen_random_prime(noctets, prime);
	}
	clock_gettime(CLOCK_MONOTONIC, &tend);

	diff = tend.tv_sec-tstart.tv_sec;

	printf("TOTAL: %ld seconds\n", diff);
	printf("Average: %f seconds to generate one random prime of %d octets length\n", diff / (1.0*nruns), noctets);
	mpi_free(prime);
	close(entropy_source);
}

/* Test encryption+decryption on noctets of random data, using sk
 * Output is written to file.
 */
void test_rsa_keys( RSA_secret_key *sk, unsigned int noctets, FILE *file ) {
	RSA_public_key pk;
	MPI test = mpi_alloc ( mpi_nlimb_hint_from_nbytes (noctets) );
	MPI out1 = mpi_alloc ( mpi_nlimb_hint_from_nbytes (noctets) );
	MPI out2 = mpi_alloc ( mpi_nlimb_hint_from_nbytes (noctets) );

	pk.n = mpi_copy(sk->n);
	pk.e = mpi_copy(sk->e);
	unsigned char *p;
	p = xmalloc(noctets);

	fprintf(file, "TEST encrypt/decrypt on %d octets of random data\n", noctets);
	fflush(file);
	if (get_random_octets( noctets, p) == noctets) {
		mpi_set_buffer( test, p, noctets, 0 );

		fprintf(file, "TEST data:\n");
		mpi_print(file, test, 1);
		fprintf(file, "\n");
		fflush(file);

		public_rsa( out1, test, &pk );
		secret_rsa( out2, out1, sk );

		fprintf(file, "ENCRYPTED with PUBLIC key data:\n");
		mpi_print(file, out1, 1);
		fprintf(file, "\n");
		fflush(file);

		fprintf(file, "DECRYPTED with SECRET key:\n");
		mpi_print(file, out2, 1);
		fprintf(file, "\n");
		fflush(file);

		if( mpi_cmp( test, out2 ) )
			fprintf(file, "FAILED: RSA operation: public(secret) failed\n");
		else
			fprintf(file, "PASSED: RSA operation: public(secret) passed\n");
		fflush(file);

		secret_rsa( out1, test, sk );
		public_rsa( out2, out1, &pk );
		if( mpi_cmp( test, out2 ) )
			fprintf(file, "FAILED: RSA operation: secret(public) failed\n");
		else
			fprintf(file, "PASSED: RSA operation: secret(public) passed\n");
	}
	else
		fprintf(file, "FAILED: not enough bits returned from entropy source\n");

	fflush(file);
	xfree(p);
	mpi_free( pk.n);
	mpi_free( pk.e);

	mpi_free( test );
	mpi_free( out1 );
	mpi_free( out2 );
}

void test_rsa( int nruns, FILE *fkeys, FILE *fout) {
	RSA_secret_key sk;
	int noctets = KEY_LENGTH_OCTETS;
	int noctets_pq = noctets / 2;
	int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
	int nlimbs_pq = mpi_nlimb_hint_from_nbytes(noctets_pq);
	int i;

	sk.n = mpi_alloc(nlimbs);
	sk.e = mpi_alloc(nlimbs);
	sk.d = mpi_alloc(nlimbs);
	sk.p = mpi_alloc(nlimbs_pq);
	sk.q = mpi_alloc(nlimbs_pq);
	sk.u = mpi_alloc(nlimbs_pq);

	printf("TEST RSA key generation and use with %d runs\n", nruns);
	fflush(stdout);

	for (i = 0;i < nruns; i++) {
		gen_keypair(&sk);
		printf(".");
		fflush(stdout);

		mpi_print(fkeys, sk.n, 1);
		fwrite("\n", sizeof(char), 1, fkeys);

		mpi_print(fkeys, sk.e, 1);
		fwrite("\n", sizeof(char), 1, fkeys);

		mpi_print(fkeys, sk.d, 1);
		fwrite("\n", sizeof(char), 1, fkeys);

		mpi_print(fkeys, sk.p, 1);
		fwrite("\n", sizeof(char), 1, fkeys);

		mpi_print(fkeys, sk.q, 1);
		fwrite("\n", sizeof(char), 1, fkeys);

		mpi_print(fkeys, sk.u, 1);
		fwrite("\n", sizeof(char), 1, fkeys);

		test_rsa_keys(&sk, noctets_pq, fout);
		printf("*");
		fflush(stdout);
	}

	mpi_free(sk.n);
	mpi_free(sk.e);
	mpi_free(sk.d);
	mpi_free(sk.p);
	mpi_free(sk.q);
	mpi_free(sk.u);

}

void test_rsa_8e(int nruns) {
  RSA_secret_key sk;
	int noctets = KEY_LENGTH_OCTETS;
	int noctets_pq = noctets / 2;
	int nlimbs_pq = mpi_nlimb_hint_from_nbytes(noctets_pq);

  sk.n = mpi_alloc(0);
  sk.e = mpi_alloc(0);
  sk.d = mpi_alloc(0);
  sk.p = mpi_alloc(0);
  sk.q = mpi_alloc(0);
  sk.u = mpi_alloc(0);

  mpi_fromstr(sk.n, "0x\
B51BE851F39159EAC714F3E0376713A84DAD36A82D446D0A257A391870F45FAE13C4CC\
F400DDA9F604991134C0934161554EEFEAA3147BF0EADC77B99E2B9B6E4EE942EA9D07\
5F015EE2465B491F4130E04E1BBB6CCDC98F6E8789D4F7FCA3E3FF83C6100CAF2B764E\
A5AF7CBA9B27C13EE72EA7A8602F34B32E17C2BA56CFBA4223F7D9A03C23336095D34F\
BF66E88BF5CE661D66C251DFAD4CB2BA8D1E1669AC927894EA20DABABD2495BC2A4BA3\
A25C79ABEC2D57F45F0F889D962C777A663D0AB25D3650DFDC6D77C528803C0C6E12BD\
05281B33C603BEA66A0C2ACBEBD1CA53D32C2269294C9B93E742CA563AF39E939C32CE\
51D5ED827F9C217EF58CC518B635D0E03BA778BCEBAF9A2CDB493282D751A5977CB907\
C8708D1EF1CAE644C1F2525DDE98E29761B1ADF0965F08AA856DF540AEFD67F96B92AE\
83636C31A507C59635C6D435C5E7EE333DC2257C07BC0FCE27CF400F6EB7A6B90FFF00\
C3C1179615BF5DA6137476926C09D8CCD03257DFCAEF12BE9DC1D3F621D6C97D7F3E6D\
534337579B4B65AE212ACC26FC3861E24033E6F12A601D473A65EFC5F25ABD5D6049EA\
DD6D76BA60AA218C5EBE13439AAFFF0088C49ACC0E9F7DE56DB03F585E1AC2862EB990\
59724FD407C4ACD3DD14A53A6A35F6AFAE03EA53A4E742CC370087692E206A2422FF9D");

  sk.e = mpi_alloc(nlimbs_pq);
  int i;
  char echar[109];
  int ne = 109;
  for (i=0;i<ne;i++)
    echar[i] = 0;

  echar[ne-1] = 59;
  echar[ne-2] = 153;
  echar[ne-3] = 145;
  echar[ne-4] = 109;
  echar[ne-5] = 236;
  echar[ne-6] = 157;
  echar[ne-7] = 64;
  echar[ne-8] = 195;
  //NB: this test WILL FAIL if only mpi_set_buffer called.
  mpi_set_buffer(sk.e, echar, ne, 0);
  mpi_normalize(sk.e);

  mpi_fromstr(sk.d, "0x\
7694F5266A995D31DCF3AE40A35AAE4B6F6E2D625EDE8AEF3DF4418C1C5B6D46FBC8AC\
1C018B475BB531807C6CB649A3D2A3044B11560B15DFD17E29E2294CBBE4D2E787B048\
D7EF19DB02392534DBBE8C0F57DCA17448B5DCDA08A69C3177749BEA150BBC506372DD\
D6DBE48869567B31B00FB855AB4700A0458570393F2AA6A5887DAB0E6FD194B970AED2\
A6AA1AE13C1B4BA1154F7D2C55699429CD634425460B961C581639E6CC005B6FDEF273\
E5A8A34F39E5F7999AEA6E6767A9842203C00763BEDECFB2FCBC4D071AADB81D3DBB32\
58872EBA06804183AE66DE1859758BB1752486DC95887DA71BA231E115FFA43AB5F596\
21F5DA9BDF780BB35E3DAA06C2BE83FFE160BE6C625D8D33A42491510E22AD545AE0FE\
933F2A70FCBF794156EE6FDB4351404706EC528BD865A3F75B66ACE3186620B5713F44\
D2D185BC2F8B42B2C9BD8274D11D4E4449D9237398A4D576A0722871B96C2675E32EAD\
C8E2DB958FB016D9DBDE9653FC7A346689D348F1161C3E183C19DDD92A313E2191435E\
449E819FC3B04CA8B7874B3283AE52FEE822525BAAA14F7E28DF2B1EA9383FBEFA7A4B\
AB22BC178CDCF5064E09D8EAAAC4EEF50550E8CB5D3F3079D80FECC4A7B2587BFA6B68\
0798D6A6175BA3ABAC52B2BE583849FC3C47A6B7B9BB6CE18AF23BFC54E8F04AA6AF3");
  mpi_fromstr(sk.p, "0x\
C9AE5920BA2CFC9A765C25D8B75E8A42845F5B13F8B9386698C31D01BDDE572BD181E4\
5FD46666BB9D3F5043D2B3F7B4B3D301DA403CED22ADBB60544D2000EBB3FEF3E1674D\
B2F2BB81A81573B3556689FD2AF740367EB9C7CFFC08BD95471849C456B9AD93BA9462\
A541FBD7618E9BF8F8B8DC76233D22826085E06F8CC22C4DB46DE8A6E666FBF678052E\
80B5D116B4CAC4FCA1C3348F45895D823842E6A4E2B605F0F8CCD9A75F59B3B4BBC102\
B9B7F948EC28AB60BF4FD5441E4EF48B25D6A50C5AAEB882EE9862E042F54510366730\
B8DD56C02FC43CD95F6EF7B92379E6DED28764CDD22899C845F484EF8F777B9A527FC1");
  mpi_fromstr(sk.q, "0x\
E5E324CDCAEA29DE1EFB3E2280B51E4461A692A5844F64E6917677907A7825A8ABBEF1\
1E0D8A5D70DF703D4D4014FE0A125E5A409AD7DC9B5F2ECBDF518C8ECE783F217268CF\
ED93689AEB5D970B3C898B7ACB8868E2D284A85F1B82926C67F6F6675F78799CC280E4\
197AB3800B00ED9B063B9A00F483CDD5158DCE31B575F579E4206D32E483994B58D5EA\
7FBE224326672ED00BA1B432796E78B80816D641BE4F81BF8CCA5A2E93A0E9FA4D6133\
4E893903E133DA215295FAF00F9BA1F224BC700ABCD6A94FB4C1A006BD5673D304B207\
F8EE6752F41C4D2F7DE310266EAF61B0545A26FAC66A46B90015FC2374D4FD01F836DD");
  mpi_fromstr(sk.u, "0x\
746B5BD406C84FDBC8EF4DEC7D79831630B45579D7865695BDB288C0E8DB39749200B0\
720F6FAF1CBB3F2EE6C6FF3DA72B4C8505D50732DBEE2E92CD9A13B6919D5173DBA708\
B44C36129A3494DCD77B9991F88F528FF11706E0D6EFC67705937F5A11FCBC984F89F2\
A4168A8ED2A391FAD06C1E15F838B890126DF650DA803661448F8CEA755F15432A83C8\
99CB0AFCB5D922514DF19697416DDC79CA2AC7CB30AEADEC2D68B0F43D178DAB33656E\
3CDF08A3D2B903797E74210478526D49AA740F906789740826DDD3CF2E5F032B9E0536\
85560848F127A1A844BF00C5819FFEB2016E0DBC86BF375554DC28EC2DC7FD8830AA3D");

	test_rsa_keys(&sk, noctets_pq, stdout);

	mpi_free(sk.n);
	mpi_free(sk.e);
	mpi_free(sk.d);
	mpi_free(sk.p);
	mpi_free(sk.q);
	mpi_free(sk.u);
}

void test_rsa_exp() {
	MPI msg = mpi_alloc(0);
	MPI expected = mpi_alloc(0);
	MPI result;

	RSA_public_key pk;
	pk.n = mpi_alloc(0);
	pk.e = mpi_alloc(0);

	printf("TEST verify of rsa exponentiation on input data: \n");

	mpi_fromstr(msg, "0x\
5B6A8A0ACF4F4DB3F82EAC2D20255E4DF3E4B7C799603210766F26EF87C8980E737579\
EC08E6505A51D19654C26D806BAF1B62F9C032E0B13D02AF99F7313BFCFD68DA46836E\
CA529D7360948550F982C6476C054A97FD01635AB44BFBDBE2A90BE06F7984AC8534C3\
8613747F340C18176E6D5F0C10246A2FCE3A668EACB6165C2052497CA2EE483F4FD8D0\
6A9911BD97E9B6720521D872BD08FF8DA11A1B8DB147F252E4E69AE6201D3B374B171D\
F445EF2BF509D468FD57CEB5840349B14C6E2AAA194D9531D238B85B8F0DD352D1E596\
71539B429849E5D965E438BF9EFFC338DF9AADF304C4130D5A05E006ED855F37A06242\
28097EF92F6E78CAE0CB97");

	mpi_fromstr(expected, "0x\
1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF003051300\
D0609608648016503040203050004406255509399A3AF322C486C770C5F7F6E05E18FC\
3E2219A03CA56C7501426A597187468B2F71B4A198C807171B73D0E7DBC3EEF6EA6AFF\
693DE58E18FF84395BE");
	result = mpi_alloc( mpi_get_nlimbs(expected) );

	mpi_fromstr(pk.n, "0x\
CDD49A674BAF76D3B73E25BC6DF66EF3ABEDDCA461D3CCB6416793E3437C7806562694\
73C2212D5FD5EED17AA067FEC001D8E76EC901EDEDF960304F891BD3CAD7F9A335D1A2\
EC37EABEFF3FBE6D3C726DC68E599EBFE5456EF19813398CD7D548D746A30AA47D4293\
968BFBAFCBF65A90DFFC87816FEE2A01E1DC699F4DDABB84965514C0D909D54FDA7062\
A2037B50B771C153D5429BA4BA335EAB840F9551E9CD9DF8BB4A6DC3ED1318FF3969F7\
B99D9FB90CAB968813F8AD4F9A069C9639A74D70A659C69C29692567CE863B88E191CC\
9535B91B417D0AF14BE09C78B53AF9C5F494BCF2C60349FFA93C81E817AC682F0055A6\
07BB56D6A281C1A04CEFE1");

	mpi_fromstr( pk.e, "0x10001");

	mpi_print( stdout, msg, 1);
	printf("\n");

	public_rsa( result, msg, &pk);
	if ( mpi_cmp( result, expected) != 0 )
		printf( "FAILED\n");
	else
		printf( "PASSED\n");

	printf("Expected:\n");
	mpi_print( stdout, expected, 1);
	printf("\n");

	printf("Obtained:\n");
	mpi_print( stdout, result, 1);
	printf("\n");

	mpi_free( pk.n );
	mpi_free( pk.e );
	mpi_free( msg );
	mpi_free( expected );
	mpi_free( result );
}

void time_rsa_gen( int nruns ) {
	struct timespec tstart, tend;
	long int diff;
	int i;

	RSA_secret_key sk;
	int noctets = KEY_LENGTH_OCTETS;
	int noctets_pq = noctets / 2;
	int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
	int nlimbs_pq = mpi_nlimb_hint_from_nbytes(noctets_pq);
	sk.n = mpi_alloc(nlimbs);
	sk.e = mpi_alloc(nlimbs);
	sk.d = mpi_alloc(nlimbs);
	sk.p = mpi_alloc(nlimbs_pq);
	sk.q = mpi_alloc(nlimbs_pq);
	sk.u = mpi_alloc(nlimbs_pq);

	clock_gettime(CLOCK_MONOTONIC, &tstart);
	for (i = 0;i < nruns; i++) {
		gen_keypair(&sk);
	}
	clock_gettime(CLOCK_MONOTONIC, &tend);

	diff = tend.tv_sec-tstart.tv_sec;

	printf("TOTAL: %ld seconds for generating %d key pairs\n", diff, nruns);
	printf("Average (%d runs): %f seconds per TMSR RSA key pair.\n",
				nruns, diff / (1.0*nruns));
	mpi_free(sk.n);
	mpi_free(sk.e);
	mpi_free(sk.d);
	mpi_free(sk.p);
	mpi_free(sk.q);
	mpi_free(sk.u);
}

void test_mpi_buffer() {
  unsigned int noctets = 10;
  int nlimbs = mpi_nlimb_hint_from_nbytes( noctets );
  MPI m = mpi_alloc( nlimbs );
  unsigned char *setbuffer = xmalloc( noctets );
  unsigned char *getbuffer;
  unsigned int i, sign, mpilen, nerrors;

  for (i=0; i< noctets; i++)
    setbuffer[i] = i;

  mpi_set_buffer( m, setbuffer, noctets, 0);

  getbuffer = mpi_get_buffer( m, &mpilen, &sign );

  if (mpilen == noctets -1 ) {
    nerrors = 0;
    for (i=0;i<noctets-1;i++)
      if (setbuffer[i+1] != getbuffer[i])
        nerrors = nerrors + 1;
    if (nerrors == 0) {
      printf("WARNING: 0-led octet discarded by mpi_set_buffer!\n");
      printf("Value ret by mpi_get_buffer != value given to set_buffer!\n");
    }
    else
      printf("FAIL: got different lengths and %d different values!\n", nerrors);
  }
  else if (mpilen != noctets)
    printf("FAIL: mpilen is %d; noctets is %d\n", mpilen, noctets);
  else
  {
    nerrors = 0;
    for (i=0;i<noctets-1;i++) {
      if (setbuffer[i]!=getbuffer[i])
        nerrors= nerrors+1;
    }
    if (nerrors>0)
      printf("FAIL: got %d different values!\n", nerrors);
    else printf("PASSED: mpi_get/set_buffer\n");
  }

  mpi_free(m);
  xfree(setbuffer);
  xfree(getbuffer);
}

void test_dirty_float_rng( int nruns ) {
  int i, status;
  float dirty;

  printf("Running test for smg rng dirty float with %d runs\n", nruns);
  for (i=0; i<nruns; i++) {
    status = rng_dirty_float( &dirty );
    printf("Run %d: %f status %s\n", i+1, dirty, status>0 ? "OK" : "FAIL");
  }
}

void test_ieee_float_rng( int nruns ) {
  int i, status;
  float ieee;

  printf("Running test for smg rng ieee 745/1985 float with %d runs\n", nruns);
  for (i=0; i<nruns; i++) {
    status = rng_float_754_1985( &ieee );
    printf("Run %d: %f status %s\n", i+1, ieee, status>0 ? "OK" : "FAIL");
  }
}

void test_uint32_rng( int nruns ) {
  int i, status;
  uint32_t n;

  printf("Running test for smg rng unsigned int32 with %d runs\n", nruns);
  for (i=0; i<nruns; i++) {
    status = rng_uint32( &n );
    printf("Run %d: %"PRIu32" status %s\n", i+1, n, status>0 ? "OK" : "FAIL");
  }
}

void test_uint64_rng( int nruns ) {
  int i, status;
  uint64_t n;

  printf("Running test for smg rng unsigned int64 with %d runs\n", nruns);
  for (i=0; i<nruns; i++) {
    status = rng_uint64( &n );
    printf("Run %d: %"PRIu64" status %s\n", i+1, n, status>0 ? "OK" : "FAIL");
  }
}


int main(int ac, char **av)
{
	int nruns;
	int id;
	FILE *fk;
	FILE *fout;

	if (ac<2) {
		printf("Usage: %s number_of_runs/octets [testID]\n", av[0]);
		return -1;
	}
	nruns = atoi(av[1]);

	if (ac < 3)
		id = -1;
	else
		id = atoi(av[2]);

	switch ( id ) {
		case 0:
			printf("Timing entropy source...\n");
			time_entropy_source(nruns, 4096);
			break;
		case 1:
			test_entropy_output(nruns, "entropy_source_output.txt");
			break;
		case 2:
			/* tests on miller-rabin */
			/* a few primes (decimal): 65537, 116447, 411949103, 20943302231 */
			test_is_composite(nruns, "0x10001", 0);
			test_is_composite(nruns, "0x1C6DF", 0);
			test_is_composite(nruns, "0x188DD82F", 0);
			test_is_composite(nruns, "0x4E0516E57", 0);
			/* a few mersenne primes (decimal): 2^13 - 1 = 8191, 2^17 - 1 = 131071, 2^31 - 1 = 2147483647 */
			test_is_composite(nruns, "0x1FFF", 0);
			test_is_composite(nruns, "0x1FFFF", 0);
			test_is_composite(nruns, "0x7FFFFFFF", 0);
			/* a few carmichael numbers, in decimal: 561, 60977817398996785 */
			test_is_composite(nruns, "0x231", 1);
			test_is_composite(nruns, "0xD8A300793EEF31", 1);
			/* an even number */
			test_is_composite(nruns, "0x15A9E672864B1E", 1);
			/* a phuctor-found non-prime public exponent: 170141183460469231731687303715884105731 */
			test_is_composite(nruns, "0x80000000000000000000000000000003", 1);
			break;
		case 3:
			time_mr(nruns);
			break;
		case 4:
			test_rpng(nruns);
			break;
		case 5:
			time_rpng(nruns);
			break;
		case 6:
			fk = fopen("keys.asc", "a");
			if ( fk == NULL )
				err("Failed to open file keys.asc!");
			fout = fopen("check_keys.asc", "a");
			if ( fout == NULL ) {
				fclose(fk);
				err("Failed to open file keys_check.asc!");
			}
			test_rsa(nruns, fk, fout);
			fclose(fk);
			fclose(fout);
			break;
		case 7:
			test_rsa_exp();
			break;
		case 8:
			time_rsa_gen(nruns);
			break;
    case 9:
      test_mpi_buffer();
      break;
    case 10:
      test_dirty_float_rng(nruns);
      break;
    case 11:
      test_ieee_float_rng(nruns);
      break;
    case 12:
      test_uint32_rng(nruns);
      break;
    case 13:
      test_uint64_rng(nruns);
      break;
    case 14:
      test_rsa_8e(nruns);
      break;
		default:
			printf("Current test ids:\n");
			printf("0 for timing entropy source\n");
			printf("1 for entropy output test\n");
			printf("2 for is_composite (Miller-Rabin) test\n");
			printf("3 for timing Miller-Rabin\n");
			printf("4 for random prime number generator test\n");
			printf("5 for timing random prime number generator\n");
			printf("6 for testing rsa key pair generation and use; \
writes to keys.asc and check_keys.asc\n");
			printf("7 for testing rsa exponentiation (fixed data)\n");
			printf("8 for timing rsa key pair generator\n");
      printf("9 for testing mpi_set/get_buffer\n");
      printf("10 for testing smg_rng dirty float\n");
      printf("11 for testing smg_rng ieee 745/1985 float\n");
      printf("12 for testing smg_rng uint32 \n");
      printf("13 for testing smg_rng uint64 \n");
      printf("14 for testing rsa with 8-octets e \n");
	}

  return 0;
}