コード例 #1
0
ファイル: expspeed.c プロジェクト: robacklin/uclinux-linux
void do_mul_exp(BIGNUM *r, BIGNUM *a, BIGNUM *b, BIGNUM *c, BN_CTX *ctx)
	{
	int i,k;
	double tm;
	long num;
	BN_MONT_CTX m;

	memset(&m,0,sizeof(m));

	num=BASENUM;
	for (i=0; i<NUM_SIZES; i++)
		{
		BN_rand(a,sizes[i],1,0);
		BN_rand(b,sizes[i],1,0);
		BN_rand(c,sizes[i],1,1);
		BN_mod(a,a,c,ctx);
		BN_mod(b,b,c,ctx);

		BN_MONT_CTX_set(&m,c,ctx);

		Time_F(START);
		for (k=0; k<num; k++)
			BN_mod_exp_mont(r,a,b,c,ctx,&m);
		tm=Time_F(STOP);
		printf("mul %4d ^ %4d %% %d -> %8.3fms %5.1f\n",sizes[i],sizes[i],sizes[i],tm*1000.0/num,tm*mul_c[i]/num);
		num/=7;
		if (num <= 0) num=1;
		}

	}
コード例 #2
0
ファイル: bnspeed.c プロジェクト: neominds/iwe194030
void do_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
{
    int i, j, k;
    double tm;
    long num;

    for (i = 0; i < NUM_SIZES; i++) {
        num = BASENUM;
        if (i)
            num /= (i * 3);
        BN_rand(a, sizes[i], 1, 0);
        for (j = i; j < NUM_SIZES; j++) {
            BN_rand(b, sizes[j], 1, 0);
            Time_F(START);
            for (k = 0; k < num; k++)
                BN_mul(r, b, a, ctx);
            tm = Time_F(STOP);
            /*printf("mul %4d x %4d -> %8.3fms\n", sizes[i], sizes[j],
                   tm * 1000.0 / num);*//* LEVANCIO S10 comment delete R.Miura 2016/02/03 */
        }
    }

    for (i = 0; i < NUM_SIZES; i++) {
        num = BASENUM;
        if (i)
            num /= (i * 3);
        BN_rand(a, sizes[i], 1, 0);
        Time_F(START);
        for (k = 0; k < num; k++)
            BN_sqr(r, a, ctx);
        tm = Time_F(STOP);
        /*printf("sqr %4d x %4d -> %8.3fms\n", sizes[i], sizes[i],
               tm * 1000.0 / num);*//* LEVANCIO S10 comment delete R.Miura 2016/02/03 */
    }

    for (i = 0; i < NUM_SIZES; i++) {
        num = BASENUM / 10;
        if (i)
            num /= (i * 3);
        BN_rand(a, sizes[i] - 1, 1, 0);
        for (j = i; j < NUM_SIZES; j++) {
            BN_rand(b, sizes[j], 1, 0);
            Time_F(START);
            for (k = 0; k < 100000; k++)
                BN_div(r, NULL, b, a, ctx);
            tm = Time_F(STOP);
            /*printf("div %4d / %4d -> %8.3fms\n", sizes[j], sizes[i] - 1,
                   tm * 1000.0 / num);*//* LEVANCIO S10 comment delete R.Miura 2016/02/03 */
        }
    }
}
コード例 #3
0
ファイル: bnspeed.cpp プロジェクト: Sorcha/NETMF-LPC
void do_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
	{
	int i,j,k;
	double tm;
	long num;

	for (i=0; i<NUM_SIZES; i++)
		{
		num=BASENUM;
		if (i) num/=(i*3);
		BN_rand(a,sizes[i],1,0);
		for (j=i; j<NUM_SIZES; j++)
			{
			BN_rand(b,sizes[j],1,0);
			Time_F(START);
			for (k=0; k<num; k++)
				BN_mul(r,b,a,ctx);
			tm=Time_F(STOP);
			TINYCLR_SSL_FPRINTF("mul %4d x %4d -> %8.3fms\n",sizes[i],sizes[j],tm*1000.0/num);
			}
		}

	for (i=0; i<NUM_SIZES; i++)
		{
		num=BASENUM;
		if (i) num/=(i*3);
		BN_rand(a,sizes[i],1,0);
		Time_F(START);
		for (k=0; k<num; k++)
			BN_sqr(r,a,ctx);
		tm=Time_F(STOP);
		TINYCLR_SSL_FPRINTF("sqr %4d x %4d -> %8.3fms\n",sizes[i],sizes[i],tm*1000.0/num);
		}

	for (i=0; i<NUM_SIZES; i++)
		{
		num=BASENUM/10;
		if (i) num/=(i*3);
		BN_rand(a,sizes[i]-1,1,0);
		for (j=i; j<NUM_SIZES; j++)
			{
			BN_rand(b,sizes[j],1,0);
			Time_F(START);
			for (k=0; k<100000; k++)
				BN_div(r, NULL, b, a,ctx);
			tm=Time_F(STOP);
			TINYCLR_SSL_FPRINTF("div %4d / %4d -> %8.3fms\n",sizes[j],sizes[i]-1,tm*1000.0/num);
			}
		}
	}
