1 /* crypto/bn/bntest.c */

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

     3  * All rights reserved.

     4  *

     5  * This package is an SSL implementation written

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

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

     8  * 

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

    10  * the following conditions are aheared to.  The following conditions

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

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

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

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

    15  * 

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

    17  * the code are not to be removed.

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

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

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

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

    22  * 

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

    24  * modification, are permitted provided that the following conditions

    25  * are met:

    26  * 1. Redistributions of source code must retain the copyright

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

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

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

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

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

    32  *    must display the following acknowledgement:

    33  *    "This product includes cryptographic software written by

    34  *     Eric Young (eay@cryptsoft.com)"

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

    36  *    being used are not cryptographic related :-).

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

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

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

    40  * 

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

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

    43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

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

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

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

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

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

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

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

    51  * SUCH DAMAGE.

    52  * 

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

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

    55  * copied and put under another distribution licence

    56  * [including the GNU Public Licence.]

    57  */

    58 /* ====================================================================

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

    60  *

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

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

    63  *

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

    65  * license provided above.

    66  *

    67  * The binary polynomial arithmetic software is originally written by 

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

    69  *

    70  */

    71  /*

    72  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

    73  */

    74 

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

    76  * deprecated functions for openssl-internal code */

    77 #ifndef SYMBIAN 

    78 #ifdef OPENSSL_NO_DEPRECATED

    79 #undef OPENSSL_NO_DEPRECATED

    80 #endif

    81 #endif

    82 

    83 #ifdef SYMBIAN

    84 #include <e32def.h>

    85 #endif

    86 

    87 

    88 #include <stdio.h>

    89 #include <stdlib.h>

    90 #include <string.h>

    91 #ifndef SYMBIAN

    92 #include "../e_os.h"

    93 #else

    94 #include "e_os.h"

    95 #endif

    96 

    97 #include <openssl/bio.h>

    98 #include <openssl/bn.h>

    99 #include <openssl/rand.h>

   100 #include <openssl/x509.h>

   101 #include <openssl/err.h>

   102 #ifdef SYMBIAN

   103 #ifdef stdin

   104 #undef stdin

   105 #endif

   106 #ifdef stdout

   107 #undef stdout

   108 #endif

   109 #ifdef stderr

   110 #undef stderr

   111 #endif

   112 #define stdin fp_stdin

   113 #define stdout fp_stdout

   114 #define stderr fp_stderr

   115 extern FILE *fp_stdout;

   116 extern FILE *fp_stderr;

   117 #endif	

   118 

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

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

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

   122 

   123 int test_add(BIO *bp);

   124 int test_sub(BIO *bp);

   125 int test_lshift1(BIO *bp);

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

   127 int test_rshift1(BIO *bp);

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

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

   130 int test_div_word(BIO *bp);

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

   132 int test_mul(BIO *bp);

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

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

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

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

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

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

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

   140 int test_gf2m_add(BIO *bp);

   141 int test_gf2m_mod(BIO *bp);

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

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

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

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

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

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

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

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

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

   151 int rand_neg(void);

   152 static int results=0;

   153 

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

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

   156 

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

   158 

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

   160 	{

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

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

   163 	BIO_puts(out, m);

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

   165 	}

   166 

   167 #ifndef SYMBIAN

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

   169 #else

   170 int bn_main(int argc, char *argv[])

   171 #endif

   172 

   173 	{

   174 	BN_CTX *ctx;

   175 	BIO *out;

   176 	char *outfile=NULL;

   177 

   178 	results = 0;

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

   180 	if(errno==ENOMEM)

   181   {

   182 	 return 1;

   183 	}  

   184 #ifndef SYMBIAN    

   185 	argc--;

   186 	argv++;

   187 #endif	

   188 	while (argc >= 1)

   189 		{

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

   191 			results=1;

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

   193 			{

   194 			if (--argc < 1) break;

   195 			outfile= *(++argv);

   196 			}

   197 		argc--;

   198 		argv++;

   199 		}

   200 

   201 

   202 	ctx=BN_CTX_new();

   203 	if(ctx == NULL&&errno==ENOMEM)

   204   {

   205 	    return 1;

   206 	}  

   207 	if (ctx == NULL)

   208 	return 1;

   209 	out=BIO_new(BIO_s_file());

   210 	if(out == NULL&&errno==ENOMEM)

   211   {

   212 	    return 1;

   213 	}  

   214 

   215 	if (out == NULL) 

   216 	return 1;

   217 	if (outfile == NULL)

   218 		{

   219 		BIO_set_fp(out,stdout,BIO_NOCLOSE);

   220 		if(errno==ENOMEM)

   221     {

   222 	    return 1;

   223 	  }  

   224 		}

   225 	else

   226 		{

   227 		if (!BIO_write_filename(out,outfile))

   228 			{

   229   			return 1;

   230    		}

   231 		}

   232 

   233 	if (!results)

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

   235  	if(errno==ENOMEM)

   236   {

   237 	 return 1;

   238 	}  

   239 	message(out,"BN_add");

   240 	if (!test_add(out)) 

   241 	{

   242 	if(errno==ENOMEM)

   243   {

   244 	 return 1;

   245 	}  

   246 	goto err;

   247   }

   248 	(void)BIO_flush(out);

   249   if(errno==ENOMEM)

   250   {

   251 	 return 1;

   252 	}  

   253 

   254 	message(out,"BN_sub");

   255 	if (!test_sub(out))

   256 	{

   257 	if(errno==ENOMEM)

   258   {

   259 	 return 1;

   260 	}  

   261   goto err;

   262 	} 

   263 	(void)BIO_flush(out);

   264 	if(errno==ENOMEM)

   265   {

   266 	 return 1;

   267 	}  

   268 

   269 	message(out,"BN_lshift1");

   270 	if (!test_lshift1(out))

   271 	{

   272 	if(errno==ENOMEM)

   273   {

   274 	 return 1;

   275 	}	

   276 	goto err;

   277   }

   278 	(void)BIO_flush(out);

   279  	if(errno==ENOMEM)

   280   {

   281 	 return 1;

   282 	}

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

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

   285 	{

   286 		if(errno==ENOMEM)

   287    {

   288 	  return 1;

   289 	 }

   290 	 goto err;

   291 	}    

   292 	(void)BIO_flush(out);

   293   if(errno==ENOMEM)

   294   {

   295 	 return 1;

   296 	}

   297 	message(out,"BN_lshift");

   298 	if (!test_lshift(out,ctx,NULL))

   299 	{

   300 	 if(errno==ENOMEM)

   301    {

   302 	  return 1;

   303 	 } 

   304 		goto err;

   305 	}	

   306 	(void)BIO_flush(out);

   307 	if(errno==ENOMEM)

   308   {

   309 	 return 1;

   310 	}

   311 	message(out,"BN_rshift1");

   312 	if (!test_rshift1(out))

   313 	{

   314 	if(errno==ENOMEM)

   315   {

   316 	 return 1;

   317 	}	

   318 	goto err;

   319   }	

   320 	(void)BIO_flush(out);

   321   if(errno==ENOMEM)

   322   {

   323 	 return 1;

   324 	}

   325 	message(out,"BN_rshift");

   326 	if (!test_rshift(out,ctx))

   327 	{

   328 		if(errno==ENOMEM)

   329     {

   330 	   return 1;

   331 	  }

   332 		goto err;

   333 	}	 

   334 	(void)BIO_flush(out);

   335 	if(errno==ENOMEM)

   336   {

   337 	 return 1;

   338 	}

   339 	message(out,"BN_sqr");

   340 	if (!test_sqr(out,ctx))

   341 	{

   342 	 if(errno==ENOMEM)

   343    {

   344 	  return 1;

   345 	 } 

   346 		goto err;

   347   }	

   348 	(void)BIO_flush(out);

   349 	if(errno==ENOMEM)

   350   {

   351 	 return 1;

   352 	}

   353 

   354 	message(out,"BN_mul");

   355 	if (!test_mul(out))

   356 	{

   357 	 if(errno==ENOMEM)

   358    {

   359 	  return 1;

   360 	 }

   361 		goto err;

   362 	} 	

   363 	(void)BIO_flush(out);

   364   if(errno==ENOMEM)

   365   {

   366 	 return 1;

   367 	}

   368 	message(out,"BN_div");

   369 	if (!test_div(out,ctx))

   370 	{

   371 		if(errno==ENOMEM)

   372    {

   373 	   return 1;

   374 	 }

   375 	 goto err;

   376 	}	 

   377 	(void)BIO_flush(out);

   378   if(errno==ENOMEM)

   379   {

   380 	 return 1;

   381 	}

   382 	message(out,"BN_div_word");

   383 	if (!test_div_word(out))

   384 	{

   385 		if(errno==ENOMEM)

   386    {

   387 	  return 1;

   388 	 }

   389 		 goto err;

   390 	}	 

   391 	(void)BIO_flush(out);

   392   if(errno==ENOMEM)

   393   {

   394 	 return 1;

   395 	}

   396 	message(out,"BN_div_recp");

   397 	if (!test_div_recp(out,ctx))

   398 	{

   399 		if(errno==ENOMEM)

   400    {

   401 	   return 1;

   402 	 }

   403 	 goto err;

   404 	}	 

   405 	(void)BIO_flush(out);

   406  if(errno==ENOMEM)

   407   {

   408 	 return 1;

   409 	}

   410 	message(out,"BN_mod");

   411 	if (!test_mod(out,ctx))

   412 	{

   413 		if(errno==ENOMEM)

   414    {

   415 	   return 1;

   416 	 } 

   417 		goto err;

   418 	}	

   419 	(void)BIO_flush(out);

   420   if(errno==ENOMEM)

   421   {

   422 	 return 1;

   423 	}

   424 	message(out,"BN_mod_mul");

   425 	if (!test_mod_mul(out,ctx))

   426 	{

   427 	 if(errno==ENOMEM)

   428    {

   429 	  return 1;

   430 	 } 

   431 		goto err;

   432 	}	

   433 	(void)BIO_flush(out);

   434   if(errno==ENOMEM)

   435   {

   436 	 return 1;

   437 	}

   438 	message(out,"BN_mont");

   439 	if (!test_mont(out,ctx))

   440 	{

   441 		if(errno==ENOMEM)

   442    {

   443 	  return 1;

   444 	 }

   445 		 goto err;

   446 	}	 

   447 	(void)BIO_flush(out);

   448   if(errno==ENOMEM)

   449   {

   450 	 return 1;

   451 	}

   452 	message(out,"BN_mod_exp");

   453 	if (!test_mod_exp(out,ctx))

   454 	{

   455 	 	if(errno==ENOMEM)

   456   {

   457 	 return 1;

   458 	}

   459 		 goto err;

   460 	}	 

   461 	(void)BIO_flush(out);

   462   if(errno==ENOMEM)

   463   {

   464 	 return 1;

   465 	}

   466 	message(out,"BN_mod_exp_mont_consttime");

   467 	if (!test_mod_exp_mont_consttime(out,ctx))

   468 	{

   469 		if(errno==ENOMEM)

   470   {

   471 	 return 1;

   472 	}

   473 		 goto err;

   474   }	

   475 	(void)BIO_flush(out);

   476   if(errno==ENOMEM)

   477   {

   478 	 return 1;

   479 	}

   480 	message(out,"BN_exp");

   481 	if (!test_exp(out,ctx))

   482 	{

   483 		if(errno==ENOMEM)

   484   {

   485 	 return 1;

   486 	}

   487 		 goto err;

   488 	}	 

   489 	(void)BIO_flush(out);

   490   if(errno==ENOMEM)

   491   {

   492 	 return 1;

   493 	}

   494 	message(out,"BN_kronecker");

   495 	if (!test_kron(out,ctx)) 

   496 	{

   497 		if(errno==ENOMEM)

   498   {

   499 	 return 1;

   500 	}

   501 		goto err;

   502 	}	

   503 	(void)BIO_flush(out);

   504   if(errno==ENOMEM)

   505   {

   506 	 return 1;

   507 	}

   508 	message(out,"BN_mod_sqrt");

   509 	if (!test_sqrt(out,ctx))

   510 	{

   511 		if(errno==ENOMEM)

   512   {

   513 	 return 1;

   514 	}

   515 		 goto err;

   516 	}	 

   517 	(void)BIO_flush(out);

   518   if(errno==ENOMEM)

   519   {

   520 	 return 1;

   521 	}

   522 	message(out,"BN_GF2m_add");

   523 	if (!test_gf2m_add(out))

   524 	{

   525 		if(errno==ENOMEM)

   526   {

   527 	 return 1;

   528 	}

   529 		 goto err;

   530 	}	 

   531 	(void)BIO_flush(out);

   532 if(errno==ENOMEM)

   533   {

   534 	 return 1;

   535 	}

   536 	message(out,"BN_GF2m_mod");

   537 	if (!test_gf2m_mod(out))

   538 	{

   539 		if(errno==ENOMEM)

   540   {

   541 	 return 1;

   542 	} 

   543 		goto err;

   544 	}	

   545 	(void)BIO_flush(out);

   546   if(errno==ENOMEM)

   547   {

   548 	 return 1;

   549 	}

   550 	message(out,"BN_GF2m_mod_mul");

   551 	if (!test_gf2m_mod_mul(out,ctx))

   552 	{

   553 		if(errno==ENOMEM)

   554    {

   555 	  return 1;

   556 	 }

   557 		goto err;

   558 	}	

   559 	(void)BIO_flush(out);

   560   if(errno==ENOMEM)

   561   {

   562 	 return 1;

   563 	}

   564 	message(out,"BN_GF2m_mod_sqr");

   565 	if (!test_gf2m_mod_sqr(out,ctx))

   566 	{

   567 		if(errno==ENOMEM)

   568   {

   569 	 return 1;

   570 	}

   571 		 goto err;

   572 	}	 

   573 	(void)BIO_flush(out);

   574 if(errno==ENOMEM)

   575   {

   576 	 return 1;

   577 	}

   578 	message(out,"BN_GF2m_mod_inv");

   579 	if (!test_gf2m_mod_inv(out,ctx))

   580 	{

   581 	if(errno==ENOMEM)

   582   {

   583 	 return 1;

   584 	}

   585 		 goto err;

   586 	}	 

   587 	(void)BIO_flush(out);

   588   if(errno==ENOMEM)

   589   {

   590 	 return 1;

   591 	}

   592 	message(out,"BN_GF2m_mod_div");

   593 	if (!test_gf2m_mod_div(out,ctx))

   594 	{

   595 	 if(errno==ENOMEM)

   596    {

   597 	  return 1;

   598 	 }

   599 		 goto err;

   600 	}	 

   601 	(void)BIO_flush(out);

   602   if(errno==ENOMEM)

   603   {

   604 	 return 1;

   605 	}

   606 	message(out,"BN_GF2m_mod_exp");

   607 	if (!test_gf2m_mod_exp(out,ctx))

   608 	{

   609 	 if(errno==ENOMEM)

   610    {

   611 	  return 1;

   612 	 }

   613 		 goto err;

   614 	}	 

   615 	(void)BIO_flush(out);

   616   if(errno==ENOMEM)

   617   {

   618 	 return 1;

   619 	}

   620 	message(out,"BN_GF2m_mod_sqrt");

   621 	if (!test_gf2m_mod_sqrt(out,ctx))

   622 	{

   623 	 if(errno==ENOMEM)

   624    {

   625 	  return 1;

   626 	 }

   627 		 goto err;

   628 	}	 

   629 	(void)BIO_flush(out);

   630   if(errno==ENOMEM)

   631   {

   632 	 return 1;

   633 	}

   634 	message(out,"BN_GF2m_mod_solve_quad");

   635 	if (!test_gf2m_mod_solve_quad(out,ctx))

   636 	{

   637    if(errno==ENOMEM)

   638    {

   639 	  return 1;

   640 	 }		

   641 		 goto err;

   642 	}	 

   643 	(void)BIO_flush(out);

   644   if(errno==ENOMEM)

   645   {

   646 	 return 1;

   647 	}

   648 	BN_CTX_free(ctx);

   649   if(errno==ENOMEM)

   650   {

   651 	 return 1;

   652 	}

   653 	BIO_free(out);

   654   if(errno==ENOMEM)

   655   {

   656 	 return 1;

   657 	}

   658 #ifdef SYMBIAN	

   659 	CRYPTO_cleanup_all_ex_data();

   660 		if(errno==ENOMEM)

   661   {

   662 	  return 1;

   663 	}

   664 	ERR_remove_state(0);

   665      if(errno==ENOMEM)

   666    {

   667 	  return 1;

   668 	 }

   669     ERR_free_strings();

   670    if(errno==ENOMEM)

   671    {

   672 	  return 1;

   673 	 }    

   674 

   675 #endif

   676     fprintf(stderr,"Test case passed!\n");

   677     fprintf(stdout,"Test case passed!\n");

   678     return 0;

   679 err:

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

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

   682   if(errno==ENOMEM)

   683   {

   684 	 return 1;

   685 	}	                      

   686 	(void)BIO_flush(out);

   687 	if(errno==ENOMEM)

   688   {

   689 	 return 1;

   690 	}

   691 	ERR_load_crypto_strings();

   692 	if(errno==ENOMEM)

   693   {

   694 	 return 1;

   695 	}

   696 	ERR_print_errors_fp(stderr);

   697   if(errno==ENOMEM)

   698   {

   699 	 return 1;

   700 	}

   701 	ERR_remove_state(0);

   702      if(errno==ENOMEM)

   703    {

   704 	  return 1;

   705 	 }

   706     ERR_free_strings();

   707    if(errno==ENOMEM)

   708    {

   709 	  return 1;

   710 	 }    

   711    

   712 	#ifdef SYMBIAN	

   713 	CRYPTO_cleanup_all_ex_data();

   714 		if(errno==ENOMEM)

   715   {

   716 	  return 1;

   717 	}

   718 

   719 #endif

   720 	return(1);

   721 	}

   722 

   723 

   724 int test_add(BIO *bp)

   725 	{

   726 	BIGNUM a,b,c;

   727 	int i;

   728 

   729 	BN_init(&a);

   730 	

   731 	if(errno==ENOMEM)

   732   {

   733 	 return 0;

   734 	}

   735 	BN_init(&b);

   736  if(errno==ENOMEM)

   737   {

   738 	 return 0;

   739 	}

   740 

   741 	BN_init(&c);

   742 	if(errno==ENOMEM)

   743   {

   744 	 return 0;

   745 	}

   746 

   747 

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

   749 	if(errno==ENOMEM)

   750   {

   751 	 return 0;

   752 	}

   753 

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

   755 		{

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

   757 		if(errno==ENOMEM)

   758    {

   759 	  return 0;

   760 	 }

   761 		a.neg=rand_neg();

   762 		if(errno==ENOMEM)

   763    {

   764 	  return 0;

   765 	 }

   766 		b.neg=rand_neg();

   767 	 if(errno==ENOMEM)

   768    {

   769 	  return 0;

   770 	 }

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

   772 	if(errno==ENOMEM)

   773   {

   774 	 return 0;

   775 	}

   776 

   777 		if (bp != NULL)

   778 			{

   779 			if (!results)

   780 				{

   781 				BN_print(bp,&a);

   782 				if(errno==ENOMEM)

   783         {

   784 	        return 0;

   785 	      }

   786 				BIO_puts(bp," + ");

   787 				if(errno==ENOMEM)

   788         {

   789 	        return 0;

   790 	      }

   791 				

   792 				BN_print(bp,&b);

   793 				if(errno==ENOMEM)

   794         {

   795 	        return 0;

   796 	      }

   797 				

   798 				BIO_puts(bp," - ");

   799 				if(errno==ENOMEM)

   800         {

   801 	        return 0;

   802 	      }

   803 				

   804 				}

   805 			BN_print(bp,&c);

   806 			if(errno==ENOMEM)

   807       {

   808 	      return 0;

   809 	    }

   810 			

   811 			BIO_puts(bp,"\n");

   812 			if(errno==ENOMEM)

   813       {

   814 	      return 0;

   815 	    }

   816 

   817 			}

   818 		a.neg=!a.neg;

   819 		b.neg=!b.neg;

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

   821 		if(errno==ENOMEM)

   822     {

   823      return 0;

   824     }

   825 		

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

   827 		if(errno==ENOMEM)

   828     {

   829      return 0;

   830     }

   831 		

   832 		if(!BN_is_zero(&c))

   833 		    {

   834      		 if(errno==ENOMEM)

   835          {

   836            return 0;

   837          }

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

   839 		    return 0;

   840 		    }

   841 		}

   842 	BN_free(&a);

   843   if(errno==ENOMEM)

   844   {

   845     return 0;

   846   }

   847 	

   848 	BN_free(&b);

   849   if(errno==ENOMEM)

   850   {

   851     return 0;

   852   }

   853 	

   854 	BN_free(&c);

   855   if(errno==ENOMEM)

   856   {

   857     return 0;

   858   }

   859 	return(1);

   860 	}

   861 

   862 int test_sub(BIO *bp)

   863 	{

   864 	BIGNUM a,b,c;

   865 	int i;

   866 

   867 	BN_init(&a);

   868   if(errno==ENOMEM)

   869   {

   870     return 0;

   871   }

   872 	

   873 	BN_init(&b);

   874   if(errno==ENOMEM)

   875   {

   876     return 0;

   877   }

   878 	

   879 	BN_init(&c);

   880   if(errno==ENOMEM)

   881   {

   882     return 0;

   883   }

   884 

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

   886 		{

   887 		if (i < num1)

   888 			{

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

   890 		  if(errno==ENOMEM)

   891       {

   892        return 0;

   893       }

   894 			BN_copy(&b,&a);

   895 		  if(errno==ENOMEM)

   896       {

   897        return 0;

   898       }

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

   900 		  if(errno==ENOMEM)

   901       {

   902        return 0;

   903       }

   904 			BN_add_word(&b,i);

   905 		  if(errno==ENOMEM)

   906       {

   907        return 0;

   908       }

   909 			

   910 			}

   911 		else

   912 			{

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

   914 		  if(errno==ENOMEM)

   915       {

   916        return 0;

   917       }

   918 			a.neg=rand_neg();

   919 		  if(errno==ENOMEM)

   920       {

   921        return 0;

   922       }

   923 			b.neg=rand_neg();

   924 		  if(errno==ENOMEM)

   925       {

   926        return 0;

   927       }

   928 			

   929 			}

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

   931 	  if(errno==ENOMEM)

   932     {

   933      return 0;

   934     }

   935 		

   936 		if (bp != NULL)

   937 			{

   938 			if (!results)

   939 				{

   940 				BN_print(bp,&a);

   941   		  if(errno==ENOMEM)

   942         {

   943          return 0;

   944         }

   945 

   946 				BIO_puts(bp," - ");

   947   		  if(errno==ENOMEM)

   948         {

   949          return 0;

   950         }

   951 				

   952 				BN_print(bp,&b);

   953   		  if(errno==ENOMEM)

   954         {

   955          return 0;

   956         }

   957 				

   958 				BIO_puts(bp," - ");

   959   		  if(errno==ENOMEM)

   960         {

   961          return 0;

   962         }

   963 				

   964 				}

   965 			BN_print(bp,&c);

   966  		  if(errno==ENOMEM)

   967       {

   968        return 0;

   969       }

   970 			

   971 			BIO_puts(bp,"\n");

   972  		  if(errno==ENOMEM)

   973       {

   974        return 0;

   975       }

   976 			

   977 			}

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

   979 	  if(errno==ENOMEM)

   980     {

   981      return 0;

   982     }

   983 		

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

   985 	  if(errno==ENOMEM)

   986     {

   987      return 0;

   988     }

   989 		

   990 		if(!BN_is_zero(&c))

   991 		    {

   992      	  if(errno==ENOMEM)

   993         {

   994           return 0;

   995         }

   996 		    	

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

   998 		    return 0;

   999 		    }

  1000 		}

  1001 	BN_free(&a);

  1002   if(errno==ENOMEM)

  1003   {

  1004    return 0;

  1005   }

  1006 	BN_free(&b);

  1007   if(errno==ENOMEM)

  1008   {

  1009    return 0;

  1010   }

  1011 	BN_free(&c);

  1012   if(errno==ENOMEM)

  1013   {

  1014    return 0;

  1015   }

  1016 	return(1);

  1017 	}

  1018 

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

  1020 	{

  1021 	BIGNUM a,b,c,d,e;

  1022 	int i;

  1023 

  1024 	BN_init(&a);

  1025   if(errno==ENOMEM)

  1026   {

  1027    return 0;

  1028   }

  1029 	

  1030 	BN_init(&b);

  1031   if(errno==ENOMEM)

  1032   {

  1033    return 0;

  1034   }

  1035 	

  1036 	BN_init(&c);

  1037   if(errno==ENOMEM)

  1038   {

  1039    return 0;

  1040   }

  1041 	

  1042 	BN_init(&d);

  1043   if(errno==ENOMEM)

  1044   {

  1045    return 0;

  1046   }

  1047 	

  1048 	BN_init(&e);

  1049   if(errno==ENOMEM)

  1050   {

  1051    return 0;

  1052   }

  1053 	

  1054 

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

  1056 		{

  1057 		if (i < num1)

  1058 			{

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

  1060       if(errno==ENOMEM)

  1061       {

  1062         return 0;

  1063       }

  1064 			

  1065 			BN_copy(&b,&a);

  1066       if(errno==ENOMEM)

  1067       {

  1068         return 0;

  1069       }

  1070 			BN_lshift(&a,&a,i);

  1071       if(errno==ENOMEM)

  1072       {

  1073         return 0;

  1074       }

  1075 			BN_add_word(&a,i);

  1076       if(errno==ENOMEM)

  1077       {

  1078         return 0;

  1079       }

  1080 			}

  1081 		else

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

  1083       if(errno==ENOMEM)

  1084       {

  1085         return 0;

  1086       }

  1087 			

  1088 		a.neg=rand_neg();

  1089     if(errno==ENOMEM)

  1090     {

  1091       return 0;

  1092     }

  1093 		b.neg=rand_neg();

  1094     if(errno==ENOMEM)

  1095     {

  1096       return 0;

  1097     }

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

  1099     if(errno==ENOMEM)

  1100     {

  1101       return 0;

  1102     }

  1103 		if (bp != NULL)

  1104 			{

  1105 			if (!results)

  1106 				{

  1107 				BN_print(bp,&a);

  1108         if(errno==ENOMEM)

  1109         {

  1110          return 0;

  1111         }

  1112 				BIO_puts(bp," / ");

  1113         if(errno==ENOMEM)

  1114         {

  1115          return 0;

  1116         }

  1117 				

  1118 				BN_print(bp,&b);

  1119         if(errno==ENOMEM)

  1120         {

  1121          return 0;

  1122         }

  1123 				

  1124 				BIO_puts(bp," - ");

  1125         if(errno==ENOMEM)

  1126         {

  1127          return 0;

  1128         }

  1129 				

  1130 				}

  1131 			BN_print(bp,&d);

  1132       if(errno==ENOMEM)

  1133       {

  1134        return 0;

  1135       }