text: /*
  	Validate ed25519 implementation against the official test vectors from 
  	http://ed25519.cr.yp.to/software.html
  */
  
  #include <stdio.h>
  #include <string.h>
  #include <time.h>
  #include "ed25519.h"
  
  #include "test-ticks.h"
  
  static void
  edassert(int check, int round, const char *failreason) {
  	if (check)
  		return;
  	printf("round %d, %s\n", round, failreason);
  	exit(1);
  }
  
  static void
  edassert_die(const unsigned char *a, const unsigned char *b, size_t len, int round, const char *failreason) {
  	size_t i;
  	if (round > 0)
  		printf("round %d, %s\n", round, failreason);
  	else
  		printf("%s\n", failreason);
  	printf("want: "); for (i = 0; i < len; i++) printf("%02x,", a[i]); printf("\n");
  	printf("got : "); for (i = 0; i < len; i++) printf("%02x,", b[i]); printf("\n");
  	printf("diff: "); for (i = 0; i < len; i++) if (a[i] ^ b[i]) printf("%02x,", a[i] ^ b[i]); else printf("  ,"); printf("\n\n");
  	exit(1);
  }
  
  static void
  edassert_equal(const unsigned char *a, const unsigned char *b, size_t len, const char *failreason) {
  	if (memcmp(a, b, len) == 0)
  		return;
  	edassert_die(a, b, len, -1, failreason);
  }
  
  static void
  edassert_equal_round(const unsigned char *a, const unsigned char *b, size_t len, int round, const char *failreason) {
  	if (memcmp(a, b, len) == 0)
  		return;
  	edassert_die(a, b, len, round, failreason);
  }
  
  
  /* test data */
  typedef struct test_data_t {
  	unsigned char sk[32], pk[32], sig[64];
  	const char *m;
  } test_data;
  
  
  test_data dataset[] = {
  #include "regression.h"
  };
  
  /* result of the curve25519 scalarmult ((|255| * basepoint) * basepoint)... 1024 times */
  const curved25519_key curved25519_expected = {
  	0xac,0xce,0x24,0xb1,0xd4,0xa2,0x36,0x21,
  	0x15,0xe2,0x3e,0x84,0x3c,0x23,0x2b,0x5f,
  	0x95,0x6c,0xc0,0x7b,0x95,0x82,0xd7,0x93,
  	0xd5,0x19,0xb6,0xf1,0xfb,0x96,0xd6,0x04
  };
  
  
  /* from ed25519-donna-batchverify.h */
  extern unsigned char batch_point_buffer[3][32];
  
  /* y coordinate of the final point from 'amd64-51-30k' with the same random generator */
  static const unsigned char batch_verify_y[32] = {
  	0x51,0xe7,0x68,0xe0,0xf7,0xa1,0x88,0x45,
  	0xde,0xa1,0xcb,0xd9,0x37,0xd4,0x78,0x53,
  	0x1b,0x95,0xdb,0xbe,0x66,0x59,0x29,0x3b,
  	0x94,0x51,0x2f,0xbc,0x0d,0x66,0xba,0x3f
  };
  
  /*
  static const unsigned char batch_verify_y[32] = {
  	0x5c,0x63,0x96,0x26,0xca,0xfe,0xfd,0xc4,
  	0x2d,0x11,0xa8,0xe4,0xc4,0x46,0x42,0x97,
  	0x97,0x92,0xbe,0xe0,0x3c,0xef,0x96,0x01,
  	0x50,0xa1,0xcc,0x8f,0x50,0x85,0x76,0x7d
  };
  
  Introducing the 128 bit r scalars to the heap _before_ the largest scalar
  fits in to 128 bits alters the heap shape and produces a different,
  yet still neutral/valid y/z value.
  
  This was the value of introducing the r scalars when the largest scalar fit
  in to 135-256 bits. You can produce it with amd64-64-24k / amd64-51-32k
  with the random sequence used in the first pass by changing
  
      unsigned long long hlen=((npoints+1)/2)|1;
  
  to
  
      unsigned long long hlen=npoints;
  
  in ge25519_multi_scalarmult.c
  
  ed25519-donna-batchverify.h has been modified to match the 
  default amd64-64-24k / amd64-51-32k behaviour
  */
  
  
  
  /* batch test */
  #define test_batch_count 64
  #define test_batch_rounds 96
  
  typedef enum batch_test_t {
  	batch_no_errors = 0,
  	batch_wrong_message = 1,
  	batch_wrong_pk = 2,
  	batch_wrong_sig = 3
  } batch_test;
  
  static int
  test_batch_instance(batch_test type, uint64_t *ticks) {
  	ed25519_secret_key sks[test_batch_count];
  	ed25519_public_key pks[test_batch_count];
  	ed25519_signature sigs[test_batch_count];
  	unsigned char messages[test_batch_count][128];
  	size_t message_lengths[test_batch_count];
  	const unsigned char *message_pointers[test_batch_count];
  	const unsigned char *pk_pointers[test_batch_count];
  	const unsigned char *sig_pointers[test_batch_count];
  	int valid[test_batch_count], ret, validret;
  	size_t i;
  	uint64_t t;
  
  	/* generate keys */
  	for (i = 0; i < test_batch_count; i++) {
  		ed25519_randombytes_unsafe(sks[i], sizeof(sks[i]));
  		ed25519_publickey(sks[i], pks[i]);
  		pk_pointers[i] = pks[i];
  	}
  
  	/* generate messages */
  	ed25519_randombytes_unsafe(messages, sizeof(messages));
  	for (i = 0; i < test_batch_count; i++) {
  		message_pointers[i] = messages[i];
  		message_lengths[i] = (i & 127) + 1;
  	}
  
  	/* sign messages */
  	for (i = 0; i < test_batch_count; i++) {
  		ed25519_sign(message_pointers[i], message_lengths[i], sks[i], pks[i], sigs[i]);
  		sig_pointers[i] = sigs[i];
  	}
  
  	validret = 0;
  	if (type == batch_wrong_message) {
  		message_pointers[0] = message_pointers[1];
  		validret = 1|2;
  	} else if (type == batch_wrong_pk) {
  		pk_pointers[0] = pk_pointers[1];
  		validret = 1|2;
  	} else if (type == batch_wrong_sig) {
  		sig_pointers[0] = sig_pointers[1];
  		validret = 1|2;
  	}
  
  	/* batch verify */
  	t = get_ticks();
  	ret = ed25519_sign_open_batch(message_pointers, message_lengths, pk_pointers, sig_pointers, test_batch_count, valid);
  	*ticks = get_ticks() - t;
  	edassert_equal((unsigned char *)&validret, (unsigned char *)&ret, sizeof(int), "batch return code");
  	for (i = 0; i < test_batch_count; i++) {
  		validret = ((type == batch_no_errors) || (i != 0)) ? 1 : 0;
  		edassert_equal((unsigned char *)&validret, (unsigned char *)&valid[i], sizeof(int), "individual batch return code");
  	}
  	return ret;
  }
  
  static void
  test_batch(void) {
  	uint64_t dummy_ticks, ticks[test_batch_rounds], best = maxticks, sum;
  	size_t i, count;
  
  	/* check the first pass for the expected result */
  	test_batch_instance(batch_no_errors, &dummy_ticks);
  	edassert_equal(batch_verify_y, batch_point_buffer[1], 32, "failed to generate expected result");
  
  	/* make sure ge25519_multi_scalarmult_vartime throws an error on the entire batch with wrong data */
  	for (i = 0; i < 4; i++) {
  		test_batch_instance(batch_wrong_message, &dummy_ticks);
  		test_batch_instance(batch_wrong_pk, &dummy_ticks);
  		test_batch_instance(batch_wrong_sig, &dummy_ticks);
  	}
  
  	/* speed test */
  	for (i = 0; i < test_batch_rounds; i++) {
  		test_batch_instance(batch_no_errors, &ticks[i]);
  		if (ticks[i] < best)
  			best = ticks[i];
  	}
  
  	/* take anything within 1% of the best time */
  	for (i = 0, sum = 0, count = 0; i < test_batch_rounds; i++) {
  		if (ticks[i] < (best * 1.01)) {
  			sum += ticks[i];
  			count++;
  		}
  	}
  	printf("%.0f ticks/verification\n", (double)sum / (count * test_batch_count));
  }
  
  static void
  test_main(void) {
  	int i, res;
  	ed25519_public_key pk;
  	ed25519_signature sig;
  	unsigned char forge[1024] = {'x'};
  	curved25519_key csk[2] = {{255}};
  	uint64_t ticks, pkticks = maxticks, signticks = maxticks, openticks = maxticks, curvedticks = maxticks;
  
  	for (i = 0; i < 1024; i++) {
  		ed25519_publickey(dataset[i].sk, pk);
  		edassert_equal_round(dataset[i].pk, pk, sizeof(pk), i, "public key didn't match");
  		ed25519_sign((unsigned char *)dataset[i].m, i, dataset[i].sk, pk, sig);
  		edassert_equal_round(dataset[i].sig, sig, sizeof(sig), i, "signature didn't match");
  		edassert(!ed25519_sign_open((unsigned char *)dataset[i].m, i, pk, sig), i, "failed to open message");
  
  		memcpy(forge, dataset[i].m, i);
  		if (i)
  			forge[i - 1] += 1;
  
  		edassert(ed25519_sign_open(forge, (i) ? i : 1, pk, sig), i, "opened forged message");
  	}
  
  	for (i = 0; i < 1024; i++)
  		curved25519_scalarmult_basepoint(csk[(i & 1) ^ 1], csk[i & 1]);
  	edassert_equal(curved25519_expected, csk[0], sizeof(curved25519_key), "curve25519 failed to generate correct value");
  
  	for (i = 0; i < 2048; i++) {
  		timeit(ed25519_publickey(dataset[0].sk, pk), pkticks)
  		edassert_equal_round(dataset[0].pk, pk, sizeof(pk), i, "public key didn't match");
  		timeit(ed25519_sign((unsigned char *)dataset[0].m, 0, dataset[0].sk, pk, sig), signticks)
  		edassert_equal_round(dataset[0].sig, sig, sizeof(sig), i, "signature didn't match");
  		timeit(res = ed25519_sign_open((unsigned char *)dataset[0].m, 0, pk, sig), openticks)
  		edassert(!res, 0, "failed to open message");
  		timeit(curved25519_scalarmult_basepoint(csk[1], csk[0]), curvedticks);
  	}
  
  	printf("testing sign performance: ");
  	clock_t start = clock();
  	for (i = 0; i < 10000; ++i) {
  		ed25519_sign((unsigned char *)dataset[0].m, 0, dataset[0].sk, pk, sig);
  	}
  	clock_t end = clock();
  
  	printf("%fus per signature\n", ((double)((end - start) * 1000)) / CLOCKS_PER_SEC / i * 1000);
  
  	printf("testing verify performance: ");
  	start = clock();
  	for (i = 0; i < 10000; ++i) {
  		ed25519_sign_open((unsigned char *)dataset[0].m, 0, pk, sig);
  	}
  	end = clock();
  
  	printf("%fus per signature\n", ((double)((end - start) * 1000)) / CLOCKS_PER_SEC / i * 1000);
  
  	printf("%.0f ticks/public key generation\n", (double)pkticks);
  	printf("%.0f ticks/signature\n", (double)signticks);
  	printf("%.0f ticks/signature verification\n", (double)openticks);
  	printf("%.0f ticks/curve25519 basepoint scalarmult\n", (double)curvedticks);
  }
  
  int
  main1(void) {
  	test_main();
  	test_batch();
  	return 0;
  }
  
  