/*

* Portions Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

* The original NIST Statistical Test Suite code is placed in public domain.

* (http://csrc.nist.gov/groups/ST/toolkit/rng/documentation_software.html) 

* 

* This software was developed at the National Institute of Standards and Technology by 

* employees of the Federal Government in the course of their official duties. Pursuant

* to title 17 Section 105 of the United States Code this software is not subject to 

* copyright protection and is in the public domain. The NIST Statistical Test Suite is

* an experimental system. NIST assumes no responsibility whatsoever for its use by other 

* parties, and makes no guarantees, expressed or implied, about its quality, reliability, 

* or any other characteristic. We would appreciate acknowledgment if the software is used.

*/

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

U T I L I T I E S

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include "openc.h"

#include "../include/externs.h"

#include "../include/utilities.h"

#include "../include/generators.h"

#include "../include/stat_fncs.h"

TBuf8<KMaxFileName> gLogFilePath;

TInt                gTemplateIndex = 1;

bool ConvertToAperiodicBits(BitSequence aSequence[32], long value);

int

displayGeneratorOptions()

{

	int		option = 0;

	printf("           G E N E R A T O R    S E L E C T I O N \n");

	printf("           ______________________________________\n\n");

	printf("    [0] Input File                 [1] Linear Congruential\n");

	printf("    [2] Quadratic Congruential I   [3] Quadratic Congruential II\n");

	printf("    [4] Cubic Congruential         [5] XOR\n");

	printf("    [6] Modular Exponentiation     [7] Blum-Blum-Shub\n");

	printf("    [8] Micali-Schnorr             [9] G Using SHA-1\n\n");

	printf("   Enter Choice: ");

	scanf("%d", &option);

	printf("\n\n");

	return option;

}

int

generatorOptions(char** streamFile)

{

	char	file[200];

	int		option = NUMOFGENERATORS+1; 

	while ( (option < 0) || (option > NUMOFGENERATORS) ) {

		option = displayGeneratorOptions();

		switch( option ) {

			case 0:

				printf("\t\tUser Prescribed Input File: ");

				scanf("%s", file);

				*streamFile = (char*)calloc(200, sizeof(char));

				sprintf(*streamFile, "%s", file);

				printf("\n");

				break;

			case 1:

				*streamFile = "Linear-Congruential";

				break;

			case 2:

				*streamFile = "Quadratic-Congruential-1";

				break;

			case 3:

				*streamFile = "Quadratic-Congruential-2";

				break;

			case 4:

				*streamFile = "Cubic-Congruential";

				break;

			case 5:

				*streamFile = "XOR";

				break;

			case 6:

				*streamFile = "Modular-Exponentiation";

				break;

			case 7:

				*streamFile = "Blum-Blum-Shub";

				break;

			case 8:

				*streamFile = "Micali-Schnorr";

				break;

			case 9:

				*streamFile = "G using SHA-1";

				break;

			/* INTRODUCE NEW PRNG NAMES HERE */

			/*

			case 10:  *streamFile = "myNewPRNG";

				break;

			*/

			default:

				printf("Error:  Out of range - Try again!\n");

				break;

		}

	}

	return option;

}

void

chooseTests()

{

	int		i;

	printf("                S T A T I S T I C A L   T E S T S\n");

	printf("                _________________________________\n\n");

	printf("    [01] Frequency                       [02] Block Frequency\n");

	printf("    [03] Cumulative Sums                 [04] Runs\n");

	printf("    [05] Longest Run of Ones             [06] Rank\n");

	printf("    [07] Discrete Fourier Transform      [08] Nonperiodic Template Matchings\n");

	printf("    [09] Overlapping Template Matchings  [10] Universal Statistical\n");

	printf("    [11] Approximate Entropy             [12] Random Excursions\n");

	printf("    [13] Random Excursions Variant       [14] Serial\n");

	printf("    [15] Linear Complexity\n\n");

	printf("         INSTRUCTIONS\n");

	printf("            Enter 0 if you DO NOT want to apply all of the\n");

	printf("            statistical tests to each sequence and 1 if you DO.\n\n");

	printf("   Enter Choice: ");

	scanf("%d", &testVector[0]);

	printf("\n");

	if ( testVector[0] == 1 )

	    {

		for( i=1; i<=NUMOFTESTS; i++ )

			testVector[i] = 1;

		// Disable Fast Fourier Transform Test.

		// NIST has discovered a problem with the Fast Fourier Transform test. 

		// At this time NIST advises disregarding the results of this test until 

		// a further update is posted.

		// Link: http://csrc.nist.gov/groups/ST/toolkit/rng/documentation_software.html

		//

		// When the FFT test is fixed remove the following 5 lines.

		printf(" Please Note: \n");

		printf(" NIST has discovered a problem with the DFT test and hence the DFT results are invalid currently.\n");

		printf(" DFT test will be disabled at the momemt in the NIST test suite run \n \n");        

		testVector[TEST_FFT] = 0; 

		testVector[0] = 0; 

	    }

	else {

		printf("         INSTRUCTIONS\n");

		printf("            Enter a 0 or 1 to indicate whether or not the numbered statistical\n");

		printf("            test should be applied to each sequence.\n\n");

		printf("      123456789111111\n");

		printf("               012345\n");

		printf("      ");

        for ( i=1; i<=NUMOFTESTS; i++ ) 

            scanf("%1d", &testVector[i]);

        printf("\n\n");

    }

}

