diff options
Diffstat (limited to 'mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11')
10 files changed, 3078 insertions, 0 deletions
diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/Makefile b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/Makefile new file mode 100644 index 0000000..10b8446 --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/Makefile @@ -0,0 +1,81 @@ +#! gmake +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1994-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +####################################################################### +# (1) Include initial platform-independent assignments (MANDATORY). # +####################################################################### + +include manifest.mn + +####################################################################### +# (2) Include "global" configuration information. (OPTIONAL) # +####################################################################### + +include $(CORE_DEPTH)/coreconf/config.mk + +####################################################################### +# (3) Include "component" configuration information. (OPTIONAL) # +####################################################################### + +#include $(CORE_DEPTH)/$(MODULE)/config/config.mk + +####################################################################### +# (4) Include "local" platform-dependent assignments (OPTIONAL). # +####################################################################### + +include config.mk + +####################################################################### +# (5) Execute "global" rules. (OPTIONAL) # +####################################################################### + +include $(CORE_DEPTH)/coreconf/rules.mk + +####################################################################### +# (6) Execute "component" rules. (OPTIONAL) # +####################################################################### + +#include $(CORE_DEPTH)/$(MODULE)/config/rules.mk +include $(CORE_DEPTH)/nss/cmd/platlibs.mk +include $(CORE_DEPTH)/nss/cmd/platrules.mk + +####################################################################### +# (7) Execute "local" rules. (OPTIONAL). # +####################################################################### + +include rules.mk diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/config.mk b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/config.mk new file mode 100644 index 0000000..d21c6bf --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/config.mk @@ -0,0 +1,61 @@ +# +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1994-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +####################################################################### +# Adjust specific variables for all platforms # +####################################################################### +OS_CFLAGS += -DNSPR20=1 + +####################################################################### +# Set the LDFLAGS value to encompass all normal link options, all # +# library names, and all special system linking options # +####################################################################### + +LDFLAGS = $(LDOPTS) $(LIBSECMOD) $(LIBHASH) $(LIBCERT) $(LIBKEY) \ +$(LIBCRYPTO) $(LIBSECUTIL) $(LIBDBM) $(LIBPLC) $(LIBPLDS) $(LIBPR) \ +$(LIBSECTOOLS) $(DLLSYSTEM) + +# These are the libraries from the PKCS #5 suite: +#LDFLAGS = $(LDOPTS) $(LIBSECTOOLS) $(LIBSSL) $(LIBPKCS7) $(LIBCERT) $(LIBKEY) $(LIBSECMOD) $(LIBCRYPTO) $(LIBSECUTIL) $(LIBSECMOD) $(LIBSSL) $(LIBPKCS7) $(LIBCERT) $(LIBKEY) $(LIBCRYPTO) $(LIBSECUTIL) $(LIBHASH) $(LIBDBM) $(LIBPLDS) $(LIBPLC) $(LIBPR) $(DLLSYSTEM) + +####################################################################### +# Set the TARGETS value to build one executable from each object file # +####################################################################### + +# TARGETS = $(OBJS:$(OBJ_SUFFIX)=$(PROG_SUFFIX)) + diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/manifest.mn b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/manifest.mn new file mode 100644 index 0000000..6edb452 --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/manifest.mn @@ -0,0 +1,50 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1994-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +CORE_DEPTH=../../../../../../.. + +#MODULE = sectools + +CSRCS = pk11test.c + +PROGRAM = pk11test + +REQUIRES = seccmd dbm nss + +REGRESSION_SPEC = pkcs11.reg + +RESULTS_SUBDIR = security/pkcs11 diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.c b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.c new file mode 100644 index 0000000..0279a80 --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.c @@ -0,0 +1,1363 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Netscape security libraries. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1994-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ +#define VERSION_MAJOR 1 +#define VERSION_MINOR 0 +#define VERSION_POINT 7 +/* Standard C includes */ +#include <stdlib.h> +#include <stdio.h> + +/* NSPR includes */ +#include <prio.h> +#include <prprf.h> +#include <plarena.h> +#include <prinit.h> +#include <prmem.h> + +/* security includes */ +#include <pkcs11t.h> +#include <secmodt.h> +#include <pk11func.h> +#include <secmod.h> +#include <secutil.h> +#include <keyt.h> + +/* replacer header file */ +#include "pk11test.h" + +#include "pkcs11.h" + +void SEC_Init(void); + +PRStatus InitCrypto(char*); +int TestUserManagement(); +int TestCrypto(); +MechInfo* GetMechInfo(CK_MECHANISM_TYPE type); +int TestEncrypt(CK_MECHANISM_TYPE mech); +int TestSign(CK_MECHANISM_TYPE mech); +int TestDigest(CK_MECHANISM_TYPE mech); +int TestHMAC(CK_MECHANISM_TYPE mech); +int TestSymmetricEncrypt(CK_MECHANISM_TYPE mech); +int TestPKEncrypt(CK_MECHANISM_TYPE mech); + + +static char* userpw = NULL; +static int secerror=0; +/* PK11SymKey *symkey=NULL;*/ +PK11SlotInfo *slot=NULL; + +/* Errors */ +enum { + NO_ERROR_AT_ALL=0, + NO_SUCH_SLOT=1, + KEY_GEN_FAILED, + CREATE_CONTEXT_FAILED, + INTERNAL_RNG_FAILED, + MECH_NOT_FOUND, + INPUT_FILE_ERROR, + KEY_COPY_FAILED, + CIPHER_OP_FAILED, + FINALIZE_FAILED, + RESULTS_DONT_MATCH, + PARAM_GEN_FAILED, + PLAINTEXT_DOESNT_MATCH, + ENCRYPTION_IS_NOOP, + WRAP_PRIVKEY_FAILED, + WRAP_SYMKEY_FAILED, + UNWRAP_SYMKEY_FAILED, + UNWRAPPED_KEY_DOESNT_MATCH, + UNWRAP_PRIVKEY_FAILED, + SIGNATURE_FAILED, + SIGNATURE_DOESNT_VERIFY, + AUTHENTICATION_FAILED, + AUTHENTICATION_SUCCEEDED, + MODDB_ACCESS +}; + +static char* errString[] = { + "No error", + "No such slot", + "Failed to generate key", + "Failed to create a cryptographic context", + "Failed to generate random bytes", + "Mechanism was not found", + "Error in input file", + "Failed to copy key from internal to external module", + "Cipher operation failed", + "Cipher finalization failed", + "Internal module produced a different result than the target module", + "Failed to generate cryptographic parameters", + "Recovered plaintext does not match original plaintext", + "Ciphertext is the same as plaintext", + "Unable to wrap private key", + "Unable to wrap symmetric key", + "Unable to unwrap symmetric key", + "Unwrapped key does not match original key", + "Unable to unwrap private key", + "Signing operation failed", + "Incorrect signature: doesn't verify", + "Failed to authenticate to slot", + "Authenticated to slot with incorrect password", + "Unable to access security module database" +}; + +/*********************************************************************** + * + * R e a d I n p u t F i l e + * + * Read tokenname and module name from the file with the indicated name. + * Pass in the addresses of pointers. They will be set to point at + * dynamically-allocated memory. + * + * Returns 0 on success, -1 on error with file. + */ +int +ReadInputFile(char *filename, char**tokenname, char**moddbname, char **userpw) +{ + PRFileDesc* file=NULL; + char readbuf[1025]; + int numbytes=0; + char *cp; + + *tokenname = NULL; + *moddbname = NULL; + + /* Open file */ + file = PR_Open(filename, PR_RDONLY, 0); + if(!file) { + return -1; + } + + /* Read in everything */ + numbytes = PR_Read(file, readbuf, 1024); + if(numbytes==-1) { + goto loser; + } + readbuf[numbytes] = '\0'; /* make sure we're null-terminated */ + + /* Get tokenname */ + cp = strtok(readbuf, "\r\n"); + if(cp == NULL) { + goto loser; + } + *tokenname = PR_Malloc(strlen(cp)+1); + strcpy(*tokenname, cp); + + /* get moddbname */ + cp = strtok(NULL, "\r\n"); + if(cp == NULL) { + goto loser; + } + *moddbname = PR_Malloc(strlen(cp)+1); + strcpy(*moddbname, cp); + + /* Get module PIN */ + cp = strtok(NULL, "\r\n"); + if(cp == NULL) { + goto loser; + } + *userpw = PR_Malloc(strlen(cp)+1); + strcpy(*userpw, cp); + + PR_Close(file); + return 0; + +loser: + if(file) { + PR_Close(file); + } + if(*tokenname) { + PR_Free(*tokenname); + *tokenname = NULL; + } + if(*moddbname) { + PR_Free(*moddbname); + *moddbname = NULL; + } + return -1; +} + +static PRBool supplyPassword=PR_TRUE; +char* +PasswordFunc(PK11SlotInfo *slot, PRBool loadcerts, void *wincx) +{ + if(supplyPassword) { + /*PR_fprintf(PR_STDOUT, "Feeding password: |%s|\n", userpw);*/ + supplyPassword = PR_FALSE; + return PL_strdup(userpw); + } else { + /*PR_fprintf(PR_STDOUT, "PasswordFunc supplying NULL.\n");*/ + return NULL; + } +} + + +/********************************************************************** + * + * m a i n + * + */ +int +main(int argc, char *argv[]) +{ + char *tokenname=NULL; + char *moddbname=NULL; + int errcode; + + if(argc < 3) { + PR_fprintf(PR_STDERR, +"\nPKCS #11 Test Suite Version %d.%d.%d\n\ +Usage: pkcs11 testid configfile\n",VERSION_MAJOR,VERSION_MINOR,VERSION_POINT); + return -1; + } + + testId = atoi(argv[1]); + if(ReadInputFile(argv[2], &tokenname, &moddbname, &userpw)) { + errcode = INPUT_FILE_ERROR; + goto loser; + } + + PR_fprintf(PR_STDOUT, "testId=%d\n", testId); + PR_fprintf(PR_STDOUT, "tokenname=%s\n", tokenname); + PR_fprintf(PR_STDOUT, "moddbname=%s\n", moddbname); + + PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0); + + if( InitCrypto(moddbname) != PR_SUCCESS ) { + errcode = MODDB_ACCESS; + goto loser; + } + + slot = PK11_FindSlotByName(tokenname); + if(!slot) { + errcode = NO_SUCH_SLOT; + goto loser; + } + + if(!REP_USE_CORRECT_PIN && userpw) { + /* don't use the pin passed in */ + userpw[0]++; + } + PK11_SetPasswordFunc(PasswordFunc); + if(PK11_NeedLogin(slot)) { + SECStatus result; + supplyPassword = PR_TRUE; + result = PK11_Authenticate(slot, PR_FALSE, NULL); + /* If we just did an invalid login, login correctly so we don't + * cause the token to lock us out */ + if(!REP_USE_CORRECT_PIN) { + userpw[0]--; + supplyPassword = PR_TRUE; + PK11_Authenticate(slot, PR_FALSE, NULL); + } + if(REP_USE_CORRECT_PIN && result!=SECSuccess) { + errcode = AUTHENTICATION_FAILED; + goto loser; + } else if(!REP_USE_CORRECT_PIN && result==SECSuccess) { + errcode = AUTHENTICATION_SUCCEEDED; + goto loser; + } + } + + errcode = TestCrypto(); + +loser: + if(tokenname) { + PR_Free(tokenname); tokenname = NULL; + } + if(moddbname) { + PR_Free(moddbname); moddbname = NULL; + } + if(errcode) { + PR_fprintf(PR_STDOUT, "Exiting with error: %s.\n\n", errString[errcode]); + } else { + PR_fprintf(PR_STDOUT, "Test was successful\n\n"); + } + return errcode; +} + +/********************************************************************** + * + * I n i t C r y p t o + * + */ +PRStatus +InitCrypto(char *moddbname) +{ + SEC_Init(); + + if( PR_Access(moddbname, PR_ACCESS_EXISTS) != PR_SUCCESS) { + PR_fprintf(PR_STDERR, "Error: %s does not exist.\n", moddbname); + return PR_FAILURE; + } + if( PR_Access(moddbname, PR_ACCESS_READ_OK) != PR_SUCCESS) { + PR_fprintf(PR_STDERR, "Error: %s is not readable.\n", + moddbname); + return PR_FAILURE; + } + + SECMOD_init(moddbname); + return PR_SUCCESS; +} + +/********************************************************************** + * + * T e s t C r y p t o + * + */ +int +TestCrypto() +{ + MechInfo *mechInfo; + int errcode; + unsigned short testcount=0; + + if(!PK11_DoesMechanism(slot, REP_MECHANISM)) { + return 0; + } + + mechInfo = GetMechInfo(REP_MECHANISM); + /*PR_fprintf(PR_STDOUT, "Using mechanism %x.\n", REP_MECHANISM);*/ + if(!mechInfo) { + PR_fprintf(PR_STDERR, "Unable to find mech %x\n", + REP_MECHANISM); + return MECH_NOT_FOUND; + } + + if(mechInfo->op & ENCRYPT_OP) { + testcount++; + errcode = TestEncrypt(REP_MECHANISM); + if(errcode) return errcode; + } + + if(mechInfo->op & SIGN_OP) { + testcount++; + errcode = TestSign(REP_MECHANISM); + if(errcode) return errcode; + } + +#if 0 + if(mechInfo->op & DIGEST_OP) { + testcount++; + errcode = TestDigest(REP_MECHANISM); + if(errcode) return errcode; + } + + if(mechInfo->op & HMAC_OP) { + testcount++; + errcode = TestHMAC(REP_MECHANISM); + if(errcode) return errcode; + } +#endif + + return 0; +} + +/********************************************************************** + * + * I s S y m m e t r i c + * + */ +int +IsSymmetric(CK_MECHANISM_TYPE mech) +{ + switch(mech) { + case CKM_RC2_ECB: + case CKM_RC2_CBC: + case CKM_RC2_CBC_PAD: + case CKM_RC4: + case CKM_RC5_ECB: + case CKM_RC5_CBC: + case CKM_RC5_CBC_PAD: + case CKM_DES_ECB: + case CKM_DES_CBC: + case CKM_DES_CBC_PAD: + case CKM_DES3_ECB: + case CKM_DES3_CBC: + case CKM_DES3_CBC_PAD: + case CKM_CAST_ECB: + case CKM_CAST_CBC: + case CKM_CAST_CBC_PAD: + case CKM_CAST3_ECB: + case CKM_CAST3_CBC: + case CKM_CAST3_CBC_PAD: + case CKM_CAST5_ECB: + case CKM_CAST5_CBC: + case CKM_CAST5_CBC_PAD: + case CKM_IDEA_ECB: + case CKM_IDEA_CBC: + case CKM_IDEA_CBC_PAD: + case CKM_CDMF_ECB: + case CKM_CDMF_CBC: + case CKM_CDMF_CBC_PAD: + case CKM_SKIPJACK_ECB64: + case CKM_SKIPJACK_CBC64: + case CKM_SKIPJACK_OFB64: + case CKM_SKIPJACK_CFB64: + case CKM_SKIPJACK_CFB32: + case CKM_SKIPJACK_CFB16: + case CKM_SKIPJACK_CFB8: + case CKM_BATON_ECB128: + case CKM_BATON_ECB96: + case CKM_BATON_CBC128: + case CKM_BATON_COUNTER: + case CKM_BATON_SHUFFLE: + case CKM_JUNIPER_ECB128: + case CKM_JUNIPER_CBC128: + case CKM_JUNIPER_COUNTER: + case CKM_JUNIPER_SHUFFLE: + return 1; + default: + return 0; + } +} + +/********************************************************************** + * + * T e s t E n c r y p t + * + */ +int +TestEncrypt(CK_MECHANISM_TYPE mech) +{ + + /*PR_fprintf(PR_STDOUT, "Inside TestEncrypt\n");*/ + if(!PK11_DoesMechanism(slot, mech)) { + /* Can't test if the slot doesn't do this mechanism */ + PR_fprintf(PR_STDERR, "Slot doesn't do this mechanism.\n"); + return 0; + } + + if(IsSymmetric(mech)) { + /*PR_fprintf(PR_STDOUT, "Is a symmetric algorithm\n");*/ + return TestSymmetricEncrypt(mech); + } else { + /*PR_fprintf(PR_STDOUT, "Is not a symmetric algorithm\n");*/ + return TestPKEncrypt(mech); + } + + return 0; +} + +/********************************************************************** + * + * G e n e r a t e P K P a r a m s + * + */ +void* +GeneratePKParams(CK_MECHANISM_TYPE mech) +{ + + /* FIPS preprocessor directives for DSA. */ + #define FIPS_DSA_TYPE siBuffer + #define FIPS_DSA_DIGEST_LENGTH 20 /* 160-bits */ + #define FIPS_DSA_SUBPRIME_LENGTH 20 /* 160-bits */ + #define FIPS_DSA_SIGNATURE_LENGTH 40 /* 320-bits */ + #define FIPS_DSA_PRIME_LENGTH 64 /* 512-bits */ + #define FIPS_DSA_BASE_LENGTH 64 /* 512-bits */ + + + CK_MECHANISM_TYPE keygenMech; + PK11RSAGenParams *rsaparams; + PQGParams *dsa_pqg; + unsigned char *dsa_P = (unsigned char *) + "\x8d\xf2\xa4\x94\x49\x22\x76\xaa" + "\x3d\x25\x75\x9b\xb0\x68\x69\xcb" + "\xea\xc0\xd8\x3a\xfb\x8d\x0c\xf7" + "\xcb\xb8\x32\x4f\x0d\x78\x82\xe5" + "\xd0\x76\x2f\xc5\xb7\x21\x0e\xaf" + "\xc2\xe9\xad\xac\x32\xab\x7a\xac" + "\x49\x69\x3d\xfb\xf8\x37\x24\xc2" + "\xec\x07\x36\xee\x31\xc8\x02\x91"; + unsigned char *dsa_Q = (unsigned char *) + "\xc7\x73\x21\x8c\x73\x7e\xc8\xee" + "\x99\x3b\x4f\x2d\xed\x30\xf4\x8e" + "\xda\xce\x91\x5f"; + unsigned char *dsa_G = (unsigned char *) + "\x62\x6d\x02\x78\x39\xea\x0a\x13" + "\x41\x31\x63\xa5\x5b\x4c\xb5\x00" + "\x29\x9d\x55\x22\x95\x6c\xef\xcb" + "\x3b\xff\x10\xf3\x99\xce\x2c\x2e" + "\x71\xcb\x9d\xe5\xfa\x24\xba\xbf" + "\x58\xe5\xb7\x95\x21\x92\x5c\x9c" + "\xc4\x2e\x9f\x6f\x46\x4b\x08\x8c" + "\xc5\x72\xaf\x53\xe6\xd7\x88\x02"; + + + keygenMech = PK11_GetKeyGen(mech); + + switch(keygenMech) { + case CKM_RSA_PKCS_KEY_PAIR_GEN: + rsaparams = PR_Malloc(sizeof(PK11RSAGenParams)); + rsaparams->keySizeInBits = REP_PK_KEY_SIZE; + rsaparams->pe = 65537L; + return (void*) rsaparams; + case CKM_ECDSA_KEY_PAIR_GEN: + case CKM_DSA_KEY_PAIR_GEN: + + /* Allocate PQG memory */ + dsa_pqg = PORT_ZAlloc(sizeof(PQGParams)); + dsa_pqg->prime.data = (unsigned char*) + PORT_ZAlloc(FIPS_DSA_PRIME_LENGTH); + dsa_pqg->subPrime.data = (unsigned char*) + PORT_ZAlloc(FIPS_DSA_SUBPRIME_LENGTH); + dsa_pqg->base.data = (unsigned char*) + PORT_ZAlloc(FIPS_DSA_BASE_LENGTH); + + dsa_pqg->prime.type = FIPS_DSA_TYPE; + PORT_Memcpy(dsa_pqg->prime.data, dsa_P, FIPS_DSA_PRIME_LENGTH); + dsa_pqg->prime.len = FIPS_DSA_PRIME_LENGTH; + + dsa_pqg->subPrime.type = FIPS_DSA_TYPE; + PORT_Memcpy( dsa_pqg->subPrime.data, dsa_Q, + FIPS_DSA_SUBPRIME_LENGTH ); + dsa_pqg->subPrime.len = FIPS_DSA_SUBPRIME_LENGTH; + + dsa_pqg->base.type = FIPS_DSA_TYPE; + PORT_Memcpy( dsa_pqg->base.data, dsa_G, FIPS_DSA_BASE_LENGTH ); + dsa_pqg->base.len = FIPS_DSA_BASE_LENGTH; + + return (void*) dsa_pqg; + + case CKM_DH_PKCS_KEY_PAIR_GEN: + case CKM_KEA_KEY_PAIR_GEN: + default: + return NULL; + } + return NULL; +} + +/********************************************************************** + * + * F r e e P K P a r a m s + * + */ +void +FreePKParams(void* p, CK_MECHANISM_TYPE mech) +{ + + switch(PK11_GetKeyGen(mech)) { + case CKM_RSA_PKCS_KEY_PAIR_GEN: + PR_Free( (PK11RSAGenParams*)p); + break; + case CKM_ECDSA_KEY_PAIR_GEN: + case CKM_DSA_KEY_PAIR_GEN: + PR_Free( (PQGParams*)p); + break; + } +} + + +/********************************************************************** + * + * T e s t P K E n c r y p t + * + */ +int +TestPKEncrypt(CK_MECHANISM_TYPE mech) +{ + PK11SlotInfo *internal; + SECStatus status; + int errcode; + SECItem *kgparams; + SECKEYPublicKey *pubk=NULL; + SECKEYPrivateKey *refPrivk=NULL, *testPrivk=NULL; + PK11SymKey *refSymKey=NULL, *testSymKey=NULL, *recoveredSymKey=NULL; + SECItem refWrappedKey, testWrappedKey; + SECItem *refSymkeyData=NULL, *testSymkeyData=NULL; + SECItem wrapParams; + int testSymKeySize; + CK_ATTRIBUTE_TYPE usages[] = { CKA_UNWRAP }; + int usageCount = 1; + + wrapParams.data = "aaaaaaaa"; + wrapParams.len = 8; + + refWrappedKey.len = 1024; + refWrappedKey.data = PR_Malloc(1024); + testWrappedKey.len = 1024; + testWrappedKey.data = PR_Malloc(1024); + + internal = PK11_GetInternalSlot(); + + /* Generate keygen parameter */ + kgparams = GeneratePKParams(mech); + if(!kgparams) { + errcode = PARAM_GEN_FAILED; + goto loser; + } + + /* + * Generate the keypair, either on the target module or on the internal + * module. + */ + if(REP_KEYGEN_ON_TARGET) { + refPrivk = PK11_GenerateKeyPair(slot, PK11_GetKeyGen(mech), + kgparams, &pubk, + (slot==internal) ? PR_FALSE : PR_TRUE /*isPerm*/, + PR_FALSE /*isSensitive*/, + NULL/*wincx*/); + } else { + refPrivk = PK11_GenerateKeyPair(internal, PK11_GetKeyGen(mech), + kgparams, &pubk, + PR_FALSE/*isPerm*/, PR_FALSE /*isSensitive*/, + NULL/*wincx*/); + } + if(!refPrivk) { + secerror = PORT_GetError(); + errcode = KEY_GEN_FAILED; + goto loser; + } + + /* + * Generate symmetric key, either on the target module or on the internal + * module. + */ + if(REP_KEYGEN_ON_TARGET) { + refSymKey = PK11_KeyGen(slot, CKM_DES_CBC_PAD, NULL, + REP_SYMKEY_SIZE, NULL); + } else { + refSymKey = PK11_KeyGen(internal, CKM_DES_CBC_PAD, NULL, + REP_SYMKEY_SIZE, NULL); + } + if(!refSymKey) { + secerror = PORT_GetError(); + errcode = KEY_GEN_FAILED; + goto loser; + } + + /* + * If we generated the keys on the internal module, we have to + * transfer them from the internal module to the target module, unless + * the target module is the internal module. + */ + if( (slot != internal) && !REP_KEYGEN_ON_TARGET) { + SECItem empty; + SECItem label; + empty.len=0; + empty.data=NULL; + label.data = "foobar"; + label.len = 6; + + /* Copy the symmetric key to the target token*/ + testSymKey = pk11_CopyToSlot(slot, + CKM_DES_CBC_PAD, + CKA_UNWRAP, + refSymKey); + if(testSymKey==NULL) { + secerror = PORT_GetError(); + errcode = KEY_COPY_FAILED; + goto loser; + } + + /* Copy the private key to the target token */ + status = PK11_WrapPrivKey(internal, + refSymKey, + refPrivk, + CKM_DES_CBC_PAD, + &wrapParams, + &refWrappedKey, + NULL /*wincx*/); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = WRAP_PRIVKEY_FAILED; + goto loser; + } + + testPrivk = PK11_UnwrapPrivKey(slot, + testSymKey, + CKM_DES_CBC_PAD, + &wrapParams, + &refWrappedKey, + &label /*label*/, + &empty /*ID Value*/, + PR_TRUE /*perm*/, + PR_TRUE /*sensitive*/, + PK11_GetKeyType(mech, 0), + usages, usageCount, + NULL /*wincx*/); + if(testPrivk==NULL) { + secerror = PORT_GetError(); + errcode = UNWRAP_PRIVKEY_FAILED; + goto loser; + } + } else { + testPrivk=refPrivk; refPrivk = NULL; + testSymKey=refSymKey; refSymKey = NULL; + } + + /* Wrap the symmetric key with the public key */ + /* !!! Which mech do we use here, the symmetric or the PK? */ + status = PK11_PubWrapSymKey(mech, pubk, testSymKey, &testWrappedKey); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = WRAP_SYMKEY_FAILED; + goto loser; + } + testSymKeySize = PK11_GetKeyLength(testSymKey); + + /* + * Unless we are testing the internal slot, do the same wrap operation + * on the internal slot and compare with the wrap done on the module + * under test. If we did the keygen on the target module, we don't + * have the keys on the internal module so we can't compare. + */ + if( (slot != internal) && !REP_KEYGEN_ON_TARGET) { + status = PK11_PubWrapSymKey(mech, pubk, refSymKey, + &refWrappedKey); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = WRAP_SYMKEY_FAILED; + goto loser; + } + + if( (testWrappedKey.len != refWrappedKey.len) || + memcmp(testWrappedKey.data, refWrappedKey.data, + testWrappedKey.len) ) { + /* Wrapped Keys don't match */ + /* !!! There's random data in these encryptions, so they'll never + * match. */ + /*errcode = RESULTS_DONT_MATCH;*/ + /*goto loser;*/ + } + } + + /* Get the data of the symmetric key */ + /* Extracting the key value may not work, depending on the token. If + * it doesn't work, we won't be able to do the comparison later */ + PK11_ExtractKeyValue(testSymKey); + testSymkeyData = PK11_GetKeyData(testSymKey); + if(testSymkeyData->data == NULL) { + /* couldn't extract key data */ + testSymkeyData = NULL; + } else { + testSymkeyData = SECITEM_DupItem(testSymkeyData); + } + + /* Destroy the symmetric key everywhere */ + if(refSymKey) { + PK11_FreeSymKey(refSymKey); refSymKey = NULL; + } + if(testSymKey) { + PK11_FreeSymKey(testSymKey); testSymKey = NULL; + } + + /* + * Unwrap the key and make sure we get the same thing back. Can only + * do this if we were able to get the key data from the test token. + */ + if(testSymkeyData != NULL) { + refSymKey = PK11_PubUnwrapSymKey(testPrivk, &testWrappedKey, + CKM_DES_CBC_PAD, CKA_WRAP, testSymKeySize); + if(refSymKey==NULL) { + secerror = PORT_GetError(); + errcode = UNWRAP_SYMKEY_FAILED; + goto loser; + } + /* We should always be able to get the key data from the internal + * module */ + PK11_ExtractKeyValue(refSymKey); + refSymkeyData = PK11_GetKeyData(refSymKey); + PR_ASSERT(refSymkeyData!=NULL && refSymkeyData->data!=NULL); + PR_ASSERT(testSymkeyData!=NULL && testSymkeyData->data!=NULL); + if(SECITEM_CompareItem(refSymkeyData, testSymkeyData) != SECEqual) { + errcode = UNWRAPPED_KEY_DOESNT_MATCH; + goto loser; + } + } + +#ifdef DEBUG + PR_fprintf(PR_STDOUT, "Successfully finished TestPKEncrypt!\n"); +#endif + + errcode = 0; + +loser: + if(refPrivk) { + SECKEY_DestroyPrivateKey(refPrivk); + } + SECITEM_FreeItem(&refWrappedKey, PR_FALSE); + SECITEM_FreeItem(&testWrappedKey, PR_FALSE); + if(refSymkeyData) { + /* do nothing, it's a copy */ + } + if(testSymkeyData) { + SECITEM_FreeItem(testSymkeyData, PR_TRUE); + } + if(pubk) { + SECKEY_DestroyPublicKey(pubk); + } + if(testPrivk) { + SECKEY_DestroyPrivateKey(testPrivk); + } + if(refSymKey) { + PK11_FreeSymKey(refSymKey); + } + if(testSymKey) { + PK11_FreeSymKey(testSymKey); + } + if(recoveredSymKey) { + PK11_FreeSymKey(recoveredSymKey); + } + return errcode; + + +} + +/********************************************************************** + * + * T e s t S y m m e t r i c E n c r y p t + * + */ +int +TestSymmetricEncrypt(CK_MECHANISM_TYPE mech) +{ + PK11Context *refcontext=NULL, *testcontext=NULL; + PK11SlotInfo *internal; + SECStatus status; + PK11SymKey* intkey=NULL, *extkey=NULL; + int errcode; + unsigned char *ptext=NULL; + int maxclen = REP_PLAINTEXT_LEN + 128; + unsigned char *refctext=NULL, *testctext=NULL; + int refclen, testclen; + unsigned char *recovered=NULL; + int reclen; + SECItem iv, *param=NULL; + + internal = PK11_GetInternalSlot(); + + ptext = PR_Malloc(REP_PLAINTEXT_LEN); + refctext = PR_Malloc(maxclen); + testctext = PR_Malloc(maxclen); + recovered = PR_Malloc(maxclen); + + /* Generate random plaintext */ + status = RNG_GenerateGlobalRandomBytes(ptext, REP_PLAINTEXT_LEN); + if(status != SECSuccess) { + errcode = INTERNAL_RNG_FAILED; + goto loser; + } + + /* Generate mechanism parameter */ + iv.len = 8; + iv.data = "aaaaaaaa"; /* !!! does this need to be random? Maybe a + * replacer variable ? */ + param = PK11_ParamFromIV(mech, &iv); + if(!param) { + errcode = PARAM_GEN_FAILED; + goto loser; + } + + /* + * Generate the key, either on the target module or the internal module. + */ + if(REP_KEYGEN_ON_TARGET) { + intkey = PK11_KeyGen(slot, mech, NULL, REP_SYMKEY_SIZE, + NULL); + } else { + intkey = PK11_KeyGen(internal, mech, NULL, REP_SYMKEY_SIZE, + NULL); + } + if(!intkey) { + secerror = PORT_GetError(); + errcode = KEY_GEN_FAILED; + goto loser; + } + + if( (slot != internal) && !REP_KEYGEN_ON_TARGET) { + /* Copy the key to the target token if it isn't there already */ + extkey = pk11_CopyToSlot(slot, mech, CKA_ENCRYPT, intkey); + if(!extkey) { + secerror = PORT_GetError(); + errcode = KEY_COPY_FAILED; + goto loser; + } + } else { + extkey = intkey; + intkey = NULL; + } + + /* Create an encryption context */ + testcontext = PK11_CreateContextBySymKey(mech, CKA_ENCRYPT, extkey, + param); + if(!testcontext) { + secerror = PORT_GetError(); + errcode = CREATE_CONTEXT_FAILED; + goto loser; + } + + /* Do the encryption */ + status = PK11_CipherOp(testcontext, testctext, &testclen, + maxclen, ptext, REP_PLAINTEXT_LEN); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = CIPHER_OP_FAILED; + goto loser; + } + status = PK11_Finalize(testcontext); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = FINALIZE_FAILED; + goto loser; + } + + /* Free the encryption context */ + PK11_DestroyContext(testcontext, PR_TRUE /*freeit*/); + testcontext = NULL; + + /* Make sure the encryption did something */ + if(!memcmp(ptext, testctext, + REP_PLAINTEXT_LEN > testclen ? testclen : REP_PLAINTEXT_LEN)) { + errcode = ENCRYPTION_IS_NOOP; + goto loser; + } + + /* + * Now do everything on the internal module and compare the results. + * If the key was generated on the target module, it doesn't exist on + * the internal module so we can't compare. + */ + if( (slot != internal) && !REP_KEYGEN_ON_TARGET) { + /* Create encryption context */ + refcontext = PK11_CreateContextBySymKey(mech, CKA_ENCRYPT, + intkey, param); + if(!refcontext) { + secerror = PORT_GetError(); + errcode = CREATE_CONTEXT_FAILED; + goto loser; + } + + /* Perform the encryption */ + status = PK11_CipherOp(refcontext, refctext, &refclen, + maxclen, ptext, REP_PLAINTEXT_LEN); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = CIPHER_OP_FAILED; + goto loser; + } + status = PK11_Finalize(refcontext); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = FINALIZE_FAILED; + goto loser; + } + + /* Free the context */ + PK11_DestroyContext(refcontext, PR_TRUE /*freeit*/); + refcontext = NULL; + + + /* Compare the ciphertext from the target module and the + * internal module + */ + if( (testclen != refclen) || + (memcmp(testctext, refctext, testclen)) ) { + errcode = RESULTS_DONT_MATCH; + goto loser; + } + } + + /* + * Decrypt the ciphertext and make sure we get back the original + * ptext + */ + + /* Create the decryption context */ + testcontext = PK11_CreateContextBySymKey(mech, CKA_DECRYPT, extkey, + param); + if(!testcontext) { + secerror = PORT_GetError(); + errcode = CREATE_CONTEXT_FAILED; + goto loser; + } + + /* Do the decryption */ + status = PK11_CipherOp(testcontext, recovered, &reclen, + maxclen, testctext, testclen); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = CIPHER_OP_FAILED; + goto loser; + } + status = PK11_Finalize(testcontext); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = FINALIZE_FAILED; + goto loser; + } + + + /* Free the encryption context */ + PK11_DestroyContext(testcontext, PR_TRUE /*freeit*/); + testcontext = NULL; + + + /* Compare the recovered text to the plaintext */ + if( (reclen != REP_PLAINTEXT_LEN) || + (memcmp(recovered, ptext, reclen)) ) { + errcode = PLAINTEXT_DOESNT_MATCH; + goto loser; + } + + +#ifdef DEBUG + PR_fprintf(PR_STDOUT, "Successfully finished TestSymmetricEncrypt!\n"); +#endif + + errcode = 0; + +loser: + if(ptext) { + PR_Free(ptext); ptext = NULL; + } + if(refctext) { + PR_Free(refctext); refctext = NULL; + } + if(testctext) { + PR_Free(testctext); testctext = NULL; + } + if(intkey) { + PK11_FreeSymKey(intkey); intkey = NULL; + } + if(extkey) { + PK11_FreeSymKey(extkey); extkey = NULL; + } + if(testcontext) { + PK11_DestroyContext(testcontext, PR_TRUE /*freeit*/); + } + if(refcontext) { + PK11_DestroyContext(refcontext, PR_TRUE /*freeit*/); + } + if(param) { + SECITEM_FreeItem(param, PR_TRUE); + param = NULL; + } + if(recovered) { + PR_Free(recovered); recovered = NULL; + } + return errcode; +} + +/********************************************************************** + * + * T e s t S i g n + * + */ +int +TestSign(CK_MECHANISM_TYPE mech) +{ + PK11SlotInfo *internal; + SECStatus status; + int errcode; + SECItem *kgparams; + SECKEYPublicKey *pubk=NULL; + SECKEYPrivateKey *refPrivk=NULL, *testPrivk=NULL; + PK11SymKey *refSymKey=NULL, *testSymKey=NULL, *recoveredSymKey=NULL; + SECItem refWrappedKey, testWrappedKey; + SECItem ptext, refSignature, testSignature; + SECItem wrapParam; + CK_ATTRIBUTE_TYPE usages[] = { CKA_SIGN }; + int usageCount = 1; + + refWrappedKey.len = 1024; + refWrappedKey.data = PR_Malloc(1024); + testWrappedKey.len = 1024; + testWrappedKey.data = PR_Malloc(1024); + refSignature.len = 1024; + refSignature.data = PR_Malloc(1024); + testSignature.len = 1024; + testSignature.data = PR_Malloc(1024); + wrapParam.data = "aaaaaaaa"; + wrapParam.len = 8; + + internal = PK11_GetInternalSlot(); + + /* Generate random ptext */ + ptext.data = PR_Malloc(20); + ptext.len = 20; + status = RNG_GenerateGlobalRandomBytes(ptext.data, 8); + if(status != SECSuccess) { + errcode = INTERNAL_RNG_FAILED; + goto loser; + } + + /* Generate keygen parameter */ + kgparams = GeneratePKParams(mech); + if(!kgparams) { + errcode = PARAM_GEN_FAILED; + goto loser; + } + + /* + * Generate the keypair, on the target module or the internal module. + */ + if(REP_KEYGEN_ON_TARGET) { + refPrivk = PK11_GenerateKeyPair(slot, PK11_GetKeyGen(mech), + kgparams, &pubk, (slot==internal) ? PR_FALSE : + PR_TRUE /*isPerm*/, + PR_FALSE /*isSensitive*/, NULL/*wincx*/); + } else { + refPrivk = PK11_GenerateKeyPair(internal, PK11_GetKeyGen(mech), + kgparams, &pubk, PR_FALSE /*isPerm*/, + PR_FALSE /*isSensitive*/, NULL/*wincx*/); + } + if(!refPrivk) { + secerror = PORT_GetError(); + errcode = KEY_GEN_FAILED; + goto loser; + } + + /* + * Generate symmetric key, on the target module or the internal module. + */ + if(REP_KEYGEN_ON_TARGET) { + refSymKey = PK11_KeyGen(slot, CKM_DES_CBC_PAD, NULL, + REP_SYMKEY_SIZE, NULL); + } else { + refSymKey = PK11_KeyGen(internal, CKM_DES_CBC_PAD, NULL, + REP_SYMKEY_SIZE, NULL); + } + if(!refSymKey) { + secerror = PORT_GetError(); + errcode = KEY_GEN_FAILED; + goto loser; + } + + /* + * If the key was generated on the internal module, copy it to the + * target module, unless the target module is the internal module. + */ + if( (slot != internal) && !REP_KEYGEN_ON_TARGET) { + SECItem empty; + SECItem label; + SECItem *pubValue; + empty.len=0; + empty.data=NULL; + label.len=6; + label.data = "foobar"; + + /* Copy the symmetric key to the target token*/ + testSymKey = pk11_CopyToSlot(slot, + CKM_DES_CBC_PAD, + CKA_WRAP, + refSymKey); + if(testSymKey==NULL) { + secerror = PORT_GetError(); + errcode = KEY_COPY_FAILED; + goto loser; + } + + /* Copy the private key to the target token */ + status = PK11_WrapPrivKey(internal, + refSymKey, + refPrivk, + CKM_DES_CBC_PAD, + &wrapParam, + &refWrappedKey, + NULL /*wincx*/); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = WRAP_PRIVKEY_FAILED; + goto loser; + } + + switch(pubk->keyType) { + case dsaKey: + pubValue = SECITEM_DupItem(&pubk->u.dsa.publicValue); + break; + case rsaKey: + pubValue = SECITEM_DupItem(&pubk->u.rsa.modulus); + break; + default: + pubValue = NULL; + } + testPrivk = PK11_UnwrapPrivKey(slot, + testSymKey, + CKM_DES_CBC_PAD, + &wrapParam, + &refWrappedKey, + &label /*label*/, + pubValue /*ID Value*/, + PR_TRUE /*perm*/, + PR_TRUE /*sensitive*/, + PK11_GetKeyType(mech, 0), + usages, usageCount, + NULL /*wincx*/); + if(pubValue) { + SECITEM_FreeItem(pubValue, PR_TRUE); + pubValue = NULL; + } + if(testPrivk==NULL) { + secerror = PORT_GetError(); + errcode = UNWRAP_PRIVKEY_FAILED; + goto loser; + } + } else { + testPrivk=refPrivk; refPrivk = NULL; + testSymKey=refSymKey; refSymKey = NULL; + } + + /* Sign the data with the private key */ + status = PK11_Sign(testPrivk, &testSignature, &ptext); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = SIGNATURE_FAILED; + goto loser; + } + + /* + * Unless we are testing the internal slot, do the same wrap operation + * on the internal slot and compare with the signature done on the + * module under test + * Also, DSA signatures contain random data, so comparing them + * is useless (I suppose if they are the same something is wrong!). + */ + if( (slot != internal) && !REP_KEYGEN_ON_TARGET + && mech != CKM_DSA && mech != CKM_DSA_SHA1) { + status = PK11_Sign(refPrivk, &refSignature, &ptext); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = SIGNATURE_FAILED; + goto loser; + } + + if( SECITEM_CompareItem(&refSignature, &testSignature) + != SECEqual) { + errcode = RESULTS_DONT_MATCH; + goto loser; + } + } + + + /* + * Verify the signature. + */ + status = PK11_Verify(pubk, &testSignature, &ptext, NULL /*wincx*/); + if(status != SECSuccess) { + secerror = PORT_GetError(); + errcode = SIGNATURE_DOESNT_VERIFY; + goto loser; + } + + +#ifdef DEBUG + PR_fprintf(PR_STDOUT, "Successfully finished TestSign!\n"); +#endif + + errcode = 0; + +loser: + SECITEM_FreeItem(&refWrappedKey, PR_FALSE); + SECITEM_FreeItem(&testWrappedKey, PR_FALSE); + SECITEM_FreeItem(&ptext, PR_FALSE); + SECITEM_FreeItem(&refSignature, PR_FALSE); + SECITEM_FreeItem(&testSignature, PR_FALSE); + if(refPrivk) { + SECKEY_DestroyPrivateKey(refPrivk); + } + if(pubk) { + SECKEY_DestroyPublicKey(pubk); + } + if(testPrivk) { + SECKEY_DestroyPrivateKey(testPrivk); + } + if(refSymKey) { + PK11_FreeSymKey(refSymKey); + } + if(testSymKey) { + PK11_FreeSymKey(testSymKey); + } + if(recoveredSymKey) { + PK11_FreeSymKey(recoveredSymKey); + } + return errcode; + + +} + +/********************************************************************** + * + * T e s t D i g e s t + * + */ +int +TestDigest(CK_MECHANISM_TYPE mech) +{ + return 0; +} + +/********************************************************************** + * + * T e s t H M A C + * + */ +int +TestHMAC(CK_MECHANISM_TYPE mech) +{ + return 0; +} + +/********************************************************************** + * + * G e t M e c h I n f o + * + */ +MechInfo* +GetMechInfo(CK_MECHANISM_TYPE type) +{ + /* mechInfo array is sorted by type, so we can do a binary search + l is the left-most possible matching index + r is the rightmost possible matching index + mid is approximately the middle point between l and r */ + int l, r, mid; + + l = 0; r = numMechs-1; + + while(l <= r) { + mid = (l+r)/2; + if(mechInfo[mid].type == type) { + return &(mechInfo[mid]); + } else if(mechInfo[mid].type < type) { + l = mid+1; + } else { + r = mid-1; + } + } + + /* If l > r, the pointers have crossed without finding the element. */ + return NULL; +} diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.h b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.h new file mode 100755 index 0000000..87b026d --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.h @@ -0,0 +1,114 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Netscape security libraries. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1994-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ +#ifndef PK11TEST_H +#define PK11TEST_H + +#define REP_SYMKEY_MECHANISM CKM_DES_KEY_GEN + +/* symmetric key size in bytes */ +#define REP_SYMKEY_SIZE 8 + +#define REP_PK_KEY_SIZE 1024 +#define REP_PLAINTEXT_LEN 8 +#define REP_MECHANISM mechanism[testId/2/2%46] +#define REP_USE_CORRECT_PIN UseCorrectPin[testId%2] +#define REP_KEYGEN_ON_TARGET KeyGenOnTarget[testId/2%2] +#define CKM_NO_OP 0x80001111 + +int testId = 0; + +PRBool UseCorrectPin[] = { + PR_TRUE, + PR_FALSE +}; + +PRBool KeyGenOnTarget[] = { + PR_TRUE, + PR_FALSE +}; + +CK_MECHANISM_TYPE mechanism[] = { + CKM_NO_OP, + CKM_RSA_PKCS, + CKM_RSA_9796, + CKM_RSA_X_509, + CKM_MD2_RSA_PKCS, + CKM_MD5_RSA_PKCS, + CKM_SHA1_RSA_PKCS, + CKM_DSA, + CKM_DSA_SHA1, + CKM_ECDSA, + CKM_ECDSA_SHA1, + CKM_RC2_ECB, + CKM_RC2_CBC, + CKM_RC4, + CKM_RC5_ECB, + CKM_RC5_CBC, + CKM_DES_ECB, + CKM_DES_CBC, + CKM_DES3_ECB, + CKM_DES3_CBC, + CKM_CAST_ECB, + CKM_CAST_CBC, + CKM_CAST3_ECB, + CKM_CAST3_CBC, + CKM_CAST5_ECB, + CKM_CAST5_CBC, + CKM_IDEA_ECB, + CKM_IDEA_CBC, + CKM_CDMF_ECB, + CKM_CDMF_CBC, + CKM_SKIPJACK_ECB64, + CKM_SKIPJACK_CBC64, + CKM_SKIPJACK_OFB64, + CKM_SKIPJACK_CFB64, + CKM_SKIPJACK_CFB32, + CKM_SKIPJACK_CFB16, + CKM_SKIPJACK_CFB8, + CKM_BATON_ECB128, + CKM_BATON_ECB96, + CKM_BATON_CBC128, + CKM_BATON_COUNTER, + CKM_BATON_SHUFFLE, + CKM_JUNIPER_ECB128, + CKM_JUNIPER_CBC128, + CKM_JUNIPER_COUNTER, + CKM_JUNIPER_SHUFFLE +}; + + + +#endif diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.htp b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.htp new file mode 100644 index 0000000..46e8a60 --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pk11test.htp @@ -0,0 +1,53 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Netscape security libraries. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1994-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ +#ifndef PK11TEST_H +#define PK11TEST_H + +#define REP_SYMKEY_MECHANISM CKM_DES_KEY_GEN + +/* symmetric key size in bytes */ +#define REP_SYMKEY_SIZE 8 + +#define REP_PK_KEY_SIZE 1024 +#define REP_PLAINTEXT_LEN 8 +#define REP_MECHANISM $[mechanism] +#define REP_USE_CORRECT_PIN $[UseCorrectPin] +#define REP_KEYGEN_ON_TARGET $[KeyGenOnTarget] +#define CKM_NO_OP 0x80001111 + +$[DATA-TO-TEST] + +#endif diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.h b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.h new file mode 100644 index 0000000..68e0d2f --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.h @@ -0,0 +1,193 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Netscape security libraries. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1994-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ +#ifndef PKCS11_H +#define PKCS11_H + +#define NULL_OP 0x00 +#define ENCRYPT_OP 0x01 +#define SIGN_OP 0x02 +#define KEYGEN_OP 0x04 +#define DIGEST_OP 0x08 +#define HMAC_OP 0x10 + +typedef struct { + CK_MECHANISM_TYPE type; + int op; + CK_MECHANISM_TYPE keygenMech; +} MechInfo; + +static int numMechs=118; +static MechInfo mechInfo[] = { + {CKM_RSA_PKCS_KEY_PAIR_GEN, + KEYGEN_OP, CKM_RSA_PKCS_KEY_PAIR_GEN}, + {CKM_RSA_PKCS, ENCRYPT_OP | SIGN_OP, + CKM_RSA_PKCS_KEY_PAIR_GEN}, + {CKM_RSA_9796, SIGN_OP, CKM_RSA_PKCS_KEY_PAIR_GEN}, + {CKM_RSA_X_509, ENCRYPT_OP | SIGN_OP, + CKM_RSA_PKCS_KEY_PAIR_GEN}, + {CKM_MD2_RSA_PKCS, SIGN_OP, CKM_RSA_PKCS_KEY_PAIR_GEN}, + {CKM_MD5_RSA_PKCS, SIGN_OP, CKM_RSA_PKCS_KEY_PAIR_GEN}, + {CKM_SHA1_RSA_PKCS, SIGN_OP, CKM_RSA_PKCS_KEY_PAIR_GEN}, + {CKM_DSA_KEY_PAIR_GEN, KEYGEN_OP, CKM_DSA_KEY_PAIR_GEN}, + {CKM_DSA, SIGN_OP, CKM_DSA_KEY_PAIR_GEN}, + {CKM_DSA_SHA1, SIGN_OP, CKM_DSA_KEY_PAIR_GEN}, + {CKM_DH_PKCS_KEY_PAIR_GEN, + KEYGEN_OP, CKM_DH_PKCS_KEY_PAIR_GEN}, + {CKM_DH_PKCS_DERIVE, NULL_OP, 0}, + {CKM_RC2_KEY_GEN, KEYGEN_OP, CKM_RC2_KEY_GEN}, + {CKM_RC2_ECB, ENCRYPT_OP, CKM_RC2_KEY_GEN}, + {CKM_RC2_CBC, ENCRYPT_OP, CKM_RC2_KEY_GEN}, + {CKM_RC2_MAC, NULL_OP, CKM_RC2_KEY_GEN}, + {CKM_RC2_MAC_GENERAL, NULL_OP, CKM_RC2_KEY_GEN}, + {CKM_RC2_CBC_PAD, NULL_OP, CKM_RC2_KEY_GEN}, + {CKM_RC4_KEY_GEN, KEYGEN_OP, CKM_RC4_KEY_GEN}, + {CKM_RC4, ENCRYPT_OP, CKM_RC4_KEY_GEN}, + {CKM_DES_KEY_GEN, KEYGEN_OP, CKM_DES_KEY_GEN}, + {CKM_DES_ECB, ENCRYPT_OP, CKM_DES_KEY_GEN}, + {CKM_DES_CBC, ENCRYPT_OP, CKM_DES_KEY_GEN}, + {CKM_DES_MAC, NULL_OP, CKM_DES_KEY_GEN}, + {CKM_DES_MAC_GENERAL, NULL_OP, CKM_DES_KEY_GEN}, + {CKM_DES_CBC_PAD, NULL_OP, CKM_DES_KEY_GEN}, + {CKM_DES2_KEY_GEN, KEYGEN_OP, CKM_DES2_KEY_GEN}, + {CKM_DES3_KEY_GEN, KEYGEN_OP, CKM_DES3_KEY_GEN}, + {CKM_DES3_ECB, ENCRYPT_OP, CKM_DES3_KEY_GEN}, + {CKM_DES3_CBC, ENCRYPT_OP, CKM_DES3_KEY_GEN}, + {CKM_DES3_MAC, NULL_OP, CKM_DES3_KEY_GEN}, + {CKM_DES3_MAC_GENERAL, NULL_OP, CKM_DES3_KEY_GEN}, + {CKM_DES3_CBC_PAD, NULL_OP, CKM_DES3_KEY_GEN}, + {CKM_CDMF_KEY_GEN, KEYGEN_OP, CKM_CDMF_KEY_GEN}, + {CKM_CDMF_ECB, ENCRYPT_OP, CKM_CDMF_KEY_GEN}, + {CKM_CDMF_CBC, ENCRYPT_OP, CKM_CDMF_KEY_GEN}, + {CKM_CDMF_MAC, NULL_OP, CKM_CDMF_KEY_GEN}, + {CKM_CDMF_MAC_GENERAL, NULL_OP, CKM_CDMF_KEY_GEN}, + {CKM_CDMF_CBC_PAD, NULL_OP, CKM_CDMF_KEY_GEN}, + {CKM_MD2, DIGEST_OP, 0}, + {CKM_MD2_HMAC, HMAC_OP, 0}, + {CKM_MD2_HMAC_GENERAL, HMAC_OP, 0}, + {CKM_MD5, DIGEST_OP, 0}, + {CKM_MD5_HMAC, HMAC_OP, 0}, + {CKM_MD5_HMAC_GENERAL, HMAC_OP, 0}, + {CKM_SHA_1, DIGEST_OP, 0}, + {CKM_SHA_1_HMAC, HMAC_OP, 0}, + {CKM_SHA_1_HMAC_GENERAL,HMAC_OP, 0}, + {CKM_CAST_KEY_GEN, KEYGEN_OP, CKM_CAST_KEY_GEN}, + {CKM_CAST_ECB, ENCRYPT_OP, CKM_CAST_KEY_GEN}, + {CKM_CAST_CBC, ENCRYPT_OP, CKM_CAST_KEY_GEN}, + {CKM_CAST_MAC, NULL_OP, CKM_CAST_KEY_GEN}, + {CKM_CAST_MAC_GENERAL, NULL_OP, CKM_CAST_KEY_GEN}, + {CKM_CAST_CBC_PAD, NULL_OP, CKM_CAST_KEY_GEN}, + {CKM_CAST3_KEY_GEN, KEYGEN_OP, CKM_CAST3_KEY_GEN}, + {CKM_CAST3_ECB, ENCRYPT_OP, CKM_CAST3_KEY_GEN}, + {CKM_CAST3_CBC, ENCRYPT_OP, CKM_CAST3_KEY_GEN}, + {CKM_CAST3_MAC, NULL_OP, CKM_CAST3_KEY_GEN}, + {CKM_CAST3_MAC_GENERAL, NULL_OP, CKM_CAST3_KEY_GEN}, + {CKM_CAST3_CBC_PAD, NULL_OP, CKM_CAST3_KEY_GEN}, + {CKM_CAST5_KEY_GEN, KEYGEN_OP, CKM_CAST5_KEY_GEN}, + {CKM_CAST5_ECB, ENCRYPT_OP, CKM_CAST5_KEY_GEN}, + {CKM_CAST5_CBC, ENCRYPT_OP, CKM_CAST5_KEY_GEN}, + {CKM_CAST5_MAC, NULL_OP, CKM_CAST5_KEY_GEN}, + {CKM_CAST5_MAC_GENERAL, NULL_OP, CKM_CAST5_KEY_GEN}, + {CKM_CAST5_CBC_PAD, NULL_OP, CKM_CAST5_KEY_GEN}, + {CKM_RC5_KEY_GEN, KEYGEN_OP, CKM_RC5_KEY_GEN}, + {CKM_RC5_ECB, ENCRYPT_OP, CKM_RC5_KEY_GEN}, + {CKM_RC5_CBC, ENCRYPT_OP, CKM_RC5_KEY_GEN}, + {CKM_RC5_MAC, NULL_OP, CKM_RC5_KEY_GEN}, + {CKM_RC5_MAC_GENERAL, NULL_OP, CKM_RC5_KEY_GEN}, + {CKM_RC5_CBC_PAD, NULL_OP, CKM_RC5_KEY_GEN}, + {CKM_IDEA_KEY_GEN, KEYGEN_OP, CKM_IDEA_KEY_GEN}, + {CKM_IDEA_ECB, ENCRYPT_OP, CKM_IDEA_KEY_GEN}, + {CKM_IDEA_CBC, ENCRYPT_OP, CKM_IDEA_KEY_GEN}, + {CKM_IDEA_MAC, NULL_OP, CKM_IDEA_KEY_GEN}, + {CKM_IDEA_MAC_GENERAL, NULL_OP, CKM_IDEA_KEY_GEN}, + {CKM_IDEA_CBC_PAD, NULL_OP, CKM_IDEA_KEY_GEN}, + {CKM_GENERIC_SECRET_KEY_GEN, + KEYGEN_OP, CKM_GENERIC_SECRET_KEY_GEN}, +/* SSL mechanisms? + {CKM_SSL3_PRE_MASTER_KEY_GEN}, + {CKM_SSL3_MASTER_KEY_DERIVE}, + {CKM_SSL3_KEY_AND_MAC_DERIVE}, + {CKM_SSL3_MD5_MAC}, + {CKM_SSL3_SHA1_MAC}, +*/ + {CKM_PBE_MD2_DES_CBC, KEYGEN_OP, 0}, + {CKM_PBE_MD5_DES_CBC, KEYGEN_OP, 0}, + {CKM_PBE_MD5_CAST_CBC, KEYGEN_OP, 0}, + {CKM_PBE_MD5_CAST3_CBC, KEYGEN_OP, 0}, + {CKM_PBE_MD5_CAST5_CBC, KEYGEN_OP, 0}, + {CKM_PBE_MD5_CAST128_CBC, + KEYGEN_OP, 0}, + {CKM_PBE_SHA1_CAST5_CBC,KEYGEN_OP, 0}, + {CKM_PBE_SHA1_CAST128_CBC, + KEYGEN_OP, 0}, + {CKM_PBE_SHA1_RC4_128, KEYGEN_OP, 0}, + {CKM_PBE_SHA1_RC4_40, KEYGEN_OP, 0}, + {CKM_PBE_SHA1_DES3_EDE_CBC, + KEYGEN_OP, 0}, + {CKM_PBE_SHA1_DES2_EDE_CBC, + KEYGEN_OP, 0}, + {CKM_PBE_SHA1_RC2_128_CBC, + KEYGEN_OP, 0}, + {CKM_PBE_SHA1_RC2_40_CBC, + KEYGEN_OP, 0}, + {CKM_PBA_SHA1_WITH_SHA1_HMAC, + KEYGEN_OP, 0}, + {CKM_SKIPJACK_KEY_GEN, KEYGEN_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_SKIPJACK_ECB64, ENCRYPT_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_SKIPJACK_CBC64, ENCRYPT_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_SKIPJACK_OFB64, ENCRYPT_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_SKIPJACK_CFB64, ENCRYPT_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_SKIPJACK_CFB32, ENCRYPT_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_SKIPJACK_CFB16, ENCRYPT_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_SKIPJACK_CFB8, ENCRYPT_OP, CKM_SKIPJACK_KEY_GEN}, + {CKM_KEA_KEY_PAIR_GEN, KEYGEN_OP, 0}, + {CKM_BATON_KEY_GEN, KEYGEN_OP, CKM_BATON_KEY_GEN}, + {CKM_BATON_ECB128, ENCRYPT_OP, CKM_BATON_KEY_GEN}, + {CKM_BATON_ECB96, ENCRYPT_OP, CKM_BATON_KEY_GEN}, + {CKM_BATON_CBC128, ENCRYPT_OP, CKM_BATON_KEY_GEN}, + {CKM_BATON_COUNTER, ENCRYPT_OP, CKM_BATON_KEY_GEN}, + {CKM_BATON_SHUFFLE, ENCRYPT_OP, CKM_BATON_KEY_GEN}, + {CKM_ECDSA_KEY_PAIR_GEN,KEYGEN_OP, CKM_ECDSA_KEY_PAIR_GEN}, + {CKM_ECDSA, SIGN_OP, CKM_ECDSA_KEY_PAIR_GEN}, + {CKM_ECDSA_SHA1, SIGN_OP, CKM_ECDSA_KEY_PAIR_GEN}, + {CKM_JUNIPER_KEY_GEN, KEYGEN_OP, CKM_JUNIPER_KEY_GEN}, + {CKM_JUNIPER_ECB128, ENCRYPT_OP, CKM_JUNIPER_KEY_GEN}, + {CKM_JUNIPER_CBC128, ENCRYPT_OP, CKM_JUNIPER_KEY_GEN}, + {CKM_JUNIPER_COUNTER, ENCRYPT_OP, CKM_JUNIPER_KEY_GEN}, + {CKM_JUNIPER_SHUFFLE, ENCRYPT_OP, CKM_JUNIPER_KEY_GEN}, + {CKM_FASTHASH, DIGEST_OP, 0} +}; + +#endif diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.reg b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.reg new file mode 100644 index 0000000..ed4e53b --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.reg @@ -0,0 +1,964 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1994-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** +[General] +mut=PKCS11 +mutversion=1.0 +htmlout=NOW +reporterSpec=NOW +program=pk11test +globalArgs=internal + +[Test-1] + +testId=0 +testname=Use supplied pin, Generate keys on target token, NO OP, + +[Test-2] + +testId=4 +testname=Use supplied pin, Generate keys on target token, RSA PKCS, + +[Test-3] + +testId=8 +testname=Use supplied pin, Generate keys on target token, RSA 9796, + +[Test-4] + +testId=12 +testname=Use supplied pin, Generate keys on target token, RSA X.509, + +[Test-5] + +testId=16 +testname=Use supplied pin, Generate keys on target token, MD2 RSA PKCS, + +[Test-6] + +testId=20 +testname=Use supplied pin, Generate keys on target token, MD5 RSA PKCS, + +[Test-7] + +testId=24 +testname=Use supplied pin, Generate keys on target token, SHA1 RSA PKCS, + +[Test-8] + +testId=28 +testname=Use supplied pin, Generate keys on target token, DSA, + +[Test-9] + +testId=32 +testname=Use supplied pin, Generate keys on target token, DSA SHA1, + +[Test-10] + +testId=36 +testname=Use supplied pin, Generate keys on target token, ECDSA, + +[Test-11] + +testId=40 +testname=Use supplied pin, Generate keys on target token, ECDSA SHA1, + +[Test-12] + +testId=44 +testname=Use supplied pin, Generate keys on target token, RC2 ECB, + +[Test-13] + +testId=48 +testname=Use supplied pin, Generate keys on target token, RC2 CBC, + +[Test-14] + +testId=52 +testname=Use supplied pin, Generate keys on target token, RC4, + +[Test-15] + +testId=56 +testname=Use supplied pin, Generate keys on target token, RC5 ECB, + +[Test-16] + +testId=60 +testname=Use supplied pin, Generate keys on target token, RC5 CBC, + +[Test-17] + +testId=64 +testname=Use supplied pin, Generate keys on target token, DES ECB, + +[Test-18] + +testId=68 +testname=Use supplied pin, Generate keys on target token, DES CBC, + +[Test-19] + +testId=72 +testname=Use supplied pin, Generate keys on target token, DES3 ECB, + +[Test-20] + +testId=76 +testname=Use supplied pin, Generate keys on target token, DES3 CBC, + +[Test-21] + +testId=80 +testname=Use supplied pin, Generate keys on target token, CAST ECB, + +[Test-22] + +testId=84 +testname=Use supplied pin, Generate keys on target token, CAST CBC, + +[Test-23] + +testId=88 +testname=Use supplied pin, Generate keys on target token, CAST3 ECB, + +[Test-24] + +testId=92 +testname=Use supplied pin, Generate keys on target token, CAST3 CBC, + +[Test-25] + +testId=96 +testname=Use supplied pin, Generate keys on target token, CAST5 ECB, + +[Test-26] + +testId=100 +testname=Use supplied pin, Generate keys on target token, CAST5 CBC, + +[Test-27] + +testId=104 +testname=Use supplied pin, Generate keys on target token, IDEA ECB, + +[Test-28] + +testId=108 +testname=Use supplied pin, Generate keys on target token, IDEA CBC, + +[Test-29] + +testId=112 +testname=Use supplied pin, Generate keys on target token, CDMF ECB, + +[Test-30] + +testId=116 +testname=Use supplied pin, Generate keys on target token, CDMF CBC, + +[Test-31] + +testId=120 +testname=Use supplied pin, Generate keys on target token, SKIPJACK ECB64, + +[Test-32] + +testId=124 +testname=Use supplied pin, Generate keys on target token, SKIPJACK CBC64, + +[Test-33] + +testId=128 +testname=Use supplied pin, Generate keys on target token, SKIPJACK OFB64, + +[Test-34] + +testId=132 +testname=Use supplied pin, Generate keys on target token, SKIPJACK CFB64, + +[Test-35] + +testId=136 +testname=Use supplied pin, Generate keys on target token, SKIPJACK CFB32, + +[Test-36] + +testId=140 +testname=Use supplied pin, Generate keys on target token, SKIPJACK CFB16, + +[Test-37] + +testId=144 +testname=Use supplied pin, Generate keys on target token, SKIPJACK CFB8, + +[Test-38] + +testId=148 +testname=Use supplied pin, Generate keys on target token, BATON ECB128, + +[Test-39] + +testId=152 +testname=Use supplied pin, Generate keys on target token, BATON ECB96, + +[Test-40] + +testId=156 +testname=Use supplied pin, Generate keys on target token, BATON CBC128, + +[Test-41] + +testId=160 +testname=Use supplied pin, Generate keys on target token, BATON counter, + +[Test-42] + +testId=164 +testname=Use supplied pin, Generate keys on target token, BATON shuffle, + +[Test-43] + +testId=168 +testname=Use supplied pin, Generate keys on target token, JUNIPER ECB128, + +[Test-44] + +testId=172 +testname=Use supplied pin, Generate keys on target token, JUNIPER CBC128, + +[Test-45] + +testId=176 +testname=Use supplied pin, Generate keys on target token, JUNIPER counter, + +[Test-46] + +testId=180 +testname=Use supplied pin, Generate keys on target token, JUNIPER shuffle, + +[Test-47] + +testId=2 +testname=Use supplied pin, Generate keys on internal module, NO OP, + +[Test-48] + +testId=6 +testname=Use supplied pin, Generate keys on internal module, RSA PKCS, + +[Test-49] + +testId=10 +testname=Use supplied pin, Generate keys on internal module, RSA 9796, + +[Test-50] + +testId=14 +testname=Use supplied pin, Generate keys on internal module, RSA X.509, + +[Test-51] + +testId=18 +testname=Use supplied pin, Generate keys on internal module, MD2 RSA PKCS, + +[Test-52] + +testId=22 +testname=Use supplied pin, Generate keys on internal module, MD5 RSA PKCS, + +[Test-53] + +testId=26 +testname=Use supplied pin, Generate keys on internal module, SHA1 RSA PKCS, + +[Test-54] + +testId=30 +testname=Use supplied pin, Generate keys on internal module, DSA, + +[Test-55] + +testId=34 +testname=Use supplied pin, Generate keys on internal module, DSA SHA1, + +[Test-56] + +testId=38 +testname=Use supplied pin, Generate keys on internal module, ECDSA, + +[Test-57] + +testId=42 +testname=Use supplied pin, Generate keys on internal module, ECDSA SHA1, + +[Test-58] + +testId=46 +testname=Use supplied pin, Generate keys on internal module, RC2 ECB, + +[Test-59] + +testId=50 +testname=Use supplied pin, Generate keys on internal module, RC2 CBC, + +[Test-60] + +testId=54 +testname=Use supplied pin, Generate keys on internal module, RC4, + +[Test-61] + +testId=58 +testname=Use supplied pin, Generate keys on internal module, RC5 ECB, + +[Test-62] + +testId=62 +testname=Use supplied pin, Generate keys on internal module, RC5 CBC, + +[Test-63] + +testId=66 +testname=Use supplied pin, Generate keys on internal module, DES ECB, + +[Test-64] + +testId=70 +testname=Use supplied pin, Generate keys on internal module, DES CBC, + +[Test-65] + +testId=74 +testname=Use supplied pin, Generate keys on internal module, DES3 ECB, + +[Test-66] + +testId=78 +testname=Use supplied pin, Generate keys on internal module, DES3 CBC, + +[Test-67] + +testId=82 +testname=Use supplied pin, Generate keys on internal module, CAST ECB, + +[Test-68] + +testId=86 +testname=Use supplied pin, Generate keys on internal module, CAST CBC, + +[Test-69] + +testId=90 +testname=Use supplied pin, Generate keys on internal module, CAST3 ECB, + +[Test-70] + +testId=94 +testname=Use supplied pin, Generate keys on internal module, CAST3 CBC, + +[Test-71] + +testId=98 +testname=Use supplied pin, Generate keys on internal module, CAST5 ECB, + +[Test-72] + +testId=102 +testname=Use supplied pin, Generate keys on internal module, CAST5 CBC, + +[Test-73] + +testId=106 +testname=Use supplied pin, Generate keys on internal module, IDEA ECB, + +[Test-74] + +testId=110 +testname=Use supplied pin, Generate keys on internal module, IDEA CBC, + +[Test-75] + +testId=114 +testname=Use supplied pin, Generate keys on internal module, CDMF ECB, + +[Test-76] + +testId=118 +testname=Use supplied pin, Generate keys on internal module, CDMF CBC, + +[Test-77] + +testId=122 +testname=Use supplied pin, Generate keys on internal module, SKIPJACK ECB64, + +[Test-78] + +testId=126 +testname=Use supplied pin, Generate keys on internal module, SKIPJACK CBC64, + +[Test-79] + +testId=130 +testname=Use supplied pin, Generate keys on internal module, SKIPJACK OFB64, + +[Test-80] + +testId=134 +testname=Use supplied pin, Generate keys on internal module, SKIPJACK CFB64, + +[Test-81] + +testId=138 +testname=Use supplied pin, Generate keys on internal module, SKIPJACK CFB32, + +[Test-82] + +testId=142 +testname=Use supplied pin, Generate keys on internal module, SKIPJACK CFB16, + +[Test-83] + +testId=146 +testname=Use supplied pin, Generate keys on internal module, SKIPJACK CFB8, + +[Test-84] + +testId=150 +testname=Use supplied pin, Generate keys on internal module, BATON ECB128, + +[Test-85] + +testId=154 +testname=Use supplied pin, Generate keys on internal module, BATON ECB96, + +[Test-86] + +testId=158 +testname=Use supplied pin, Generate keys on internal module, BATON CBC128, + +[Test-87] + +testId=162 +testname=Use supplied pin, Generate keys on internal module, BATON counter, + +[Test-88] + +testId=166 +testname=Use supplied pin, Generate keys on internal module, BATON shuffle, + +[Test-89] + +testId=170 +testname=Use supplied pin, Generate keys on internal module, JUNIPER ECB128, + +[Test-90] + +testId=174 +testname=Use supplied pin, Generate keys on internal module, JUNIPER CBC128, + +[Test-91] + +testId=178 +testname=Use supplied pin, Generate keys on internal module, JUNIPER counter, + +[Test-92] + +testId=182 +testname=Use supplied pin, Generate keys on internal module, JUNIPER shuffle, + +[Test-93] + +testId=1 +testname=Use different (incorrect) pin, Generate keys on target token, NO OP, + +[Test-94] + +testId=5 +testname=Use different (incorrect) pin, Generate keys on target token, RSA PKCS, + +[Test-95] + +testId=9 +testname=Use different (incorrect) pin, Generate keys on target token, RSA 9796, + +[Test-96] + +testId=13 +testname=Use different (incorrect) pin, Generate keys on target token, RSA X.509, + +[Test-97] + +testId=17 +testname=Use different (incorrect) pin, Generate keys on target token, MD2 RSA PKCS, + +[Test-98] + +testId=21 +testname=Use different (incorrect) pin, Generate keys on target token, MD5 RSA PKCS, + +[Test-99] + +testId=25 +testname=Use different (incorrect) pin, Generate keys on target token, SHA1 RSA PKCS, + +[Test-100] + +testId=29 +testname=Use different (incorrect) pin, Generate keys on target token, DSA, + +[Test-101] + +testId=33 +testname=Use different (incorrect) pin, Generate keys on target token, DSA SHA1, + +[Test-102] + +testId=37 +testname=Use different (incorrect) pin, Generate keys on target token, ECDSA, + +[Test-103] + +testId=41 +testname=Use different (incorrect) pin, Generate keys on target token, ECDSA SHA1, + +[Test-104] + +testId=45 +testname=Use different (incorrect) pin, Generate keys on target token, RC2 ECB, + +[Test-105] + +testId=49 +testname=Use different (incorrect) pin, Generate keys on target token, RC2 CBC, + +[Test-106] + +testId=53 +testname=Use different (incorrect) pin, Generate keys on target token, RC4, + +[Test-107] + +testId=57 +testname=Use different (incorrect) pin, Generate keys on target token, RC5 ECB, + +[Test-108] + +testId=61 +testname=Use different (incorrect) pin, Generate keys on target token, RC5 CBC, + +[Test-109] + +testId=65 +testname=Use different (incorrect) pin, Generate keys on target token, DES ECB, + +[Test-110] + +testId=69 +testname=Use different (incorrect) pin, Generate keys on target token, DES CBC, + +[Test-111] + +testId=73 +testname=Use different (incorrect) pin, Generate keys on target token, DES3 ECB, + +[Test-112] + +testId=77 +testname=Use different (incorrect) pin, Generate keys on target token, DES3 CBC, + +[Test-113] + +testId=81 +testname=Use different (incorrect) pin, Generate keys on target token, CAST ECB, + +[Test-114] + +testId=85 +testname=Use different (incorrect) pin, Generate keys on target token, CAST CBC, + +[Test-115] + +testId=89 +testname=Use different (incorrect) pin, Generate keys on target token, CAST3 ECB, + +[Test-116] + +testId=93 +testname=Use different (incorrect) pin, Generate keys on target token, CAST3 CBC, + +[Test-117] + +testId=97 +testname=Use different (incorrect) pin, Generate keys on target token, CAST5 ECB, + +[Test-118] + +testId=101 +testname=Use different (incorrect) pin, Generate keys on target token, CAST5 CBC, + +[Test-119] + +testId=105 +testname=Use different (incorrect) pin, Generate keys on target token, IDEA ECB, + +[Test-120] + +testId=109 +testname=Use different (incorrect) pin, Generate keys on target token, IDEA CBC, + +[Test-121] + +testId=113 +testname=Use different (incorrect) pin, Generate keys on target token, CDMF ECB, + +[Test-122] + +testId=117 +testname=Use different (incorrect) pin, Generate keys on target token, CDMF CBC, + +[Test-123] + +testId=121 +testname=Use different (incorrect) pin, Generate keys on target token, SKIPJACK ECB64, + +[Test-124] + +testId=125 +testname=Use different (incorrect) pin, Generate keys on target token, SKIPJACK CBC64, + +[Test-125] + +testId=129 +testname=Use different (incorrect) pin, Generate keys on target token, SKIPJACK OFB64, + +[Test-126] + +testId=133 +testname=Use different (incorrect) pin, Generate keys on target token, SKIPJACK CFB64, + +[Test-127] + +testId=137 +testname=Use different (incorrect) pin, Generate keys on target token, SKIPJACK CFB32, + +[Test-128] + +testId=141 +testname=Use different (incorrect) pin, Generate keys on target token, SKIPJACK CFB16, + +[Test-129] + +testId=145 +testname=Use different (incorrect) pin, Generate keys on target token, SKIPJACK CFB8, + +[Test-130] + +testId=149 +testname=Use different (incorrect) pin, Generate keys on target token, BATON ECB128, + +[Test-131] + +testId=153 +testname=Use different (incorrect) pin, Generate keys on target token, BATON ECB96, + +[Test-132] + +testId=157 +testname=Use different (incorrect) pin, Generate keys on target token, BATON CBC128, + +[Test-133] + +testId=161 +testname=Use different (incorrect) pin, Generate keys on target token, BATON counter, + +[Test-134] + +testId=165 +testname=Use different (incorrect) pin, Generate keys on target token, BATON shuffle, + +[Test-135] + +testId=169 +testname=Use different (incorrect) pin, Generate keys on target token, JUNIPER ECB128, + +[Test-136] + +testId=173 +testname=Use different (incorrect) pin, Generate keys on target token, JUNIPER CBC128, + +[Test-137] + +testId=177 +testname=Use different (incorrect) pin, Generate keys on target token, JUNIPER counter, + +[Test-138] + +testId=181 +testname=Use different (incorrect) pin, Generate keys on target token, JUNIPER shuffle, + +[Test-139] + +testId=3 +testname=Use different (incorrect) pin, Generate keys on internal module, NO OP, + +[Test-140] + +testId=7 +testname=Use different (incorrect) pin, Generate keys on internal module, RSA PKCS, + +[Test-141] + +testId=11 +testname=Use different (incorrect) pin, Generate keys on internal module, RSA 9796, + +[Test-142] + +testId=15 +testname=Use different (incorrect) pin, Generate keys on internal module, RSA X.509, + +[Test-143] + +testId=19 +testname=Use different (incorrect) pin, Generate keys on internal module, MD2 RSA PKCS, + +[Test-144] + +testId=23 +testname=Use different (incorrect) pin, Generate keys on internal module, MD5 RSA PKCS, + +[Test-145] + +testId=27 +testname=Use different (incorrect) pin, Generate keys on internal module, SHA1 RSA PKCS, + +[Test-146] + +testId=31 +testname=Use different (incorrect) pin, Generate keys on internal module, DSA, + +[Test-147] + +testId=35 +testname=Use different (incorrect) pin, Generate keys on internal module, DSA SHA1, + +[Test-148] + +testId=39 +testname=Use different (incorrect) pin, Generate keys on internal module, ECDSA, + +[Test-149] + +testId=43 +testname=Use different (incorrect) pin, Generate keys on internal module, ECDSA SHA1, + +[Test-150] + +testId=47 +testname=Use different (incorrect) pin, Generate keys on internal module, RC2 ECB, + +[Test-151] + +testId=51 +testname=Use different (incorrect) pin, Generate keys on internal module, RC2 CBC, + +[Test-152] + +testId=55 +testname=Use different (incorrect) pin, Generate keys on internal module, RC4, + +[Test-153] + +testId=59 +testname=Use different (incorrect) pin, Generate keys on internal module, RC5 ECB, + +[Test-154] + +testId=63 +testname=Use different (incorrect) pin, Generate keys on internal module, RC5 CBC, + +[Test-155] + +testId=67 +testname=Use different (incorrect) pin, Generate keys on internal module, DES ECB, + +[Test-156] + +testId=71 +testname=Use different (incorrect) pin, Generate keys on internal module, DES CBC, + +[Test-157] + +testId=75 +testname=Use different (incorrect) pin, Generate keys on internal module, DES3 ECB, + +[Test-158] + +testId=79 +testname=Use different (incorrect) pin, Generate keys on internal module, DES3 CBC, + +[Test-159] + +testId=83 +testname=Use different (incorrect) pin, Generate keys on internal module, CAST ECB, + +[Test-160] + +testId=87 +testname=Use different (incorrect) pin, Generate keys on internal module, CAST CBC, + +[Test-161] + +testId=91 +testname=Use different (incorrect) pin, Generate keys on internal module, CAST3 ECB, + +[Test-162] + +testId=95 +testname=Use different (incorrect) pin, Generate keys on internal module, CAST3 CBC, + +[Test-163] + +testId=99 +testname=Use different (incorrect) pin, Generate keys on internal module, CAST5 ECB, + +[Test-164] + +testId=103 +testname=Use different (incorrect) pin, Generate keys on internal module, CAST5 CBC, + +[Test-165] + +testId=107 +testname=Use different (incorrect) pin, Generate keys on internal module, IDEA ECB, + +[Test-166] + +testId=111 +testname=Use different (incorrect) pin, Generate keys on internal module, IDEA CBC, + +[Test-167] + +testId=115 +testname=Use different (incorrect) pin, Generate keys on internal module, CDMF ECB, + +[Test-168] + +testId=119 +testname=Use different (incorrect) pin, Generate keys on internal module, CDMF CBC, + +[Test-169] + +testId=123 +testname=Use different (incorrect) pin, Generate keys on internal module, SKIPJACK ECB64, + +[Test-170] + +testId=127 +testname=Use different (incorrect) pin, Generate keys on internal module, SKIPJACK CBC64, + +[Test-171] + +testId=131 +testname=Use different (incorrect) pin, Generate keys on internal module, SKIPJACK OFB64, + +[Test-172] + +testId=135 +testname=Use different (incorrect) pin, Generate keys on internal module, SKIPJACK CFB64, + +[Test-173] + +testId=139 +testname=Use different (incorrect) pin, Generate keys on internal module, SKIPJACK CFB32, + +[Test-174] + +testId=143 +testname=Use different (incorrect) pin, Generate keys on internal module, SKIPJACK CFB16, + +[Test-175] + +testId=147 +testname=Use different (incorrect) pin, Generate keys on internal module, SKIPJACK CFB8, + +[Test-176] + +testId=151 +testname=Use different (incorrect) pin, Generate keys on internal module, BATON ECB128, + +[Test-177] + +testId=155 +testname=Use different (incorrect) pin, Generate keys on internal module, BATON ECB96, + +[Test-178] + +testId=159 +testname=Use different (incorrect) pin, Generate keys on internal module, BATON CBC128, + +[Test-179] + +testId=163 +testname=Use different (incorrect) pin, Generate keys on internal module, BATON counter, + +[Test-180] + +testId=167 +testname=Use different (incorrect) pin, Generate keys on internal module, BATON shuffle, + +[Test-181] + +testId=171 +testname=Use different (incorrect) pin, Generate keys on internal module, JUNIPER ECB128, + +[Test-182] + +testId=175 +testname=Use different (incorrect) pin, Generate keys on internal module, JUNIPER CBC128, + +[Test-183] + +testId=179 +testname=Use different (incorrect) pin, Generate keys on internal module, JUNIPER counter, + +[Test-184] + +testId=183 +testname=Use different (incorrect) pin, Generate keys on internal module, JUNIPER shuffle, + diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.rep b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.rep new file mode 100644 index 0000000..bc8bdcc --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/pkcs11.rep @@ -0,0 +1,161 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1994-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** +[General] +mut=PKCS11 +mutversion=1.0 +cTemplate=pk11test.htp +testPrefix=pk11test +testSuffix=.h +#timeout= +regressSpecfile=pkcs11.reg +regressOutput=NOW +reporterOutput=NOW +singleSource=TRUE +firstExitCode=100 + +[UseCorrectPin] +IMPORTANCE=HIGH +TYPE=PRBool +Use supplied pin, =PR_TRUE +Use different (incorrect) pin, =PR_FALSE + +[KeyGenOnTarget] +IMPORTANCE=HIGH +TYPE=PRBool +Generate keys on target token, = PR_TRUE +Generate keys on internal module, = PR_FALSE + +[mechanism] +IMPORTANCE=HIGH +TYPE = CK_MECHANISM_TYPE +NO OP, = CKM_NO_OP +RSA PKCS, = CKM_RSA_PKCS +RSA 9796, = CKM_RSA_9796 +RSA X.509, = CKM_RSA_X_509 +MD2 RSA PKCS, = CKM_MD2_RSA_PKCS +MD5 RSA PKCS, = CKM_MD5_RSA_PKCS +SHA1 RSA PKCS, = CKM_SHA1_RSA_PKCS +DSA, = CKM_DSA +DSA SHA1, = CKM_DSA_SHA1 +ECDSA, = CKM_ECDSA +ECDSA SHA1, = CKM_ECDSA_SHA1 +RC2 ECB, = CKM_RC2_ECB +RC2 CBC, = CKM_RC2_CBC +#RC2 CBC PAD, = CKM_RC2_CBC_PAD +#RC2 MAC general, = CKM_RC2_MAC_GENERAL +#RC2 MAC, = CKM_RC2_MAC +RC4, = CKM_RC4 +RC5 ECB, = CKM_RC5_ECB +RC5 CBC, = CKM_RC5_CBC +#RC5 CBC PAD, = CKM_RC5_CBC_PAD +#RC5 MAC general, = CKM_RC5_MAC_GENERAL +#RC5 MAC, = CKM_RC5_MAC +DES ECB, = CKM_DES_ECB +DES CBC, = CKM_DES_CBC +#DES CBC PAD, = CKM_DES_CBC_PAD +#DES MAC general, = CKM_DES_MAC_GENERAL +#DES MAC, = CKM_DES_MAC +#DES2 keygen, = CKM_DES2_KEY_GEN +DES3 ECB, = CKM_DES3_ECB +DES3 CBC, = CKM_DES3_CBC +#DES3 CBC pad, = CKM_DES3_CBC_PAD +#DES3 MAC general, = CKM_DES3_MAC_GENERAL +#DES3 MAC, = CKM_DES3_MAC +CAST ECB, = CKM_CAST_ECB +CAST CBC, = CKM_CAST_CBC +#CAST CBC PAD, = CKM_CAST_CBC_PAD +#CAST MAC general, = CKM_CAST_MAC_GENERAL +#CAST MAC, = CKM_CAST_MAC +CAST3 ECB, = CKM_CAST3_ECB +CAST3 CBC, = CKM_CAST3_CBC +#CAST3 CBC PAD, = CKM_CAST3_CBC_PAD +#CAST3 MAC general, = CKM_CAST3_MAC_GENERAL +#CAST3 MAC, = CKM_CAST3_MAC +CAST5 ECB, = CKM_CAST5_ECB +CAST5 CBC, = CKM_CAST5_CBC +#CAST5 CBC PAD, = CKM_CAST5_CBC_PAD +#CAST5 MAC general, = CKM_CAST5_MAC_GENERAL +#CAST5 MAC, = CKM_CAST5_MAC +IDEA ECB, = CKM_IDEA_ECB +IDEA CBC, = CKM_IDEA_CBC +#IDEA CBC PAD, = CKM_IDEA_CBC_PAD +#IDEA MAC general, = CKM_IDEA_MAC_GENERAL +#IDEA MAC, = CKM_IDEA_MAC +CDMF ECB, = CKM_CDMF_ECB +CDMF CBC, = CKM_CDMF_CBC +#CDMF CBC PAD, = CKM_CDMF_CBC_PAD +#CDMF MAC general, = CKM_CDMF_MAC_GENERAL +#CDMF MAC, = CKM_CDMF_MAC +SKIPJACK ECB64, = CKM_SKIPJACK_ECB64 +SKIPJACK CBC64, = CKM_SKIPJACK_CBC64 +SKIPJACK OFB64, = CKM_SKIPJACK_OFB64 +SKIPJACK CFB64, = CKM_SKIPJACK_CFB64 +SKIPJACK CFB32, = CKM_SKIPJACK_CFB32 +SKIPJACK CFB16, = CKM_SKIPJACK_CFB16 +SKIPJACK CFB8, = CKM_SKIPJACK_CFB8 +BATON ECB128, = CKM_BATON_ECB128 +BATON ECB96, = CKM_BATON_ECB96 +BATON CBC128, = CKM_BATON_CBC128 +BATON counter, = CKM_BATON_COUNTER +BATON shuffle, = CKM_BATON_SHUFFLE +JUNIPER ECB128, = CKM_JUNIPER_ECB128 +JUNIPER CBC128, = CKM_JUNIPER_CBC128 +JUNIPER counter, = CKM_JUNIPER_COUNTER +JUNIPER shuffle, = CKM_JUNIPER_SHUFFLE +#MD2 digest, = CKM_MD2 +#MD2 HMAC general, = CKM_MD2_HMAC_GENERAL +#MD2 HMAC, = CKM_MD2_HMAC +#MD5 digest, = CKM_MD5 +#MD5 HMAC general, = CKM_MD5_HMAC_GENERAL +#MD5 HMAC, = CKM_MD5_HMAC +#SHA1 digest, = CKM_SHA_1 +#SHA1 HMAC general, = CKM_SHA_1_HMAC_GENERAL +#SHA1 HMAC, = CKM_SHA_1_HMAC +#Fasthash, = CKM_FASTHASH +#CKM_PBE_MD2_DES_CBC = CKM_PBE_MD2_DES_CBC +#CKM_PBE_MD5_DES_CBC = CKM_PBE_MD5_DES_CBC +#CKM_PBE_MD5_CAST_CBC = CKM_PBE_MD5_CAST_CBC +#CKM_PBE_MD5_CAST3_CBC = CKM_PBE_MD5_CAST3_CBC +#CKM_PBE_MD5_CAST5_CBC = CKM_PBE_MD5_CAST5_CBC +#CKM_PBE_SHA1_CAST5_CBC = CKM_PBE_SHA1_CAST5_CBC +#CKM_PBE_SHA1_RC4_128 = CKM_PBE_SHA1_RC4_128 +#CKM_PBE_SHA1_RC4_40 = CKM_PBE_SHA1_RC4_40 +#CKM_PBE_SHA1_DES3_EDE_CBC = CKM_PBE_SHA1_DES3_EDE_CBC +#CKM_PBE_SHA1_DES2_EDE_CBC = CKM_PBE_SHA1_DES2_EDE_CBC +#CKM_PBE_SHA1_RC2_128_CBC = CKM_PBE_SHA1_RC2_128_CBC +#CKM_PBE_SHA1_RC2_40_CBC = CKM_PBE_SHA1_RC2_40_CBC +#CKM_PBA_SHA1_WITH_SHA1_HMAC = CKM_PBA_SHA1_WITH_SHA1_HMAC diff --git a/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/rules.mk b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/rules.mk new file mode 100644 index 0000000..bca6e39 --- /dev/null +++ b/mozilla/security/nss/tests/pkcs11/netscape/suites/security/pkcs11/rules.mk @@ -0,0 +1,38 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is the Netscape security libraries. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1994-2000 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +pk11test.c: pk11test.h pkcs11.h |