/* crypto/bn/bntest.c */

/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

 * All rights reserved.

 *

 * This package is an SSL implementation written

 * by Eric Young (eay@cryptsoft.com).

 * The implementation was written so as to conform with Netscapes SSL.

 * 

 * This library is free for commercial and non-commercial use as long as

 * the following conditions are aheared to.  The following conditions

 * apply to all code found in this distribution, be it the RC4, RSA,

 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

 * included with this distribution is covered by the same copyright terms

 * except that the holder is Tim Hudson (tjh@cryptsoft.com).

 * 

 * Copyright remains Eric Young's, and as such any Copyright notices in

 * the code are not to be removed.

 * If this package is used in a product, Eric Young should be given attribution

 * as the author of the parts of the library used.

 * This can be in the form of a textual message at program startup or

 * in documentation (online or textual) provided with the package.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *    "This product includes cryptographic software written by

 *     Eric Young (eay@cryptsoft.com)"

 *    The word 'cryptographic' can be left out if the rouines from the library

 *    being used are not cryptographic related :-).

 * 4. If you include any Windows specific code (or a derivative thereof) from 

 *    the apps directory (application code) you must include an acknowledgement:

 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

 * 

 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 * 

 * The licence and distribution terms for any publically available version or

 * derivative of this code cannot be changed.  i.e. this code cannot simply be

 * copied and put under another distribution licence

 * [including the GNU Public Licence.]

 */

/* ====================================================================

 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

 *

 * Portions of the attached software ("Contribution") are developed by 

 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.

 *

 * The Contribution is licensed pursuant to the Eric Young open source

 * license provided above.

 *

 * The binary polynomial arithmetic software is originally written by 

 * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.

 *

 */

/* Until the key-gen callbacks are modified to use newer prototypes, we allow

 * deprecated functions for openssl-internal code */

#ifdef OPENSSL_NO_DEPRECATED

#undef OPENSSL_NO_DEPRECATED

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "e_os.h"

#include <openssl/bio.h>

#include <openssl/bn.h>

#include <openssl/rand.h>

#include <openssl/x509.h>

#include <openssl/err.h>

const int num0 = 100; /* number of tests */

const int num1 = 50;  /* additional tests for some functions */

const int num2 = 5;   /* number of tests for slow functions */

int test_add(BIO *bp);

int test_sub(BIO *bp);

int test_lshift1(BIO *bp);

int test_lshift(BIO *bp,BN_CTX *ctx,BIGNUM *a_);

int test_rshift1(BIO *bp);

int test_rshift(BIO *bp,BN_CTX *ctx);

int test_div(BIO *bp,BN_CTX *ctx);

int test_div_word(BIO *bp);

int test_div_recp(BIO *bp,BN_CTX *ctx);

int test_mul(BIO *bp);

int test_sqr(BIO *bp,BN_CTX *ctx);

int test_mont(BIO *bp,BN_CTX *ctx);

int test_mod(BIO *bp,BN_CTX *ctx);

int test_mod_mul(BIO *bp,BN_CTX *ctx);

int test_mod_exp(BIO *bp,BN_CTX *ctx);

int test_mod_exp_mont_consttime(BIO *bp,BN_CTX *ctx);

int test_exp(BIO *bp,BN_CTX *ctx);

int test_gf2m_add(BIO *bp);

int test_gf2m_mod(BIO *bp);

int test_gf2m_mod_mul(BIO *bp,BN_CTX *ctx);

int test_gf2m_mod_sqr(BIO *bp,BN_CTX *ctx);

int test_gf2m_mod_inv(BIO *bp,BN_CTX *ctx);

int test_gf2m_mod_div(BIO *bp,BN_CTX *ctx);

int test_gf2m_mod_exp(BIO *bp,BN_CTX *ctx);

int test_gf2m_mod_sqrt(BIO *bp,BN_CTX *ctx);

int test_gf2m_mod_solve_quad(BIO *bp,BN_CTX *ctx);

int test_kron(BIO *bp,BN_CTX *ctx);

int test_sqrt(BIO *bp,BN_CTX *ctx);

int rand_neg(void);

static int results=0;

static unsigned char lst[]="\xC6\x4F\x43\x04\x2A\xEA\xCA\x6E\x58\x36\x80\x5B\xE8\xC9"

"\x9B\x04\x5D\x48\x36\xC2\xFD\x16\xC9\x64\xF0";

static const char rnd_seed[] = "string to make the random number generator think it has entropy";