void

fixParameters()

{

	int		counter, testid;

	//  Check to see if any parameterized tests are selected

	if ( (testVector[TEST_BLOCK_FREQUENCY] != 1) && (testVector[TEST_NONPERIODIC] != 1) && 

		 (testVector[TEST_OVERLAPPING] != 1) && (testVector[TEST_APEN] != 1) &&

		 (testVector[TEST_SERIAL] != 1) && (testVector[TEST_LINEARCOMPLEXITY] != 1) )

			return;

	do {

		counter = 1;

		printf("        P a r a m e t e r   A d j u s t m e n t s\n");

		printf("        -----------------------------------------\n");

		if ( testVector[TEST_BLOCK_FREQUENCY] == 1 )

			printf("    [%d] Block Frequency Test - block length(M):         %d\n", counter++, tp.blockFrequencyBlockLength);

		if ( testVector[TEST_NONPERIODIC] == 1 )

			printf("    [%d] NonOverlapping Template Test - block length(m): %d\n", counter++, tp.nonOverlappingTemplateBlockLength);

		if ( testVector[TEST_OVERLAPPING] == 1 )

			printf("    [%d] Overlapping Template Test - block length(m):    %d\n", counter++, tp.overlappingTemplateBlockLength);

		if ( testVector[TEST_APEN] == 1 )

			printf("    [%d] Approximate Entropy Test - block length(m):     %d\n", counter++, tp.approximateEntropyBlockLength);

		if ( testVector[TEST_SERIAL] == 1 )

			printf("    [%d] Serial Test - block length(m):                  %d\n", counter++, tp.serialBlockLength);

		if ( testVector[TEST_LINEARCOMPLEXITY] == 1 )

			printf("    [%d] Linear Complexity Test - block length(M):       %d\n", counter++, tp.linearComplexitySequenceLength);

		printf("\n");

		printf("   Select Test (0 to continue): ");

		scanf("%1d", &testid);

		printf("\n");

		counter = 0;

		if ( testVector[TEST_BLOCK_FREQUENCY] == 1 ) {

			counter++;

			if ( counter == testid ) {

				printf("   Enter Block Frequency Test block length: ");

				scanf("%d", &tp.blockFrequencyBlockLength);

				printf("\n");

				continue;

			}

		}

		if ( testVector[TEST_NONPERIODIC] == 1 ) {

			counter++;

			if ( counter == testid ) {

				printf("   Enter NonOverlapping Template Test block Length: ");

				scanf("%d", &tp.nonOverlappingTemplateBlockLength);

				printf("\n");

				continue;

			}

		}

		if ( testVector[TEST_OVERLAPPING] == 1 ) {

			counter++;

			if ( counter == testid ) {

				printf("   Enter Overlapping Template Test block Length: ");

				scanf("%d", &tp.overlappingTemplateBlockLength);

				printf("\n");

				continue;

			}

		}

		if ( testVector[TEST_APEN] == 1 ) {

			counter++;

			if ( counter == testid ) {

				printf("   Enter Approximate Entropy Test block Length: ");

				scanf("%d", &tp.approximateEntropyBlockLength);

				printf("\n");

				continue;

			}

		}

		if ( testVector[TEST_SERIAL] == 1 ) {

			counter++;

			if ( counter == testid ) {

				printf("   Enter Serial Test block Length: ");

				scanf("%d", &tp.serialBlockLength);

				printf("\n");

				continue;

			}

		}

		if ( testVector[TEST_LINEARCOMPLEXITY] == 1 ) {

			counter++;

			if ( counter == testid ) {

				printf("   Enter Linear Complexity Test block Length: ");

				scanf("%d", &tp.linearComplexitySequenceLength);

				printf("\n");

				continue;

			}

		}

	} while ( testid != 0 );

}