コード例 #4
0
ファイル: rc5speed.c プロジェクト: Henauxg/minix
int main(int argc, char **argv)
{
    long count;
    static unsigned char buf[BUFSIZE];
    static unsigned char key[] = {
        0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
        0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
    };
    RC5_32_KEY sch;
    double a, b, c, d;
#ifndef SIGALRM
    long ca, cb, cc;
#endif

#ifndef TIMES
    printf("To get the most accurate results, try to run this\n");
    printf("program when this computer is idle.\n");
#endif

#ifndef SIGALRM
    printf("First we calculate the approximate speed ...\n");
    RC5_32_set_key(&sch, 16, key, 12);
    count = 10;
    do {
        long i;
        RC5_32_INT data[2];

        count *= 2;
        Time_F(START);
        for (i = count; i; i--)
            RC5_32_encrypt(data, &sch);
        d = Time_F(STOP);
    } while (d < 3.0);
    ca = count / 512;
    cb = count;
    cc = count * 8 / BUFSIZE + 1;
    printf("Doing RC5_32_set_key %ld times\n", ca);
# define COND(d) (count != (d))
# define COUNT(d) (d)
#else
# define COND(c) (run)
# define COUNT(d) (count)
    signal(SIGALRM, sig_done);
    printf("Doing RC5_32_set_key for 10 seconds\n");
    alarm(10);
#endif

    Time_F(START);
    for (count = 0, run = 1; COND(ca); count += 4) {
        RC5_32_set_key(&sch, 16, key, 12);
        RC5_32_set_key(&sch, 16, key, 12);
        RC5_32_set_key(&sch, 16, key, 12);
        RC5_32_set_key(&sch, 16, key, 12);
    }
    d = Time_F(STOP);
    printf("%ld RC5_32_set_key's in %.2f seconds\n", count, d);
    a = ((double)COUNT(ca)) / d;

#ifdef SIGALRM
    printf("Doing RC5_32_encrypt's for 10 seconds\n");
    alarm(10);
#else
    printf("Doing RC5_32_encrypt %ld times\n", cb);
#endif
    Time_F(START);
    for (count = 0, run = 1; COND(cb); count += 4) {
        RC5_32_INT data[2];

        RC5_32_encrypt(data, &sch);
        RC5_32_encrypt(data, &sch);
        RC5_32_encrypt(data, &sch);
        RC5_32_encrypt(data, &sch);
    }
    d = Time_F(STOP);
    printf("%ld RC5_32_encrypt's in %.2f second\n", count, d);
    b = ((double)COUNT(cb) * 8) / d;

#ifdef SIGALRM
    printf("Doing RC5_32_cbc_encrypt on %ld byte blocks for 10 seconds\n",
           BUFSIZE);
    alarm(10);
#else
    printf("Doing RC5_32_cbc_encrypt %ld times on %ld byte blocks\n", cc,
           BUFSIZE);
#endif
    Time_F(START);
    for (count = 0, run = 1; COND(cc); count++)
        RC5_32_cbc_encrypt(buf, buf, BUFSIZE, &sch, &(key[0]), RC5_ENCRYPT);
    d = Time_F(STOP);
    printf("%ld RC5_32_cbc_encrypt's of %ld byte blocks in %.2f second\n",
           count, BUFSIZE, d);
    c = ((double)COUNT(cc) * BUFSIZE) / d;

    printf("RC5_32/12/16 set_key       per sec = %12.2f (%9.3fuS)\n", a,
           1.0e6 / a);
    printf("RC5_32/12/16 raw ecb bytes per sec = %12.2f (%9.3fuS)\n", b,
           8.0e6 / b);
    printf("RC5_32/12/16 cbc     bytes per sec = %12.2f (%9.3fuS)\n", c,
           8.0e6 / c);
    exit(0);
#if defined(LINT) || defined(OPENSSL_SYS_MSDOS)
    return (0);
#endif
}
コード例 #5
0
int main(int argc, char **argv)
	{
	long count;
	static unsigned char buf[BUFSIZE];
	static char key[16]={	0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,
				0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0};
	BF_KEY sch;
	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

	BF_set_key(&sch,16,key);

#ifndef SIGALRM
	fprintf(stderr,"First we calculate the approximate speed ...\n");
	count=10;
	do	{
		long i;
		unsigned long data[2];

		count*=2;
		Time_F(START);
		for (i=count; i; i--)
			BF_encrypt(data,&sch);
		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

	time_it(BF_encrypt_normal,	"BF_encrypt_normal ", 0);
	time_it(BF_encrypt_ptr,		"BF_encrypt_ptr    ", 1);
	time_it(BF_encrypt_ptr2,	"BF_encrypt_ptr2   ", 2);
	num+=3;

	str[0]="<nothing>";
	print_it("BF_encrypt_normal ",0);
	max=tm[0];
	max_idx=0;
	str[1]="ptr      ";
	print_it("BF_encrypt_ptr ",1);
	if (max < tm[1]) { max=tm[1]; max_idx=1; }
	str[2]="ptr2     ";
	print_it("BF_encrypt_ptr2 ",2);
	if (max < tm[2]) { max=tm[2]; max_idx=2; }

	printf("options    BF 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<3; 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("-DBF_DEFAULT_OPTIONS\n");
		break;
	case 1:
		printf("-DBF_PTR\n");
		break;
	case 2:
		printf("-DBF_PTR2\n");
		break;
		}
	exit(0);
#if defined(LINT) || defined(OPENSSL_SYS_MSDOS)
	return(0);
#endif
	}
コード例 #6
0
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 a,b,c,d,e;
#ifndef SIGALRM
	long ca,cb,cc,cd,ce;
#endif

#ifndef TIMES
	printf("To get the most accurate results, try to run this\n");
	printf("program when this computer is idle.\n");
#endif

	DES_set_key_unchecked(&key2,&sch2);
	DES_set_key_unchecked(&key3,&sch3);

#ifndef SIGALRM
	printf("First we calculate the approximate speed ...\n");
	DES_set_key_unchecked(&key,&sch);
	count=10;
	do	{
		long i;
		DES_LONG data[2];

		count*=2;
		Time_F(START);
		for (i=count; i; i--)
			DES_encrypt1(data,&sch,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;
	printf("Doing set_key %ld times\n",ca);
#define COND(d)	(count != (d))
#define COUNT(d) (d)
#else
#define COND(c)	(run)
#define COUNT(d) (count)
	signal(SIGALRM,sig_done);
	printf("Doing set_key for 10 seconds\n");
	alarm(10);
#endif

	Time_F(START);
	for (count=0,run=1; COND(ca); count++)
		DES_set_key_unchecked(&key,&sch);
	d=Time_F(STOP);
	printf("%ld set_key's in %.2f seconds\n",count,d);
	a=((double)COUNT(ca))/d;

#ifdef SIGALRM
	printf("Doing DES_encrypt's for 10 seconds\n");
	alarm(10);
#else
	printf("Doing DES_encrypt %ld times\n",cb);
#endif
	Time_F(START);
	for (count=0,run=1; COND(cb); count++)
		{
		DES_LONG data[2];

		DES_encrypt1(data,&sch,DES_ENCRYPT);
		}
	d=Time_F(STOP);
	printf("%ld DES_encrypt's in %.2f second\n",count,d);
	b=((double)COUNT(cb)*8)/d;

#ifdef SIGALRM
	printf("Doing DES_cbc_encrypt on %ld byte blocks for 10 seconds\n",
		BUFSIZE);
	alarm(10);
#else
	printf("Doing DES_cbc_encrypt %ld times on %ld byte blocks\n",cc,
		BUFSIZE);
#endif
	Time_F(START);
	for (count=0,run=1; COND(cc); count++)
		DES_ncbc_encrypt(buf,buf,BUFSIZE,&sch,
			&key,DES_ENCRYPT);
	d=Time_F(STOP);
	printf("%ld DES_cbc_encrypt's of %ld byte blocks in %.2f second\n",
		count,BUFSIZE,d);
	c=((double)COUNT(cc)*BUFSIZE)/d;

#ifdef SIGALRM
	printf("Doing DES_ede_cbc_encrypt on %ld byte blocks for 10 seconds\n",
		BUFSIZE);
	alarm(10);
#else
	printf("Doing DES_ede_cbc_encrypt %ld times on %ld byte blocks\n",cd,
		BUFSIZE);
#endif
	Time_F(START);
	for (count=0,run=1; COND(cd); count++)
		DES_ede3_cbc_encrypt(buf,buf,BUFSIZE,
			&sch,
			&sch2,
			&sch3,
			&key,
			DES_ENCRYPT);
	d=Time_F(STOP);
	printf("%ld DES_ede_cbc_encrypt's of %ld byte blocks in %.2f second\n",
		count,BUFSIZE,d);
	d=((double)COUNT(cd)*BUFSIZE)/d;

#ifdef SIGALRM
	printf("Doing crypt for 10 seconds\n");
	alarm(10);
#else
	printf("Doing crypt %ld times\n",ce);
#endif
	Time_F(START);
	for (count=0,run=1; COND(ce); count++)
		crypt("testing1","ef");
	e=Time_F(STOP);
	printf("%ld crypts in %.2f second\n",count,e);
	e=((double)COUNT(ce))/e;

	printf("set_key            per sec = %12.2f (%9.3fuS)\n",a,1.0e6/a);
	printf("DES raw ecb bytes  per sec = %12.2f (%9.3fuS)\n",b,8.0e6/b);
	printf("DES cbc bytes      per sec = %12.2f (%9.3fuS)\n",c,8.0e6/c);
	printf("DES ede cbc bytes  per sec = %12.2f (%9.3fuS)\n",d,8.0e6/d);
	printf("crypt              per sec = %12.2f (%9.3fuS)\n",e,1.0e6/e);
	exit(0);
#if defined(LINT) || defined(OPENSSL_SYS_MSDOS)
	return(0);
#endif
	}
コード例 #7
0
ファイル: sslspeed.c プロジェクト: TomMD/ics-openvpn
    jdoubleArray Java_de_blinkt_openvpn_core_NativeUtils_getOpenSSLSpeed(JNIEnv* env, jclass thiz, jstring algorithm, jint testnumber)
{
    static const unsigned char key16[16] = {
        0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
        0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
    };
    const EVP_CIPHER *evp_cipher = NULL;

    const char* alg = (*env)->GetStringUTFChars( env, algorithm , NULL ) ;

    evp_cipher = EVP_get_cipherbyname(alg);
    if (evp_cipher == NULL)
        evp_md = EVP_get_digestbyname(alg);
    if (evp_cipher == NULL && evp_md == NULL) {
        //        BIO_printf(bio_err, "%s: %s is an unknown cipher or digest\n", prog, opt_arg());
        //jniThrowException(env, "java/security/NoSuchAlgorithmException", "Algorithm not found");
        return NULL;
    }


    const char* name;

    loopargs_t *loopargs = NULL;
    int loopargs_len = 1;
    int async_jobs=0;
    loopargs = malloc(loopargs_len * sizeof(loopargs_t));
    memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));


    jdoubleArray ret = (*env)->NewDoubleArray(env, 3);

    if (testnum < 0 || testnum >= SIZE_NUM)
        return NULL;

    testnum = testnumber;


    for (int i = 0; i < loopargs_len; i++) {
        int misalign=0;
        loopargs[i].buf_malloc = malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1);
        loopargs[i].buf2_malloc = malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1);
        /* Align the start of buffers on a 64 byte boundary */
        loopargs[i].buf = loopargs[i].buf_malloc + misalign;
        loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
    }


    int count;
    float d;
    if (evp_cipher) {
        name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
        /*
         * -O3 -fschedule-insns messes up an optimization here!
         * names[D_EVP] somehow becomes NULL
         */


        for (int k = 0; k < loopargs_len; k++) {
            loopargs[k].ctx = EVP_CIPHER_CTX_new();
            if (decrypt)
                EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
            else
                EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
            EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
        }

        Time_F(START);
        pthread_t timer_thread;

        if (pthread_create(&timer_thread, NULL, stop_run, NULL))
            return NULL;

        count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
        d = Time_F(STOP);
        for (int k = 0; k < loopargs_len; k++) {
            EVP_CIPHER_CTX_free(loopargs[k].ctx);
        }
    }
    if (evp_md) {
        name = OBJ_nid2ln(EVP_MD_type(evp_md));
        //            print_message(names[D_EVP], save_count, lengths[testnum]);

        pthread_t timer_thread;
        if (pthread_create(&timer_thread, NULL, stop_run, NULL))
            return NULL;

        Time_F(START);
        count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
        d = Time_F(STOP);
    }

    // Save results in hacky way
    double results[] = {(double) lengths[testnum], (double) count, d};


    (*env)->SetDoubleArrayRegion(env, ret, 0, 3, results);
    //        print_result(D_EVP, testnum, count, d);


    return ret;
}
コード例 #8
0
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
	TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"To get the most accurate results, try to run this\n");
	TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_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
	TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_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
	TINYCLR_SSL_PRINTF("options    des ecb/s\n");
	TINYCLR_SSL_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;
		TINYCLR_SSL_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:
		TINYCLR_SSL_PRINTF("-DDES_DEFAULT_OPTIONS\n");
		break;
	case 1:
		TINYCLR_SSL_PRINTF("-DDES_UNROLL\n");
		break;
	case 2:
		TINYCLR_SSL_PRINTF("-DDES_RISC1\n");
		break;
	case 3:
		TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC1\n");
		break;
	case 4:
		TINYCLR_SSL_PRINTF("-DDES_RISC2\n");
		break;
	case 5:
		TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC2\n");
		break;
	case 6:
		TINYCLR_SSL_PRINTF("-DDES_PTR\n");
		break;
	case 7:
		TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_PTR\n");
		break;
	case 8:
		TINYCLR_SSL_PRINTF("-DDES_RISC1 -DDES_PTR\n");
		break;
	case 9:
		TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC1 -DDES_PTR\n");
		break;
	case 10:
		TINYCLR_SSL_PRINTF("-DDES_RISC2 -DDES_PTR\n");
		break;
	case 11:
		TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC2 -DDES_PTR\n");
		break;
		}
	TINYCLR_SSL_EXIT(0);
