blapitest.c

来自「支持SSL v2/v3, TLS, PKCS #5, PKCS #7, PKCS」· C语言 代码 · 共 1,834 行 · 第 1/4 页

rc5_cbc_test(blapitestInfo *info)
{
	SECStatus rv;
	RC5Context *rc5cx;
	PRIntervalTime time1, time2;
	int i, numiter;
	numiter = info->repetitions;
	fillitem(&info->key, info->keysize, "tmp.key");
	fillitem(&info->in, info->bufsize, "tmp.pt");
	fillitem(&info->iv, info->bufsize, "tmp.iv");
	TIMESTART();
	for (i=0; i<numiter-1; i++) {
		rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
		                          info->iv.data, NSS_RC5_CBC);
		RC5_DestroyContext(rc5cx, PR_TRUE);
	}
	rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
	                          info->iv.data, NSS_RC5_CBC);
	TIMEFINISH("RC5 CBC CONTEXT CREATE", info->key.len);
	if (!rc5cx) {
		fprintf(stderr,"%s:  Failed to create encryption context!\n", progName);
		return SECFailure;
	}
	info->out.len = 2*info->in.len;
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	if (info->encrypt) {
		TIMESTART();
		for (i=0; i<numiter; i++)
			rv = RC5_Encrypt(rc5cx, info->out.data, &info->out.len, 
			                 info->out.len, info->in.data, info->in.len);
		TIMEFINISH("RC5 CBC ENCRYPT", info->in.len);
		if (info->performance) {
			/*  reset the context */
			RC5_DestroyContext(rc5cx, PR_TRUE);
			rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
			                          info->iv.data, NSS_RC5_CBC);
			rv = RC5_Encrypt(rc5cx, info->out.data, &info->out.len, 
			                 info->out.len, info->in.data, info->in.len);
		}
		if (rv) {
			fprintf(stderr, "%s:  Failed to encrypt!\n", progName);
			CHECKERROR(rv, __LINE__);
		}
	} else {
		TIMESTART();
		for (i=0; i<numiter; i++)
			rv = RC5_Decrypt(rc5cx, info->out.data, &info->out.len, 
			                 info->out.len, info->in.data, info->in.len);
		TIMEFINISH("RC5 CBC DECRYPT", info->in.len);
		if (info->performance) {
			/*  reset the context */
			RC5_DestroyContext(rc5cx, PR_TRUE);
			rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
			                          info->iv.data, NSS_RC5_CBC);
			rv = RC5_Decrypt(rc5cx, info->out.data, &info->out.len, 
			                 info->out.len, info->in.data, info->in.len);
		}
		if (rv) {
			fprintf(stderr, "%s:  Failed to decrypt!\n", progName);
			CHECKERROR(rv, __LINE__);
		}
	}
	RC5_DestroyContext(rc5cx, PR_TRUE);
	return rv;
}
#endif

static SECStatus
rsa_test(blapitestInfo *info)
{
	RSAPrivateKey *key;
	SECItem expitem;
	SECStatus rv;
	PRIntervalTime time1, time2;
	int i, j, numiter;
	unsigned int modLen;
	numiter = info->repetitions;
	fillitem(&info->in, info->bufsize, "tmp.pt");
	if (info->key.len > 0) {
		key = rsakey_from_filedata(&info->key);
	} else {
		expitem.len = 4;
		expitem.data = (unsigned char *)PORT_ZAlloc(4);
		expitem.data[0] = (info->rsapubexp >> 24) & 0xff;
		expitem.data[1] = (info->rsapubexp >> 16) & 0xff;
		expitem.data[2] = (info->rsapubexp >>  8) & 0xff;
		expitem.data[3] = (info->rsapubexp & 0xff);
		TIMESTART();
		for (i=0; i<numiter-1; i++) {
			key = RSA_NewKey(info->keysize*8, &expitem);
			PORT_FreeArena(key->arena, PR_TRUE);
		}
		key = RSA_NewKey(info->keysize*8, &expitem);
		TIMEFINISH("RSA KEY GEN", info->keysize);
		rsakey_to_file(key, "tmp.key");
	}
	if (key->modulus.data[0] == 0) {
		/* integer value of input must be less than modulus */
		if (info->in.data[0] >= key->modulus.data[1])
			return SECFailure;
	} else {
		if (info->in.data[0] >= key->modulus.data[0])
			return SECFailure;
	}
	modLen = key->modulus.len - !key->modulus.data[0];
	if (info->in.len % modLen != 0) {
		fprintf(stderr, "Input buffer must be a multiple of modulus length!\n");
		return SECFailure;
	}
	info->out.len = info->in.len; 
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	if (info->encrypt) {
		RSAPublicKey pubkey;
		SECITEM_CopyItem(key->arena, &pubkey.modulus, &key->modulus);
		SECITEM_CopyItem(key->arena, &pubkey.publicExponent, 
		                             &key->publicExponent);
		TIMESTART();
		for (i=0; i<numiter; i++) {
			for (j=0; j<info->in.len; j+=pubkey.modulus.len) {
				rv = RSA_PublicKeyOp(&pubkey, &info->out.data[j], 
				                              &info->in.data[j]);
			}
		}
		TIMEFINISH("RSA ENCRYPT", info->in.len);
		CHECKERROR(rv, __LINE__);
	} else {
		TIMESTART();
		for (i=info->repetitions; i>0; i--) {
			for (j=0; j<info->in.len; j+=key->modulus.len) {
				rv = RSA_PrivateKeyOp(key, &info->out.data[j], 
				                           &info->in.data[j]);
			}
		}
		TIMEFINISH("RSA DECRYPT", info->in.len);
		CHECKERROR(rv, __LINE__);
	}
	PORT_FreeArena(key->arena, PR_TRUE);
	return SECSuccess;
}