void

fileBasedBitStreams(char *streamFile)

{

	FILE	*fp;

	int		mode;

	printf("   Input File Format:\n");

	printf("    [0] ASCII - A sequence of ASCII 0's and 1's\n");

	printf("    [1] Binary - Each byte in data file contains 8 bits of data\n\n");

	printf("   Select input mode:  ");

	scanf("%1d", &mode);

	printf("\n");

	if ( mode == 0 ) {

		if ( (fp = fopen(streamFile, "r")) == NULL ) {

			printf("ERROR IN FUNCTION fileBasedBitStreams:  file %s could not be opened.\n",  streamFile);

			exit(-1);

		}

		readBinaryDigitsInASCIIFormat(fp, streamFile);

		fclose(fp);

	}

	else if ( mode == 1 ) {

		if ( (fp = fopen(streamFile, "rb")) == NULL ) {

			printf("ERROR IN FUNCTION fileBasedBitStreams:  file %s could not be opened.\n", streamFile);

			exit(-1);

		}

		readHexDigitsInBinaryFormat(fp);

		fclose(fp);

	}

}

void

readBinaryDigitsInASCIIFormat(FILE *fp, char *streamFile)

{

	int		i, j, num_0s, num_1s, bitsRead, bit;

	if ( (epsilon = (BitSequence *) calloc(tp.n, sizeof(BitSequence))) == NULL ) {

		printf("BITSTREAM DEFINITION:  Insufficient memory available.\n");

		printf("Statistical Testing Aborted!\n");

		return;

	}

	printf("     Statistical Testing In Progress.........\n\n");   

	for ( i=0; i<tp.numOfBitStreams; i++ ) {

		num_0s = 0;

		num_1s = 0;

		bitsRead = 0;

		for ( j=0; j<tp.n; j++ ) {

			if ( fscanf(fp, "%1d", &bit) == EOF ) {

				printf("ERROR:  Insufficient data in file %s.  %d bits were read.\n", streamFile, bitsRead);

				fclose(fp);

				free(epsilon);

				return;

			}

			else {

				bitsRead++;

				if ( bit == 0 ) 

					num_0s++;

				else 

					num_1s++;

				epsilon[j] = (BitSequence)bit;

			}

		}

		fprintf(freqfp, "\t\tBITSREAD = %d 0s = %d 1s = %d\n", bitsRead, num_0s, num_1s);

		nist_test_suite();

	}

	free(epsilon);

}

void

readHexDigitsInBinaryFormat(FILE *fp)

{

	int		i, done, num_0s, num_1s, bitsRead;

	BYTE	buffer[4];

	if ( (epsilon = (BitSequence *) calloc(tp.n,sizeof(BitSequence))) == NULL ) {

		printf("BITSTREAM DEFINITION:  Insufficient memory available.\n");

		return;

	}

	printf("     Statistical Testing In Progress.........\n\n");   

	for ( i=0; i<tp.numOfBitStreams; i++ ) {

		num_0s = 0;

		num_1s = 0;

		bitsRead = 0;

		done = 0;

		do {

			if ( fread(buffer, sizeof(unsigned char), 4, fp) != 4 ) {

				printf("READ ERROR:  Insufficient data in file.\n");

				free(epsilon);

				return;

			}

			done = convertToBits(buffer, 32, tp.n, &num_0s, &num_1s, &bitsRead);

		} while ( !done );

		fprintf(freqfp, "\t\tBITSREAD = %d 0s = %d 1s = %d\n", bitsRead, num_0s, num_1s);

		nist_test_suite();

	}

	free(epsilon);

}

int

convertToBits(const BYTE *x, int xBitLength, int bitsNeeded, int *num_0s, int *num_1s, int *bitsRead)

{

	int		i, j, count, bit;

	BYTE	mask;

	int		zeros, ones;

	count = 0;

	zeros = ones = 0;

	for ( i=0; i<(xBitLength+7)/8; i++ ) {

		mask = 0x80;

		for ( j=0; j<8; j++ ) {

			if ( *(x+i) & mask ) {

				bit = 1;

				(*num_1s)++;

				ones++;

			}

			else {

				bit = 0;

				(*num_0s)++;

				zeros++;

			}

			mask >>= 1;

			epsilon[*bitsRead] = (BitSequence)bit;

			(*bitsRead)++;

			if ( *bitsRead == bitsNeeded )

				return 1;

			if ( ++count == xBitLength )

				return 0;

		}

	}

	return 0;

}

void

openOutputStreams(int option)

