mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-11-14 03:30:17 +01:00
98d377b37b
bug920719, bug1026148, bug1028647, bug963150, bug1030486, bug1025729, bug836658, bug1028582, bug1038728, bug1038526, bug1042634, bug1047210, bug1043891, bug1043108, bug1046735, bug1043082, bug1036735, bug1046718, bug1050107, bug1054625, bug1057465, bug1057476, bug1041326, bug1058933, bug1064636, bug1057161, bug1078669, bug1049435, bug1070493, bug1083360, bug1028764, bug1065990, bug1073330, bug1064670, bug1094650
677 lines
21 KiB
C
677 lines
21 KiB
C
/* 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 "seccomon.h"
|
|
#include "cert.h"
|
|
#include "secutil.h"
|
|
#include "nspr.h"
|
|
#include "nss.h"
|
|
#include "blapi.h"
|
|
#include "plgetopt.h"
|
|
#include "lowkeyi.h"
|
|
#include "pk11pub.h"
|
|
|
|
|
|
#define DEFAULT_ITERS 10
|
|
#define DEFAULT_DURATION 10
|
|
#define DEFAULT_KEY_BITS 1024
|
|
#define MIN_KEY_BITS 512
|
|
#define MAX_KEY_BITS 65536
|
|
#define BUFFER_BYTES MAX_KEY_BITS / 8
|
|
#define DEFAULT_THREADS 1
|
|
#define DEFAULT_EXPONENT 0x10001
|
|
|
|
extern NSSLOWKEYPrivateKey * getDefaultRSAPrivateKey(void);
|
|
extern NSSLOWKEYPublicKey * getDefaultRSAPublicKey(void);
|
|
|
|
secuPWData pwData = { PW_NONE, NULL };
|
|
|
|
typedef struct TimingContextStr TimingContext;
|
|
|
|
struct TimingContextStr {
|
|
PRTime start;
|
|
PRTime end;
|
|
PRTime interval;
|
|
|
|
long days;
|
|
int hours;
|
|
int minutes;
|
|
int seconds;
|
|
int millisecs;
|
|
};
|
|
|
|
TimingContext *CreateTimingContext(void) {
|
|
return PORT_Alloc(sizeof(TimingContext));
|
|
}
|
|
|
|
void DestroyTimingContext(TimingContext *ctx) {
|
|
PORT_Free(ctx);
|
|
}
|
|
|
|
void TimingBegin(TimingContext *ctx, PRTime begin) {
|
|
ctx->start = begin;
|
|
}
|
|
|
|
static void timingUpdate(TimingContext *ctx) {
|
|
PRInt64 tmp, remaining;
|
|
PRInt64 L1000,L60,L24;
|
|
|
|
LL_I2L(L1000,1000);
|
|
LL_I2L(L60,60);
|
|
LL_I2L(L24,24);
|
|
|
|
LL_DIV(remaining, ctx->interval, L1000);
|
|
LL_MOD(tmp, remaining, L1000);
|
|
LL_L2I(ctx->millisecs, tmp);
|
|
LL_DIV(remaining, remaining, L1000);
|
|
LL_MOD(tmp, remaining, L60);
|
|
LL_L2I(ctx->seconds, tmp);
|
|
LL_DIV(remaining, remaining, L60);
|
|
LL_MOD(tmp, remaining, L60);
|
|
LL_L2I(ctx->minutes, tmp);
|
|
LL_DIV(remaining, remaining, L60);
|
|
LL_MOD(tmp, remaining, L24);
|
|
LL_L2I(ctx->hours, tmp);
|
|
LL_DIV(remaining, remaining, L24);
|
|
LL_L2I(ctx->days, remaining);
|
|
}
|
|
|
|
void TimingEnd(TimingContext *ctx, PRTime end) {
|
|
ctx->end = end;
|
|
LL_SUB(ctx->interval, ctx->end, ctx->start);
|
|
PORT_Assert(LL_GE_ZERO(ctx->interval));
|
|
timingUpdate(ctx);
|
|
}
|
|
|
|
void TimingDivide(TimingContext *ctx, int divisor) {
|
|
PRInt64 tmp;
|
|
|
|
LL_I2L(tmp, divisor);
|
|
LL_DIV(ctx->interval, ctx->interval, tmp);
|
|
|
|
timingUpdate(ctx);
|
|
}
|
|
|
|
char *TimingGenerateString(TimingContext *ctx) {
|
|
char *buf = NULL;
|
|
|
|
if (ctx->days != 0) {
|
|
buf = PR_sprintf_append(buf, "%d days", ctx->days);
|
|
}
|
|
if (ctx->hours != 0) {
|
|
if (buf != NULL) buf = PR_sprintf_append(buf, ", ");
|
|
buf = PR_sprintf_append(buf, "%d hours", ctx->hours);
|
|
}
|
|
if (ctx->minutes != 0) {
|
|
if (buf != NULL) buf = PR_sprintf_append(buf, ", ");
|
|
buf = PR_sprintf_append(buf, "%d minutes", ctx->minutes);
|
|
}
|
|
if (buf != NULL) buf = PR_sprintf_append(buf, ", and ");
|
|
if (!buf && ctx->seconds == 0) {
|
|
int interval;
|
|
LL_L2I(interval, ctx->interval);
|
|
if (ctx->millisecs < 100)
|
|
buf = PR_sprintf_append(buf, "%d microseconds", interval);
|
|
else
|
|
buf = PR_sprintf_append(buf, "%d milliseconds", ctx->millisecs);
|
|
} else if (ctx->millisecs == 0) {
|
|
buf = PR_sprintf_append(buf, "%d seconds", ctx->seconds);
|
|
} else {
|
|
buf = PR_sprintf_append(buf, "%d.%03d seconds",
|
|
ctx->seconds, ctx->millisecs);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
void
|
|
Usage(char *progName)
|
|
{
|
|
fprintf(stderr, "Usage: %s [-s | -e] [-i iterations | -p period] "
|
|
"[-t threads]\n[-n none [-k keylength] [ [-g] -x exponent] |\n"
|
|
" -n token:nickname [-d certdir] [-w password] |\n"
|
|
" -h token [-d certdir] [-w password] [-g] [-k keylength] "
|
|
"[-x exponent] [-f pwfile]\n",
|
|
progName);
|
|
fprintf(stderr, "%-20s Cert database directory (default is ~/.netscape)\n",
|
|
"-d certdir");
|
|
fprintf(stderr, "%-20s How many operations to perform\n", "-i iterations");
|
|
fprintf(stderr, "%-20s How many seconds to run\n", "-p period");
|
|
fprintf(stderr, "%-20s Perform signing (private key) operations\n", "-s");
|
|
fprintf(stderr, "%-20s Perform encryption (public key) operations\n","-e");
|
|
fprintf(stderr, "%-20s Nickname of certificate or key, prefixed "
|
|
"by optional token name\n", "-n nickname");
|
|
fprintf(stderr, "%-20s PKCS#11 token to perform operation with.\n",
|
|
"-h token");
|
|
fprintf(stderr, "%-20s key size in bits, from %d to %d\n", "-k keylength",
|
|
MIN_KEY_BITS, MAX_KEY_BITS);
|
|
fprintf(stderr, "%-20s token password\n", "-w password");
|
|
fprintf(stderr, "%-20s temporary key generation. Not for token keys.\n",
|
|
"-g");
|
|
fprintf(stderr, "%-20s set public exponent for keygen\n", "-x");
|
|
fprintf(stderr, "%-20s Number of execution threads (default 1)\n",
|
|
"-t threads");
|
|
exit(-1);
|
|
}
|
|
|
|
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");
|
|
}
|
|
|
|
static void
|
|
dumpItem( SECItem * item, const char * description)
|
|
{
|
|
if (item->len & 1 && item->data[0] == 0) {
|
|
printf("%s: (%d bytes)\n", description, item->len - 1);
|
|
dumpBytes(item->data + 1, item->len - 1);
|
|
} else {
|
|
printf("%s: (%d bytes)\n", description, item->len);
|
|
dumpBytes(item->data, item->len);
|
|
}
|
|
}
|
|
|
|
void
|
|
printPrivKey(NSSLOWKEYPrivateKey * privKey)
|
|
{
|
|
RSAPrivateKey *rsa = &privKey->u.rsa;
|
|
|
|
dumpItem( &rsa->modulus, "n");
|
|
dumpItem( &rsa->publicExponent, "e");
|
|
dumpItem( &rsa->privateExponent, "d");
|
|
dumpItem( &rsa->prime1, "P");
|
|
dumpItem( &rsa->prime2, "Q");
|
|
dumpItem( &rsa->exponent1, "d % (P-1)");
|
|
dumpItem( &rsa->exponent2, "d % (Q-1)");
|
|
dumpItem( &rsa->coefficient, "(Q ** -1) % P");
|
|
puts("");
|
|
}
|
|
|
|
typedef SECStatus (* RSAOp)(void * key,
|
|
unsigned char * output,
|
|
unsigned char * input);
|
|
|
|
typedef struct {
|
|
SECKEYPublicKey* pubKey;
|
|
SECKEYPrivateKey* privKey;
|
|
} PK11Keys;
|
|
|
|
|
|
SECStatus PK11_PublicKeyOp (SECKEYPublicKey* key,
|
|
unsigned char * output,
|
|
unsigned char * input)
|
|
{
|
|
return PK11_PubEncryptRaw(key, output, input, key->u.rsa.modulus.len,
|
|
NULL);
|
|
}
|
|
|
|
SECStatus PK11_PrivateKeyOp (PK11Keys* keys,
|
|
unsigned char * output,
|
|
unsigned char * input)
|
|
{
|
|
unsigned outLen = 0;
|
|
return PK11_PrivDecryptRaw(keys->privKey,
|
|
output, &outLen,
|
|
keys->pubKey->u.rsa.modulus.len, input,
|
|
keys->pubKey->u.rsa.modulus.len);
|
|
}
|
|
typedef struct ThreadRunDataStr ThreadRunData;
|
|
|
|
struct ThreadRunDataStr {
|
|
const PRBool *doIters;
|
|
const void *rsaKey;
|
|
const unsigned char *buf;
|
|
RSAOp fn;
|
|
int seconds;
|
|
long iters;
|
|
long iterRes;
|
|
PRErrorCode errNum;
|
|
SECStatus status;
|
|
};
|
|
|
|
|
|
void ThreadExecFunction(void *data)
|
|
{
|
|
ThreadRunData *tdata = (ThreadRunData*)data;
|
|
unsigned char buf2[BUFFER_BYTES];
|
|
|
|
tdata->status = SECSuccess;
|
|
if (*tdata->doIters) {
|
|
long i = tdata->iters;
|
|
tdata->iterRes = 0;
|
|
while (i--) {
|
|
SECStatus rv = tdata->fn((void*)tdata->rsaKey, buf2,
|
|
(unsigned char*)tdata->buf);
|
|
if (rv != SECSuccess) {
|
|
tdata->errNum = PORT_GetError();
|
|
tdata->status = rv;
|
|
break;
|
|
}
|
|
tdata->iterRes++;
|
|
}
|
|
} else {
|
|
PRIntervalTime total = PR_SecondsToInterval(tdata->seconds);
|
|
PRIntervalTime start = PR_IntervalNow();
|
|
tdata->iterRes = 0;
|
|
while (PR_IntervalNow() - start < total) {
|
|
SECStatus rv = tdata->fn((void*)tdata->rsaKey, buf2,
|
|
(unsigned char*)tdata->buf);
|
|
if (rv != SECSuccess) {
|
|
tdata->errNum = PORT_GetError();
|
|
tdata->status = rv;
|
|
break;
|
|
}
|
|
tdata->iterRes++;
|
|
}
|
|
}
|
|
}
|
|
|
|
#define INT_ARG(arg,def) atol(arg)>0?atol(arg):def
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
TimingContext * timeCtx = NULL;
|
|
SECKEYPublicKey * pubHighKey = NULL;
|
|
SECKEYPrivateKey * privHighKey = NULL;
|
|
NSSLOWKEYPrivateKey * privKey = NULL;
|
|
NSSLOWKEYPublicKey * pubKey = NULL;
|
|
CERTCertificate * cert = NULL;
|
|
char * progName = NULL;
|
|
char * secDir = NULL;
|
|
char * nickname = NULL;
|
|
char * slotname = NULL;
|
|
long keybits = 0;
|
|
RSAOp fn;
|
|
void * rsaKey = NULL;
|
|
PLOptState * optstate;
|
|
PLOptStatus optstatus;
|
|
long iters = DEFAULT_ITERS;
|
|
int i;
|
|
PRBool doPriv = PR_FALSE;
|
|
PRBool doPub = PR_FALSE;
|
|
int rv;
|
|
unsigned char buf[BUFFER_BYTES];
|
|
unsigned char buf2[BUFFER_BYTES];
|
|
int seconds = DEFAULT_DURATION;
|
|
PRBool doIters = PR_FALSE;
|
|
PRBool doTime = PR_FALSE;
|
|
PRBool useTokenKey = PR_FALSE; /* use PKCS#11 token
|
|
object key */
|
|
PRBool useSessionKey = PR_FALSE; /* use PKCS#11 session
|
|
object key */
|
|
PRBool useBLKey = PR_FALSE; /* use freebl */
|
|
PK11SlotInfo* slot = NULL; /* slot for session
|
|
object key operations */
|
|
PRBool doKeyGen = PR_FALSE;
|
|
int publicExponent = DEFAULT_EXPONENT;
|
|
PK11Keys keys;
|
|
int peCount = 0;
|
|
CK_BYTE pubEx[4];
|
|
SECItem pe;
|
|
RSAPublicKey pubKeyStr;
|
|
int threadNum = DEFAULT_THREADS;
|
|
ThreadRunData ** runDataArr = NULL;
|
|
PRThread ** threadsArr = NULL;
|
|
int calcThreads = 0;
|
|
|
|
progName = strrchr(argv[0], '/');
|
|
if (!progName)
|
|
progName = strrchr(argv[0], '\\');
|
|
progName = progName ? progName+1 : argv[0];
|
|
|
|
optstate = PL_CreateOptState(argc, argv, "d:ef:gh:i:k:n:p:st:w:x:");
|
|
while ((optstatus = PL_GetNextOpt(optstate)) == PL_OPT_OK) {
|
|
switch (optstate->option) {
|
|
case '?':
|
|
Usage(progName);
|
|
break;
|
|
case 'd':
|
|
secDir = PORT_Strdup(optstate->value);
|
|
break;
|
|
case 'i':
|
|
iters = INT_ARG(optstate->value, DEFAULT_ITERS);
|
|
doIters = PR_TRUE;
|
|
break;
|
|
case 's':
|
|
doPriv = PR_TRUE;
|
|
break;
|
|
case 'e':
|
|
doPub = PR_TRUE;
|
|
break;
|
|
case 'g':
|
|
doKeyGen = PR_TRUE;
|
|
break;
|
|
case 'n':
|
|
nickname = PORT_Strdup(optstate->value);
|
|
/* for compatibility, nickname of "none" means go to freebl */
|
|
if (nickname && strcmp(nickname, "none")) {
|
|
useTokenKey = PR_TRUE;
|
|
} else {
|
|
useBLKey = PR_TRUE;
|
|
}
|
|
break;
|
|
case 'p':
|
|
seconds = INT_ARG(optstate->value, DEFAULT_DURATION);
|
|
doTime = PR_TRUE;
|
|
break;
|
|
case 'h':
|
|
slotname = PORT_Strdup(optstate->value);
|
|
useSessionKey = PR_TRUE;
|
|
break;
|
|
case 'k':
|
|
keybits = INT_ARG(optstate->value, DEFAULT_KEY_BITS);
|
|
break;
|
|
case 'w':
|
|
pwData.data = PORT_Strdup(optstate->value);;
|
|
pwData.source = PW_PLAINTEXT;
|
|
break;
|
|
case 'f':
|
|
pwData.data = PORT_Strdup(optstate->value);
|
|
pwData.source = PW_FROMFILE;
|
|
break;
|
|
case 'x':
|
|
/* -x public exponent (for RSA keygen) */
|
|
publicExponent = INT_ARG(optstate->value, DEFAULT_EXPONENT);
|
|
break;
|
|
case 't':
|
|
threadNum = INT_ARG(optstate->value, DEFAULT_THREADS);
|
|
break;
|
|
}
|
|
}
|
|
if (optstatus == PL_OPT_BAD)
|
|
Usage(progName);
|
|
|
|
if ((doPriv && doPub) || (doIters && doTime) ||
|
|
((useTokenKey + useSessionKey + useBLKey) != PR_TRUE) ||
|
|
(useTokenKey && keybits) || (useTokenKey && doKeyGen) ||
|
|
(keybits && (keybits<MIN_KEY_BITS || keybits>MAX_KEY_BITS))) {
|
|
Usage(progName);
|
|
}
|
|
|
|
if (doIters && doTime) Usage(progName);
|
|
|
|
if (!doTime) {
|
|
doIters = PR_TRUE;
|
|
}
|
|
|
|
PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
|
|
|
|
PK11_SetPasswordFunc(SECU_GetModulePassword);
|
|
secDir = SECU_ConfigDirectory(secDir);
|
|
|
|
if (useTokenKey || useSessionKey) {
|
|
rv = NSS_Init(secDir);
|
|
if (rv != SECSuccess) {
|
|
fprintf(stderr, "NSS_Init failed.\n");
|
|
exit(1);
|
|
}
|
|
} else {
|
|
rv = NSS_NoDB_Init(NULL);
|
|
if (rv != SECSuccess) {
|
|
fprintf(stderr, "NSS_NoDB_Init failed.\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
if (useTokenKey) {
|
|
CK_OBJECT_HANDLE kh = CK_INVALID_HANDLE;
|
|
|
|
cert = PK11_FindCertFromNickname(nickname, &pwData);
|
|
if (cert == NULL) {
|
|
fprintf(stderr,
|
|
"Can't find certificate by name \"%s\"\n", nickname);
|
|
exit(1);
|
|
}
|
|
pubHighKey = CERT_ExtractPublicKey(cert);
|
|
if (pubHighKey == NULL) {
|
|
fprintf(stderr, "Can't extract public key from certificate");
|
|
exit(1);
|
|
}
|
|
|
|
if (doPub) {
|
|
/* do public key ops */
|
|
fn = (RSAOp)PK11_PublicKeyOp;
|
|
rsaKey = (void *) pubHighKey;
|
|
|
|
kh = PK11_ImportPublicKey(cert->slot, pubHighKey, PR_FALSE);
|
|
if (CK_INVALID_HANDLE == kh) {
|
|
fprintf(stderr,
|
|
"Unable to import public key to certificate slot.");
|
|
exit(1);
|
|
}
|
|
pubHighKey->pkcs11Slot = PK11_ReferenceSlot(cert->slot);
|
|
pubHighKey->pkcs11ID = kh;
|
|
printf("Using PKCS#11 for RSA encryption with token %s.\n",
|
|
PK11_GetTokenName(cert->slot));
|
|
} else {
|
|
/* do private key ops */
|
|
privHighKey = PK11_FindKeyByAnyCert(cert, &pwData);
|
|
if (privHighKey == NULL) {
|
|
fprintf(stderr,
|
|
"Can't find private key by name \"%s\"\n", nickname);
|
|
exit(1);
|
|
}
|
|
|
|
SECKEY_CacheStaticFlags(privHighKey);
|
|
fn = (RSAOp)PK11_PrivateKeyOp;
|
|
keys.privKey = privHighKey;
|
|
keys.pubKey = pubHighKey;
|
|
rsaKey = (void *) &keys;
|
|
printf("Using PKCS#11 for RSA decryption with token %s.\n",
|
|
PK11_GetTokenName(privHighKey->pkcs11Slot));
|
|
}
|
|
} else
|
|
|
|
if (useSessionKey) {
|
|
/* use PKCS#11 session key objects */
|
|
PK11RSAGenParams rsaparams;
|
|
void * params;
|
|
|
|
slot = PK11_FindSlotByName(slotname); /* locate target slot */
|
|
if (!slot) {
|
|
fprintf(stderr, "Can't find slot \"%s\"\n", slotname);
|
|
exit(1);
|
|
}
|
|
|
|
/* do a temporary keygen in selected slot */
|
|
if (!keybits) {
|
|
keybits = DEFAULT_KEY_BITS;
|
|
}
|
|
|
|
printf("Using PKCS#11 with %ld bits session key in token %s.\n",
|
|
keybits, PK11_GetTokenName(slot));
|
|
|
|
rsaparams.keySizeInBits = keybits;
|
|
rsaparams.pe = publicExponent;
|
|
params = &rsaparams;
|
|
|
|
fprintf(stderr,"\nGenerating RSA key. This may take a few moments.\n");
|
|
|
|
privHighKey = PK11_GenerateKeyPair(slot, CKM_RSA_PKCS_KEY_PAIR_GEN,
|
|
params, &pubHighKey, PR_FALSE,
|
|
PR_FALSE, (void*)&pwData);
|
|
if (!privHighKey) {
|
|
fprintf(stderr,
|
|
"Key generation failed in token \"%s\"\n",
|
|
PK11_GetTokenName(slot));
|
|
exit(1);
|
|
}
|
|
|
|
SECKEY_CacheStaticFlags(privHighKey);
|
|
|
|
fprintf(stderr,"Keygen completed.\n");
|
|
|
|
if (doPub) {
|
|
/* do public key operations */
|
|
fn = (RSAOp)PK11_PublicKeyOp;
|
|
rsaKey = (void *) pubHighKey;
|
|
} else {
|
|
/* do private key operations */
|
|
fn = (RSAOp)PK11_PrivateKeyOp;
|
|
keys.privKey = privHighKey;
|
|
keys.pubKey = pubHighKey;
|
|
rsaKey = (void *) &keys;
|
|
}
|
|
} else
|
|
|
|
{
|
|
/* use freebl directly */
|
|
if (!keybits) {
|
|
keybits = DEFAULT_KEY_BITS;
|
|
}
|
|
if (!doKeyGen) {
|
|
if (keybits != DEFAULT_KEY_BITS) {
|
|
doKeyGen = PR_TRUE;
|
|
}
|
|
}
|
|
printf("Using freebl with %ld bits key.\n", keybits);
|
|
if (doKeyGen) {
|
|
fprintf(stderr,"\nGenerating RSA key. "
|
|
"This may take a few moments.\n");
|
|
for (i=0; i < 4; i++) {
|
|
if (peCount || (publicExponent & ((unsigned long)0xff000000L >>
|
|
(i*8)))) {
|
|
pubEx[peCount] = (CK_BYTE)((publicExponent >>
|
|
(3-i)*8) & 0xff);
|
|
peCount++;
|
|
}
|
|
}
|
|
pe.len = peCount;
|
|
pe.data = &pubEx[0];
|
|
pe.type = siBuffer;
|
|
|
|
rsaKey = RSA_NewKey(keybits, &pe);
|
|
fprintf(stderr,"Keygen completed.\n");
|
|
} else {
|
|
/* use a hardcoded key */
|
|
printf("Using hardcoded %ld bits key.\n", keybits);
|
|
if (doPub) {
|
|
pubKey = getDefaultRSAPublicKey();
|
|
} else {
|
|
privKey = getDefaultRSAPrivateKey();
|
|
}
|
|
}
|
|
|
|
if (doPub) {
|
|
/* do public key operations */
|
|
fn = (RSAOp)RSA_PublicKeyOp;
|
|
if (rsaKey) {
|
|
/* convert the RSAPrivateKey to RSAPublicKey */
|
|
pubKeyStr.arena = NULL;
|
|
pubKeyStr.modulus = ((RSAPrivateKey*)rsaKey)->modulus;
|
|
pubKeyStr.publicExponent =
|
|
((RSAPrivateKey*)rsaKey)->publicExponent;
|
|
rsaKey = &pubKeyStr;
|
|
} else {
|
|
/* convert NSSLOWKeyPublicKey to RSAPublicKey */
|
|
rsaKey = (void *)(&pubKey->u.rsa);
|
|
}
|
|
PORT_Assert(rsaKey);
|
|
} else {
|
|
/* do private key operations */
|
|
fn = (RSAOp)RSA_PrivateKeyOp;
|
|
if (privKey) {
|
|
/* convert NSSLOWKeyPrivateKey to RSAPrivateKey */
|
|
rsaKey = (void *)(&privKey->u.rsa);
|
|
}
|
|
PORT_Assert(rsaKey);
|
|
}
|
|
}
|
|
|
|
memset(buf, 1, sizeof buf);
|
|
rv = fn(rsaKey, buf2, buf);
|
|
if (rv != SECSuccess) {
|
|
PRErrorCode errNum;
|
|
const char * errStr = NULL;
|
|
|
|
errNum = PORT_GetError();
|
|
if (errNum)
|
|
errStr = SECU_Strerror(errNum);
|
|
else
|
|
errNum = rv;
|
|
if (!errStr)
|
|
errStr = "(null)";
|
|
fprintf(stderr, "Error in RSA operation: %d : %s\n", errNum, errStr);
|
|
exit(1);
|
|
}
|
|
|
|
threadsArr = (PRThread**)PORT_Alloc(threadNum*sizeof(PRThread*));
|
|
runDataArr = (ThreadRunData**)PORT_Alloc(threadNum*sizeof(ThreadRunData*));
|
|
timeCtx = CreateTimingContext();
|
|
TimingBegin(timeCtx, PR_Now());
|
|
for (i = 0;i < threadNum;i++) {
|
|
runDataArr[i] = (ThreadRunData*)PORT_Alloc(sizeof(ThreadRunData));
|
|
runDataArr[i]->fn = fn;
|
|
runDataArr[i]->buf = buf;
|
|
runDataArr[i]->doIters = &doIters;
|
|
runDataArr[i]->rsaKey = rsaKey;
|
|
runDataArr[i]->seconds = seconds;
|
|
runDataArr[i]->iters = iters;
|
|
threadsArr[i] =
|
|
PR_CreateThread(PR_USER_THREAD,
|
|
ThreadExecFunction,
|
|
(void*) runDataArr[i],
|
|
PR_PRIORITY_NORMAL,
|
|
PR_GLOBAL_THREAD,
|
|
PR_JOINABLE_THREAD,
|
|
0);
|
|
}
|
|
iters = 0;
|
|
calcThreads = 0;
|
|
for (i = 0;i < threadNum;i++, calcThreads++)
|
|
{
|
|
PR_JoinThread(threadsArr[i]);
|
|
if (runDataArr[i]->status != SECSuccess) {
|
|
const char * errStr = SECU_Strerror(runDataArr[i]->errNum);
|
|
fprintf(stderr, "Thread %d: Error in RSA operation: %d : %s\n",
|
|
i, runDataArr[i]->errNum, errStr);
|
|
calcThreads -= 1;
|
|
} else {
|
|
iters += runDataArr[i]->iterRes;
|
|
}
|
|
PORT_Free((void*)runDataArr[i]);
|
|
}
|
|
PORT_Free(runDataArr);
|
|
PORT_Free(threadsArr);
|
|
|
|
TimingEnd(timeCtx, PR_Now());
|
|
|
|
printf("%ld iterations in %s\n",
|
|
iters, TimingGenerateString(timeCtx));
|
|
printf("%.2f operations/s .\n", ((double)(iters)*(double)1000000.0) /
|
|
(double)timeCtx->interval );
|
|
TimingDivide(timeCtx, iters);
|
|
printf("one operation every %s\n", TimingGenerateString(timeCtx));
|
|
|
|
if (pubHighKey) {
|
|
SECKEY_DestroyPublicKey(pubHighKey);
|
|
}
|
|
|
|
if (privHighKey) {
|
|
SECKEY_DestroyPrivateKey(privHighKey);
|
|
}
|
|
|
|
if (cert) {
|
|
CERT_DestroyCertificate(cert);
|
|
}
|
|
|
|
if (NSS_Shutdown() != SECSuccess) {
|
|
exit(1);
|
|
}
|
|
|
|
return 0;
|
|
}
|