(1 . 5)(1 . 6)
/* mpi.h  -  Multi Precision Integers
 * Modified by No Such Labs. (C) 2015. See README.
 * Modified by S.MG, 2018. Added mpi_get_alloced, function for retrieving currently allocated number of limbs.
 *
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
(75 . 6)(76 . 7)
void mpi_m_check( MPI a );
void mpi_swap( MPI a, MPI b);
int  mpi_get_nlimbs (MPI a);
int mpi_get_alloced (MPI a);	/* returns the allocated memory space for this MPI, in number of limbs */
int  mpi_is_neg (MPI a);
unsigned int mpi_nlimb_hint_from_nbytes (unsigned int nbytes);
unsigned int mpi_nlimb_hint_from_nbits (unsigned int nbits);

(1 . 5)(1 . 6)
/* mpiutil.ac  -  Utility functions for MPI
 * Modified by No Such Labs. (C) 2015. See README.
 * Modified by S.MG, 2018. Added mpi_get_alloced(MPI a)
 *
 * This file was originally part of Gnu Privacy Guard (GPG), ver. 1.4.10,
 * SHA256(gnupg-1.4.10.tar.gz):
(477 . 6)(478 . 14)
  return a->nlimbs;
}

/*
 * Returns the allocated space for the given MPI, as number of limbs.
 */
int
mpi_get_alloced (MPI a)
{
	return a->alloced;
}

int 
mpi_is_neg (MPI a)

(8 . 6)(8 . 13)
#include "mpi.h"
#include "knobs.h"

/*
 * These are constants as per TMSR RSA specification, NOT knobs!
 * TMSR key length is 4096 bits (512 octets); this means 2 primes of 2048 bits (256 octets) each.
 * NB: if you choose here an odd key length in octets you might end up with a smaller actual key, read the code.
 */
static const int KEY_LENGTH_OCTETS = 512;

/*********truerandom.c*********/

/*
(63 . 6)(70 . 22)
 */
int is_composite( MPI n, int nwitnesses, int entropy_source);

/**
 * Generates a random number that has passed the Miller-Rabin test for primality (see function is_composite above).
 * NB: top 2 bits and bottom bit are ALWAYS 1! (i.e. a mask 110....01 is applied to the random bits)
 *    a prime of 8*noctets long will have only (8*noctets-3) bits that are randomly chosen!
 * NB: this method does NOT allocate space for the requested MPI; it is the caller's responsibility to allocate it!
 * The source of randomness is ENTROPY_SOURCE in eucrypt/smg_rsa/include/knobs.h
 * The number of witnesses checked by Miller-Rabin is M_R_ITERATIONS in eucrypt/smg_rsa/include/knobs.h
 * Preconditions:
 *			noctets > 0 (at least one octet!)
 *			output has known allocated memory for at least nlimbs(noctets)
 *			successful access to the entropy source
 * @param noctets the length of the desired prime number, in octets
 * @param output an MPI with sufficient memory allocated for a number that is noctets long
 */
void gen_random_prime( unsigned int noctets, MPI output);


#endif /*SMG_RSA*/

(103 . 3)(103 . 47)

	return evidence;
}

/**
 * Generates a random number that has passed the Miller-Rabin test for primality (see function is_composite above).
 * NB: top 2 bits and bottom bit are ALWAYS 1! (i.e. a mask 11.....1 is applied)
 *    a prime of 8*noctets long will have only 8*noctets-3 bits that are randomly chosen
 * NB: this method does NOT allocate space for the requested MPI; it is the caller's responsibility to allocate it!
 * The source of randomness is ENTROPY_SOURCE in eucrypt/smg_rsa/include/knobs.h
 * The number of witnesses checked by Miller-Rabin is M_R_ITERATIONS in eucrypt/smg_rsa/include/knobs.h
 * Preconditions:
 *			noctets > 0 (at least one octet!)
 *			memory allocated for noctets in output MPI
 *			successful access to the entropy source
 */
void gen_random_prime( unsigned int noctets, MPI output )
{
	/* precondition: at least one octet long */
	assert(noctets > 0);

	/* precondition: enough memory allocated for the limbs corresponding to noctets */
	unsigned int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
	assert(mpi_get_alloced(output) >= nlimbs);

	/* precondition: access to the entropy source */
	int entropy_source = open_entropy_source(ENTROPY_SOURCE); /* source of random bits */
	assert(entropy_source >= 0);

	unsigned int nbits = 8*noctets;														/* length of MPI in bits */

	/*
   * loop until a prime is found: get noctets of random bits, trim and apply 110...01 mask, check if prime
	 */
	unsigned char *p = xmalloc( noctets );
	do {
		get_random_octets_from( noctets, p, entropy_source );
		mpi_set_buffer( output, p, noctets, 0);	/* convert to MPI representation */
		mpi_set_highbit( output, nbits - 1 );		/* trim at required size and set top bit */
		mpi_set_bit( output, nbits - 2);					/* set second top bit */
		mpi_set_bit( output, 0 );								/* set bottom bit to unsure odd number */
	}	while (is_composite(output, M_R_ITERATIONS, entropy_source));

	/* tidy up, a prime was found */
	xfree(p);
	close(entropy_source);
}

(4 . 6)(4 . 7)
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <stdio.h>

void err(char *msg)
{
(30 . 6)(31 . 43)
	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;
(52 . 49)(90 . 161)
	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);
}

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

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

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

	if (id == 0 || id == 1) {
		printf("Timing entropy source...\n");
		time_entropy_source(nruns,4096);
	}

	if (id == 0 || id == 2) {

		/* 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);
	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;
		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");
	}

	if (id > 2)
		printf("Current test ids: 0 for all, 1 for entropy source test only, 2 for is_composite test only.");

  return 0;
}

(16 . 27)(16 . 19)
		return -1;
	}

	//input and output speeds
	/* input and output speeds */
	cfsetospeed(&tty, (speed_t)speed);
	cfsetispeed(&tty, (speed_t)speed);

	tty.c_cflag |= (CLOCAL | CREAD);	//ignore modem controls
	tty.c_cflag &= ~CSIZE;
	tty.c_cflag |= CS8;			//8 bit characters
	tty.c_cflag &= ~PARENB;	//no parity bit
	tty.c_cflag &= ~CSTOPB;	//only need 1 stop bit
	tty.c_cflag &= ~CRTSCTS;	//no hardware flow control
	/* raw */
	tty.c_lflag &= ~(ECHO | ECHOE | ECHOK);
	tty.c_oflag &= ~OPOST;

	//non-canonical mode
	tty.c_cflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
	tty.c_cflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
	tty.c_cflag &= ~OPOST;

	//read at least one octet at a time; timeout 1 tenth of second between octets read
	/* read at least one octet at a time; BLOCK until at least VMIN octets read */
	tty.c_cc[VMIN] = 1;
	tty.c_cc[VTIME] = 1;
	tty.c_cc[VTIME] = 0;

	if (tcsetattr(fd, TCSANOW, &tty) != 0)
	if (tcsetattr(fd, TCSAFLUSH, &tty) != 0)
		return -1;

	return 0;