int bdDivide_s(T q, T r, T u, T v)
	/* Computes quotient q = u / v and remainder r = u mod v (safe) */
{
	size_t dig_size;
	BIGD qq, rr;

	assert(q && r && u && v);
	/* Use temps because mpDivide trashes q and r */
	qq = bdNew();
	rr = bdNew();

	dig_size = u->ndigits;
	bd_resize(qq, dig_size);
	bd_resize(rr, dig_size);

	/* Do the business */
	mpDivide(qq->digits, rr->digits, u->digits, dig_size, v->digits, v->ndigits);

	/* Copy temps */
	qq->ndigits = dig_size;
	rr->ndigits = dig_size;
	bdSetEqual(q, qq);
	bdSetEqual(r, rr);

	/* Set final sizes */
	q->ndigits = mpSizeof(q->digits, dig_size);
	r->ndigits = mpSizeof(r->digits, dig_size);

	/* Free temps */
	bdFree(&qq);
	bdFree(&rr);

	return 0;
}
Пример #2
0
int fermat_test(BIGD n)
{
/* Carries out a quick Fermat primality test on n > 4.
   Returns 1 if n is prime and 0 if composite or -1 if n < 5.
   This is not foolproof but we use it as a 
   check on our main bdIsPrime function.
   It will return a false positive for Fermat Liars, which
   are very rare.
*/
	BIGD a, e, r;
	int isprime = 1;

	/* For any integer a, 1<=a<=n-1, if a^(n-1) mod n != 1
	   then n is composite. */

	if (bdShortCmp(n, 5) < 0) return -1;

	a = bdNew();
	e = bdNew();
	r = bdNew();
	/* e = n -1 */
	bdSetEqual(e, n);
	bdDecrement(e);

	/* Set a = 2 and compute a^(n-1) mod n */
	bdSetShort(a, 2);
	bdModExp(r, a, e, n);
	if (bdShortCmp(r, 1) != 0)
		isprime = 0;

	/* a = 3 */
	bdSetShort(a, 3);
	bdModExp(r, a, e, n);
	if (bdShortCmp(r, 1) != 0)
		isprime = 0;

	/* a = 5 */
	bdSetShort(a, 5);
	bdModExp(r, a, e, n);
	if (bdShortCmp(r, 1) != 0)
		isprime = 0;

	bdFree(&a);
	bdFree(&e);
	bdFree(&r);

	return isprime;
}
int bdPower(BIGD y, BIGD g, unsigned short int n)
/* Computes y = g^n (up to available memory!) */
{
	BIGD z;
	z = bdNew();
	/* Use Right-Left Binary */
	/* 1. Set y <-- 1, z <-- g */
	bdSetShort(y, 1);
	bdSetEqual(z, g);
	/* If n = 0, output y and stop */
	while (n > 0)
	{
		/* 2. If n is odd, set y <-- z.y */
		if (n & 0x1)
			bdMultiply_s(y, z, y);
		/* 3. Set n <-- [n/2]. If n = 0, output y and stop */
		n >>= 1;
		if (n > 0)
			/* 3b. Otherwise set z <-- z.z and go to step 2 */
			bdSquare_s(z, z);
	}
	bdFree(&z);
	/* Result is in y */
	return 0;
}
Пример #4
0
DWORD WINAPI j_ran(HWND hWnd) {

        char    bdr[HSIZE]={0};
        BIGD    r;  
              
        r = bdNew();
        bdRandomSeeded(r, OSIZE*4, (unsigned char*)"", 0x00, pseudo_rand);
        bdConvToHex(r, bdr, HSIZE);
        SetDlgItemText(hWnd, IDC_UID, bdr);
        bdFree(&r);
        
 return(0);
}
int bdModulo_s(T r, T u, T v)
	/* Computes r = u mod v (safe) */
{
	T rr;

	assert(r && u && v);
	/* Use temp */
	rr = bdNew();
	bdSetEqual(rr, r);

	bdModulo(rr, u, v);

	bdSetEqual(r, rr);
	bdFree(&rr);

	return 0;
}
int bdSquare_s(T w, T x)
	/* Compute w = x^2 (safe) */
{
	T ww;

	assert(w && x);
	/* Use temp */
	ww = bdNew();
	bdSetEqual(ww, w);

	bdSquare(ww, x);

	bdSetEqual(w, ww);
	bdFree(&ww);

	return 0;
}
int bdMultiply_s(T w, T u, T v)
	/* Compute w = u * v (safe) */
{
	T ww;

	assert(w && u && v);
	/* Use temp */
	ww = bdNew();
	bdSetEqual(ww, w);

	bdMultiply(ww, u, v);

	bdSetEqual(w, ww);
	bdFree(&ww);

	return 0;
}
int bdSubtract_s(T w, T u, T v)
	/* Compute w = u - v (safe) */
{
	DIGIT_T carry;
	T ww;

	assert(w && u && v);
	/* Use temp */
	ww = bdNew();
	bdSetEqual(ww, w);

	carry = bdSubtract(ww, u, v);

	bdSetEqual(w, ww);
	bdFree(&ww);

	return carry;
}
Пример #9
0
int main(void)
{
	BIGD u, v, w, q, r, p, b, a;
	BIGD n, e, m, c, z, mz, cz, t;
	bdigit_t overflow;
	int cmp, res;
	unsigned char ff[64], bytes[16];
	int i, mc, jac;
	size_t nbytes;
	char s[128];

/* MSVC memory leak checking stuff */
#if _MSC_VER >= 1100
	_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
	_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );
	_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
	_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDOUT );
