diff -r 345b1ca54e88 -r 039a3e647356 kerneltest/e32utils/nistsecurerng/src/genutils.cpp
--- a/kerneltest/e32utils/nistsecurerng/src/genutils.cpp	Wed Sep 15 13:42:27 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,693 +0,0 @@
-/*
-* 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.
-*/
-
-/*
- * file: mp.c
- *
- * DESCRIPTION
- *
- * These functions comprise a multi-precision integer arithmetic
- * and discrete function package.
- */
-
-#include	"../include/genutils.h"
-
-#define	MAXPLEN		384
-
-
-/*****************************************
-** greater - Test if x > y               *
-**                                       *
-** Returns TRUE (1) if x greater than y, *
-** otherwise FALSE (0).                  *
-**                                       *
-** Parameters:                           *
-**                                       *
-**  x      Address of array x            *
-**  y      Address of array y            *
-**  l      Length both x and y in bytes  *
-**                                       *
-******************************************/ 
-int greater(BYTE *x, BYTE *y, int l)
-{
-	int		i;
-
-	for ( i=0; i<l; i++ )
-		if ( x[i] != y[i] )
-			break;
-
-	if ( i == l )
-		return 0;
-
-	if ( x[i] > y[i] )
-		return 1;
-
-	return 0;
-}
-
-
-/*****************************************
-** less - Test if x < y                  *
-**                                       *
-** Returns TRUE (1) if x less than y,    *
-** otherwise FALSE (0).                  *
-**                                       *
-** Parameters:                           *
-**                                       *
-**  x      Address of array x            *
-**  y      Address of array y            *
-**  l      Length both x and y in bytes  *
-**                                       *
-******************************************/ 
-int less(BYTE *x, BYTE *y, int l)
-{
-	int		i;
-
-	for ( i=0; i<l; i++ )
-		if ( x[i] != y[i] )
-			break;
-
-	if ( i == l ) {
-		return 0;
-	}
-
-	if ( x[i] < y[i] ) {
-		return 1;
-	}
-
-	return 0;
-}
-
-
-/*****************************************
-** bshl - shifts array left              *
-**                  by one bit.          *
-**                                       *	
-** x = x * 2                             *
-**                                       *
-** Parameters:                           *	
-**                                       *
-**  x      Address of array x            *
-**  l      Length array x in bytes       *
-**                                       *
-******************************************/ 
-BYTE bshl(BYTE *x, int l)
-{
-	BYTE	*p;
-	int		c1, c2;
-
-	p = x + l - 1;
-	c1 = 0;
-	c2 = 0;
-	while ( p != x ) {
-		if ( *p & 0x80 )
-			c2 = 1;
-		*p <<= 1;  /* shift the word left once (ls bit = 0) */
-		if ( c1 )
-			*p |= 1;
-		c1 = c2;
-		c2 = 0;
-		p--;
-	}
-
-	if ( *p & 0x80 )
-		c2 = 1;
-	*p <<= 1;  /* shift the word left once (ls bit = 0) */
-	if ( c1 )
-		*p |= (DIGIT)1;
-
-	return (BYTE)c2;
-}
-
-
-/*****************************************
-** bshr - shifts array right             *
-**                   by one bit.         *
-**                                       *	
-** x = x / 2                             *
-**                                       *
-** Parameters:                           *	
-**                                       *
-**  x      Address of array x            *
-**  l      Length array x in bytes       *	
-**                                       *
-******************************************/
-void bshr(BYTE *x, int l)	
-{
-	BYTE	*p;
-	int		c1,c2;
-
-	p = x;
-	c1 = 0;
-	c2 = 0;
-	while ( p != x+l-1 ) {
-		if ( *p & 0x01 )
-			c2 = 1;
-		*p >>= 1;  /* shift the word right once (ms bit = 0) */
-		if ( c1 )
-			*p |= 0x80;
-		c1 = c2;
-		c2 = 0;
-		p++;
-	}
-
-	*p >>= 1;  /* shift the word right once (ms bit = 0) */
-	if ( c1 )
-		*p |= 0x80;
-}
-
-
-/*****************************************
-** Mult - Multiply two integers          *
-**                                       *
-** A = B * C                             *
-**                                       *
-** Parameters:                           *	
-**                                       *
-**  A      Address of the result         *
-**  B      Address of the multiplier     *
-**  C      Address of the multiplicand   *
-**  LB      Length of B in bytes         *
-**  LC      Length of C in bytes         *
-**                                       *
-**  NOTE:  A MUST be LB+LC in length     *
-**                                       *
-******************************************/
-int Mult(BYTE *A, BYTE *B, int LB, BYTE *C, int LC)
-{
-	int    i, j;
-	int    k = 0;
-	DIGIT	result;
-
-
-	for ( i=LB-1; i>=0; i-- ) {
-		result = 0;
-		for ( j=LC-1; j>=0; j-- ) {
-			k = i+j+1;
-			result = (DIGIT)((DIGIT)A[k] + ((DIGIT)(B[i] * C[j])) + (result >> 8));
-			A[k] = (BYTE)result;
-			}
-		A[--k] = (BYTE)(result >> 8);
-	}
-
-	return 0;
-}
-
-
-void ModSqr(BYTE *A, BYTE *B, int LB, BYTE *M, int LM)
-{
-
-	Square(A, B, LB);
-	Mod(A, 2*LB, M, LM);
-}
-
-void ModMult(BYTE *A, BYTE *B, int LB, BYTE *C, int LC, BYTE *M, int LM)
-{
-	Mult(A, B, LB, C, LC);
-	Mod(A, (LB+LC), M, LM);
-}
-
-
-/*****************************************
-** smult - Multiply array by a scalar.   *
-**                                       *
-** A = b * C                             *
-**                                       *
-** Parameters:                           *	
-**                                       *
-**  A      Address of the result         *
-**  b      Scalar (1 BYTE)               *
-**  C      Address of the multiplicand   *
-**  L      Length of C in bytes          *
-**                                       *
-**  NOTE:  A MUST be L+1 in length       *
-**                                       *
-******************************************/
-void smult(BYTE *A, BYTE b, BYTE *C, int L)
-{
-	int		i;
-	DIGIT	result;
-
-	result = 0;
-	for ( i=L-1; i>0; i-- ) {
-		result = (DIGIT)(A[i] + ((DIGIT)b * C[i]) + (result >> 8));
-		A[i] = (BYTE)(result & 0xff);
-		A[i-1] = (BYTE)(result >> 8);
-	}
-}
-
-/*****************************************
-** Square() - Square an integer          *
-**                                       *
-** A = B^2                               *
-**                                       *
-** Parameters:                           *
-**                                       *
-**  A      Address of the result         *
-**  B      Address of the operand        *
-**  L      Length of B in bytes          *
-**                                       *
-**  NOTE:  A MUST be 2*L in length       *
-**                                       *
-******************************************/
-void Square(BYTE *A, BYTE *B, int L)
-{
-	Mult(A, B, L, B, L);
-}
-
-/*****************************************
-** ModExp - Modular Exponentiation       *
-**                                       *
-** A = B ** C (MOD M)                    *
-**                                       *	
-** Parameters:                           *	
-**                                       *
-**  A      Address of result             *
-**  B      Address of mantissa           *
-**  C      Address of exponent           *
-**  M      Address of modulus            *
-**  LB     Length of B in bytes          *
-**  LC     Length of C in bytes          *
-**  LM     Length of M in bytes          *
-**                                       *
-**  NOTE: The integer B must be less     *
-**        than the modulus M.      	 *
-**  NOTE: A must be at least 3*LM        *
-**        bytes long.  However, the      *
-**        result stored in A will be     *
-**        only LM bytes long.            *
-******************************************/
-void ModExp(BYTE *A, BYTE *B, int LB, BYTE *C, int LC, BYTE *M, int LM)
-{
-	BYTE	wmask;
-	int		bits;
-
-	bits = LC*8;
-	wmask = 0x80;
-
-	A[LM-1] = 1;
-
-	while ( !sniff_bit(C,wmask) ) {
-		wmask >>= 1;
-		bits--;
-		if ( !wmask ) {
-			wmask = 0x80;
-			C++;
-		}
-	}
-
-	while ( bits-- ) {
-		memset(A+LM, 0x00, LM*2);
-
-		/* temp = A*A (MOD M) */
-		ModSqr(A+LM, A,LM,  M,LM);
-
-		/* A = lower L bytes of temp */
-		memcpy(A, A+LM*2, LM);
-		memset(A+LM, 0x00, 2*LM);
-
-		if ( sniff_bit(C,wmask) ) {
-			memset(A+LM, 0x00, (LM+LB));
-			ModMult(A+LM, B,LB, A,LM,  M,LM);       /* temp = B * A (MOD M) */
-			memcpy(A, A+LM+(LM+LB)-LM, LM);  /* A = lower LM bytes of temp */
-			memset(A+LM, 0x00, 2*LM);
-		}
- 
-		wmask >>= 1;
-		if ( !wmask ) {
-			wmask = 0x80;
-			C++;
-		}
-	}
-}
-
-
-/* DivMod:
- *
- *   computes:
- *         quot = x / n
- *         rem = x % n
- *   returns:
- *         length of "quot"
- *
- *  len of rem is lenx+1
- */
-int DivMod(BYTE *x, int lenx, BYTE *n, int lenn, BYTE *quot, BYTE *rem)
-{
-	BYTE	*tx, *tn, *ttx, *ts, bmult[1];
-	int		i, shift, lgth_x, lgth_n, t_len, lenq;
-	DIGIT	tMSn, mult;
-	ULONG	tMSx;
-	int		underflow;
-
-	tx = x;
-	tn = n;
-	
-	/* point to the MSD of n  */
-	for ( i=0, lgth_n=lenn; i<lenn; i++, lgth_n-- ) {
-		if ( *tn )
-			break;
-		tn++;
-	}
-	if ( !lgth_n )
-		return 0;
-	
-	/* point to the MSD of x  */
-	for ( i=0, lgth_x=lenx; i<lenx; i++, lgth_x-- ) {
-		if ( *tx )
-			break;
-		tx++;
-	}
-	if ( !lgth_x )
-		return 0;
-
-	if ( lgth_x < lgth_n )
-		lenq = 1;
-	else
-		lenq = lgth_x - lgth_n + 1;
-	memset(quot, 0x00, lenq);
-	
-	/* Loop while x > n,  WATCH OUT if lgth_x == lgth_n */
-	while ( (lgth_x > lgth_n) || ((lgth_x == lgth_n) && !less(tx, tn, lgth_n)) ) {
-		shift = 1;
-		if ( lgth_n == 1 ) {
-			if ( *tx < *tn ) {
-				tMSx = (DIGIT) (((*tx) << 8) | *(tx+1));
-				tMSn = *tn;
-				shift = 0;
-			}
-			else {
-				tMSx = *tx;
-				tMSn = *tn;
-			}
-		}
-		else if ( lgth_n > 1 ) {
-			tMSx = (DIGIT) (((*tx) << 8) | *(tx+1));
-			tMSn = (DIGIT) (((*tn) << 8) | *(tn+1));
-			if ( (tMSx < tMSn) || ((tMSx == tMSn) && less(tx, tn, lgth_n)) ) {
-				tMSx = (tMSx << 8) | *(tx+2);
-				shift = 0;
-			}
-		}
-		else {
-			tMSx = (DIGIT) (((*tx) << 8) | *(tx+1));
-			tMSn = *tn;
-			shift = 0;
-		}
-
-		mult = (DIGIT) (tMSx / tMSn);
-		if ( mult > 0xff )
-			mult = 0xff;
-		bmult[0] = (BYTE)(mult & 0xff);
-
-		ts = rem;
-		do {
-			memset(ts, 0x00, lgth_x+1);
-			Mult(ts, tn, lgth_n, bmult, 1);
-
-			underflow = 0;
-			if ( shift ) {
-				if ( ts[0] != 0 )
-					underflow = 1;
-				else {
-					for ( i=0; i<lgth_x; i++ )
-						ts[i] = ts[i+1];
-					ts[lgth_x] = 0x00;
-				}
-			}
-			if ( greater(ts, tx, lgth_x) || underflow ) {
-				bmult[0]--;
-				underflow = 1;
-			}
-			else
-				underflow = 0;
-		} while ( underflow );
-		sub(tx, lgth_x, ts, lgth_x);
-		if ( shift )
-			quot[lenq - (lgth_x - lgth_n) - 1] = bmult[0];
-		else
-			quot[lenq - (lgth_x - lgth_n)] = bmult[0];
-		
-		ttx = tx;
-		t_len = lgth_x;
-		for ( i=0, lgth_x=t_len; i<t_len; i++, lgth_x-- ) {
-			if ( *ttx )
-				break;
-			ttx++;
-		}
-		tx = ttx;
-	}
-	memset(rem, 0x00, lenn);
-	if ( lgth_x )
-		memcpy(rem+lenn-lgth_x, tx, lgth_x);
-
-	return lenq;
-}
-
-
-/* 
- * Mod - Computes an integer modulo another integer
- *
- * x = x (mod n)
- *
- */
-void Mod(BYTE *x, int lenx, BYTE *n, int lenn)
-{
-	BYTE	quot[MAXPLEN+1], rem[2*MAXPLEN+1];
-
-	memset(quot, 0x00, sizeof(quot));
-	memset(rem, 0x00, sizeof(rem));
-	if ( DivMod(x, lenx, n, lenn, quot, rem) ) {
-		memset(x, 0x00, lenx);
-		memcpy(x+lenx-lenn, rem, lenn);
-	}
-}
-
-/* 
- * Div - Computes the integer division of two numbers
- *
- * x = x / n
- *
- */
-void Div(BYTE *x, int lenx, BYTE *n, int lenn)
-{
-	BYTE	quot[MAXPLEN+1], rem[2*MAXPLEN+1];
-	int		lenq;
-
-	memset(quot, 0x00, sizeof(quot));
-	memset(rem, 0x00, sizeof(rem));
-	if ( (lenq = DivMod(x, lenx, n, lenn, quot, rem)) != 0 ) {
-		memset(x, 0x00, lenx);
-		memcpy(x+lenx-lenq, quot, lenq);
-	}
-}
-
-
-/*****************************************
-** sub - Subtract two integers           *
-**                                       *
-** A = A - B                             *
-**                                       *
-**                                       *
-** Parameters:                           *	
-**                                       *
-**  A      Address of subtrahend integer *
-**  B      Address of subtractor integer *
-**  L      Length of A and B in bytes    *
-**                                       *
-**  NOTE: In order to save RAM, B is     *
-**        two's complemented twice,      *
-**        rather than using a copy of B  *
-**                                       *
-******************************************/
-void sub(BYTE *A, int LA, BYTE *B, int LB)
-{
-	BYTE	*tb;
-
-	tb = (BYTE *)calloc(LA, 1);
-	memcpy(tb, B, LB);
-	negate(tb, LB);
-	add(A, LA, tb, LA);
-
-	FREE(tb);
-}
-
-
-/*****************************************
-** negate - Negate an integer            *
-**                                       *
-** A = -A                                *
-**                                       *
-**                                       *
-** Parameters:                           *	
-**                                       *
-**  A      Address of integer to negate  *
-**  L      Length of A in bytes          *
-**                                       *
-******************************************/
-int negate(BYTE *A, int L)
-{
-	int		i, tL;
-	DIGIT	accum;
-
-	/* Take one's complement of A */
-	for ( i=0; i<L; i++ )
-		A[i] = (BYTE)(~(A[i]));
-
-	/* Add one to get two's complement of A */
-	accum = 1;
-	tL = L-1;
-	while ( accum && (tL >= 0) ) {
-		accum = (DIGIT)(accum + A[tL]);
-		A[tL--] = (BYTE)(accum & 0xff);
-		accum = (DIGIT)(accum >> 8);
-	}
-
-	return accum;
-}
-
-
-/*
- * add()
- *
- * A = A + B
- *
- * LB must be <= LA
- *
- */
-BYTE add(BYTE *A, int LA, BYTE *B, int LB)
-{
-	int		i, indexA, indexB;
-	DIGIT	accum;
-
-	indexA = LA - 1; 	/* LSD of result */
-	indexB = LB - 1; 	/* LSD of B */
-
-	accum = 0;
-	for ( i = 0; i < LB; i++ ) {
-		accum = (DIGIT)(accum + A[indexA]);
-		accum = (DIGIT)(accum + B[indexB--]);
-		A[indexA--] = (BYTE)(accum & 0xff);
-		accum = (DIGIT)(accum >> 8);
-	}
-
-	if ( LA > LB )
-		while ( accum  && (indexA >= 0) ) {
-			accum = (DIGIT)(accum + A[indexA]);
-			A[indexA--] = (BYTE)(accum & 0xff);
-			accum = (DIGIT)(accum >> 8);
-		}
-
-	return (BYTE)accum;
-}
-
-
-void prettyprintBstr(char *S, BYTE *A, int L)
-{
-	int		i, extra, ctrb, ctrl;
-
-	if ( L == 0 )
-		printf("%s <empty>", S);
-	else
-		printf("%s\n\t", S);
-	extra = L % 24;
-	if ( extra ) {
-		ctrb = 0;
-		for ( i=0; i<24-extra; i++ ) {
-			printf("  ");
-			if ( ++ctrb == 4) {
-				printf(" ");
-				ctrb = 0;
-			}
-		}
-
-		for ( i=0; i<extra; i++ ) {
-			printf("%02X", A[i]);
-			if ( ++ctrb == 4) {
-				printf(" ");
-				ctrb = 0;
-			}
-		}
-		printf("\n\t");
-	}
-
-	ctrb = ctrl = 0;
-	for ( i=extra; i<L; i++ ) {
-		printf("%02X", A[i]);
-		if ( ++ctrb == 4) {
-			ctrl++;
-			if ( ctrl == 6 ) {
-				printf("\n\t");
-				ctrl = 0;
-			}
-			else
-				printf(" ");
-			ctrb = 0;
-		}
-	}
-	printf("\n\n");
-}
-
-
-/**********************************************************************/
-/*  Performs byte reverse for PC based implementation (little endian) */
-/**********************************************************************/
-void byteReverse(ULONG *buffer, int byteCount)
-{
-	ULONG value;
-	int count;
-
-	byteCount /= sizeof( ULONG );
-	for( count = 0; count < byteCount; count++ ) {
-		value = ( buffer[ count ] << 16 ) | ( buffer[ count ] >> 16 );
-		buffer[ count ] = ( ( value & 0xFF00FF00L ) >> 8 ) | ( ( value & 0x00FF00FFL ) << 8 );
-	}
-}
-
-void
-ahtopb (char *ascii_hex, BYTE *p_binary, int bin_len)
-{
-	BYTE    nibble;
-	int     i; 
-	
-	for ( i=0; i<bin_len; i++ ) {
-        nibble = ascii_hex[i * 2];
-	    if ( nibble > 'F' )
-	        nibble -= 0x20;   
-	    if ( nibble > '9' )
-	        nibble -= 7;      
-	    nibble -= '0';   
-	    p_binary[i] = (BYTE)(nibble << 4);
-		
-	    nibble = ascii_hex[i * 2 + 1];
-	    if ( nibble > 'F' )
-			nibble -= 0x20;
-        if ( nibble > '9' )
-            nibble -= 7;   
-        nibble -= '0';
-		p_binary[i] = (BYTE)(p_binary[i] + nibble);
-	}
-}