#if defined(LINT) || defined(OPENSSL_SYS_MSDOS)
	return(0);
#endif
	}
コード例 #9
0
void do_mul_exp(BIGNUM *r, BIGNUM *a, BIGNUM *b, BIGNUM *c, BN_CTX *ctx)
	{
	int i,k;
	double tm;
	long num;

	num=BASENUM;
	for (i=NUM_START; i<NUM_SIZES; i++)
		{
#ifdef C_PRIME
#  ifdef TEST_SQRT
		if (!BN_set_word(a, 64)) goto err;
		if (!BN_set_word(b, P_MOD_64)) goto err;
#    define ADD a
#    define REM b
#  else
#    define ADD NULL
#    define REM NULL
#  endif
		if (!BN_generate_prime(c,sizes[i],0,ADD,REM,genprime_cb,NULL)) goto err;
		putc('\n', stderr);
		fflush(stderr);
#endif

		for (k=0; k<num; k++)
			{
			if (k%50 == 0) /* Average over num/50 different choices of random numbers. */
				{
				if (!BN_pseudo_rand(a,sizes[i],1,0)) goto err;

				if (!BN_pseudo_rand(b,sizes[i],1,0)) goto err;

#ifndef C_PRIME
				if (!BN_pseudo_rand(c,sizes[i],1,1)) goto err;
#endif

#ifdef TEST_SQRT				
				if (!BN_mod_sqr(a,a,c,ctx)) goto err;
				if (!BN_mod_sqr(b,b,c,ctx)) goto err;
#else
				if (!BN_nnmod(a,a,c,ctx)) goto err;
				if (!BN_nnmod(b,b,c,ctx)) goto err;
#endif

				if (k == 0)
					Time_F(START);
				}

#if defined(TEST_EXP)
			if (!BN_mod_exp(r,a,b,c,ctx)) goto err;
#elif defined(TEST_MUL)
			{
			int i = 0;
			for (i = 0; i < 50; i++)
				if (!BN_mod_mul(r,a,b,c,ctx)) goto err;
			}
#elif defined(TEST_SQR)
			{
			int i = 0;
			for (i = 0; i < 50; i++)
				{
				if (!BN_mod_sqr(r,a,c,ctx)) goto err;
				if (!BN_mod_sqr(r,b,c,ctx)) goto err;
				}
			}
#elif defined(TEST_GCD)
			if (!BN_gcd(r,a,b,ctx)) goto err;
			if (!BN_gcd(r,b,c,ctx)) goto err;
			if (!BN_gcd(r,c,a,ctx)) goto err;
#elif defined(TEST_KRON)
			if (-2 == BN_kronecker(a,b,ctx)) goto err;
			if (-2 == BN_kronecker(b,c,ctx)) goto err;
			if (-2 == BN_kronecker(c,a,ctx)) goto err;
#elif defined(TEST_INV)
			if (!BN_mod_inverse(r,a,c,ctx)) goto err;
			if (!BN_mod_inverse(r,b,c,ctx)) goto err;
#else /* TEST_SQRT */
			if (!BN_mod_sqrt(r,a,c,ctx)) goto err;
			if (!BN_mod_sqrt(r,b,c,ctx)) goto err;
#endif
			}
		tm=Time_F(STOP);
		printf(
#if defined(TEST_EXP)
			"modexp %4d ^ %4d %% %4d"
#elif defined(TEST_MUL)
			"50*modmul %4d %4d %4d"
#elif defined(TEST_SQR)
			"100*modsqr %4d %4d %4d"
#elif defined(TEST_GCD)
			"3*gcd %4d %4d %4d"
#elif defined(TEST_KRON)
			"3*kronecker %4d %4d %4d"
#elif defined(TEST_INV)
			"2*inv %4d %4d mod %4d"
#else /* TEST_SQRT */
			"2*sqrt [prime == %d (mod 64)] %4d %4d mod %4d"
#endif
			" -> %8.3fms %5.1f (%ld)\n",
#ifdef TEST_SQRT
			P_MOD_64,
#endif
			sizes[i],sizes[i],sizes[i],tm*1000.0/num,tm*mul_c[i]/num, num);
		num/=7;
		if (num <= 0) num=1;
		}
	return;

 err:
	ERR_print_errors_fp(stderr);
	}