The Tor Browser: security/nss/lib/freebl/mpi/mdxptest.c@6474c204b198 (annotated)

security/nss/lib/freebl/mpi/mdxptest.c@6474c204b198 (annotated)

security/nss/lib/freebl/mpi/mdxptest.c

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <malloc.h>
 #include <time.h>
 #include "mpi.h"
 #include "mpi-priv.h"
 /* #define OLD_WAY 1  */
 /* This key is the 1024-bit test key used for speed testing of RSA private
 ** key ops.
 */
 #define CONST const
 static CONST unsigned char default_n[128] = {
 xc2,0xae,0x96,0x89,0xaf,0xce,0xd0,0x7b,0x3b,0x35,0xfd,0x0f,0xb1,0xf4,0x7a,0xd1,
 x3c,0x7d,0xb5,0x86,0xf2,0x68,0x36,0xc9,0x97,0xe6,0x82,0x94,0x86,0xaa,0x05,0x39,
 xec,0x11,0x51,0xcc,0x5c,0xa1,0x59,0xba,0x29,0x18,0xf3,0x28,0xf1,0x9d,0xe3,0xae,
 x96,0x5d,0x6d,0x87,0x73,0xf6,0xf6,0x1f,0xd0,0x2d,0xfb,0x2f,0x7a,0x13,0x7f,0xc8,
 x0c,0x7a,0xe9,0x85,0xfb,0xce,0x74,0x86,0xf8,0xef,0x2f,0x85,0x37,0x73,0x0f,0x62,
 x4e,0x93,0x17,0xb7,0x7e,0x84,0x9a,0x94,0x11,0x05,0xca,0x0d,0x31,0x4b,0x2a,0xc8,
 xdf,0xfe,0xe9,0x0c,0x13,0xc7,0xf2,0xad,0x19,0x64,0x28,0x3c,0xb5,0x6a,0xc8,0x4b,
 x79,0xea,0x7c,0xce,0x75,0x92,0x45,0x3e,0xa3,0x9d,0x64,0x6f,0x04,0x69,0x19,0x17
 };
 static CONST unsigned char default_d[128] = {
 x13,0xcb,0xbc,0xf2,0xf3,0x35,0x8c,0x6d,0x7b,0x6f,0xd9,0xf3,0xa6,0x9c,0xbd,0x80,
 x59,0x2e,0x4f,0x2f,0x11,0xa7,0x17,0x2b,0x18,0x8f,0x0f,0xe8,0x1a,0x69,0x5f,0x6e,
 xac,0x5a,0x76,0x7e,0xd9,0x4c,0x6e,0xdb,0x47,0x22,0x8a,0x57,0x37,0x7a,0x5e,0x94,
 x7a,0x25,0xb5,0xe5,0x78,0x1d,0x3c,0x99,0xaf,0x89,0x7d,0x69,0x2e,0x78,0x9d,0x1d,
 x84,0xc8,0xc1,0xd7,0x1a,0xb2,0x6d,0x2d,0x8a,0xd9,0xab,0x6b,0xce,0xae,0xb0,0xa0,
 x58,0x55,0xad,0x5c,0x40,0x8a,0xd6,0x96,0x08,0x8a,0xe8,0x63,0xe6,0x3d,0x6c,0x20,
 x49,0xc7,0xaf,0x0f,0x25,0x73,0xd3,0x69,0x43,0x3b,0xf2,0x32,0xf8,0x3d,0x5e,0xee,
 x7a,0xca,0xd6,0x94,0x55,0xe5,0xbd,0x25,0x34,0x8d,0x63,0x40,0xb5,0x8a,0xc3,0x01
 };
 #define DEFAULT_ITERS 50
 typedef clock_t timetype;
 #define gettime(x) *(x) = clock()
 #define subtime(a, b) a -= b
 #define msec(x) ((clock_t)((double)x * 1000.0 / CLOCKS_PER_SEC))
 #define sec(x) (x / CLOCKS_PER_SEC)
 struct TimingContextStr {
     timetype start;
     timetype end;
     timetype interval;
     int   minutes;
     int   seconds;
     int   millisecs;
 };
 typedef struct TimingContextStr TimingContext;
 TimingContext *CreateTimingContext(void)
 {
     return (TimingContext *)malloc(sizeof(TimingContext));
 }
 void DestroyTimingContext(TimingContext *ctx)
 {
     free(ctx);
 }
 void TimingBegin(TimingContext *ctx)
 {
     gettime(&ctx->start);
 }
 static void timingUpdate(TimingContext *ctx)
 {
     ctx->millisecs = msec(ctx->interval) % 1000;
     ctx->seconds   = sec(ctx->interval);
     ctx->minutes   = ctx->seconds / 60;
     ctx->seconds  %= 60;
 }
 void TimingEnd(TimingContext *ctx)
 {
     gettime(&ctx->end);
     ctx->interval = ctx->end;
     subtime(ctx->interval, ctx->start);
     timingUpdate(ctx);
 }
 char *TimingGenerateString(TimingContext *ctx)
 {
     static char sBuf[4096];
     sprintf(sBuf, "%d minutes, %d.%03d seconds", ctx->minutes,
 				ctx->seconds, ctx->millisecs);
     return sBuf;
 }
 static void
 dumpBytes( unsigned char * b, int l)
 {
     int i;
     if (l <= 0)
         return;
     for (i = 0; i < l; ++i) {
         if (i % 16 == 0)
             printf("\t");
         printf(" %02x", b[i]);
         if (i % 16 == 15)
             printf("\n");
     }
     if ((i % 16) != 0)
         printf("\n");
     printf("\n");
 }
 static mp_err
 testNewFuncs(const unsigned char * modulusBytes, int modulus_len)
 {
     mp_err mperr	= MP_OKAY;
     mp_int modulus;
     unsigned char buf[512];
     mperr = mp_init(&modulus);
     mperr = mp_read_unsigned_octets(&modulus,  modulusBytes,  modulus_len );
     mperr = mp_to_fixlen_octets(&modulus, buf, modulus_len);
     mperr = mp_to_fixlen_octets(&modulus, buf, modulus_len+1);
     mperr = mp_to_fixlen_octets(&modulus, buf, modulus_len+4);
     mperr = mp_to_unsigned_octets(&modulus, buf, modulus_len);
     mperr = mp_to_signed_octets(&modulus, buf, modulus_len + 1);
     mp_clear(&modulus);
     return mperr;
 }
 int
 testModExp( const unsigned char *      modulusBytes,
 	    const unsigned int         expo,
 	    const unsigned char *      input,
 	          unsigned char *      output,
 	          int                  modulus_len)
 {
     mp_err mperr	= MP_OKAY;
     mp_int modulus;
     mp_int base;
     mp_int exponent;
     mp_int result;
     mperr  = mp_init(&modulus);
     mperr += mp_init(&base);
     mperr += mp_init(&exponent);
     mperr += mp_init(&result);
     /* we initialize all mp_ints unconditionally, even if some fail.
     ** This guarantees that the DIGITS pointer is valid (even if null).
     ** So, mp_clear will do the right thing below.
     */
     if (mperr == MP_OKAY) {
       mperr  = mp_read_unsigned_octets(&modulus,
 		modulusBytes + (sizeof default_n - modulus_len),  modulus_len );
       mperr += mp_read_unsigned_octets(&base,     input,         modulus_len );
       mp_set(&exponent, expo);
       if (mperr == MP_OKAY) {
 #if OLD_WAY
 	mperr = s_mp_exptmod(&base, &exponent, &modulus, &result);
 #else
 	mperr = mp_exptmod(&base, &exponent, &modulus, &result);
 #endif
 	if (mperr == MP_OKAY) {
 	  mperr = mp_to_fixlen_octets(&result, output, modulus_len);
 	}
       }
     }
     mp_clear(&base);
     mp_clear(&result);
     mp_clear(&modulus);
     mp_clear(&exponent);
     return (int)mperr;
 }
 int
 doModExp(   const unsigned char *      modulusBytes,
 	    const unsigned char *      exponentBytes,
 	    const unsigned char *      input,
 	          unsigned char *      output,
 	          int                  modulus_len)
 {
     mp_err mperr	= MP_OKAY;
     mp_int modulus;
     mp_int base;
     mp_int exponent;
     mp_int result;
     mperr  = mp_init(&modulus);
     mperr += mp_init(&base);
     mperr += mp_init(&exponent);
     mperr += mp_init(&result);
     /* we initialize all mp_ints unconditionally, even if some fail.
     ** This guarantees that the DIGITS pointer is valid (even if null).
     ** So, mp_clear will do the right thing below.
     */
     if (mperr == MP_OKAY) {
       mperr  = mp_read_unsigned_octets(&modulus,
 		modulusBytes + (sizeof default_n - modulus_len),  modulus_len );
       mperr += mp_read_unsigned_octets(&exponent, exponentBytes, modulus_len );
       mperr += mp_read_unsigned_octets(&base,     input,         modulus_len );
       if (mperr == MP_OKAY) {
 #if OLD_WAY
 	mperr = s_mp_exptmod(&base, &exponent, &modulus, &result);
 #else
 	mperr = mp_exptmod(&base, &exponent, &modulus, &result);
 #endif
 	if (mperr == MP_OKAY) {
 	  mperr = mp_to_fixlen_octets(&result, output, modulus_len);
 	}
       }
     }
     mp_clear(&base);
     mp_clear(&result);
     mp_clear(&modulus);
     mp_clear(&exponent);
     return (int)mperr;
 }
 int
 main(int argc, char **argv)
 {
     TimingContext *	  timeCtx;
     char *		  progName;
     long 		  iters 	= DEFAULT_ITERS;
     unsigned int 	  modulus_len;
     int		 	  i;
     int 		  rv;
     unsigned char 	  buf [1024];
     unsigned char 	  buf2[1024];
     progName = strrchr(argv[0], '/');
     if (!progName)
 	progName = strrchr(argv[0], '\\');
     progName = progName ? progName+1 : argv[0];
     if (argc >= 2) {
 	iters = atol(argv[1]);
     }
     if (argc >= 3) {
 	modulus_len = atol(argv[2]);
     } else
 	modulus_len = sizeof default_n;
     /* no library init function !? */
     memset(buf, 0x41, sizeof buf);
   if (iters < 2) {
     testNewFuncs( default_n, modulus_len);
     testNewFuncs( default_n+1, modulus_len - 1);
     testNewFuncs( default_n+2, modulus_len - 2);
     testNewFuncs( default_n+3, modulus_len - 3);
     printf("%lu allocations, %lu frees, %lu copies\n", mp_allocs, mp_frees, mp_copies);
     rv = testModExp(default_n, 0, buf, buf2, modulus_len);
     dumpBytes((unsigned char *)buf2, modulus_len);
     printf("%lu allocations, %lu frees, %lu copies\n", mp_allocs, mp_frees, mp_copies);
     rv = testModExp(default_n, 1, buf, buf2, modulus_len);
     dumpBytes((unsigned char *)buf2, modulus_len);
     printf("%lu allocations, %lu frees, %lu copies\n", mp_allocs, mp_frees, mp_copies);
     rv = testModExp(default_n, 2, buf, buf2, modulus_len);
     dumpBytes((unsigned char *)buf2, modulus_len);
     printf("%lu allocations, %lu frees, %lu copies\n", mp_allocs, mp_frees, mp_copies);
     rv = testModExp(default_n, 3, buf, buf2, modulus_len);
     dumpBytes((unsigned char *)buf2, modulus_len);
   }
     printf("%lu allocations, %lu frees, %lu copies\n", mp_allocs, mp_frees, mp_copies);
     rv = doModExp(default_n, default_d, buf, buf2, modulus_len);
     if (rv != 0) {
 	fprintf(stderr, "Error in modexp operation:\n");
 	exit(1);
     }
     dumpBytes((unsigned char *)buf2, modulus_len);
     printf("%lu allocations, %lu frees, %lu copies\n", mp_allocs, mp_frees, mp_copies);
     timeCtx = CreateTimingContext();
     TimingBegin(timeCtx);
     i = iters;
     while (i--) {
 	rv = doModExp(default_n, default_d, buf, buf2, modulus_len);
 	if (rv != 0) {
 	    fprintf(stderr, "Error in modexp operation\n");
 	    exit(1);
 	}
     }
     TimingEnd(timeCtx);
     printf("%ld iterations in %s\n", iters, TimingGenerateString(timeCtx));
     printf("%lu allocations, %lu frees, %lu copies\n", mp_allocs, mp_frees, mp_copies);
     return 0;
 }

The Tor Browser / annotate

security/nss/lib/freebl/mpi/mdxptest.c@6474c204b198 (annotated)

security/nss/lib/freebl/mpi/mdxptest.c