static SECStatus
pqg_test(blapitestInfo *info)
{
	SECStatus rv = SECSuccess;
	PQGVerify *verify;
	PRIntervalTime time1, time2;
	int i, numiter;
	numiter = info->repetitions;
	if (info->pqg.len > 0) {
		info->params = pqg_from_filedata(&info->pqg);
	} else {
		TIMESTART();
		for (i=0; i<numiter-1; i++) {
			rv = PQG_ParamGen(info->keysize, &info->params, &verify);
			PORT_FreeArena(info->params->arena, PR_TRUE);
		}
		rv = PQG_ParamGen(info->keysize, &info->params, &verify);
		TIMEFINISH("PQG PARAM GEN", info->keysize);
		pqg_to_file(info->params, "tmp.pqg");
	}
	CHECKERROR(rv, __LINE__);
	return rv;
}

static SECStatus
dsa_test(blapitestInfo *info)
{
	DSAPrivateKey *key;
	SECStatus rv = SECSuccess;
	PRIntervalTime time1, time2;
	int i, numiter;
	numiter = info->repetitions;
	fillitem(&info->in, info->bufsize, "tmp.pt");
	if (info->key.len > 0) {
		key = dsakey_from_filedata(&info->key);
	} else {
		pqg_test(info);
		if (info->useseed) {
			if (info->seed.len == 0)
				get_and_write_random_bytes(&info->seed, DSA_SUBPRIME_LEN, 
				                           "tmp.seed");
			rv = DSA_NewKeyFromSeed(info->params, info->seed.data, &key);
		} else {
			rv = DSA_NewKey(info->params, &key);
		}
		CHECKERROR(rv, __LINE__);
		dsakey_to_file(key, "tmp.key");
	}
	if (info->sign) {
		info->out.len = DSA_SIGNATURE_LEN;
		info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
		if (info->usesigseed) {
			if (info->sigseed.len == 0)
				get_and_write_random_bytes(&info->sigseed, DSA_SUBPRIME_LEN,
				                           "tmp.sigseed");
			TIMESTART();
			rv = DSA_SignDigestWithSeed(key, &info->out, &info->in, 
			                            info->sigseed.data);
			TIMEFINISH("DSA SIGN", info->in.len);
		} else {
			TIMESTART();
			for (i=0; i<numiter; i++)
				rv = DSA_SignDigest(key, &info->out, &info->in);
			TIMEFINISH("DSA SIGN", info->in.len);
		}
		CHECKERROR(rv, __LINE__);
	} else {
		DSAPublicKey pubkey;
		PRArenaPool *arena;
		arena = key->params.arena;
		SECITEM_CopyItem(arena, &pubkey.params.prime, &key->params.prime);
		SECITEM_CopyItem(arena, &pubkey.params.subPrime, &key->params.subPrime);
		SECITEM_CopyItem(arena, &pubkey.params.base, &key->params.base);
		SECITEM_CopyItem(arena, &pubkey.publicValue, &key->publicValue);
		TIMESTART();
		for (i=0; i<numiter; i++)
			rv = DSA_VerifyDigest(&pubkey, &info->out, &info->in);
		TIMEFINISH("DSA VERIFY", info->in.len);
		if (rv != SECSuccess) {
			PR_fprintf(PR_STDOUT, "Signature failed verification!\n");
			CHECKERROR(rv, __LINE__);
		} /*else {
			PR_fprintf(PR_STDOUT, "Signature verified.\n");
		}*/
	}
	PORT_FreeArena(key->params.arena, PR_TRUE);
	return SECSuccess;
}