{

	int		i, numOfBitStreams, numOfOpenFiles = 0;

	char	freqfn[200], statsDir[200], resultsDir[200];

    TBuf16<200>      logFilePath;

    logFilePath.Copy(_L("c:\\nist"));

    printf("      Directory for logs : ");

    gConsole->Printf(logFilePath);

    ReadStringFromConsole(logFilePath);

    gConsole->Printf(_L("\r\n"));

    gLogFilePath.Copy(logFilePath);

    TBuf8<100> tempName;

    TBuf<100> directoryName;

    for(i = 1; i <= NUMOFTESTS; ++i)

        {

        tempName.Format(_L8("%s\\experiments\\%s\\%s\\"), gLogFilePath.PtrZ(),  generatorDir[option], testNames[i]);

        directoryName.Copy(tempName);

        gFileSession.MkDirAll(directoryName);

        }

	sprintf(freqfn, "%s\\experiments\\%s\\freq", gLogFilePath.PtrZ(), generatorDir[option]);

	if ( (freqfp = fopen(freqfn, "w")) == NULL ) {

		printf("\t\tMAIN:  Could not open freq file: experiments/%s/freq", generatorDir[option]);

		exit(-1);

	}

	TBuf8<512> finalAnalysisReport;

    finalAnalysisReport.Format(_L8("%s\\finalAnalysisReport"), gLogFilePath.PtrZ());

    if ( (summary = fopen((const char *)finalAnalysisReport.PtrZ(), "w")) == NULL ) {

		printf("\t\tMAIN:  Could not open stats file: %s\\experiments\\%s\\finalAnalysisReport",gLogFilePath.PtrZ(), generatorDir[option]);

		exit(-1);

	}

	for( i=1; i<=NUMOFTESTS; i++ ) {

		if ( testVector[i] == 1 ) {

			sprintf(statsDir, "%s\\experiments\\%s\\%s\\stats", gLogFilePath.PtrZ(), generatorDir[option], testNames[i]);

			sprintf(resultsDir, "%s\\experiments\\%s\\%s\\results", gLogFilePath.PtrZ(), generatorDir[option], testNames[i]);

			if ( (stats[i] = fopen(statsDir, "w")) == NULL ) {	/* STATISTICS LOG */

				printf("ERROR: LOG FILES COULD NOT BE OPENED.\n");

				printf("       MAX # OF OPENED FILES HAS BEEN REACHED = %d\n", numOfOpenFiles);

				printf("-OR-   THE OUTPUT DIRECTORY DOES NOT EXIST.\n");

				exit(-1);

			}

			else

				numOfOpenFiles++;

			if ( (results[i] = fopen(resultsDir, "w")) == NULL ) {	/* P_VALUES LOG   */

				 printf("ERROR: LOG FILES COULD NOT BE OPENED.\n");

				 printf("       MAX # OF OPENED FILES HAS BEEN REACHED = %d\n", numOfOpenFiles);

				 printf("-OR-   THE OUTPUT DIRECTORY DOES NOT EXIST.\n");

				 exit(-1);

			}

			else

				numOfOpenFiles++;

		}

	}

	printf("   How many bitstreams? ");

	scanf("%d", &numOfBitStreams);

	tp.numOfBitStreams = numOfBitStreams;

	printf("\n");

}

void

invokeTestSuite(int option, char *streamFile)

{

	fprintf(freqfp, "________________________________________________________________________________\n\n");

	fprintf(freqfp, "\t\tALPHA = %6.4f\n", ALPHA);

	fprintf(freqfp, "________________________________________________________________________________\n\n");

	if ( option != 0 )

		printf("     Statistical Testing In Progress.........\n\n");

	switch( option ) {

		case 0:

			fileBasedBitStreams(streamFile);

			break;

		case 1:

			lcg();

			break;

		case 2:

			quadRes1();

			break;

		case 3:

			quadRes2();

			break;

		case 4:

			cubicRes();

			break;

		case 5:

			exclusiveOR();

			break;

		case 6:

			modExp();

			break;

		case 7:

			bbs();

			break;

		case 8:

			micali_schnorr();

			break;

		case 9:

			SHA1();

			break;

		case 10:

		    HASH_DRBG();

		    break;

		/* INTRODUCE NEW PSEUDO RANDOM NUMBER GENERATORS HERE */

		default:

			printf("Error in invokeTestSuite!\n");

			break;

	}

	printf("     Statistical Testing Complete!!!!!!!!!!!!\n\n");

}

void

nist_test_suite()

{

	if ( (testVector[0] == 1) || (testVector[TEST_FREQUENCY] == 1) ) 

		Frequency(tp.n);