MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/ssl/tsrc/crypto_test/src/exptest.c
author sl
Tue, 10 Jun 2014 14:32:02 +0200 (2014-06-10)
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /* crypto/bn/exptest.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  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

    60  */

    61 #include <stdio.h>

    62 #include <stdlib.h>

    63 #include <string.h>

    64 #ifndef SYMBIAN

    65 #include "../e_os.h"

    66 #else

    67 #include "e_os.h"

    68 #endif

    69 

    70 #include <openssl/bio.h>

    71 #include <openssl/bn.h>

    72 #include <openssl/rand.h>

    73 #include <openssl/err.h>

    74 #ifdef SYMBIAN

    75 #ifdef stdin

    76 #undef stdin

    77 #endif

    78 #ifdef stdout

    79 #undef stdout

    80 #endif

    81 #ifdef stderr

    82 #undef stderr

    83 #endif

    84 

    85 #define stdin fp_stdin

    86 #define stdout fp_stdout

    87 #define stderr fp_stderr

    88 

    89 extern FILE *fp_stdout;

    90 extern FILE *fp_stderr;

    91 #endif

    92 

    93 

    94 #define NUM_BITS	(BN_BITS*2)

    95 

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

    97 #ifndef SYMBIAN

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

    99 #else

   100 int exp_main(int argc, char *argv[])

   101 #endif

   102 	{

   103 	BN_CTX *ctx;

   104 	BIO *out=NULL;

   105 	int i,ret;

   106 	unsigned char c;

   107 	BIGNUM *r_mont,*r_mont_const,*r_recp,*r_simple,*a,*b,*m;

   108   

   109     

   110 	RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_rand may fail, and we don't

   111 	                                       * even check its return value

   112 	                                       * (which we should) */

   113   if(errno==ENOMEM)

   114   {

   115 	  return 1;

   116   }	                                       

   117 

   118 	ERR_load_BN_strings();

   119 	if(errno==ENOMEM)

   120     {

   121 	  return 1;

   122 	}	    

   123 

   124 	ctx=BN_CTX_new();

   125 	if (ctx == NULL)

   126 	{

   127 	 if(errno==ENOMEM)

   128      {

   129 	  return 1;

   130 	 }

   131 	 return 1;	    

   132 	} 

   133 	r_mont=BN_new();

   134 	if(r_mont==NULL&&errno==ENOMEM)

   135     {

   136 	  return 1;

   137 	}	    

   138 	r_mont_const=BN_new();

   139 	if(r_mont_const==NULL&&errno==ENOMEM)

   140   {

   141 	  return 1;

   142 	}	    

   143 

   144 	r_recp=BN_new();

   145 	if(r_recp==NULL&&errno==ENOMEM)

   146    {

   147 	  return 1;

   148 	}	    

   149 

   150 	r_simple=BN_new();

   151 	if(r_simple==NULL&&errno==ENOMEM)

   152   {

   153 	  return 1;

   154 	}	    

   155 

   156 	a=BN_new();

   157 	if(a==NULL&&errno==ENOMEM)

   158   {

   159 	  return 1;

   160 	}	    

   161 

   162 	b=BN_new();

   163 	if(b==NULL&&errno==ENOMEM)

   164   {

   165 	  return 1;

   166 	}	    

   167 	

   168 	m=BN_new();

   169 	if(m==NULL&&errno==ENOMEM)

   170   {

   171 	  return 1;

   172 	}	    

   173 	

   174 	if (	(r_mont == NULL) || (r_recp == NULL) ||

   175 		(a == NULL) || (b == NULL))

   176 		goto err;

   177 

   178 	out=BIO_new(BIO_s_file());

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

   180   {

   181 	  return 1;

   182 	}	    

   183 	if (out == NULL) 

   184 	return 1;

   185 	BIO_set_fp(out,stdout,BIO_NOCLOSE);

   186 	if(errno==ENOMEM)

   187   {

   188 	  return 1;

   189 	}	    

   190 

   191 	for (i=0; i<200; i++)

   192 		{

   193 		RAND_bytes(&c,1);

   194   	if(errno==ENOMEM)

   195     {

   196 	    return 1;

   197 	  }	    

   198 

   199 		c=(c%BN_BITS)-BN_BITS2;

   200 		BN_rand(a,NUM_BITS+c,0,0);

   201 		if(errno==ENOMEM)

   202     {

   203 	   return 1;

   204 	  }	    

   205 		RAND_bytes(&c,1);

   206   	if(errno==ENOMEM)

   207     {

   208 	    return 1;

   209 	  }	    

   210 		c=(c%BN_BITS)-BN_BITS2;

   211 		BN_rand(b,NUM_BITS+c,0,0);

   212   	if(errno==ENOMEM)

   213     {

   214 	    return 1;

   215 	  }	    

   216 		RAND_bytes(&c,1);

   217 		if(errno==ENOMEM)

   218     {

   219 	   return 1;

   220 	  }	    

   221 

   222 		c=(c%BN_BITS)-BN_BITS2;

   223 		BN_rand(m,NUM_BITS+c,0,1);

   224 		if(errno==ENOMEM)

   225     {

   226 	   return 1;

   227 	  }	    

   228 

   229 		BN_mod(a,a,m,ctx);

   230 		if(errno==ENOMEM)

   231     {

   232 	   return 1;

   233 	  }	    

   234 	

   235 		BN_mod(b,b,m,ctx);

   236 		if(errno==ENOMEM)

   237       {

   238 	   return 1;

   239 	  }	    

   240 

   241 		ret=BN_mod_exp_mont(r_mont,a,b,m,ctx,NULL);

   242 		if (ret <= 0)

   243 			{

   244 			if(errno==ENOMEM)

   245       {

   246 	     return 1;

   247 	    }	    

   248 			fprintf(stdout,"BN_mod_exp_mont() problems\n");

   249 			ERR_print_errors(out);

   250   		if(errno==ENOMEM)

   251       {

   252 	     return 1;

   253 	    }	    

   254 			return 1;

   255 			}

   256 

   257 		ret=BN_mod_exp_recp(r_recp,a,b,m,ctx);

   258 		if (ret <= 0)

   259 			{

   260   		if(errno==ENOMEM)

   261        {

   262 	       return 1;

   263 	     }	    

   264 			fprintf(stdout,"BN_mod_exp_recp() problems\n");

   265 			ERR_print_errors(out);

   266 			if(errno==ENOMEM)

   267       {

   268 	    return 1;

   269 	    }	    

   270 			return 1;

   271 			}

   272 

   273 		ret=BN_mod_exp_simple(r_simple,a,b,m,ctx);

   274 		if (ret <= 0)

   275 			{

   276   		if(errno==ENOMEM)

   277        {

   278 	       return 1;

   279 	     }	    

   280 			fprintf(stdout,"BN_mod_exp_simple() problems\n");

   281 			ERR_print_errors(out);

   282   		if(errno==ENOMEM)

   283        {

   284 	       return 1;

   285 	     }	    

   286 			return 1;

   287 			}

   288 

   289 		ret=BN_mod_exp_mont_consttime(r_mont_const,a,b,m,ctx,NULL);

   290 		if (ret <= 0)

   291 			{

   292   		if(errno==ENOMEM)

   293        {

   294 	       return 1;

   295 	     }	    

   296 			fprintf(stdout,"BN_mod_exp_mont_consttime() problems\n");

   297 			ERR_print_errors(out);

   298   		if(errno==ENOMEM)

   299        {

   300 	       return 1;

   301 	     }	    

   302 			return 1;

   303 			}

   304 

   305 		if (BN_cmp(r_simple, r_mont) == 0

   306 		    && BN_cmp(r_simple,r_recp) == 0

   307 			&& BN_cmp(r_simple,r_mont_const) == 0)

   308 			{

   309   		if(errno==ENOMEM)

   310        {

   311 	       return 1;

   312 	     }	    

   313       fprintf(stdout,".");

   314 			fflush(stdout);

   315 			}

   316 		else

   317 		  	{

   318 			if (BN_cmp(r_simple,r_mont) != 0)

   319        {

   320  	  		if(errno==ENOMEM)

   321         {

   322 	        return 1;

   323 	      }	    

   324 				fprintf(stdout,"\nsimple and mont results differ\n");

   325        }				

   326 			if (BN_cmp(r_simple,r_mont) != 0)

   327 			{

   328  	  		if(errno==ENOMEM)

   329         {

   330 	        return 1;

   331 	      }	    

   332 				fprintf(stdout,"\nsimple and mont const time results differ\n");

   333 			}	

   334 			if (BN_cmp(r_simple,r_recp) != 0)

   335 			{

   336  	  		if(errno==ENOMEM)

   337         {

   338 	        return 1;

   339 	      }	    

   340 				fprintf(stdout,"\nsimple and recp results differ\n");

   341       }

   342 			fprintf(stdout,"a (%3d) = ",BN_num_bits(a));   BN_print(out,a);

   343   		if(errno==ENOMEM)

   344       {

   345 	       return 1;

   346       }	    

   347 			fprintf(stdout,"\nb (%3d) = ",BN_num_bits(b)); BN_print(out,b);

   348  	  	if(errno==ENOMEM)

   349       {

   350 	       return 1;

   351       }	    

   352 			fprintf(stdout,"\nm (%3d) = ",BN_num_bits(m)); BN_print(out,m);

   353  	  	if(errno==ENOMEM)

   354       {

   355 	       return 1;

   356       }	    

   357 			fprintf(stdout,"\nsimple   =");	BN_print(out,r_simple);

   358  	  	if(errno==ENOMEM)

   359       {

   360 	       return 1;

   361       }	    

   362 			fprintf(stdout,"\nrecp     =");	BN_print(out,r_recp);

   363  	  	if(errno==ENOMEM)

   364       {

   365 	       return 1;

   366       }	    

   367 			fprintf(stdout,"\nmont     ="); BN_print(out,r_mont);

   368  	  	if(errno==ENOMEM)

   369       {

   370 	       return 1;

   371       }	    

   372 			fprintf(stdout,"\nmont_ct  ="); BN_print(out,r_mont_const);

   373  	  	if(errno==ENOMEM)

   374       {

   375 	       return 1;

   376       }	    

   377 			fprintf(stdout,"\n");

   378 			return 1;

   379 			}

   380 		}

   381 	BN_free(r_mont);

   382 	BN_free(r_mont_const);

   383 	BN_free(r_recp);

   384 	BN_free(r_simple);

   385 	BN_free(a);

   386 	BN_free(b);

   387 	BN_free(m);

   388 	BN_CTX_free(ctx);

   389 	ERR_remove_state(0);

   390 	if(errno==ENOMEM)

   391   {

   392     return 1;

   393   }	    

   394 	CRYPTO_mem_leaks(out);

   395 	if(errno==ENOMEM)

   396   {

   397     return 1;

   398   }	    

   399 	BIO_free(out);

   400 	if(errno==ENOMEM)

   401    {

   402 	  return 1;

   403 	 }    

   404  

   405     CRYPTO_cleanup_all_ex_data();

   406    if(errno==ENOMEM)

   407    {

   408 	  return 1;

   409 	 }    

   410  

   411 	fprintf(stdout," done\n");

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

   413 	return 0;

   414 err:

   415 	ERR_load_crypto_strings();

   416 	if(errno==ENOMEM)

   417   {

   418     return 1;

   419   }	    

   420 	

   421 	ERR_print_errors(out);

   422 	if(errno==ENOMEM)

   423   {

   424     return 1;

   425   }	    

   426 	

   427 	

   428 #ifdef OPENSSL_SYS_NETWARE

   429     fprintf(stdout,"ERROR\n");

   430 #endif

   431 	return(1);

   432 	}

   433
Symaptic