/* crypto/des/des_opts.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.]

  */

 /* define PART1, PART2, PART3 or PART4 to build only with a few of the options.

  * This is for machines with 64k code segment size restrictions. */

 #if !defined(OPENSSL_SYS_MSDOS) && (!defined(OPENSSL_SYS_VMS) || defined(__DECC)) && !defined(OPENSSL_SYS_MACOSX)

 #define TIMES

 #endif

 #include <stdio.h>

 #ifndef OPENSSL_SYS_MSDOS

 #include <openssl/e_os2.h>

 #include OPENSSL_UNISTD

 #else

 #include <io.h>

 extern void exit();

 #endif

 #ifndef OPENSSL_SYS_NETWARE

 #include <signal.h>

 #endif

 #ifndef _IRIX

 #include <time.h>

 #endif

 #ifdef TIMES

 #include <sys/types.h>

 #include <sys/times.h>

 #endif

 /* Depending on the VMS version, the tms structure is perhaps defined.

    The __TMS macro will show if it was.  If it wasn't defined, we should

    undefine TIMES, since that tells the rest of the program how things

    should be handled.				-- Richard Levitte */

 #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__TMS)

 #undef TIMES

 #endif

 #ifndef TIMES

 #include <sys/timeb.h>

 #endif

 #if defined(sun) || defined(__ultrix)

 #define _POSIX_SOURCE

 #include <limits.h>

 #include <sys/param.h>

 #endif

 #include <openssl/des.h>

 #include "spr.h"

 #define DES_DEFAULT_OPTIONS

 #if !defined(PART1) && !defined(PART2) && !defined(PART3) && !defined(PART4)

 #define PART1

 #define PART2

 #define PART3

 #define PART4

 #endif

 #ifdef PART1

 #undef DES_UNROLL

 #undef DES_RISC1

 #undef DES_RISC2

 #undef DES_PTR

 #undef D_ENCRYPT

 #define DES_encrypt1 des_encrypt_u4_cisc_idx

 #define DES_encrypt2 des_encrypt2_u4_cisc_idx

 #define DES_encrypt3 des_encrypt3_u4_cisc_idx

 #define DES_decrypt3 des_decrypt3_u4_cisc_idx

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #define DES_UNROLL

 #undef DES_RISC1

 #undef DES_RISC2

 #undef DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u16_cisc_idx

 #define DES_encrypt2 des_encrypt2_u16_cisc_idx

 #define DES_encrypt3 des_encrypt3_u16_cisc_idx

 #define DES_decrypt3 des_decrypt3_u16_cisc_idx

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #undef DES_UNROLL

 #define DES_RISC1

 #undef DES_RISC2

 #undef DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u4_risc1_idx

 #define DES_encrypt2 des_encrypt2_u4_risc1_idx

 #define DES_encrypt3 des_encrypt3_u4_risc1_idx

 #define DES_decrypt3 des_decrypt3_u4_risc1_idx

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #endif

 #ifdef PART2

 #undef DES_UNROLL

 #undef DES_RISC1

 #define DES_RISC2

 #undef DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u4_risc2_idx

 #define DES_encrypt2 des_encrypt2_u4_risc2_idx

 #define DES_encrypt3 des_encrypt3_u4_risc2_idx

 #define DES_decrypt3 des_decrypt3_u4_risc2_idx

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #define DES_UNROLL

 #define DES_RISC1

 #undef DES_RISC2

 #undef DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u16_risc1_idx

 #define DES_encrypt2 des_encrypt2_u16_risc1_idx

 #define DES_encrypt3 des_encrypt3_u16_risc1_idx

 #define DES_decrypt3 des_decrypt3_u16_risc1_idx

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #define DES_UNROLL

 #undef DES_RISC1

 #define DES_RISC2

 #undef DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u16_risc2_idx

 #define DES_encrypt2 des_encrypt2_u16_risc2_idx

 #define DES_encrypt3 des_encrypt3_u16_risc2_idx

 #define DES_decrypt3 des_decrypt3_u16_risc2_idx

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #endif

 #ifdef PART3

 #undef DES_UNROLL

 #undef DES_RISC1

 #undef DES_RISC2

 #define DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u4_cisc_ptr

 #define DES_encrypt2 des_encrypt2_u4_cisc_ptr

 #define DES_encrypt3 des_encrypt3_u4_cisc_ptr

 #define DES_decrypt3 des_decrypt3_u4_cisc_ptr

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #define DES_UNROLL

 #undef DES_RISC1

 #undef DES_RISC2

 #define DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u16_cisc_ptr

 #define DES_encrypt2 des_encrypt2_u16_cisc_ptr

 #define DES_encrypt3 des_encrypt3_u16_cisc_ptr

 #define DES_decrypt3 des_decrypt3_u16_cisc_ptr

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #undef DES_UNROLL

 #define DES_RISC1

 #undef DES_RISC2

 #define DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u4_risc1_ptr

 #define DES_encrypt2 des_encrypt2_u4_risc1_ptr

 #define DES_encrypt3 des_encrypt3_u4_risc1_ptr

 #define DES_decrypt3 des_decrypt3_u4_risc1_ptr

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #endif

 #ifdef PART4

 #undef DES_UNROLL

 #undef DES_RISC1

 #define DES_RISC2

 #define DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u4_risc2_ptr

 #define DES_encrypt2 des_encrypt2_u4_risc2_ptr

 #define DES_encrypt3 des_encrypt3_u4_risc2_ptr

 #define DES_decrypt3 des_decrypt3_u4_risc2_ptr

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #define DES_UNROLL

 #define DES_RISC1

 #undef DES_RISC2

 #define DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u16_risc1_ptr

 #define DES_encrypt2 des_encrypt2_u16_risc1_ptr

 #define DES_encrypt3 des_encrypt3_u16_risc1_ptr

 #define DES_decrypt3 des_decrypt3_u16_risc1_ptr

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #define DES_UNROLL

 #undef DES_RISC1

 #define DES_RISC2

 #define DES_PTR

 #undef D_ENCRYPT

 #undef DES_encrypt1

 #undef DES_encrypt2

 #undef DES_encrypt3

 #undef DES_decrypt3

 #define DES_encrypt1 des_encrypt_u16_risc2_ptr

 #define DES_encrypt2 des_encrypt2_u16_risc2_ptr

 #define DES_encrypt3 des_encrypt3_u16_risc2_ptr

 #define DES_decrypt3 des_decrypt3_u16_risc2_ptr

 #undef HEADER_DES_LOCL_H

 #include "des_enc.c"

 #endif

 /* The following if from times(3) man page.  It may need to be changed */

 #ifndef HZ

 # ifndef CLK_TCK

 #  ifndef _BSD_CLK_TCK_ /* FreeBSD fix */

 #   define HZ	100.0

 #  else /* _BSD_CLK_TCK_ */

 #   define HZ ((double)_BSD_CLK_TCK_)

 #  endif

 # else /* CLK_TCK */

 #  define HZ ((double)CLK_TCK)

 # endif

 #endif

 #define BUFSIZE	((long)1024)

 long run=0;

 double Time_F(int s);

 #ifdef SIGALRM

 #if defined(__STDC__) || defined(sgi)

 #define SIGRETTYPE void

 #else

 #define SIGRETTYPE int

 #endif

 SIGRETTYPE sig_done(int sig);

 SIGRETTYPE sig_done(int sig)

 	{

 	signal(SIGALRM,sig_done);

 	run=0;

 #ifdef LINT

 	sig=sig;

 #endif

 	}

 #endif

 #define START	0

 #define STOP	1

 double Time_F(int s)

 	{

 	double ret;

 #ifdef TIMES

 	static struct tms tstart,tend;

 	if (s == START)

 		{

 		times(&tstart);

 		return(0);

 		}

 	else

 		{

 		times(&tend);

 		ret=((double)(tend.tms_utime-tstart.tms_utime))/HZ;

 		return((ret == 0.0)?1e-6:ret);

 		}

 #else /* !times() */

 	static struct timeb tstart,tend;

 	long i;

 	if (s == START)

 		{

 		ftime(&tstart);

 		return(0);

 		}

 	else

 		{

 		ftime(&tend);

 		i=(long)tend.millitm-(long)tstart.millitm;

 		ret=((double)(tend.time-tstart.time))+((double)i)/1000.0;

 		return((ret == 0.0)?1e-6:ret);

 		}

 #endif

 	}

 #ifdef SIGALRM

 #define print_name(name) fprintf(stderr,"Doing %s's for 10 seconds\n",name); alarm(10);

 #else

 #define print_name(name) fprintf(stderr,"Doing %s %ld times\n",name,cb);

 #endif

 #define time_it(func,name,index) \

 	print_name(name); \

 	Time_F(START); \

 	for (count=0,run=1; COND(cb); count++) \

 		{ \

 		unsigned long d[2]; \

 		func(d,&sch,DES_ENCRYPT); \

 		} \

 	tm[index]=Time_F(STOP); \

 	fprintf(stderr,"%ld %s's in %.2f second\n",count,name,tm[index]); \

 	tm[index]=((double)COUNT(cb))/tm[index];

 #define print_it(name,index) \

 	fprintf(stderr,"%s bytes per sec = %12.2f (%5.1fuS)\n",name, \

 		tm[index]*8,1.0e6/tm[index]);

 int main(int argc, char **argv)

 	{

 	long count;

 	static unsigned char buf[BUFSIZE];

 	static DES_cblock key ={0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0};

 	static DES_cblock key2={0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12};

 	static DES_cblock key3={0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12,0x34};

 	DES_key_schedule sch,sch2,sch3;

 	double d,tm[16],max=0;

 	int rank[16];

 	char *str[16];

 	int max_idx=0,i,num=0,j;

 #ifndef SIGALARM

 	long ca,cb,cc,cd,ce;

 #endif

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

 		{

 		tm[i]=0.0;

 		rank[i]=0;

 		}

 #ifndef TIMES

 	fprintf(stderr,"To get the most accurate results, try to run this\n");

 	fprintf(stderr,"program when this computer is idle.\n");

 #endif

 	DES_set_key_unchecked(&key,&sch);

 	DES_set_key_unchecked(&key2,&sch2);

 	DES_set_key_unchecked(&key3,&sch3);

 #ifndef SIGALRM

 	fprintf(stderr,"First we calculate the approximate speed ...\n");

 	DES_set_key_unchecked(&key,sch);

 	count=10;

 	do	{

 		long i;

 		unsigned long data[2];

 		count*=2;

 		Time_F(START);

 		for (i=count; i; i--)

 			DES_encrypt1(data,&(sch[0]),DES_ENCRYPT);

 		d=Time_F(STOP);

 		} while (d < 3.0);

 	ca=count;

 	cb=count*3;

 	cc=count*3*8/BUFSIZE+1;

 	cd=count*8/BUFSIZE+1;

 	ce=count/20+1;

 #define COND(d) (count != (d))

 #define COUNT(d) (d)

 #else

 #define COND(c) (run)

 #define COUNT(d) (count)

         signal(SIGALRM,sig_done);

         alarm(10);

 #endif

 #ifdef PART1

 	time_it(des_encrypt_u4_cisc_idx,  "des_encrypt_u4_cisc_idx  ", 0);

 	time_it(des_encrypt_u16_cisc_idx, "des_encrypt_u16_cisc_idx ", 1);

 	time_it(des_encrypt_u4_risc1_idx, "des_encrypt_u4_risc1_idx ", 2);

 	num+=3;

 #endif

 #ifdef PART2

 	time_it(des_encrypt_u16_risc1_idx,"des_encrypt_u16_risc1_idx", 3);

 	time_it(des_encrypt_u4_risc2_idx, "des_encrypt_u4_risc2_idx ", 4);

 	time_it(des_encrypt_u16_risc2_idx,"des_encrypt_u16_risc2_idx", 5);

 	num+=3;

 #endif

 #ifdef PART3

 	time_it(des_encrypt_u4_cisc_ptr,  "des_encrypt_u4_cisc_ptr  ", 6);

 	time_it(des_encrypt_u16_cisc_ptr, "des_encrypt_u16_cisc_ptr ", 7);

 	time_it(des_encrypt_u4_risc1_ptr, "des_encrypt_u4_risc1_ptr ", 8);

 	num+=3;

 #endif

 #ifdef PART4

 	time_it(des_encrypt_u16_risc1_ptr,"des_encrypt_u16_risc1_ptr", 9);

 	time_it(des_encrypt_u4_risc2_ptr, "des_encrypt_u4_risc2_ptr ",10);

 	time_it(des_encrypt_u16_risc2_ptr,"des_encrypt_u16_risc2_ptr",11);

 	num+=3;

 #endif

 #ifdef PART1

 	str[0]=" 4  c i";

 	print_it("des_encrypt_u4_cisc_idx  ",0);

 	max=tm[0];

 	max_idx=0;

 	str[1]="16  c i";

 	print_it("des_encrypt_u16_cisc_idx ",1);

 	if (max < tm[1]) { max=tm[1]; max_idx=1; }

 	str[2]=" 4 r1 i";

 	print_it("des_encrypt_u4_risc1_idx ",2);

 	if (max < tm[2]) { max=tm[2]; max_idx=2; }

 #endif

 #ifdef PART2

 	str[3]="16 r1 i";

 	print_it("des_encrypt_u16_risc1_idx",3);

 	if (max < tm[3]) { max=tm[3]; max_idx=3; }

 	str[4]=" 4 r2 i";

 	print_it("des_encrypt_u4_risc2_idx ",4);

 	if (max < tm[4]) { max=tm[4]; max_idx=4; }

 	str[5]="16 r2 i";

 	print_it("des_encrypt_u16_risc2_idx",5);

 	if (max < tm[5]) { max=tm[5]; max_idx=5; }

 #endif

 #ifdef PART3

 	str[6]=" 4  c p";

 	print_it("des_encrypt_u4_cisc_ptr  ",6);

 	if (max < tm[6]) { max=tm[6]; max_idx=6; }

 	str[7]="16  c p";

 	print_it("des_encrypt_u16_cisc_ptr ",7);

 	if (max < tm[7]) { max=tm[7]; max_idx=7; }

 	str[8]=" 4 r1 p";

 	print_it("des_encrypt_u4_risc1_ptr ",8);

 	if (max < tm[8]) { max=tm[8]; max_idx=8; }

 #endif

 #ifdef PART4

 	str[9]="16 r1 p";

 	print_it("des_encrypt_u16_risc1_ptr",9);

 	if (max < tm[9]) { max=tm[9]; max_idx=9; }

 	str[10]=" 4 r2 p";

 	print_it("des_encrypt_u4_risc2_ptr ",10);

 	if (max < tm[10]) { max=tm[10]; max_idx=10; }

 	str[11]="16 r2 p";

 	print_it("des_encrypt_u16_risc2_ptr",11);

 	if (max < tm[11]) { max=tm[11]; max_idx=11; }

 #endif

 	printf("options    des ecb/s\n");

 	printf("%s %12.2f 100.0%%\n",str[max_idx],tm[max_idx]);

 	d=tm[max_idx];

 	tm[max_idx]= -2.0;

 	max= -1.0;

 	for (;;)

 		{

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

 			{

 			if (max < tm[i]) { max=tm[i]; j=i; }

 			}

 		if (max < 0.0) break;

 		printf("%s %12.2f  %4.1f%%\n",str[j],tm[j],tm[j]/d*100.0);

 		tm[j]= -2.0;

 		max= -1.0;

 		}

 	switch (max_idx)

 		{

 	case 0:

 		printf("-DDES_DEFAULT_OPTIONS\n");

 		break;

 	case 1:

 		printf("-DDES_UNROLL\n");

 		break;

 	case 2:

 		printf("-DDES_RISC1\n");

 		break;

 	case 3:

 		printf("-DDES_UNROLL -DDES_RISC1\n");

 		break;

 	case 4:

 		printf("-DDES_RISC2\n");

 		break;

 	case 5:

 		printf("-DDES_UNROLL -DDES_RISC2\n");

 		break;

 	case 6:

 		printf("-DDES_PTR\n");

 		break;

 	case 7:

 		printf("-DDES_UNROLL -DDES_PTR\n");

 		break;

 	case 8:

 		printf("-DDES_RISC1 -DDES_PTR\n");

 		break;

 	case 9:

 		printf("-DDES_UNROLL -DDES_RISC1 -DDES_PTR\n");

 		break;

 	case 10:

 		printf("-DDES_RISC2 -DDES_PTR\n");

 		break;

 	case 11:

 		printf("-DDES_UNROLL -DDES_RISC2 -DDES_PTR\n");

 		break;

 		}

 	exit(0);

 #if defined(LINT) || defined(OPENSSL_SYS_MSDOS)

 	return(0);

 #endif

 	}