static void message(BIO *out, char *m)

	{

	fprintf(stderr, "test %s\n", m);

	BIO_puts(out, "print \"test ");

	BIO_puts(out, m);

	BIO_puts(out, "\\n\"\n");

	}

int main(int argc, char *argv[])

	{

	BN_CTX *ctx;

	BIO *out;

	char *outfile=NULL;

	results = 0;

	RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_generate_prime may fail */

	argc--;

	argv++;

	while (argc >= 1)

		{

		if (strcmp(*argv,"-results") == 0)

			results=1;

		else if (strcmp(*argv,"-out") == 0)

			{

			if (--argc < 1) break;

			outfile= *(++argv);

			}

		argc--;

		argv++;

		}

	ctx=BN_CTX_new();

	if (ctx == NULL) EXIT(1);

	out=BIO_new(BIO_s_file());

	if (out == NULL) EXIT(1);

	if (outfile == NULL)

		{

		BIO_set_fp(out,stdout,BIO_NOCLOSE);

		}

	else

		{

		if (!BIO_write_filename(out,outfile))

			{

			perror(outfile);

			EXIT(1);

			}

		}

	if (!results)

		BIO_puts(out,"obase=16\nibase=16\n");

	message(out,"BN_add");

	if (!test_add(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_sub");

	if (!test_sub(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_lshift1");

	if (!test_lshift1(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_lshift (fixed)");

	if (!test_lshift(out,ctx,BN_bin2bn(lst,sizeof(lst)-1,NULL)))

	    goto err;

	(void)BIO_flush(out);

	message(out,"BN_lshift");

	if (!test_lshift(out,ctx,NULL)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_rshift1");

	if (!test_rshift1(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_rshift");

	if (!test_rshift(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_sqr");

	if (!test_sqr(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_mul");

	if (!test_mul(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_div");

	if (!test_div(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_div_word");

	if (!test_div_word(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_div_recp");

	if (!test_div_recp(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_mod");

	if (!test_mod(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_mod_mul");

	if (!test_mod_mul(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_mont");

	if (!test_mont(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_mod_exp");

	if (!test_mod_exp(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_mod_exp_mont_consttime");

	if (!test_mod_exp_mont_consttime(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_exp");

	if (!test_exp(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_kronecker");

	if (!test_kron(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_mod_sqrt");

	if (!test_sqrt(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_add");

	if (!test_gf2m_add(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod");

	if (!test_gf2m_mod(out)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod_mul");

	if (!test_gf2m_mod_mul(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod_sqr");

	if (!test_gf2m_mod_sqr(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod_inv");

	if (!test_gf2m_mod_inv(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod_div");

	if (!test_gf2m_mod_div(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod_exp");

	if (!test_gf2m_mod_exp(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod_sqrt");

	if (!test_gf2m_mod_sqrt(out,ctx)) goto err;

	(void)BIO_flush(out);

	message(out,"BN_GF2m_mod_solve_quad");

	if (!test_gf2m_mod_solve_quad(out,ctx)) goto err;

	(void)BIO_flush(out);

	BN_CTX_free(ctx);

	BIO_free(out);

/**/

	EXIT(0);

err:

	BIO_puts(out,"1\n"); /* make sure the Perl script fed by bc notices

	                      * the failure, see test_bn in test/Makefile.ssl*/

	(void)BIO_flush(out);

	ERR_load_crypto_strings();

	ERR_print_errors_fp(stderr);

	EXIT(1);

	return(1);

	}

int test_add(BIO *bp)

	{

	BIGNUM a,b,c;

	int i;

	BN_init(&a);

	BN_init(&b);

	BN_init(&c);

	BN_bntest_rand(&a,512,0,0);

	for (i=0; i<num0; i++)

		{

		BN_bntest_rand(&b,450+i,0,0);

		a.neg=rand_neg();

		b.neg=rand_neg();

		BN_add(&c,&a,&b);

		if (bp != NULL)

			{

			if (!results)

				{

				BN_print(bp,&a);

				BIO_puts(bp," + ");

				BN_print(bp,&b);

				BIO_puts(bp," - ");

				}

			BN_print(bp,&c);

			BIO_puts(bp,"\n");

			}

		a.neg=!a.neg;

		b.neg=!b.neg;

		BN_add(&c,&c,&b);

		BN_add(&c,&c,&a);

		if(!BN_is_zero(&c))

		    {

		    fprintf(stderr,"Add test failed!\n");

		    return 0;

		    }

		}

	BN_free(&a);

	BN_free(&b);

	BN_free(&c);

	return(1);

	}

int test_sub(BIO *bp)

	{

	BIGNUM a,b,c;

	int i;

	BN_init(&a);

	BN_init(&b);

	BN_init(&c);

	for (i=0; i<num0+num1; i++)

		{

		if (i < num1)

			{

			BN_bntest_rand(&a,512,0,0);

			BN_copy(&b,&a);

			if (BN_set_bit(&a,i)==0) return(0);

			BN_add_word(&b,i);

			}

		else

			{

			BN_bntest_rand(&b,400+i-num1,0,0);

			a.neg=rand_neg();

			b.neg=rand_neg();

			}

		BN_sub(&c,&a,&b);

		if (bp != NULL)

			{

			if (!results)

				{

				BN_print(bp,&a);

				BIO_puts(bp," - ");

				BN_print(bp,&b);

				BIO_puts(bp," - ");

				}

			BN_print(bp,&c);

			BIO_puts(bp,"\n");

			}

		BN_add(&c,&c,&b);

		BN_sub(&c,&c,&a);

		if(!BN_is_zero(&c))

		    {

		    fprintf(stderr,"Subtract test failed!\n");

		    return 0;

		    }

		}

	BN_free(&a);

	BN_free(&b);

	BN_free(&c);

	return(1);

	}

int test_div(BIO *bp, BN_CTX *ctx)

	{

	BIGNUM a,b,c,d,e;

	int i;

	BN_init(&a);

	BN_init(&b);

	BN_init(&c);

	BN_init(&d);

	BN_init(&e);

	for (i=0; i<num0+num1; i++)

		{

		if (i < num1)

			{

			BN_bntest_rand(&a,400,0,0);

			BN_copy(&b,&a);

			BN_lshift(&a,&a,i);

			BN_add_word(&a,i);

			}

		else

			BN_bntest_rand(&b,50+3*(i-num1),0,0);

		a.neg=rand_neg();

		b.neg=rand_neg();

		BN_div(&d,&c,&a,&b,ctx);

		if (bp != NULL)

			{

			if (!results)

				{

				BN_print(bp,&a);

				BIO_puts(bp," / ");

				BN_print(bp,&b);

				BIO_puts(bp," - ");

				}

			BN_print(bp,&d);

			BIO_puts(bp,"\n");

			if (!results)

				{

				BN_print(bp,&a);

				BIO_puts(bp," % ");

				BN_print(bp,&b);

				BIO_puts(bp," - ");

				}

			BN_print(bp,&c);

			BIO_puts(bp,"\n");

			}

		BN_mul(&e,&d,&b,ctx);

		BN_add(&d,&e,&c);

		BN_sub(&d,&d,&a);

		if(!BN_is_zero(&d))

		    {

		    fprintf(stderr,"Division test failed!\n");

		    return 0;

		    }

		}

	BN_free(&a);

	BN_free(&b);

	BN_free(&c);

	BN_free(&d);

	BN_free(&e);

	return(1);

	}

static void print_word(BIO *bp,BN_ULONG w)

	{

#ifdef SIXTY_FOUR_BIT

	if (sizeof(w) > sizeof(unsigned long))

		{

		unsigned long	h=(unsigned long)(w>>32),

				l=(unsigned long)(w);

		if (h)	BIO_printf(bp,"%lX%08lX",h,l);

		else	BIO_printf(bp,"%lX",l);

		return;

		}

#endif

	BIO_printf(bp,"%lX",w);

	}

int test_div_word(BIO *bp)

	{

	BIGNUM   a,b;

	BN_ULONG r,s;

	int i;

	BN_init(&a);

	BN_init(&b);

	for (i=0; i<num0; i++)

		{

		do {

			BN_bntest_rand(&a,512,-1,0);

			BN_bntest_rand(&b,BN_BITS2,-1,0);

			s = b.d[0];

		} while (!s);

		BN_copy(&b, &a);

		r = BN_div_word(&b, s);

		if (bp != NULL)

			{

			if (!results)

				{

				BN_print(bp,&a);

				BIO_puts(bp," / ");

				print_word(bp,s);

				BIO_puts(bp," - ");

				}

			BN_print(bp,&b);

			BIO_puts(bp,"\n");

			if (!results)

				{

				BN_print(bp,&a);

				BIO_puts(bp," % ");

				print_word(bp,s);

				BIO_puts(bp," - ");