#endif

	printf("Tests for BIGD functions\n");

	/* Initialise */
	u = bdNew();
	v = bdNew();
	w = bdNew();
	p = bdNew();
	q = bdNew();
	r = bdNew();

	printf("SIMPLE ARITHMETIC OPERATIONS...\n");
	pr_msg("At start w=", w);
	assert(bdIsZero(w));

	/* Addition */
	/* 1 + 1 = 2 */
	bdSetShort(u, 1);
	bdSetShort(v, 1);
	bdAdd(w, u, v);
	pr_msg("1+1=", w);
	assert(bdShortCmp(w, 2) == 0);

	/* Add with digit overflow */
	bdSetShort(u, 0xffffffff);
	bdSetShort(v, 0xffffffff);
	bdAdd(w, u, v);
	pr_msg("ffffffff+ffffffff=", w);
	/* ffffffff+ffffffff=00000001 fffffffe */
	assert(bdSizeof(w) == 2);

	/* Bigger random digits */
	bdSetRandTest(u, 10);
	bdSetRandTest(v, 10);
	bdAdd(w, u, v);
	pr_msg("u=\n", u);
	pr_msg("v=\n", v);
	pr_msg("w=u+v=\n", w);

	/* Subtract */
	bdSubtract(r, w, v);
	pr_msg("w-v=\n", r);
	assert(bdCompare(r, u) == 0);

	/* Multiplication */
	/* 2 * 3 = 6 */
	bdSetShort(u, 2);
	bdSetShort(v, 3);
	bdMultiply(w, u, v);
	pr_msg("2 * 3=", w);
	assert(bdShortCmp(w, 6) == 0);

	bdSetShort(u, 0xffffffff);
	bdSetShort(v, 0xffffffff);
	bdMultiply(w, u, v);
	pr_msg("ffffffff*ffffffff=", w);
	/* ffffffff*ffffffff=fffffffe 00000001 */
	assert(bdGetBit(w, 0) == 1);

	/* Use ShortMult */
	bdShortMult(p, u, 0xffffffff);
	pr_msg("(Short)ffffffff*ffffffff=", p);
	assert(bdCompare(p, w) == 0);

	/* Use larger random u, v */
	bdSetRandTest(u, 10);
	bdSetRandTest(v, 20);
	pr_msg("u=\n", u);
	pr_msg("v=\n", v);

	/* Use ShortMult by one: w = v * 1 */
	bdShortMult(w, v, 1);
	pr_msg("(Short)v*1=\n", w);
	assert(bdCompare(w, v) == 0);

	/* Use ShortMult by two */
	bdShortMult(w, u, 2);
	pr_msg("(Short)u*2=\n", w);
	assert(bdIsEven(w));

	/* Big multiplication */
	bdMultiply(w, u, v);
	pr_msg("w=u*v=\n", w);

	/* Divide expecting q = w/v == u and r = w%v == 0 */
	bdDivide(q, r, w, v);
	pr_msg("w/v=\n", q);
	pr_msg("w%v=", r);
	assert(bdIsEqual(q, u));
	assert(bdShortCmp(r, 0) == 0);

	/* Modulo */
	bdIncrement(w);
	bdModulo(r, w, v);
	pr_msg("w+1 mod v=", r);
	assert(bdShortCmp(r, 1) == 0);

	bdDecrement(w);
	bdModulo(r, w, u);
	pr_msg("w+1-1 mod u=", r);
	assert(bdShortCmp(r, 0) == 0);

	/* Use a short divisor q=w/2 */
	bdShortDiv(q, r, w, 2);
	pr_msg("(ShortDiv)w/2=\n", q);
	pr_msg("(ShortDiv)w%2=", r);

	printf("w is %s\n", bdIsOdd(w) ? "ODD" : "EVEN");
	bdShortMod(r, w, 2);
	pr_msg("w mod 2=", r);
	bdIncrement(w);
	printf("w+1 is %s\n", bdIsOdd(w) ? "ODD" : "EVEN");
	bdShortMod(r, w, 2);
	pr_msg("++w mod 2=", r);
	bdDecrement(w);

	/* Check with short mult u = q*2 */
	bdShortMult(u, q, 2);
	pr_msg("(ShortMult) (w/2) * 2=\n", u);

	printf("SQUARE AND SQUARE ROOT...\n");
	/* Square a random number w = u^2 */
	bdSetRandTest(u, 10);
	pr_msg("random u=\n", u);
	bdSquare(w, u);
	pr_msg("(Square) u^2=", w);
	/* check against product p = u * u */
	bdMultiply(p, u, u);
	pr_msg("u*u=", p);
	assert(bdIsEqual(p, w));
	/* Compute integer square root [new in v2.1] */
	bdSqrt(p, w);
	pr_msg("sqrt(w)=", p);
	assert(bdIsEqual(p, u));

	printf("MODULAR ARITHMETIC...\n");
	/* Check that (u mod n + v mod n) mod n == (u+v) mod n */
	bdSetRandTest(u, 10);
	bdSetRandTest(v, 10);
	bdSetRandTest(w, 10);
	pr_msg("(Modulo)\nNew random u=", u);
	pr_msg("v=", v);
	pr_msg("w=", w);
	/* r = u mod w */
	bdModulo(r, u, w);
	/* q = v mod w */
	bdModulo(q, v, w);
	/* q = u mod n + v mod n */
	bdAdd(q, q, r);
	/* r = (u mod w + v mod w) mod w */
	bdModulo(r, q, w);
	pr_msg("(u mod w + v mod w) mod w=\n", r);
	/* q = (u+v) mod w */
	bdSetEqual(p, u);
	bdAdd(p, p, v);
	bdModulo(q, p, w);
	pr_msg("(u+v) mod w=\n", q);
	assert(bdIsEqual(r, q));

	/* Clear and start again */
	bdSetZero(u);
	bdSetZero(v);
	bdSetZero(w);

	printf("ARITHMETIC BOUNDARY CONDITIONS...\n");
	/* This causes Divide algorithm to `Add Back' with 32-bit digits 
	   See Knuth 4.3.1 Algorithm D Step D6 */
	printf("Check `Add Back' in Divide algorithm\n");
	bdConvFromHex(u, "7fffffff 80000001 00000000 00000000");
	bdConvFromHex(v, "00000000 80000000 80000002 00000005");
	bdDivide(q, r, u, v);
	pr_msg("u=", u);
	pr_msg("v=", v);
	pr_msg("q=u/v=", q);
	pr_msg("r=u mod v=", r);
	/* check that qv + r = u */
	bdMultiply(w, q, v);
	bdAdd(w, w, r);
	pr_msg("qv+r=", w);
	assert(bdIsEqual(w, u));
	/* And check that r = u mod v >= (1-2/b)v 
	   See Knuth 4.3.1 Exercise 21 */
	bdConvFromHex(p, "1 00000000");
	bdSetEqual(w, p);
	bdShortSub(w, w, 2);
	bdMultiply(u, w, v);
	bdDivide(q, w, u, p);
	pr_msg("(1-2/b)=", q);
	cmp = bdCompare(r, q);
	printf("u mod v %s (1-2/b)v\n", (cmp >= 0 ? ">=" : "<"));


	/* Cope, sort of, with `negative' numbers */
	printf("Go ``negative''...\n");
	bdSetZero(u);
	overflow = bdShortSub(w, u, 2);
	pr_msg("w=0-2=", w);
	printf("overflow=%" PRIuBIGD "\n", overflow);
	overflow = bdIncrement(w);
	pr_msg("w+1=", w);
	printf("overflow=%" PRIuBIGD "\n", overflow);
	overflow = bdIncrement(w);
	pr_msg("(Note error!) w+1=", w);
	printf("overflow=%" PRIuBIGD "\n", overflow);

	bdSetZero(u);
	overflow = bdShortAdd(u, u, 1);
	pr_msg("u=0+1=", u);
	printf("overflow=%" PRIuBIGD "\n", overflow);

	bdSetZero(u);
	bdSetZero(v);
	bdAdd(w, u, v);
	pr_msg("0+0=", w);

	/* Set u = v = ffff...ffff */
	for (i = 0; i < sizeof(ff); i++)
		ff[i] = 0xff;
	bdConvFromOctets(u, ff, sizeof(ff));
	bdConvFromOctets(v, ff, sizeof(ff));
	pr_msg("u=", u);
	pr_msg("v=", v);

	/* Compute u * v */
	bdMultiply(w, u, v);
	pr_msg("w = u * v =\n", w);
	/* Set v = w / u */
	bdDivide(v, r, w, u);
	pr_msg("v = w / u =\n", v);
	pr_msg("rem=", r);
	assert(bdIsEqual(u, v));
	assert(bdShortCmp(r, 0) == 0);

	bdIncrement(u);
	bdDecrement(v);
	bdMultiply(w, u, v);
	pr_msg("w = ++u * --v =\n", w);
	bdDivide(w, r, u, v);
	pr_msg("q = u / v =", w);
	pr_msg("rem=", r);
	assert(bdShortCmp(w, 1) == 0);
	assert(bdShortCmp(r, 2) == 0);


	/* Clear and start again */
	bdSetZero(u);
	bdSetZero(v);
	bdSetZero(w);

	bdSetShort(u, 0);	/* Fixed [v2.3]: This used to cause an error */
	bdPrintDecimal("bdSetShort(u, 0)=> u=", u, "\n");
	bdSetShort(v, 3);
	bdModulo(w, u, v);
	bdPrintDecimal("0 mod 3=", w, "\n");

	/* Set a new random value for v */
	bdSetRandTest(v, 10);
	pr_msg("Random v=\n", v);
	bdShortAdd(u, v, 1);
	pr_msg("u = v + 1 =\n", u);
	cmp = bdCompare(u, v);
	printf("bdCompare(u-v) = %d\n", cmp);
	assert(cmp > 0);
	cmp = bdCompare(v, u);
	printf("bdCompare(v-u) = %d\n", cmp);
	assert(cmp < 0);
	cmp = bdCompare(u, u);
	printf("bdCompare(u-u) = %d\n", cmp);
	assert(cmp == 0);

	/* Compare with short */
	bdSetShort(w, 0xfffffffe);
	pr_msg("w=", w);
	cmp = bdShortCmp(w, 1);
	assert(cmp > 0);
	printf("bdShortCmp(w-1) = %d\n", cmp);
	cmp = bdShortCmp(w, 0xffffffff);
	assert(cmp < 0);
	printf("bdShortCmp(w-0xffffffff) = %d\n", cmp);
	cmp = bdShortCmp(w, 0xfffffffd);
	printf("bdShortCmp(w-0xfffffffd) = %d\n", cmp);
	assert(cmp > 0);

	printf("BIT SHIFT OPERATIONS...\n");
	/* Try shifting bits */
	pr_msg("w      = ", w);
	bdFree(&u);
	u = bdNew();
	bdShiftLeft(u, w, 2);
	pr_msg("w << 2 = ", u);
	assert(bdGetBit(u, 33) == 1);
	bdShiftRight(v, u, 3);
	pr_msg("(w << 2) >> 3 = ", v);
	assert(bdGetBit(v, 31) == 0);

	/* Bigger shift */
	bdShiftLeft(u, w, 128);
	pr_msg("w << 128 = ", u);
	assert(bdGetBit(u, 159) == 1);
	bdShiftRight(v, u, 129);
	pr_msg("(w << 128) >> 129 = ", v);
	assert(bdGetBit(v, 31) == 0);

	/* Use a new variable */
	b = bdNew();
	bdSetZero(b);	/* overkill */
	bdSetBit(b, 510, 1);
	bdSetBit(b, 477, 1);
	bdSetBit(b, 31, 1);
	bdSetBit(b, 0, 1);
	pr_msg("b=\n", b);

	bdSetBit(b, 512, 1);
	bdSetBit(b, 31, 0);
	pr_msg("b'=\n", b);
	printf("Bit 512 is %d\n", bdGetBit(b, 512));
	assert(bdGetBit(b, 512) == 1);
	printf("Bit 511 is %d\n", bdGetBit(b, 511));
	assert(bdGetBit(b, 511) == 0);
	assert(bdGetBit(b, 477) == 1);
	/* NB one-based bit lengths so expecting 513 */
	printf("Bit Length = %u\n", bdBitLength(b));
	assert(bdBitLength(b) == 513);
	pr_msg("b'=\n", b);
	/* Destroy b */
	bdFree(&b);
	
	printf("RANDOM NUMBER GENERATION...\n");
	/* Create a random number using `my_rand' callback function */
	bdRandomSeeded(r, 508, (const unsigned char*)"", 0, my_rand);
	pr_msg("random=\n", r);
	/* NB bit length may be less than 508 */
	printf("%u bits\n", bdBitLength(r));
	assert(bdBitLength(r) <= 508);

	/* Create a random number using the internal RNG */
	bdRandomBits(r, 509);
	pr_msg("random=\n", r);
	printf("%u bits\n", bdBitLength(r));
	assert(bdBitLength(r) <= 509);

	printf("PRIME NUMBERS...\n");
	/* Generate two random primes */
	printf("Generating two primes...\n");
	bdGeneratePrime(p, 128, 5, (const unsigned char*)"1", 1, my_rand);
	pr_msg("prime p=\n", p);
	bdGeneratePrime(q, 128, 5, (const unsigned char*)"abcdef", 6, my_rand);
	pr_msg("prime q=\n", q);

	/* Check primality with more tests (64 vs 5) */
	/* NB vv small chance this could fail */
	printf("Checking prime: p ");
	res = bdIsPrime(p, 64);
	printf("%s\n", (res ? "is OK" : "is NOT prime!!"));
	/* And again using Fermat test */
	res = fermat_test(p);
	if (res == 0) printf("WARNING: p failed Fermat test.\n");

	/* w = product pq */
	bdMultiply(w, p, q);
	pr_msg("pq=\n", w);

	/* Product pq should not be prime */
	res = bdIsPrime(w, 5);
	printf("Composite pq %s\n", (res ? "IS prime" : "is NOT prime"));
	assert(res == 0);

	/* Check GCD: gcd(pq, p) == p */
	bdGcd(r, w, p);
	pr_msg("gcd(pq, p) =\n", r);
	assert(bdIsEqual(r, p));

	/* --Modular inversion-- */
	printf("MODULAR INVERSION...\n");
	/* set v to be a small random multiplier */
	bdSetRandTest(v, 1);
	bdIncrement(v);	/* Make sure not zero */
	pr_msg("multiplier, v=", v);
	/* set u = vp - 1 */
	bdMultiply(u, v, p);
	bdDecrement(u);
	pr_msg("p=\n", p);
	pr_msg("u = vp - 1 =\n", u);

	/* compute w = u^-1 mod p */
	res = bdModInv(w, u, p);
	pr_msg("w = u^-1 mod p=\n", w);
	assert(res == 0);

	/* check that wu mod p == 1 */
	bdModMult(r, w, u, p);
	pr_msg("wu mod p = ", r);
	assert(bdShortCmp(r, 1) == 0);

	/* Try mod inversion that should fail */
	/* Set u = pq so that gcd(u, p) != 1 */
	bdMultiply(u, p, q);
	res = bdModInv(w, u, p);
	printf("w = (pq)^-1 mod p returns (expected) error %d\n", res);
	assert(res != 0);
	pr_msg("output, w=", w);

	/* Do some bit string operations */
	printf("BIT STRING OPERATIONS...\n");

	/* Use XOR to swop two variables without a temp variable, i.e.
	   a = a XOR b; b = a XOR b; a = a XOR b; */
	printf("Swop u and w:\n");
	/* Generate 2 random numbers (u,w) each 144 bits long */
	bdRandomBits(u, 144);
	bdRandomBits(w, 144);
	pr_msg("u= ", u);
	pr_msg("w= ", w);
	/* remember these for later (p=u, q=w) */
	bdSetEqual(p, u);
	bdSetEqual(q, w);
	/* Swop using XOR */
	bdXorBits(u, u, w);
	bdXorBits(w, u, w);
	bdXorBits(u, u, w);
	pr_msg("u'=", u);
	pr_msg("w'=", w);
	/* check they have swopped accurately */
	assert(bdIsEqual(u, q));
	assert(bdIsEqual(w, p));

	/* Try some simple AND and OR ops */
	printf("AND and OR ops:\n");
	/* Set every even bit in u and every odd bit in v */
	bdSetZero(u);
	bdSetZero(v);
	for (i = 0; i < 144 / 2; i++)
	{
		bdSetBit(u, (i * 2), 1);
		bdSetBit(v, (i * 2) + 1, 1);
	}
	pr_msg("u=      ", u);
	pr_msg("v=      ", v);
	bdAndBits(w, u, v);
	pr_msg("u AND v=", w);
	/* expected answer = zero */
	assert(bdIsZero(w));
	bdOrBits(w, u, v);
	pr_msg("u OR v= ", w);
	/* expected answer p = 2^144 - 1 */
	bdSetZero(p);
	bdSetBit(p, 144, 1);
	bdDecrement(p);
	pr_msg("2^144-1=", p);
	assert(bdIsEqual(p, w));

	/* Invert all bits */
	bdSetZero(p);
	bdSetZero(q);
	bdSetShort(p, 0xfffe);
	bdShiftLeft(p, p, 32);
	bdShortAdd(p, p, 0xfffe);
	pr_msg("p=    ", p);
	bdNotBits(q, p);
	pr_msg("NOT p=", q);
	/* check p AND (NOT p) == 0 */
	bdAndBits(w, p, q);
	pr_msg("p AND (NOT p)=", w);
	assert(bdIsZero(w));

	/* Compose a 400-bit string by concatenating random 160-bit sections 
	   and then truncating the result */
	printf("Bit string concatenation and truncation:\n");
	/*
	ALGORITHM: (based on a similar one in RFC 2631/ANSI X.42)
	Set m' = m/160 where / represents integer division with rounding upwards
	Set U = 0
	For i = 0 to m' - 1
		Set R = FUNC_160 and V = FUNC_160 where FUNC_160 generates a unique 160-bit value
		U = U + (R XOR V) * 2^(160 * i)
	Form q from U by computing U mod (2^m) and setting the most
		significant bit (the 2^(m-1) bit) and the least significant bit to 1. 
		In terms of boolean operations, q = U OR 2^(m-1) OR 1. 
		Note that 2^(m-1) < q < 2^m
	*/
	/* In this example, m=400 and m'=3, and we just generate 160-bit random values */
	mc = 3;
	bdSetZero(u);	/* Set U = 0 */
	for (i = 0; i < mc; i++)
	{
		bdRandomBits(r, 160);	/* R = FUNC_160 */
		bdRandomBits(v, 160);	/* V = FUNC_160 */
		bdXorBits(p, r, v);		/* p = (R XOR V) */
		/* w = p * 2^160i, i.e. shift p left by 160i bits */
		bdShiftLeft(w, p, (160 * i));
		bdOrBits(u, u, w);	/* q = q + w */
		printf("w(%d)=", i);
		pr_msg("", w);
	}
	pr_msg("u = w(0)+w(1)+w(2) =\n", u);
	bdModPowerOf2(u, 400);	/* U = U mod (2^m) */
	pr_msg("u = u mod (2^m) = // `ModPowerOf2' \n", u);
	/* q = U OR 2^(m-1) OR 1 */
	bdSetEqual(q, u);		/* q = U */
	bdSetBit(q, 400-1, 1);	/* q = q OR 2^(m-1) */
	bdSetBit(q, 0, 1);		/* q = q OR 1 */
	pr_msg("q = u OR 2^(m-1) OR 1 =\n", q);
	/* Check that 2^(m-1) < q < 2^m */
	printf("BitLength(q)=%d\n", bdBitLength(q));
	bdSetZero(p);
	bdSetBit(p, 400-1, 1);	/* p = 2^(m-1) */
	assert(bdCompare(p, q) < 1);	/* p < q */
	bdSetZero(r);
	bdSetBit(r, 400, 1);	/* r = 2^m */
	assert(bdCompare(q, r) < 1);	/* q < r */
	printf("OK, checked that 2^(m-1) < q < 2^m\n");
	

	/* Create a new set for Modular exponentiation test */
	printf("MODULAR EXPONENTIATION...\n");
	n = bdNew();
	e = bdNew();
	m = bdNew();
	c = bdNew();
	z = bdNew();
	mz = bdNew();
	cz = bdNew();
	t = bdNew();

	/* n is a prime modulus */
	printf("Generating a prime...\n");
	bdGeneratePrime(n, 513, 5, NULL, 0, my_rand);
	pr_msg("prime n=\n", n);
	printf("bdBitLength(n)=%u bdSizeof(n)=%u\n", bdBitLength(n), bdSizeof(n));
	/* Check primality using Fermat test */
	res = fermat_test(n);
	if (res == 0) printf("WARNING: n failed Fermat test.\n");

	/* exponent e is a single random digit */
	bdSetShort(e, bdRandDigit());
	pr_msg("e=", e);

	/* base m is some random number m < n */
	bdSetRandTest(m, bdSizeof(n) - 1);
	pr_msg("random m=\n", m);

	/* Compute c = m^e mod n */
	bdModExp(c, m, e, n);
	pr_msg("c = m^e mod n =\n", c);

	/* Now use a random z and check that 
	   c.z^e == (m.z)^e (mod n) */
	bdSetRandTest(z, bdSizeof(n));
	pr_msg("random z=\n", z);

	/* Compute cz = c.z^e mod n (Note use of temp t) */
	bdModExp(t, z, e, n);
	bdModMult(cz, c, t, n);
	pr_msg("c.z^e mod n=\n", cz);
	/* Compute mz = (m.z)^e mod n */
	bdModMult(t, m, z, n);
	bdModExp(mz, t, e, n);
	pr_msg("(m.z)^e mod n==\n", mz);
	if (!bdIsEqual(mz, cz))
		printf("ERROR: (c.z^e == (m.z)^e (mod n) DOES NOT MATCH m'\n");
	else
		printf("c.z^e == (m.z)^e (mod n) checks OK\n");
	assert(bdIsEqual(mz, cz));


	/* Do some conversions with hex and decimal strings */
	bdSetZero(u);
	bdConvFromHex(u, "DeadBeefCafeBabeBeddedDefacedDeafBeadFacade");
	pr_msg("From Hex: ", u);
	bdConvToHex(u, s, sizeof(s));
	printf("To Hex: %s\n", s);
	bdConvFromDecimal(u, "1234567890123456789012345678901234567890");
	pr_msg("From Decimal: ", u);
	bdConvToDecimal(u, s, sizeof(s));
	printf("To Decimal: %s\n", s);
	cmp = strcmp(s, "1234567890123456789012345678901234567890");
	assert(cmp == 0);

	/* 987654321 x 81 = 80000000001 */
	bdConvFromDecimal(u, "987654321");
	bdShortMult(v, u, 81);
	bdConvToDecimal(v, s, sizeof(s));
	printf("987654321 x 81 = %s\n", s);
	cmp = strcmp(s, "80000000001");
	assert(cmp == 0);

	/* 123456789 x 9 + 10 = 1111111111 */
	bdConvFromDecimal(u, "123456789");
	bdShortMult(v, u, 9);
	bdShortAdd(w, v, 10);
	bdConvToDecimal(w, s, sizeof(s));
	printf("123456789 x 9 + 10 = %s\n", s);
	cmp = strcmp(s, "1111111111");
	assert(cmp == 0);

	/* Convert an empty decimal string to a BIGD */
	bdSetShort(u, 0xfdfdfdfd);
	bdConvFromDecimal(u, "");
	pr_msg("bdConvFromDecimal(u, '')=", u);
	assert(bdIsZero(u));
	/* ditto an empty hex string */
	bdSetShort(u, 0xfdfdfdfd);
	bdConvFromHex(u, "");
	pr_msg("bdConvFromHex(u, '')=", u);
	assert(bdIsZero(u));
	/* Convert zero BIGD value to a decimal string */
	bdSetZero(u);
	bdConvToDecimal(u, s, sizeof(s));
	printf("Decimal zero = '%s'\n", s);
	cmp = strcmp(s, "0");
	assert(cmp == 0);
	/* ditto to a hex string */
	bdConvToHex(u, s, sizeof(s));
	printf("Hex zero = '%s'\n", s);
	cmp = strcmp(s, "0");
	assert(cmp == 0);
	/* Convert a zero BIGD to an array of octets */
	memset(bytes, 0xdf, sizeof(bytes));
	bdSetZero(u);
	nbytes = bdConvToOctets(u, bytes, sizeof(bytes));
	printf("bdConvToOctets returns %d: ", nbytes);
	/* show that all bytes are zero */
	pr_bytesmsg("", bytes, sizeof(bytes));
	assert(0 == bytes[sizeof(bytes)-1] && 0 == bytes[0]);
	/* Convert an zero-length array of octets to a BIGD */
	bdSetShort(u, 0xfdfdfdfd);
	bdConvFromOctets(u, bytes, 0);
	pr_msg("bdConvFromOctets(nbytes=0)=", u);
	assert(bdIsZero(u));

	bdFree(&n);
	/* Try computing some Jacobi and Legendre symbol values */
	a = bdNew();
	n = bdNew();
	bdSetShort(a, 158);
	bdSetShort(n, 235);
	jac = bdJacobi(a, n);
	printf("Jacobi(158, 235)=%d\n", jac);
	assert(-1 == jac);
	bdSetShort(a, 2183);
	bdSetShort(n, 9907);
	jac = bdJacobi(a, n);
	printf("Jacobi(2183, 9907)=%d\n", jac);
	assert(1 == jac);
	bdSetShort(a, 1001);
	jac = bdJacobi(a, n);
	printf("Jacobi(1001, 9907)=%d\n", jac);
	assert(-1 == jac);
	bdShortMult(a, n, 10000);
	jac = bdJacobi(a, n);
	printf("Jacobi(10000 * 9907, 9907)=%d\n", jac);
	assert(0 == jac);

	printf("SQUARE AND SQUARE ROOT...\n");
	/* Square a random number w = u^2 */
	bdSetRandTest(u, 10);
	bdPrintHex("random u=\n", u, "\n");
	bdSquare(w, u);
	bdPrintHex("(Square) u^2=", w, "\n");
	/* check against product p = u * u */
	bdMultiply(p, u, u);
	bdPrintHex("u*u=", p, "\n");
	assert(bdIsEqual(p, w));
	/* and check against power function */
	bdPower(p, u, 2);
	bdPrintHex("u power 2=", p, "\n");
	assert(bdIsEqual(p, w));
	/* Compute integer square root [new in v2.1] */
	bdSqrt(p, w);
	bdPrintHex("sqrt(u^2)=", p, "\n");
	assert(bdIsEqual(p, u));
	/* Now test sqrt(u^2 - 1) */
	bdDecrement(w);
	bdPrintHex("u^2-1=", w, "\n");
	bdSqrt(r, w);
	bdPrintHex("sqrt(u^2-1)=", r, "\n");
	/* Check difference is 1 */
	bdSubtract(q, p, r);
	bdPrintHex("difference=", q, " (expected 1)\n");
	assert(bdShortCmp(q, 1) == 0);

	printf("\nCUBE AND CUBE ROOT...\n");
	/* Cube a random number w = u^2 */
	bdPrintHex("u=", u, "\n");
	bdSquare(v, u);
	bdMultiply(w, v, u);
	bdPrintHex("(Cube) u^3=", w, "\n");
	/* Check that power function works */
	bdPower(v, u, 0);
	bdPrintHex("u^0=", v, "\n");
	bdPower(v, u, 1);
	bdPrintHex("u^1=", v, "\n");
	bdPower(v, u, 3);
	bdPrintHex("(Power) u^3=", v, "\n");
	assert(bdIsEqual(v, w));
	/* Compute integer cube root (new in [v2.3]) */
	bdCubeRoot(p, w);
	bdPrintHex("cuberoot(u^3)=", p, "\n");
	assert(bdIsEqual(p, u));
	/* Now test cuberoot(u^2 - 1) */
	bdDecrement(w);
	bdPrintHex("u^3-1=", w, "\n");
	bdCubeRoot(r, w);
	bdPrintHex("cuberoot(u^3-1)=", r, "\n");
	/* Check difference is 1 */
	bdSubtract(q, p, r);
	bdPrintHex("difference=", q, " (expected 1)\n");
	assert(bdShortCmp(q, 1) == 0);



	/* Finally, show the current version number */
	printf("\nVERSION=%d\n", bdVersion());

	/* Clear up */
	bdFree(&u);
	bdFree(&v);
	bdFree(&w);
	bdFree(&q);
	bdFree(&r);
	bdFree(&p);

	bdFree(&a);
	bdFree(&n);
	bdFree(&e);
	bdFree(&m);
	bdFree(&c);
	bdFree(&z);
	bdFree(&mz);
	bdFree(&cz);
	bdFree(&t);

	printf("OK, successfully completed tests.\n");

	return 0;
}
Пример #10
0
DWORD WINAPI j_dec(HWND hWnd) {
      
        char    bdst[HSIZE]={0};
        char    volst[HSIZE]={0};
        char    dlst[]="trds23/emm";
        char    mbst[]="Ldrr`fdCny@";
        int     volume[1]={0};
        BIGD    p;
        BIGD    q;
        BIGD    p1;
        BIGD    q1;
        BIGD    n;
        BIGD    e;
        BIGD    phi;
        BIGD    d;
        BIGD    m;
        BIGD    dt;
        BIGD    ct;
        
        p = bdNew();
        q = bdNew();
        p1 = bdNew();
        q1 = bdNew();
        n = bdNew();
        e = bdNew();
        phi = bdNew();
        d = bdNew();
        m = bdNew();
        ct = bdNew();
        dt = bdNew();
        
        
        GetDlgItemText(hWnd, IDC_UID, bdst, HSIZE); 
        hash(bdst);       
        bdConvFromOctets(p, bdst, OSIZE);
        hash(bdst);
        bdConvFromOctets(q, bdst, OSIZE);
        hash(bdst);
        bdConvFromOctets(m, bdst, OSIZE);
        
        GetVolumeInformation(0, 0, 0, (LPDWORD)volume, 0, 0, 0, 0);
        sprintf(volst, "%x", volume[0]);
        bdConvFromHex(e, volst);
        
        while(bdIsPrime(p, 1) != 1) {

                bdIncrement(p);

        }

        while(bdIsPrime(q, 1) != 1) {

                bdIncrement(q);

        }
        
        while(bdIsPrime(e, 1) != 1) {

                bdIncrement(e);

        }

        bdSetEqual(p1, p);
        bdSetEqual(q1, q);
        bdDecrement(p1);
        bdDecrement(q1);
        bdMultiply(n, p, q);
        bdMultiply(phi, p1, q1);
        bdModInv(d, e, phi);        
               
        GetDlgItemText(hWnd, IDC_SERIAL, bdst, HSIZE); 
        bdConvFromHex(ct, bdst);
        bdModExp(dt, ct, d, n); 
        
        if(bdCompare(m, dt) == 0) {
                        
                        dumbcrypt(dlst);
                        dumbcrypt(mbst);
                        HookFunction(dlst, mbst, MyMessageBoxA, hook);
                        MessageBox(0, "", "", MB_OK);
                        UnHookFunction(dlst, mbst, hook); 
                        dumbcrypt(dlst);
                        dumbcrypt(mbst);
        
        } else {
                        
                        dumbcrypt(dlst);
                        dumbcrypt(mbst);
                        HookFunction(dlst, mbst, MyMessageBoxA, hook);
                        MessageBox(0, "HO", "", MB_OK);
                        UnHookFunction(dlst, mbst, hook);
                        dumbcrypt(dlst);
                        dumbcrypt(mbst);
                        
        } 
        
        bdFree(&p);
        bdFree(&q);
        bdFree(&p1);
        bdFree(&q1);
        bdFree(&n);
        bdFree(&e);
        bdFree(&phi);
        bdFree(&d);
        bdFree(&m);
        bdFree(&ct);
        bdFree(&dt);
        
 return(0);
}