static SECStatus
md5_multi_test(blapitestInfo *info)
{
	SECStatus rv = SECSuccess;
	MD5Context *md5cx;
	unsigned int len;
	MD5Context *foomd5cx;
	unsigned char *foomd5;
	int i;
	if (info->in.len == 0) {
		rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
		CHECKERROR(rv, __LINE__);
	}
	md5cx = MD5_NewContext();
	if (!md5cx) {
		PR_fprintf(PR_STDERR, 
		   "%s:  Failed to create hash context!\n", progName);
		return SECFailure;
	}
	info->out.len = MD5_LENGTH;
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	MD5_Begin(md5cx);
	for (i=0; i<info->bufsize/8; i++) {
		MD5_Update(md5cx, &info->in.data[i*8], 8);
		len = MD5_FlattenSize(md5cx);
		foomd5 = PORT_Alloc(len);
		MD5_Flatten(md5cx, foomd5);
		foomd5cx = MD5_Resurrect(foomd5, NULL);
		rv = PORT_Memcmp(foomd5cx, md5cx, len);
		if (rv != SECSuccess)
			PR_fprintf(PR_STDERR, "%s:  MD5_Resurrect failed!\n", progName);
		MD5_DestroyContext(foomd5cx, PR_TRUE);
		PORT_Free(foomd5);
	}
	MD5_End(md5cx, info->out.data, &len, MD5_LENGTH);
	if (len != MD5_LENGTH)
		PR_fprintf(PR_STDERR, "%s: Bad hash size %d.\n", progName, len);
	MD5_DestroyContext(md5cx, PR_TRUE);
	return rv;
}

static SECStatus
md5_test(blapitestInfo *info)
{
	SECStatus rv = SECSuccess;
	PRIntervalTime time1, time2;
	int i;
	if (!info->hash) return SECFailure;
	if (info->multihash) return md5_multi_test(info);
	if (info->in.len == 0) {
		rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
		CHECKERROR(rv, __LINE__);
	}
	info->out.len = MD5_LENGTH;
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	TIMESTART();
	for (i=info->repetitions; i>0; i--) {
		MD5_HashBuf(info->out.data, info->in.data, info->in.len);
	}
	TIMEFINISH("MD5 HASH", info->in.len);
	return rv;
}

static SECStatus
md2_multi_test(blapitestInfo *info)
{
	SECStatus rv = SECSuccess;
	MD2Context *md2cx;
	unsigned int len;
	MD2Context *foomd2cx;
	unsigned char *foomd2;
	int i;
	if (!info->hash) return SECFailure;
	if (info->in.len == 0) {
		rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
		CHECKERROR(rv, __LINE__);
	}
	md2cx = MD2_NewContext();
	if (!md2cx) {
		PR_fprintf(PR_STDERR, 
		   "%s:  Failed to create hash context!\n", progName);
		return SECFailure;
	}
	info->out.len = MD2_LENGTH;
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	MD2_Begin(md2cx);
	for (i=0; i<info->bufsize/8; i++) {
		MD2_Update(md2cx, &info->in.data[i*8], 8);
		len = MD2_FlattenSize(md2cx);
		foomd2 = PORT_Alloc(len);
		MD2_Flatten(md2cx, foomd2);
		foomd2cx = MD2_Resurrect(foomd2, NULL);
		rv = PORT_Memcmp(foomd2cx, md2cx, len);
		if (rv != SECSuccess)
			PR_fprintf(PR_STDERR, "%s:  MD2_Resurrect failed!\n", progName);
		MD2_DestroyContext(foomd2cx, PR_TRUE);
		PORT_Free(foomd2);
	}
	MD2_End(md2cx, info->out.data, &len, MD2_LENGTH);
	if (len != MD2_LENGTH)
		PR_fprintf(PR_STDERR, "%s: Bad hash size %d.\n", progName, len);
	MD2_DestroyContext(md2cx, PR_TRUE);
	return rv;
}

