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/dhtest.c
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /* crypto/dh/dhtest.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 /* Until the key-gen callbacks are modified to use newer prototypes, we allow

    62  * deprecated functions for openssl-internal code */

    63  #ifndef SYMBIAN

    64 #ifdef OPENSSL_NO_DEPRECATED

    65 #undef OPENSSL_NO_DEPRECATED

    66 #endif

    67 #endif

    68 #include <stdio.h>

    69 #include <stdlib.h>

    70 #include <string.h>

    71 #ifndef SYMBIAN

    72 #include "../e_os.h"

    73 #else

    74 #include "e_os.h"

    75 #endif

    76 

    77 #include <openssl/crypto.h>

    78 #include <openssl/bio.h>

    79 #include <openssl/bn.h>

    80 #include <openssl/rand.h>

    81 #include <openssl/err.h>

    82 

    83 #ifdef SYMBIAN

    84 #ifdef stdin

    85 #undef stdin

    86 #endif

    87 #ifdef stdout

    88 #undef stdout

    89 #endif

    90 #ifdef stderr

    91 #undef stderr

    92 #endif

    93 

    94 #define stdin fp_stdin

    95 #define stdout fp_stdout

    96 #define stderr fp_stderr

    97 

    98 extern FILE *fp_stdout;

    99 extern FILE *fp_stderr;

   100 #endif

   101 #ifdef OPENSSL_NO_DH

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

   103 {

   104     fprintf(stdout,"No DH support\n");

   105     return(0);

   106 }

   107 #else

   108 #include <openssl/dh.h>

   109 

   110 #ifdef OPENSSL_SYS_WIN16

   111 #define MS_CALLBACK	_far _loadds

   112 #else

   113 #define MS_CALLBACK

   114 #endif

   115 

   116 static int MS_CALLBACK cb(int p, int n, BN_GENCB *arg);

   117 

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

   119 

   120 #ifndef SYMBIAN

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

   122 #else

   123 int dh_main(int argc, char *argv[])

   124 #endif

   125 	{

   126 	BN_GENCB _cb;

   127 	DH *a;

   128 	DH *b=NULL;

   129 	char buf[12];

   130 	unsigned char *abuf=NULL,*bbuf=NULL;

   131 	int i,alen,blen,aout,bout,ret=1;

   132 	BIO *out;

   133     

   134 	//CRYPTO_malloc_debug_init();

   135 	//CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);

   136 	//CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);

   137 

   138 #ifdef OPENSSL_SYS_WIN32

   139 	CRYPTO_malloc_init();

   140 #endif

   141 

   142 	RAND_seed(rnd_seed, sizeof rnd_seed);

   143 	if(errno==ENOMEM)

   144    	{

   145 	  return 1;

   146 	}

   147 	out=BIO_new(BIO_s_file());

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

   149    	{

   150 	  return 1;

   151 	}

   152 	if (out == NULL)

   153 	return 1;

   154 	//EXIT(1);

   155 	BIO_set_fp(out,stdout,BIO_NOCLOSE);

   156 	if(errno==ENOMEM)

   157    	{

   158 	  return 1;

   159 	}

   160 	

   161 	BN_GENCB_set(&_cb, &cb, out);

   162 	if(errno==ENOMEM)

   163    	{

   164 	  return 1;

   165 	}

   166 	if(((a = DH_new()) == NULL)) 

   167 	{

   168 		if(errno==ENOMEM)

   169    	   {

   170 	    return 1;

   171 	   }

   172 		goto err;	

   173 	}

   174 	if( !DH_generate_parameters_ex(a, 64,

   175 				DH_GENERATOR_5, &_cb))

   176  {

   177  	  if(a != NULL) DH_free(a);

   178  		if(errno==ENOMEM)

   179    	 {

   180 	    return 1;

   181 	   }

   182 

   183  }	

   184 	if (!DH_check(a, &i)) 

   185 	{

   186 		if(errno==ENOMEM)

   187   	   {

   188 	    return 1;

   189 	   }

   190 		goto err;	

   191 	}

   192 	if (i & DH_CHECK_P_NOT_PRIME)

   193 		BIO_puts(out, "p value is not prime\n");

   194 	if(errno==ENOMEM)

   195    	{

   196 	  return 1;

   197 	}

   198 	

   199 	if (i & DH_CHECK_P_NOT_SAFE_PRIME)

   200 		BIO_puts(out, "p value is not a safe prime\n");

   201 	if(errno==ENOMEM)

   202    	{

   203 	  return 1;

   204 	}

   205 	

   206 	if (i & DH_UNABLE_TO_CHECK_GENERATOR)

   207 		BIO_puts(out, "unable to check the generator value\n");

   208 	if(errno==ENOMEM)

   209    	{

   210 	  return 1;

   211 	}

   212 	

   213 	if (i & DH_NOT_SUITABLE_GENERATOR)

   214 		BIO_puts(out, "the g value is not a generator\n");

   215     if(errno==ENOMEM)

   216    	{

   217 	  return 1;

   218 	}

   219 	

   220 	BIO_puts(out,"\np    =");

   221 	if(errno==ENOMEM)

   222    	{

   223 	  return 1;

   224 	}

   225 	

   226 	BN_print(out,a->p);

   227 	if(errno==ENOMEM)

   228    	{

   229 	  return 1;

   230 	}

   231 	

   232 	BIO_puts(out,"\ng    =");

   233 	if(errno==ENOMEM)

   234    	{

   235 	  return 1;

   236 	}

   237 	

   238 	BN_print(out,a->g);

   239 	if(errno==ENOMEM)

   240    	{

   241 	  return 1;

   242 	}

   243 	

   244 	BIO_puts(out,"\n");

   245 	if(errno==ENOMEM)

   246    	{

   247 	  return 1;

   248 	}

   249 	

   250 	b=DH_new();

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

   252    	{

   253 	  return 1;

   254 	}

   255 	if (b == NULL) goto err;

   256 

   257 	b->p=BN_dup(a->p);

   258 	if(errno==ENOMEM)

   259    	{

   260 	  return 1;

   261 	}

   262 	b->g=BN_dup(a->g);

   263 	if(errno==ENOMEM)

   264    	{

   265 	  return 1;

   266 	}

   267 	if ((b->p == NULL) || (b->g == NULL))

   268 	{

   269 		if(errno==ENOMEM)

   270    	   {

   271 	     return 1;

   272 	   }

   273 	   goto err;

   274 	}

   275 

   276 	/* Set a to run with normal modexp and b to use constant time */

   277 	a->flags &= ~DH_FLAG_NO_EXP_CONSTTIME;

   278 	b->flags |= DH_FLAG_NO_EXP_CONSTTIME;

   279 

   280 	if (!DH_generate_key(a))

   281 	{

   282 	   if(errno==ENOMEM)

   283    	   {

   284 	     return 1;

   285 	   }

   286 	   goto err;	

   287 	}

   288 	BIO_puts(out,"pri 1=");

   289 	if(errno==ENOMEM)

   290    	{

   291 	  return 1;

   292 	}

   293 	BN_print(out,a->priv_key);

   294 	if(errno==ENOMEM)

   295    	{

   296 	  return 1;

   297 	}

   298 	BIO_puts(out,"\npub 1=");

   299 	if(errno==ENOMEM)

   300    	{

   301 	  return 1;

   302 	}

   303 	BN_print(out,a->pub_key);

   304 	if(errno==ENOMEM)

   305    	{

   306 	  return 1;

   307 	}

   308 	BIO_puts(out,"\n");

   309     if(errno==ENOMEM)

   310    	{

   311 	  return 1;

   312 	}

   313 	if (!DH_generate_key(b))

   314 	{

   315 	  if(errno==ENOMEM)

   316    	{

   317 	  return 1;

   318 	}

   319 	  goto err;	

   320 	}

   321 	BIO_puts(out,"pri 2=");

   322 	if(errno==ENOMEM)

   323    	{

   324 	  return 1;

   325 	}

   326 	BN_print(out,b->priv_key);

   327 	if(errno==ENOMEM)

   328    	{

   329 	  return 1;

   330 	}

   331 	BIO_puts(out,"\npub 2=");

   332 	if(errno==ENOMEM)

   333    	{

   334 	  return 1;

   335 	}

   336 	BN_print(out,b->pub_key);

   337 	if(errno==ENOMEM)

   338    	{

   339 	  return 1;

   340 	}

   341 	BIO_puts(out,"\n");

   342 	if(errno==ENOMEM)

   343    	{

   344 	  return 1;

   345 	}

   346 

   347 	alen=DH_size(a);

   348 	 if(errno==ENOMEM)

   349    	{

   350 	  return 1;

   351 	}

   352 	abuf=(unsigned char *)OPENSSL_malloc(alen);

   353 	 if(abuf== NULL&& errno==ENOMEM)

   354    	{

   355 	  return 1;

   356 	}

   357 	aout=DH_compute_key(abuf,b->pub_key,a);

   358     if(errno==ENOMEM)

   359    	{

   360 	  return 1;

   361 	}

   362 	BIO_puts(out,"key1 =");

   363 	if(errno==ENOMEM)

   364    	{

   365 	  return 1;

   366 	}

   367 	for (i=0; i<aout; i++)

   368 		{

   369 		sprintf(buf,"%02X",abuf[i]);

   370 		BIO_puts(out,buf);

   371 		if(errno==ENOMEM)

   372    	    {

   373 	      return 1;

   374 	     }

   375 		}

   376 	BIO_puts(out,"\n");

   377 	if(errno==ENOMEM)

   378    	{

   379 	  return 1;

   380 	}

   381 

   382 	blen=DH_size(b);

   383 	if(errno==ENOMEM)

   384    	{

   385 	  return 1;

   386 	}

   387 	bbuf=(unsigned char *)OPENSSL_malloc(blen);

   388 	if(bbuf== NULL&& errno==ENOMEM)

   389    	{

   390 	  return 1;

   391 	}

   392 	bout=DH_compute_key(bbuf,a->pub_key,b);

   393     if(errno==ENOMEM)

   394    	{

   395 	  return 1;

   396 	}

   397 	

   398 	BIO_puts(out,"key2 =");

   399 	if(errno==ENOMEM)

   400    	{

   401 	  return 1;

   402 	}

   403 	

   404 	for (i=0; i<bout; i++)

   405 		{

   406 		sprintf(buf,"%02X",bbuf[i]);

   407 		BIO_puts(out,buf);

   408 		if(errno==ENOMEM)

   409    	    {

   410 	      return 1;

   411 	     }

   412 	

   413 		}

   414 	BIO_puts(out,"\n");

   415 	if(errno==ENOMEM)

   416    	{

   417 	  return 1;

   418 	}

   419 	

   420 	if ((aout < 4) || (bout != aout) || (memcmp(abuf,bbuf,aout) != 0))

   421 		{

   422 		fprintf(stderr,"Error in DH routines\n");

   423 		ret=1;

   424 		}

   425 	else

   426 		ret=0;

   427 err:

   428 	ERR_print_errors_fp(stderr);

   429     if(errno==ENOMEM)

   430    	{

   431 	  return 1;

   432 	}

   433 	 ERR_remove_state(0);

   434      if(errno==ENOMEM)

   435    {

   436 	  return 1;

   437 	 }

   438     ERR_free_strings();

   439    if(errno==ENOMEM)

   440    {

   441 	  return 1;

   442 	 }    

   443 	if (abuf != NULL) OPENSSL_free(abuf);

   444 	if (bbuf != NULL) OPENSSL_free(bbuf);

   445 	if(b != NULL) DH_free(b);

   446 	if(a != NULL) DH_free(a);

   447 	BIO_free(out);

   448 #ifdef SYMBIAN	

   449 	CRYPTO_cleanup_all_ex_data();

   450 		if(errno==ENOMEM)

   451   {

   452 	  return 1;

   453 	}

   454 

   455 #endif	

   456 #ifdef OPENSSL_SYS_NETWARE

   457     if (ret) fprintf(stdout,"ERROR: %d\n", ret);

   458 #endif

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

   460 	//EXIT(ret);

   461 	return(ret);

   462 	}

   463 

   464 static int MS_CALLBACK cb(int p, int n, BN_GENCB *arg)

   465 	{

   466 	char c='*';

   467 

   468 	if (p == 0) c='.';

   469 	if (p == 1) c='+';

   470 	if (p == 2) c='*';

   471 	if (p == 3) c='\n';

   472 	BIO_write(arg->arg,&c,1);

   473 	if(errno==ENOMEM)

   474    	{

   475 	  return 1;

   476 	}

   477 	

   478 	(void)BIO_flush(arg->arg);

   479 	if(errno==ENOMEM)

   480    	{

   481 	  return 1;

   482 	}

   483 	

   484 #ifdef LINT

   485 	p=n;

   486 #endif

   487 	return 1;

   488 	}

   489 #endif
Symaptic