static SECStatus
md2_test(blapitestInfo *info)
{
	unsigned int len;
	MD2Context *cx = MD2_NewContext();
	SECStatus rv = SECSuccess;
	PRIntervalTime time1, time2;
	int i;
	if (!info->hash) return SECFailure;
	if (info->multihash) return md2_multi_test(info);
	if (info->in.len == 0) {
		rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
		CHECKERROR(rv, __LINE__);
	}
	info->out.len = 16;
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	info->in.data[info->in.len] = '\0';
	TIMESTART();
	for (i=0; i<info->repetitions; i++) {
		MD2_Begin(cx);
		MD2_Update(cx, info->in.data, info->in.len);
		MD2_End(cx, info->out.data, &len, 16);
	}
	TIMEFINISH("MD2 HASH", info->in.len);
	MD2_DestroyContext(cx, PR_TRUE);
	return rv;
}

static SECStatus
sha1_multi_test(blapitestInfo *info)
{
	SECStatus rv = SECSuccess;
	SHA1Context *sha1cx;
	unsigned int len;
	SHA1Context *foosha1cx;
	unsigned char *foosha1;
	int i;
	if (info->in.len == 0) {
		rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
		CHECKERROR(rv, __LINE__);
	}
	sha1cx = SHA1_NewContext();
	if (!sha1cx) {
		PR_fprintf(PR_STDERR, 
		   "%s:  Failed to create hash context!\n", progName);
		return SECFailure;
	}
	info->out.len = SHA1_LENGTH;
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	SHA1_Begin(sha1cx);
	for (i=0; i<info->bufsize/8; i++) {
		SHA1_Update(sha1cx, &info->in.data[i*8], 8);
		len = SHA1_FlattenSize(sha1cx);
		foosha1 = PORT_Alloc(len);
		SHA1_Flatten(sha1cx, foosha1);
		foosha1cx = SHA1_Resurrect(foosha1, NULL);
		rv = PORT_Memcmp(foosha1cx, sha1cx, len);
		if (rv != SECSuccess)
			PR_fprintf(PR_STDERR, "%s:  SHA1_Resurrect failed!\n", progName);
		SHA1_DestroyContext(foosha1cx, PR_TRUE);
		PORT_Free(foosha1);
	}
	SHA1_End(sha1cx, info->out.data, &len, SHA1_LENGTH);
	if (len != SHA1_LENGTH)
		PR_fprintf(PR_STDERR, "%s: Bad hash size %d.\n", progName, len);
	SHA1_DestroyContext(sha1cx, PR_TRUE);
	return rv;
}

static SECStatus
sha1_test(blapitestInfo *info)
{
	unsigned int len;
	SHA1Context *cx = SHA1_NewContext();
	SECStatus rv = SECSuccess;
	PRIntervalTime time1, time2;
	int i;
	if (!info->hash) return SECFailure;
	if (info->multihash) return sha1_multi_test(info);
	if (info->in.len == 0) {
		rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
		CHECKERROR(rv, __LINE__);
	}
	info->out.len = SHA1_LENGTH;
	info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
	info->in.data[info->in.len] = '\0';
	TIMESTART();
	for (i=info->repetitions; i>0; i--) {
		SHA1_Begin(cx);
		SHA1_Update(cx, info->in.data, info->in.len);
		SHA1_End(cx, info->out.data, &len, SHA1_LENGTH);
	}
	TIMEFINISH("SHA1 HASH", info->in.len);
	SHA1_DestroyContext(cx, PR_TRUE);
	return rv;
}

typedef SECStatus (* blapitestCryptoFn)(blapitestInfo *);

static blapitestCryptoFn crypto_fns[] =
{
	des_ecb_test,
	des_cbc_test,
	des_ede_ecb_test,
	des_ede_cbc_test,
	rc2_ecb_test,
	rc2_cbc_test,
	rc4_test,
#if NSS_SOFTOKEN_DOES_RC5
	rc5_ecb_test,
	rc5_cbc_test,
#endif
	rsa_test,
	NULL,
	pqg_test,
	dsa_test,
	NULL,
	md5_test,
	md2_test,
	sha1_test,
	NULL
};

static char *mode_strings[] =
{