/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ /* * This file implements PKCS 11 on top of our existing security modules * * For more information about PKCS 11 See PKCS 11 Token Inteface Standard. * This implementation has two slots: * slot 1 is our generic crypto support. It does not require login. * It supports Public Key ops, and all they bulk ciphers and hashes. * It can also support Private Key ops for imported Private keys. It does * not have any token storage. * slot 2 is our private key support. It requires a login before use. It * can store Private Keys and Certs as token objects. Currently only private * keys and their associated Certificates are saved on the token. * * In this implementation, session objects are only visible to the session * that created or generated them.
*/ #include"seccomon.h" #include"secitem.h" #include"pkcs11.h" #include"pkcs11i.h" #include"softoken.h" #include"lowkeyi.h" #include"blapi.h" #include"secder.h" #include"secport.h" #include"secrng.h" #include"prtypes.h" #include"nspr.h" #include"softkver.h" #include"secoid.h" #include"sftkdb.h" #include"utilpars.h" #include"ec.h" #include"secasn1.h" #include"secerr.h" #include"lgglue.h" #include"kem.h"
/* The next three strings must be exactly 32 characters long */ staticchar *manufacturerID = "Mozilla Foundation "; staticchar manufacturerID_space[33]; staticchar *libraryDescription = "NSS Internal Crypto Services "; staticchar libraryDescription_space[33];
/* * In FIPS mode, we disallow login attempts for 1 second after a login * failure so that there are at most 60 login attempts per minute.
*/ static PRIntervalTime loginWaitTime;
#define __PASTE(x, y) x##y
/* * we renamed all our internal functions, get the correct * definitions for them...
*/ #undef CK_PKCS11_FUNCTION_INFO #undef CK_NEED_ARG_LIST
/* need a special version of get info for version 2 which returns the version
* 2.4 version number */
CK_RV NSC_GetInfoV2(CK_INFO_PTR pInfo);
CK_RV NSC_GetMechanismInfoV2(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
CK_MECHANISM_INFO_PTR pInfo);
/* * the following table includes a complete list of mechanism defined by * PKCS #11 version 2.01. Those Mechanisms not supported by this PKCS #11 * module are ifdef'ed out.
*/ #define CKF_EN_DE CKF_ENCRYPT | CKF_DECRYPT #define CKF_WR_UN CKF_WRAP | CKF_UNWRAP #define CKF_SN_VR CKF_SIGN | CKF_VERIFY #define CKF_SN_RE CKF_SIGN_RECOVER | CKF_VERIFY_RECOVER #define CKF_EN_DE_MSG CKF_ENCRYPT | CKF_DECRYPT | CKF_MESSAGE_ENCRYPT | CKF_MESSAGE_DECRYPT
/* * PKCS #11 Mechanism List. * * The first argument is the PKCS #11 Mechanism we support. * The second argument is Mechanism info structure. It includes: * The minimum key size, * in bits for RSA, DSA, DH, EC*, KEA, RC2 and RC4 * algs. * in bytes for RC5, AES, Camellia, and CAST* * ignored for DES*, IDEA and FORTEZZA based * The maximum key size, * in bits for RSA, DSA, DH, EC*, KEA, RC2 and RC4 * algs. * in bytes for RC5, AES, Camellia, and CAST* * ignored for DES*, IDEA and FORTEZZA based * Flags * What operations are supported by this mechanism. * The third argument is a bool which tells if this mechanism is * supported in the database token. *
*/
staticchar *
sftk_setStringName(constchar *inString, char *buffer, int buffer_length, PRBool nullTerminate)
{ int full_length, string_length;
full_length = nullTerminate ? buffer_length - 1 : buffer_length;
string_length = PORT_Strlen(inString); /* * shorten the string, respecting utf8 encoding * to do so, we work backward from the end * bytes looking from the end are either: * - ascii [0x00,0x7f] * - the [2-n]th byte of a multibyte sequence * [0x3F,0xBF], i.e, most significant 2 bits are '10' * - the first byte of a multibyte sequence [0xC0,0xFD], * i.e, most significant 2 bits are '11' * * When the string is too long, we lop off any trailing '10' bytes, * if any. When these are all eliminated we lop off * one additional byte. Thus if we lopped any '10' * we'll be lopping a '11' byte (the first byte of the multibyte sequence), * otherwise we're lopping off an ascii character. * * To test for '10' bytes, we first AND it with * 11000000 (0xc0) so that we get 10000000 (0x80) if and only if * the byte starts with 10. We test for equality.
*/ while (string_length > full_length) { /* need to shorten */ while (string_length > 0 &&
((inString[string_length - 1] & (char)0xc0) == (char)0x80)) { /* lop off '10' byte */
string_length--;
} /* * test string_length in case bad data is received * and string consisted of all '10' bytes, * avoiding any infinite loop
*/ if (string_length) { /* remove either '11' byte or an asci byte */
string_length--;
}
}
PORT_Memset(buffer, ' ', full_length); if (nullTerminate) {
buffer[full_length] = 0;
}
PORT_Memcpy(buffer, inString, string_length); return buffer;
} /* * Configuration utils
*/ static CK_RV
sftk_configure(constchar *man, constchar *libdes)
{
/* make sure the internationalization was done correctly... */ if (man) {
manufacturerID = sftk_setStringName(man, manufacturerID_space, sizeof(manufacturerID_space), PR_TRUE);
} if (libdes) {
libraryDescription = sftk_setStringName(libdes,
libraryDescription_space, sizeof(libraryDescription_space),
PR_TRUE);
}
/* Make sure a given attribute exists. If it doesn't, initialize it to * value and len
*/
CK_RV
sftk_defaultAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type, constvoid *value, unsignedint len)
{ if (!sftk_hasAttribute(object, type)) { return sftk_AddAttributeType(object, type, value, len);
} return CKR_OK;
}
/* * check the consistancy and initialize a Data Object
*/ static CK_RV
sftk_handleDataObject(SFTKSession *session, SFTKObject *object)
{
CK_RV crv;
/* first reject private and token data objects */ if (sftk_isTrue(object, CKA_PRIVATE) || sftk_isTrue(object, CKA_TOKEN)) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
/* now just verify the required date fields */
crv = sftk_defaultAttribute(object, CKA_APPLICATION, NULL, 0); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_VALUE, NULL, 0); if (crv != CKR_OK) return crv;
return CKR_OK;
}
/* * check the consistancy and initialize a Certificate Object
*/ static CK_RV
sftk_handleCertObject(SFTKSession *session, SFTKObject *object)
{
CK_CERTIFICATE_TYPE type;
SFTKAttribute *attribute;
CK_RV crv;
/* certificates must have a type */ if (!sftk_hasAttribute(object, CKA_CERTIFICATE_TYPE)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* we can't store any certs private */ if (sftk_isTrue(object, CKA_PRIVATE)) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
/* We only support X.509 Certs for now */
attribute = sftk_FindAttribute(object, CKA_CERTIFICATE_TYPE); if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE;
type = *(CK_CERTIFICATE_TYPE *)attribute->attrib.pValue;
sftk_FreeAttribute(attribute);
if (type != CKC_X_509) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
/* X.509 Certificate */
/* make sure we have a cert */ if (!sftk_hasAttribute(object, CKA_VALUE)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* in PKCS #11, Subject is a required field */ if (!sftk_hasAttribute(object, CKA_SUBJECT)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* in PKCS #11, Issuer is a required field */ if (!sftk_hasAttribute(object, CKA_ISSUER)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* in PKCS #11, Serial is a required field */ if (!sftk_hasAttribute(object, CKA_SERIAL_NUMBER)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* add it to the object */
object->objectInfo = NULL;
object->infoFree = (SFTKFree)NULL;
/* now just verify the required date fields */
crv = sftk_defaultAttribute(object, CKA_ID, NULL, 0); if (crv != CKR_OK) { return crv;
}
/* * check the consistancy and initialize a Trust Object
*/ static CK_RV
sftk_handleTrustObject(SFTKSession *session, SFTKObject *object)
{ /* we can't store any certs private */ if (sftk_isTrue(object, CKA_PRIVATE)) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
/* certificates must have a type */ if (!sftk_hasAttribute(object, CKA_ISSUER)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_SERIAL_NUMBER)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_CERT_SHA1_HASH)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_CERT_MD5_HASH)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* * check the consistancy and initialize a Trust Object
*/ static CK_RV
sftk_handleSMimeObject(SFTKSession *session, SFTKObject *object)
{
/* we can't store any certs private */ if (sftk_isTrue(object, CKA_PRIVATE)) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
/* certificates must have a type */ if (!sftk_hasAttribute(object, CKA_SUBJECT)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_NSS_EMAIL)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* * check the consistancy and initialize a Trust Object
*/ static CK_RV
sftk_handleCrlObject(SFTKSession *session, SFTKObject *object)
{
/* we can't store any certs private */ if (sftk_isTrue(object, CKA_PRIVATE)) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
/* certificates must have a type */ if (!sftk_hasAttribute(object, CKA_SUBJECT)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_VALUE)) { return CKR_TEMPLATE_INCOMPLETE;
}
switch (key_type) { case CKK_RSA: if (!sftk_hasAttribute(object, CKA_MODULUS)) {
missing_rsa_mod_component++;
} if (!sftk_hasAttribute(object, CKA_PUBLIC_EXPONENT)) {
missing_rsa_exp_component++;
} if (!sftk_hasAttribute(object, CKA_PRIVATE_EXPONENT)) {
missing_rsa_exp_component++;
} if (!sftk_hasAttribute(object, CKA_PRIME_1)) {
missing_rsa_mod_component++;
} if (!sftk_hasAttribute(object, CKA_PRIME_2)) {
missing_rsa_mod_component++;
} if (!sftk_hasAttribute(object, CKA_EXPONENT_1)) {
missing_rsa_crt_component++;
} if (!sftk_hasAttribute(object, CKA_EXPONENT_2)) {
missing_rsa_crt_component++;
} if (!sftk_hasAttribute(object, CKA_COEFFICIENT)) {
missing_rsa_crt_component++;
} if (missing_rsa_mod_component || missing_rsa_exp_component ||
missing_rsa_crt_component) { /* we are missing a component, see if we have enough to rebuild
* the rest */ int have_exp = 2 - missing_rsa_exp_component; int have_component = 5 -
(missing_rsa_exp_component + missing_rsa_mod_component);
if ((have_exp == 0) || (have_component < 3)) { /* nope, not enough to reconstruct the private key */ return CKR_TEMPLATE_INCOMPLETE;
}
fillPrivateKey = PR_TRUE;
} /*verify the parameters for consistency*/
rv = sftk_verifyRSAPrivateKey(object, fillPrivateKey); if (rv != SECSuccess) { return CKR_TEMPLATE_INCOMPLETE;
}
/* make sure Netscape DB attribute is set correctly */
crv = sftk_Attribute2SSecItem(NULL, &mod, object, CKA_MODULUS); if (crv != CKR_OK) return crv;
crv = sftk_forceAttribute(object, CKA_NSS_DB,
sftk_item_expand(&mod)); if (mod.data)
SECITEM_ZfreeItem(&mod, PR_FALSE); if (crv != CKR_OK) return crv;
sign = CK_TRUE;
derive = CK_FALSE; break; case CKK_DSA: if (!sftk_hasAttribute(object, CKA_SUBPRIME)) { return CKR_TEMPLATE_INCOMPLETE;
}
sign = CK_TRUE;
derive = CK_FALSE; /* fall through */ case CKK_DH: if (!sftk_hasAttribute(object, CKA_PRIME)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_BASE)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_VALUE)) { return CKR_TEMPLATE_INCOMPLETE;
} /* allow subprime to be set after the fact */
crv = sftk_defaultAttribute(object, CKA_SUBPRIME, NULL, 0); if (crv != CKR_OK) { return crv;
}
encrypt = CK_FALSE;
recover = CK_FALSE;
wrap = CK_FALSE; break; case CKK_EC: case CKK_EC_EDWARDS: case CKK_EC_MONTGOMERY: if (!sftk_hasAttribute(object, CKA_EC_PARAMS)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_VALUE)) { return CKR_TEMPLATE_INCOMPLETE;
} /* for ECDSA and EDDSA. Change if the structure of any of them is modified. */
derive = (key_type == CKK_EC_EDWARDS) ? CK_FALSE : CK_TRUE; /* CK_TRUE for ECDH */
sign = (key_type == CKK_EC_MONTGOMERY) ? CK_FALSE : CK_TRUE; /* for ECDSA and EDDSA */
encrypt = CK_FALSE;
recover = CK_FALSE;
wrap = CK_FALSE; break; case CKK_NSS_JPAKE_ROUND1: if (!sftk_hasAttribute(object, CKA_PRIME) ||
!sftk_hasAttribute(object, CKA_SUBPRIME) ||
!sftk_hasAttribute(object, CKA_BASE)) { return CKR_TEMPLATE_INCOMPLETE;
} /* fall through */ case CKK_NSS_JPAKE_ROUND2: /* CKA_NSS_JPAKE_SIGNERID and CKA_NSS_JPAKE_PEERID are checked in
the J-PAKE code. */
encrypt = sign = recover = wrap = CK_FALSE;
derive = CK_TRUE;
createObjectInfo = PR_FALSE; break; case CKK_NSS_KYBER: case CKK_NSS_ML_KEM: if (!sftk_hasAttribute(object, CKA_KEY_TYPE)) { return CKR_TEMPLATE_INCOMPLETE;
} if (!sftk_hasAttribute(object, CKA_VALUE)) { return CKR_TEMPLATE_INCOMPLETE;
}
encrypt = sign = recover = wrap = CK_FALSE; break; default: return CKR_ATTRIBUTE_VALUE_INVALID;
}
crv = sftk_defaultAttribute(object, CKA_SUBJECT, NULL, 0); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_SENSITIVE, &cktrue, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_EXTRACTABLE, &cktrue, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_DECRYPT, &encrypt, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_SIGN, &sign, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_SIGN_RECOVER, &recover, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_UNWRAP, &wrap, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_DERIVE, &derive, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv; /* the next two bits get modified only in the key gen and token cases */
crv = sftk_forceAttribute(object, CKA_ALWAYS_SENSITIVE,
&ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_forceAttribute(object, CKA_NEVER_EXTRACTABLE,
&ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
/* should we check the non-token RSA private keys? */
if (!sftk_hasAttribute(object, CKA_VALUE)) { return CKR_TEMPLATE_INCOMPLETE;
} /* the next two bits get modified only in the key gen and token cases */
crv = sftk_forceAttribute(object, CKA_ALWAYS_SENSITIVE,
&ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_forceAttribute(object, CKA_NEVER_EXTRACTABLE,
&ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
/* some types of keys have a value length */
crv = CKR_OK; switch (key_type) { /* force CKA_VALUE_LEN to be set */ case CKK_GENERIC_SECRET: case CKK_RC2: case CKK_RC4: #if NSS_SOFTOKEN_DOES_RC5 case CKK_RC5: #endif #ifdef NSS_SOFTOKEN_DOES_CAST case CKK_CAST: case CKK_CAST3: case CKK_CAST5: #endif #if NSS_SOFTOKEN_DOES_IDEA case CKK_IDEA: #endif
attribute = sftk_FindAttribute(object, CKA_VALUE); /* shouldn't happen */ if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE;
crv = sftk_forceAttribute(object, CKA_VALUE_LEN,
&attribute->attrib.ulValueLen, sizeof(CK_ULONG));
sftk_FreeAttribute(attribute); break; /* force the value to have the correct parity */ case CKK_DES: case CKK_DES2: case CKK_DES3: case CKK_CDMF:
attribute = sftk_FindAttribute(object, CKA_VALUE); /* shouldn't happen */ if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE;
requiredLen = sftk_MapKeySize(key_type); if (attribute->attrib.ulValueLen != requiredLen) {
sftk_FreeAttribute(attribute); return CKR_KEY_SIZE_RANGE;
}
sftk_FormatDESKey((unsignedchar *)attribute->attrib.pValue,
attribute->attrib.ulValueLen);
sftk_FreeAttribute(attribute); break; case CKK_AES:
attribute = sftk_FindAttribute(object, CKA_VALUE); /* shouldn't happen */ if (attribute == NULL) return CKR_TEMPLATE_INCOMPLETE; if (attribute->attrib.ulValueLen != 16 &&
attribute->attrib.ulValueLen != 24 &&
attribute->attrib.ulValueLen != 32) {
sftk_FreeAttribute(attribute); return CKR_KEY_SIZE_RANGE;
}
crv = sftk_forceAttribute(object, CKA_VALUE_LEN,
&attribute->attrib.ulValueLen, sizeof(CK_ULONG));
sftk_FreeAttribute(attribute); break; default: break;
}
return crv;
}
/* * check the consistancy and initialize a Secret Key Object
*/ static CK_RV
sftk_handleSecretKeyObject(SFTKSession *session, SFTKObject *object,
CK_KEY_TYPE key_type, PRBool isFIPS)
{
CK_RV crv;
/* First validate and set defaults */
crv = validateSecretKey(session, object, key_type, isFIPS); if (crv != CKR_OK) goto loser;
/* If the object is a TOKEN object, store in the database */ if (sftk_isTrue(object, CKA_TOKEN)) {
SFTKSlot *slot = session->slot;
SFTKDBHandle *keyHandle = sftk_getKeyDB(slot);
if (keyHandle == NULL) { return CKR_TOKEN_WRITE_PROTECTED;
}
/* * check the consistancy and initialize a Key Object
*/ static CK_RV
sftk_handleKeyObject(SFTKSession *session, SFTKObject *object)
{
SFTKAttribute *attribute;
CK_KEY_TYPE key_type;
CK_BBOOL ckfalse = CK_FALSE;
CK_RV crv;
/* verify the required fields */ if (!sftk_hasAttribute(object, CKA_KEY_TYPE)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* now verify the common fields */
crv = sftk_defaultAttribute(object, CKA_ID, NULL, 0); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_START_DATE, NULL, 0); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_END_DATE, NULL, 0); if (crv != CKR_OK) return crv; /* CKA_DERIVE is common to all keys, but it's default value is
* key dependent */
crv = sftk_defaultAttribute(object, CKA_LOCAL, &ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
/* get the key type */
attribute = sftk_FindAttribute(object, CKA_KEY_TYPE); if (!attribute) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
sftk_FreeAttribute(attribute);
switch (object->objclass) { case CKO_PUBLIC_KEY: return sftk_handlePublicKeyObject(session, object, key_type); case CKO_PRIVATE_KEY: return sftk_handlePrivateKeyObject(session, object, key_type); case CKO_SECRET_KEY: /* make sure the required fields exist */ return sftk_handleSecretKeyObject(session, object, key_type,
(PRBool)(sftk_isFIPS(session->slot->slotID))); default: break;
} return CKR_ATTRIBUTE_VALUE_INVALID;
}
/* * check the consistancy and Verify a DSA Parameter Object
*/ static CK_RV
sftk_handleDSAParameterObject(SFTKSession *session, SFTKObject *object)
{
SFTKAttribute *primeAttr = NULL;
SFTKAttribute *subPrimeAttr = NULL;
SFTKAttribute *baseAttr = NULL;
SFTKAttribute *seedAttr = NULL;
SFTKAttribute *hAttr = NULL;
SFTKAttribute *attribute;
CK_RV crv = CKR_TEMPLATE_INCOMPLETE;
PQGParams params;
PQGVerify vfy, *verify = NULL;
SECStatus result, rv; /* This bool keeps track of whether or not we need verify parameters. * If a P, Q and G or supplied, we dont' need verify parameters, as we * have PQ and G. * - If G is not supplied, the presumption is that we want to * verify P and Q only. * - If counter is supplied, it is presumed we want to verify PQ because * the counter is only used in verification. * - If H is supplied, is is presumed we want to verify G because H is * only used to verify G. * - Any verification step must have the SEED (counter or H could be * missing depending on exactly what we want to verify). If SEED is supplied, * the code just goes ahead and runs verify (other errors are parameter * errors are detected by the PQG_VerifyParams function). If SEED is not * supplied, but we determined that we are trying to verify (because needVfy * is set, go ahead and return CKR_TEMPLATE_INCOMPLETE.
*/
PRBool needVfy = PR_FALSE;
loser: if (hAttr)
sftk_FreeAttribute(hAttr); if (seedAttr)
sftk_FreeAttribute(seedAttr); if (baseAttr)
sftk_FreeAttribute(baseAttr); if (subPrimeAttr)
sftk_FreeAttribute(subPrimeAttr); if (primeAttr)
sftk_FreeAttribute(primeAttr);
return crv;
}
/* * check the consistancy and initialize a Key Parameter Object
*/ static CK_RV
sftk_handleKeyParameterObject(SFTKSession *session, SFTKObject *object)
{
SFTKAttribute *attribute;
CK_KEY_TYPE key_type;
CK_BBOOL ckfalse = CK_FALSE;
CK_RV crv;
/* verify the required fields */ if (!sftk_hasAttribute(object, CKA_KEY_TYPE)) { return CKR_TEMPLATE_INCOMPLETE;
}
/* now verify the common fields */
crv = sftk_defaultAttribute(object, CKA_LOCAL, &ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
/* get the key type */
attribute = sftk_FindAttribute(object, CKA_KEY_TYPE); if (!attribute) { return CKR_ATTRIBUTE_VALUE_INVALID;
}
key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
sftk_FreeAttribute(attribute);
switch (key_type) { case CKK_DSA: return sftk_handleDSAParameterObject(session, object);
/* * Handle Object does all the object consistancy checks, automatic attribute * generation, attribute defaulting, etc. If handleObject succeeds, the object * will be assigned an object handle, and the object installed in the session * or stored in the DB.
*/
CK_RV
sftk_handleObject(SFTKObject *object, SFTKSession *session)
{
SFTKSlot *slot = session->slot;
SFTKAttribute *attribute;
CK_BBOOL ckfalse = CK_FALSE;
CK_BBOOL cktrue = CK_TRUE;
PRBool isLoggedIn, needLogin;
CK_RV crv;
/* make sure all the base object types are defined. If not set the
* defaults */
crv = sftk_defaultAttribute(object, CKA_TOKEN, &ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_PRIVATE, &ckfalse, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_LABEL, NULL, 0); if (crv != CKR_OK) return crv;
crv = sftk_defaultAttribute(object, CKA_MODIFIABLE, &cktrue, sizeof(CK_BBOOL)); if (crv != CKR_OK) return crv;
/* don't create a private object if we aren't logged in */ if (!isLoggedIn && needLogin && sftk_isTrue(object, CKA_PRIVATE)) { return CKR_USER_NOT_LOGGED_IN;
}
/* Assign a unique SESSION object handle to every new object, * whether it is a session object or a token object. * At this point, all new objects are structured as session objects. * Objects with the CKA_TOKEN attribute true will be turned into * token objects and will have a token object handle assigned to * them by a call to sftk_mkHandle in the handler for each object * class, invoked below. * * It may be helpful to note/remember that * sftk_narrowToXxxObject uses sftk_isToken, * sftk_isToken examines the sign bit of the object's handle, but * sftk_isTrue(...,CKA_TOKEN) examines the CKA_TOKEN attribute.
*/
object->handle = sftk_getNextHandle(slot);
/* get the object class */
attribute = sftk_FindAttribute(object, CKA_CLASS); if (attribute == NULL) { return CKR_TEMPLATE_INCOMPLETE;
}
object->objclass = *(CK_OBJECT_CLASS *)attribute->attrib.pValue;
sftk_FreeAttribute(attribute);
/* Now handle the specific object class. * At this point, all objects are session objects, and the session * number must be passed to the object class handlers.
*/ switch (object->objclass) { case CKO_DATA:
crv = sftk_handleDataObject(session, object); break; case CKO_CERTIFICATE:
crv = sftk_handleCertObject(session, object); break; case CKO_NSS_TRUST:
crv = sftk_handleTrustObject(session, object); break; case CKO_NSS_CRL:
crv = sftk_handleCrlObject(session, object); break; case CKO_NSS_SMIME:
crv = sftk_handleSMimeObject(session, object); break; case CKO_PRIVATE_KEY: case CKO_PUBLIC_KEY: case CKO_SECRET_KEY:
crv = sftk_handleKeyObject(session, object); break; case CKO_DOMAIN_PARAMETERS:
crv = sftk_handleKeyParameterObject(session, object); break; default:
crv = CKR_ATTRIBUTE_VALUE_INVALID; break;
}
/* can't fail from here on out unless the pk_handlXXX functions have
* failed the request */ if (crv != CKR_OK) { return crv;
}
/* Now link the object into the slot and session structures. * If the object has a true CKA_TOKEN attribute, the above object * class handlers will have set the sign bit in the object handle, * causing the following test to be true.
*/ if (sftk_isToken(object->handle)) {
sftk_convertSessionToToken(object);
} else {
object->slot = slot;
sftk_AddObject(session, object);
}
return CKR_OK;
}
/* * ******************** Public Key Utilities ***************************
*/ /* Generate a low public key structure from an object */
NSSLOWKEYPublicKey *
sftk_GetPubKey(SFTKObject *object, CK_KEY_TYPE key_type,
CK_RV *crvp)
{
NSSLOWKEYPublicKey *pubKey;
PLArenaPool *arena;
CK_RV crv;
/* fill in the structure */
pubKey->arena = arena; switch (key_type) { case CKK_RSA:
pubKey->keyType = NSSLOWKEYRSAKey;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.rsa.modulus,
object, CKA_MODULUS); if (crv != CKR_OK) break;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.rsa.publicExponent,
object, CKA_PUBLIC_EXPONENT); break; case CKK_DSA:
pubKey->keyType = NSSLOWKEYDSAKey;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.dsa.params.prime,
object, CKA_PRIME); if (crv != CKR_OK) break;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.dsa.params.subPrime,
object, CKA_SUBPRIME); if (crv != CKR_OK) break;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.dsa.params.base,
object, CKA_BASE); if (crv != CKR_OK) break;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.dsa.publicValue,
object, CKA_VALUE); break; case CKK_DH:
pubKey->keyType = NSSLOWKEYDHKey;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.dh.prime,
object, CKA_PRIME); if (crv != CKR_OK) break;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.dh.base,
object, CKA_BASE); if (crv != CKR_OK) break;
crv = sftk_Attribute2SSecItem(arena, &pubKey->u.dh.publicValue,
object, CKA_VALUE); break; case CKK_EC_EDWARDS: case CKK_EC_MONTGOMERY: case CKK_EC:
pubKey->keyType = NSSLOWKEYECKey;
crv = sftk_Attribute2SSecItem(arena,
&pubKey->u.ec.ecParams.DEREncoding,
object, CKA_EC_PARAMS); if (crv != CKR_OK) break;
/* Fill out the rest of the ecParams structure * based on the encoded params
*/ if (EC_FillParams(arena, &pubKey->u.ec.ecParams.DEREncoding,
&pubKey->u.ec.ecParams) != SECSuccess) {
crv = CKR_DOMAIN_PARAMS_INVALID; break;
}
/* special note: We can't just use the first byte to distinguish * between EC_POINT_FORM_UNCOMPRESSED and SEC_ASN1_OCTET_STRING.
* Both are 0x04. */
/* Handle the non-DER encoded case. * Some curves are always pressumed to be non-DER.
*/ if (pubKey->u.ec.ecParams.type != ec_params_named ||
(pubKey->u.ec.publicValue.len == keyLen &&
pubKey->u.ec.publicValue.data[0] == EC_POINT_FORM_UNCOMPRESSED)) { break; /* key was not DER encoded, no need to unwrap */
}
/* handle the encoded case */ if ((pubKey->u.ec.publicValue.data[0] == SEC_ASN1_OCTET_STRING) &&
pubKey->u.ec.publicValue.len > keyLen) {
SECItem publicValue;
SECStatus rv;
rv = SEC_QuickDERDecodeItem(arena, &publicValue,
SEC_ASN1_GET(SEC_OctetStringTemplate),
&pubKey->u.ec.publicValue); /* nope, didn't decode correctly */ if ((rv != SECSuccess) || (publicValue.len != keyLen)) {
crv = CKR_ATTRIBUTE_VALUE_INVALID; break;
} /* we don't handle compressed points except in the case of ECCurve25519 */ if (publicValue.data[0] != EC_POINT_FORM_UNCOMPRESSED) {
crv = CKR_ATTRIBUTE_VALUE_INVALID; break;
} /* replace our previous with the decoded key */
pubKey->u.ec.publicValue = publicValue; break;
}
crv = CKR_ATTRIBUTE_VALUE_INVALID;
} break; case CKK_NSS_KYBER: case CKK_NSS_ML_KEM:
crv = CKR_OK; break; default:
crv = CKR_KEY_TYPE_INCONSISTENT; break;
}
*crvp = crv; if (crv != CKR_OK) {
PORT_FreeArena(arena, PR_TRUE); return NULL;
}
case CKK_DSA:
privKey->keyType = NSSLOWKEYDSAKey;
SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
&privKey->u.dsa.params.prime, CKA_PRIME);
itemTemplateCount++;
SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
&privKey->u.dsa.params.subPrime, CKA_SUBPRIME);
itemTemplateCount++;
SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
&privKey->u.dsa.params.base, CKA_BASE);
itemTemplateCount++;
SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
&privKey->u.dsa.privateValue, CKA_VALUE);
itemTemplateCount++; /* privKey was zero'd so public value is already set to NULL, 0
* if we don't set it explicitly */ break;
case CKK_DH:
privKey->keyType = NSSLOWKEYDHKey;
SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
&privKey->u.dh.prime, CKA_PRIME);
itemTemplateCount++;
SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
&privKey->u.dh.base, CKA_BASE);
itemTemplateCount++;
SFTK_SET_ITEM_TEMPLATE(itemTemplate, itemTemplateCount,
&privKey->u.dh.privateValue, CKA_VALUE);
itemTemplateCount++; /* privKey was zero'd so public value is already set to NULL, 0
* if we don't set it explicitly */ break; case CKK_EC_EDWARDS: case CKK_EC_MONTGOMERY: case CKK_EC:
privKey->keyType = NSSLOWKEYECKey;
crv = sftk_Attribute2SSecItem(arena,
&privKey->u.ec.ecParams.DEREncoding,
object, CKA_EC_PARAMS); if (crv != CKR_OK) break;
/* Fill out the rest of the ecParams structure * based on the encoded params
*/ if (EC_FillParams(arena, &privKey->u.ec.ecParams.DEREncoding,
&privKey->u.ec.ecParams) != SECSuccess) {
crv = CKR_DOMAIN_PARAMS_INVALID; break;
}
crv = sftk_Attribute2SSecItem(arena, &privKey->u.ec.privateValue,
object, CKA_VALUE); if (crv != CKR_OK) break;
if (sftk_hasAttribute(object, CKA_NSS_DB)) {
crv = sftk_Attribute2SSecItem(arena, &privKey->u.ec.publicValue,
object, CKA_NSS_DB); if (crv != CKR_OK) { break;
} /* privKey was zero'd so public value is already set to NULL, 0
* if we don't set it explicitly */
} elseif (key_type == CKK_EC) { /* as no public key was provided during the import, we need to derive it here.
See: PK11_ImportAndReturnPrivateKey*/
(void)SECITEM_AllocItem(arena, &privKey->u.ec.publicValue, EC_GetPointSize(&privKey->u.ec.ecParams));
rv = EC_DerivePublicKey(&privKey->u.ec.privateValue, &privKey->u.ec.ecParams, &privKey->u.ec.publicValue); if (rv != SECSuccess) { break;
}
sftk_forceAttribute(object, CKA_NSS_DB, privKey->u.ec.publicValue.data, privKey->u.ec.publicValue.len);
}
rv = DER_SetUInteger(privKey->arena, &privKey->u.ec.version,
NSSLOWKEY_EC_PRIVATE_KEY_VERSION); if (rv != SECSuccess) {
crv = CKR_HOST_MEMORY; /* The following ifdef is needed for Linux arm distros and * Android as gcc 4.6 has a bug when targeting arm (but not * thumb). The bug has been fixed in gcc 4.7. * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=56561
*/ #ifdefined(__arm__) && !defined(__thumb__) && defined(__GNUC__)
*crvp = CKR_HOST_MEMORY; break; #endif
} break;
/* * If a partial RSA private key is present, fill in the rest if necessary, * and then verify the parameters are well-formed
*/ static SECStatus
sftk_verifyRSAPrivateKey(SFTKObject *object, PRBool fillIfNeeded)
{
RSAPrivateKey tmpKey = { 0 };
SFTKAttribute *modulus = NULL;
SFTKAttribute *prime1 = NULL;
SFTKAttribute *prime2 = NULL;
SFTKAttribute *privateExponent = NULL;
SFTKAttribute *publicExponent = NULL;
SFTKAttribute *exponent1 = NULL;
SFTKAttribute *exponent2 = NULL;
SFTKAttribute *coefficient = NULL;
SECStatus rv;
CK_RV crv;
/* first fill in the components that we have. Populate only uses
* the non-crt components, so only fill those in */
tmpKey.arena = NULL;
modulus = sftk_FindAttribute(object, CKA_MODULUS); if (modulus) {
tmpKey.modulus.data = modulus->attrib.pValue;
tmpKey.modulus.len = modulus->attrib.ulValueLen;
}
prime1 = sftk_FindAttribute(object, CKA_PRIME_1); if (prime1) {
tmpKey.prime1.data = prime1->attrib.pValue;
tmpKey.prime1.len = prime1->attrib.ulValueLen;
}
prime2 = sftk_FindAttribute(object, CKA_PRIME_2); if (prime2) {
tmpKey.prime2.data = prime2->attrib.pValue;
tmpKey.prime2.len = prime2->attrib.ulValueLen;
}
privateExponent = sftk_FindAttribute(object, CKA_PRIVATE_EXPONENT); if (privateExponent) {
tmpKey.privateExponent.data = privateExponent->attrib.pValue;
tmpKey.privateExponent.len = privateExponent->attrib.ulValueLen;
}
publicExponent = sftk_FindAttribute(object, CKA_PUBLIC_EXPONENT); if (publicExponent) {
tmpKey.publicExponent.data = publicExponent->attrib.pValue;
tmpKey.publicExponent.len = publicExponent->attrib.ulValueLen;
}
exponent1 = sftk_FindAttribute(object, CKA_EXPONENT_1); if (exponent1) {
tmpKey.exponent1.data = exponent1->attrib.pValue;
tmpKey.exponent1.len = exponent1->attrib.ulValueLen;
}
exponent2 = sftk_FindAttribute(object, CKA_EXPONENT_2); if (exponent2) {
tmpKey.exponent2.data = exponent2->attrib.pValue;
tmpKey.exponent2.len = exponent2->attrib.ulValueLen;
}
coefficient = sftk_FindAttribute(object, CKA_COEFFICIENT); if (coefficient) {
tmpKey.coefficient.data = coefficient->attrib.pValue;
tmpKey.coefficient.len = coefficient->attrib.ulValueLen;
}
if (fillIfNeeded) { /* * populate requires one exponent plus 2 other components to work. * we expected our caller to check that first. If that didn't happen, * populate will simply return an error here.
*/
rv = RSA_PopulatePrivateKey(&tmpKey); if (rv != SECSuccess) { goto loser;
}
}
rv = RSA_PrivateKeyCheck(&tmpKey); if (rv != SECSuccess) { goto loser;
} /* now that we have a fully populated key, set all our attribute values */
rv = SECFailure; if (!modulus || modulus->attrib.pValue != tmpKey.modulus.data) {
crv = sftk_forceAttribute(object, CKA_MODULUS,
sftk_item_expand(&tmpKey.modulus)); if (crv != CKR_OK) goto loser;
} if (!publicExponent ||
publicExponent->attrib.pValue != tmpKey.publicExponent.data) {
crv = sftk_forceAttribute(object, CKA_PUBLIC_EXPONENT,
sftk_item_expand(&tmpKey.publicExponent)); if (crv != CKR_OK) goto loser;
} if (!privateExponent ||
privateExponent->attrib.pValue != tmpKey.privateExponent.data) {
crv = sftk_forceAttribute(object, CKA_PRIVATE_EXPONENT,
sftk_item_expand(&tmpKey.privateExponent)); if (crv != CKR_OK) goto loser;
} if (!prime1 || prime1->attrib.pValue != tmpKey.prime1.data) {
crv = sftk_forceAttribute(object, CKA_PRIME_1,
sftk_item_expand(&tmpKey.prime1)); if (crv != CKR_OK) goto loser;
} if (!prime2 || prime2->attrib.pValue != tmpKey.prime2.data) {
crv = sftk_forceAttribute(object, CKA_PRIME_2,
sftk_item_expand(&tmpKey.prime2)); if (crv != CKR_OK) goto loser;
} if (!exponent1 || exponent1->attrib.pValue != tmpKey.exponent1.data) {
crv = sftk_forceAttribute(object, CKA_EXPONENT_1,
sftk_item_expand(&tmpKey.exponent1)); if (crv != CKR_OK) goto loser;
} if (!exponent2 || exponent2->attrib.pValue != tmpKey.exponent2.data) {
crv = sftk_forceAttribute(object, CKA_EXPONENT_2,
sftk_item_expand(&tmpKey.exponent2)); if (crv != CKR_OK) goto loser;
} if (!coefficient || coefficient->attrib.pValue != tmpKey.coefficient.data) {
crv = sftk_forceAttribute(object, CKA_COEFFICIENT,
sftk_item_expand(&tmpKey.coefficient)); if (crv != CKR_OK) goto loser;
}
rv = SECSuccess;
/* we're done (one way or the other), clean up all our stuff */
loser: if (tmpKey.arena) {
PORT_FreeArena(tmpKey.arena, PR_TRUE);
} if (modulus) {
sftk_FreeAttribute(modulus);
} if (prime1) {
sftk_FreeAttribute(prime1);
} if (prime2) {
sftk_FreeAttribute(prime2);
} if (privateExponent) {
sftk_FreeAttribute(privateExponent);
} if (publicExponent) {
sftk_FreeAttribute(publicExponent);
} if (exponent1) {
sftk_FreeAttribute(exponent1);
} if (exponent2) {
sftk_FreeAttribute(exponent2);
} if (coefficient) {
sftk_FreeAttribute(coefficient);
} return rv;
}
/* Generate a low private key structure from an object */
NSSLOWKEYPrivateKey *
sftk_GetPrivKey(SFTKObject *object, CK_KEY_TYPE key_type, CK_RV *crvp)
{
NSSLOWKEYPrivateKey *priv = NULL;
/* populate a public key object from a lowpublic keys structure */
CK_RV
sftk_PutPubKey(SFTKObject *publicKey, SFTKObject *privateKey, CK_KEY_TYPE keyType, NSSLOWKEYPublicKey *pubKey)
{
CK_OBJECT_CLASS classType = CKO_PUBLIC_KEY;
CK_BBOOL cktrue = CK_TRUE;
CK_RV crv = CKR_OK;
sftk_DeleteAttributeType(publicKey, CKA_CLASS);
sftk_DeleteAttributeType(publicKey, CKA_KEY_TYPE);
sftk_DeleteAttributeType(publicKey, CKA_VALUE);
switch (keyType) { case CKK_RSA:
sftk_DeleteAttributeType(publicKey, CKA_MODULUS);
sftk_DeleteAttributeType(publicKey, CKA_PUBLIC_EXPONENT); /* format the keys */ /* fill in the RSA dependent paramenters in the public key */
crv = sftk_AddAttributeType(publicKey, CKA_MODULUS,
sftk_item_expand(&pubKey->u.rsa.modulus)); if (crv != CKR_OK) { break;
}
crv = sftk_AddAttributeType(publicKey, CKA_PUBLIC_EXPONENT,
sftk_item_expand(&pubKey->u.rsa.publicExponent)); break; case CKK_DSA:
sftk_DeleteAttributeType(publicKey, CKA_PRIME);
sftk_DeleteAttributeType(publicKey, CKA_SUBPRIME);
sftk_DeleteAttributeType(publicKey, CKA_BASE);
crv = sftk_AddAttributeType(publicKey, CKA_PRIME,
sftk_item_expand(&pubKey->u.dsa.params.prime)); if (crv != CKR_OK) { break;
}
crv = sftk_AddAttributeType(publicKey, CKA_SUBPRIME,
sftk_item_expand(&pubKey->u.dsa.params.subPrime)); if (crv != CKR_OK) { break;
}
crv = sftk_AddAttributeType(publicKey, CKA_BASE,
sftk_item_expand(&pubKey->u.dsa.params.base)); if (crv != CKR_OK) { break;
}
crv = sftk_AddAttributeType(publicKey, CKA_VALUE,
sftk_item_expand(&pubKey->u.dsa.publicValue)); break; case CKK_DH:
sftk_DeleteAttributeType(publicKey, CKA_PRIME);
sftk_DeleteAttributeType(publicKey, CKA_BASE);
crv = sftk_AddAttributeType(publicKey, CKA_PRIME,
sftk_item_expand(&pubKey->u.dh.prime)); if (crv != CKR_OK) { break;
}
crv = sftk_AddAttributeType(publicKey, CKA_BASE,
sftk_item_expand(&pubKey->u.dh.base)); if (crv != CKR_OK) { break;
}
crv = sftk_AddAttributeType(publicKey, CKA_VALUE,
sftk_item_expand(&pubKey->u.dh.publicValue)); break; case CKK_EC: case CKK_EC_MONTGOMERY: case CKK_EC_EDWARDS:
sftk_DeleteAttributeType(publicKey, CKA_EC_PARAMS);
sftk_DeleteAttributeType(publicKey, CKA_EC_POINT);
crv = sftk_AddAttributeType(publicKey, CKA_EC_PARAMS,
sftk_item_expand(&pubKey->u.ec.ecParams.DEREncoding)); if (crv != CKR_OK) { break;
}
crv = sftk_AddAttributeType(publicKey, CKA_EC_POINT,
sftk_item_expand(&pubKey->u.ec.publicValue)); break; default: return CKR_KEY_TYPE_INCONSISTENT;
} if (crv != CKR_OK) { return crv;
}
crv = sftk_AddAttributeType(publicKey, CKA_CLASS, &classType, sizeof(CK_OBJECT_CLASS)); if (crv != CKR_OK) { return crv;
}
crv = sftk_AddAttributeType(publicKey, CKA_KEY_TYPE, &keyType, sizeof(CK_KEY_TYPE)); if (crv != CKR_OK) { return crv;
} /* now handle the operator attributes */ if (sftk_isTrue(privateKey, CKA_DECRYPT)) {
crv = sftk_forceAttribute(publicKey, CKA_ENCRYPT, &cktrue, sizeof(CK_BBOOL)); if (crv != CKR_OK) { return crv;
}
} if (sftk_isTrue(privateKey, CKA_SIGN)) {
crv = sftk_forceAttribute(publicKey, CKA_VERIFY, &cktrue, sizeof(CK_BBOOL)); if (crv != CKR_OK) { return crv;
}
} if (sftk_isTrue(privateKey, CKA_SIGN_RECOVER)) {
crv = sftk_forceAttribute(publicKey, CKA_VERIFY_RECOVER, &cktrue, sizeof(CK_BBOOL)); if (crv != CKR_OK) { return crv;
}
} if (sftk_isTrue(privateKey, CKA_DERIVE)) {
crv = sftk_forceAttribute(publicKey, CKA_DERIVE, &cktrue, sizeof(CK_BBOOL)); if (crv != CKR_OK) { return crv;
}
} return crv;
}
/* **************************** Symetric Key utils ************************
*/ /* * set the DES key with parity bits correctly
*/ void
sftk_FormatDESKey(unsignedchar *key, int length)
{ int i;
/* format the des key */ for (i = 0; i < length; i++) {
key[i] = parityTable[key[i] >> 1];
}
}
/* * check a des key (des2 or des3 subkey) for weak keys.
*/
PRBool
sftk_CheckDESKey(unsignedchar *key)
{ int i;
/* format the des key with parity */
sftk_FormatDESKey(key, 8);
for (i = 0; i < sftk_desWeakTableSize; i++) { if (PORT_Memcmp(key, sftk_desWeakTable[i], 8) == 0) { return PR_TRUE;
}
} return PR_FALSE;
}
/* * check if a des or triple des key is weak.
*/
PRBool
sftk_IsWeakKey(unsignedchar *key, CK_KEY_TYPE key_type)
{
switch (key_type) { case CKK_DES: return sftk_CheckDESKey(key); case CKM_DES2_KEY_GEN: if (sftk_CheckDESKey(key)) return PR_TRUE; return sftk_CheckDESKey(&key[8]); case CKM_DES3_KEY_GEN: if (sftk_CheckDESKey(key)) return PR_TRUE; if (sftk_CheckDESKey(&key[8])) return PR_TRUE; return sftk_CheckDESKey(&key[16]); default: break;
} return PR_FALSE;
}
/********************************************************************** * * Start of PKCS 11 functions *
**********************************************************************/
/* return the function list */
CK_RV
NSC_GetFunctionList(CK_FUNCTION_LIST_PTR *pFunctionList)
{
*pFunctionList = (CK_FUNCTION_LIST_PTR)&sftk_funcList_v2; return CKR_OK;
}
/* return the function list */
CK_RV
C_GetFunctionList(CK_FUNCTION_LIST_PTR *pFunctionList)
{ #ifdef NSS_FIPS_DISABLED return NSC_GetFunctionList(pFunctionList); #else if (NSS_GetSystemFIPSEnabled()) { return FC_GetFunctionList(pFunctionList);
} else { return NSC_GetFunctionList(pFunctionList);
} #endif
}
/* * eventually I'd like to expunge all occurances of XXX_SLOT_ID and * just go with the info in the slot. This is one place, however, * where it might be a little difficult.
*/ constchar *
sftk_getDefTokName(CK_SLOT_ID slotID)
{ staticchar buf[33];
switch (slotID) { case NETSCAPE_SLOT_ID: return"NSS Generic Crypto Services "; case PRIVATE_KEY_SLOT_ID: return"NSS Certificate DB "; case FIPS_SLOT_ID: return"NSS FIPS 140-2 Certificate DB "; default: break;
}
snprintf(buf, sizeof(buf), "NSS Application Token %08x ", (unsignedint)slotID); return buf;
}
/* look up a slot structure from the ID (used to be a macro when we only
* had two slots) */ /* if all is true, return the slot even if it has been 'unloaded' */ /* if all is false, only return the slots which are present */
SFTKSlot *
sftk_SlotFromID(CK_SLOT_ID slotID, PRBool all)
{
SFTKSlot *slot; unsignedint index = sftk_GetModuleIndex(slotID);
/* * ths function has all the common initialization that happens whenever we * create a new slot or repurpose an old slot (only valid for slotID's 4 * and greater). * * things that are not reinitialized are: * slotID (can't change) * slotDescription (can't change once defined) * the locks and hash tables (difficult to change in running code, and * unnecessary. hash tables and list are cleared on shutdown, but they * are cleared in a 'friendly' way). * session and object ID counters -- so any old sessions and objects in the * application will get properly notified that the world has changed. * * things that are reinitialized: * database (otherwise what would the point be;). * state variables related to databases. * session count stat info. * tokenDescription. * * NOTE: slotID's 4 and greater show up as removable devices. *
*/
CK_RV
SFTK_SlotReInit(SFTKSlot *slot, char *configdir, char *updatedir, char *updateID, sftk_token_parameters *params, unsignedint moduleIndex)
{
PRBool needLogin = !params->noKeyDB;
CK_RV crv;
slot->certDB = certHandle;
slot->keyDB = keyHandle;
} if (needLogin) { /* if the data base is initialized with a null password,remember that */
slot->needLogin =
(PRBool)!sftk_hasNullPassword(slot, slot->keyDB); if ((params->minPW >= 0) && (params->minPW <= SFTK_MAX_PIN)) {
slot->minimumPinLen = params->minPW;
} if ((slot->minimumPinLen == 0) && (params->pwRequired)) {
slot->minimumPinLen = 1;
} /* Make sure the pin len is set to the Minimum allowed value for fips * when in FIPS mode. NOTE: we don't set it if the database has not * been initialized yet so that we can init into level1 mode if needed
*/ if ((sftkdb_HasPasswordSet(slot->keyDB) == SECSuccess) &&
(moduleIndex == NSC_FIPS_MODULE) &&
(slot->minimumPinLen < FIPS_MIN_PIN)) {
slot->minimumPinLen = FIPS_MIN_PIN;
}
}
slot->present = PR_TRUE; return CKR_OK;
loser:
SFTK_ShutdownSlot(slot); return crv;
}
/* * initialize one of the slot structures. figure out which by the ID
*/
CK_RV
SFTK_SlotInit(char *configdir, char *updatedir, char *updateID,
sftk_token_parameters *params, unsignedint moduleIndex)
{ unsignedint i;
CK_SLOT_ID slotID = params->slotID;
SFTKSlot *slot;
CK_RV crv = CKR_HOST_MEMORY;
/* * first we initialize everything that is 'permanent' with this slot. * that is everything we aren't going to shutdown if we close this slot
* and open it up again with different databases */
/* first log out the card */ /* special case - if we are in a middle of upgrade, we want to close the * sessions to fake a token removal to tell the upper level code we have * switched from one database to another, but we don't want to * explicity logout in case we can continue the upgrade with the * existing password if possible.
*/ if (logout) {
handle = sftk_getKeyDB(slot);
SKIP_AFTER_FORK(PZ_Lock(slot->slotLock));
slot->isLoggedIn = PR_FALSE; if (slot->needLogin && handle) {
sftkdb_ClearPassword(handle);
}
SKIP_AFTER_FORK(PZ_Unlock(slot->slotLock)); if (handle) {
sftk_freeDB(handle);
}
}
/* now close all the current sessions */ /* NOTE: If you try to open new sessions before NSC_CloseAllSessions * completes, some of those new sessions may or may not be closed by * NSC_CloseAllSessions... but any session running when this code starts
* will guarrenteed be close, and no session will be partially closed */ for (i = 0; i < slot->sessHashSize; i++) {
PZLock *lock = SFTK_SESSION_LOCK(slot, i); do {
SKIP_AFTER_FORK(PZ_Lock(lock));
session = slot->head[i]; /* hand deque */ /* this duplicates function of NSC_close session functions, but * because we know that we are freeing all the sessions, we can
* do more efficient processing */ if (session) {
slot->head[i] = session->next; if (session->next)
session->next->prev = NULL;
session->next = session->prev = NULL;
SKIP_AFTER_FORK(PZ_Unlock(lock));
SKIP_AFTER_FORK(PZ_Lock(slot->slotLock));
--slot->sessionCount;
SKIP_AFTER_FORK(PZ_Unlock(slot->slotLock)); if (session->info.flags & CKF_RW_SESSION) {
(void)PR_ATOMIC_DECREMENT(&slot->rwSessionCount);
}
} else {
SKIP_AFTER_FORK(PZ_Unlock(lock));
} if (session) {
sftk_DestroySession(session);
}
} while (session != NULL);
} return CKR_OK;
}
/* * shut down the databases. * we get the slot lock (which also protects slot->certDB and slot->keyDB) * and clear the values so the new users will not find the databases. * once things are clear, we can release our references to the databases. * The databases will close when the last reference is released. * * We use reference counts so that we don't crash if someone shuts down * a token that another thread is actively using.
*/ staticvoid
sftk_DBShutdown(SFTKSlot *slot)
{
SFTKDBHandle *certHandle;
SFTKDBHandle *keyHandle;
SKIP_AFTER_FORK(PZ_Lock(slot->slotLock));
certHandle = slot->certDB;
slot->certDB = NULL;
keyHandle = slot->keyDB;
slot->keyDB = NULL;
SKIP_AFTER_FORK(PZ_Unlock(slot->slotLock)); if (certHandle) {
sftk_freeDB(certHandle);
} if (keyHandle) {
sftk_freeDB(keyHandle);
}
}
CK_RV
SFTK_ShutdownSlot(SFTKSlot *slot)
{ /* make sure no new PK11 calls work except C_GetSlotInfo */
slot->present = PR_FALSE;
/* close all outstanding sessions * the sessHashSize variable guarentees we have all the session
* mechanism set up */ if (slot->head) {
sftk_CloseAllSessions(slot, PR_TRUE);
}
/* clear all objects.. session objects are cleared as a result of * closing all the sessions. We just need to clear the token object * cache. slot->tokObjHashTable guarentees we have the token
* infrastructure set up. */ if (slot->tokObjHashTable) {
SFTK_ClearTokenKeyHashTable(slot);
}
/* clear the slot description for the next guy */
PORT_Memset(slot->tokDescription, 0, sizeof(slot->tokDescription));
/* now shut down the databases. */
sftk_DBShutdown(slot); return CKR_OK;
}
/* * initialize one of the slot structures. figure out which by the ID
*/
CK_RV
SFTK_DestroySlotData(SFTKSlot *slot)
{ unsignedint i;
SFTK_ShutdownSlot(slot);
sftk_ClearSession(&slot->moduleObjects);
if (slot->tokObjHashTable) {
PL_HashTableDestroy(slot->tokObjHashTable);
slot->tokObjHashTable = NULL;
}
/* OK everything has been disassembled, now we can finally get rid
* of the locks */
SKIP_AFTER_FORK(PZ_DestroyLock(slot->slotLock));
slot->slotLock = NULL; if (slot->sessionLock) { for (i = 0; i < slot->numSessionLocks; i++) { if (slot->sessionLock[i]) {
SKIP_AFTER_FORK(PZ_DestroyLock(slot->sessionLock[i]));
slot->sessionLock[i] = NULL;
}
}
PORT_Free(slot->sessionLock);
slot->sessionLock = NULL;
} if (slot->objectLock) {
SKIP_AFTER_FORK(PZ_DestroyLock(slot->objectLock));
slot->objectLock = NULL;
} if (slot->pwCheckLock) {
SKIP_AFTER_FORK(PR_DestroyLock(slot->pwCheckLock));
slot->pwCheckLock = NULL;
}
PORT_Free(slot); return CKR_OK;
}
switch (function) { case SECMOD_MODULE_DB_FUNCTION_FIND: if (secmod == NULL) {
PORT_SetError(SEC_ERROR_INVALID_ARGS); goto loser;
} if (rw && (dbType != NSS_DB_TYPE_LEGACY) &&
(dbType != NSS_DB_TYPE_MULTIACCESS)) { /* if we get here, we are trying to update the local database */ /* force data from the legacy DB */ char *oldSecmod = NULL; char *oldAppName = NULL; char *oldFilename = NULL;
PRBool oldrw; char **strings = NULL; int i;
dbType = NSS_DB_TYPE_LEGACY;
oldSecmod = _NSSUTIL_GetSecmodName(parameters, &dbType, &oldAppName,
&oldFilename, &oldrw);
strings = sftkdbCall_ReadSecmodDB(appName, oldFilename, oldSecmod,
(char *)parameters, oldrw); if (strings) { /* write out the strings */ for (i = 0; strings[i]; i++) {
NSSUTIL_DoModuleDBFunction(SECMOD_MODULE_DB_FUNCTION_ADD,
parameters, strings[i]);
}
sftkdbCall_ReleaseSecmodDBData(oldAppName, oldFilename, oldSecmod,
(char **)strings, oldrw);
} else { /* write out a dummy record */
NSSUTIL_DoModuleDBFunction(SECMOD_MODULE_DB_FUNCTION_ADD,
parameters, " ");
} if (oldSecmod) {
PR_smprintf_free(oldSecmod);
} if (oldAppName) {
PORT_Free(oldAppName);
} if (oldFilename) {
PORT_Free(oldFilename);
}
rvstr = NSSUTIL_DoModuleDBFunction(function, parameters, args); break;
}
rvstr = sftkdbCall_ReadSecmodDB(appName, filename, secmod,
(char *)parameters, rw); break; case SECMOD_MODULE_DB_FUNCTION_ADD: if (secmod == NULL) {
PORT_SetError(SEC_ERROR_INVALID_ARGS); goto loser;
}
rvstr = (sftkdbCall_AddSecmodDB(appName, filename, secmod,
(char *)args, rw) == SECSuccess)
? &success
: NULL; break; case SECMOD_MODULE_DB_FUNCTION_DEL: if (secmod == NULL) {
PORT_SetError(SEC_ERROR_INVALID_ARGS); goto loser;
}
rvstr = (sftkdbCall_DeleteSecmodDB(appName, filename, secmod,
(char *)args, rw) == SECSuccess)
? &success
: NULL; break; case SECMOD_MODULE_DB_FUNCTION_RELEASE:
rvstr = (sftkdbCall_ReleaseSecmodDBData(appName, filename, secmod,
(char **)args, rw) == SECSuccess)
? &success
: NULL; break;
}
loser: if (secmod)
PR_smprintf_free(secmod); if (appName)
PORT_Free(appName); if (filename)
PORT_Free(filename); return rvstr; #endif/* NSS_DISABLE_DBM */
}
staticvoid
nscFreeAllSlots(unsignedint moduleIndex)
{ /* free all the slots */
SFTKSlot *slot = NULL;
CK_SLOT_ID slotID; int i;
/* Parse the library parameters from the first occurance in the following src.: * 1. C_INITIALIZED_ARGS - lib params are included in LibraryParameters field * 2. NSS_LIB_PARAMS - env. var. containing the lib. params. * 3. NSS_LIB_PARAMS_FILE - env. var. pointion to a file with lib. params. * 4. /etc/nss/params.config - default lib. param. file location [Linux only] * 5. LIB_PARAM_DEFAULT - string ensureing the pressence at all times * "configdir='' certPrefix='' keyPrefix='' secmod='' flags=noCertDB,noModDB"
*/ static CK_RV
sftk_getParameters(CK_C_INITIALIZE_ARGS *init_args, PRBool isFIPS,
sftk_parameters *paramStrings)
{
CK_RV crv; char *libParams; constchar *filename;
PRFileDesc *file_dc;
PRBool free_mem = PR_FALSE;
if (!init_args || !init_args->LibraryParameters) { /* Library parameters were not provided via C_Initialize_args*/
/* Enviromental value has precedence to configuration filename */
libParams = PR_GetEnvSecure("NSS_LIB_PARAMS");
if (!libParams) { /* Load from config filename or use default */
filename = PR_GetEnvSecure("NSS_LIB_PARAMS_FILE"); #ifdef XP_UNIX /* Use default configuration file for Linux only */ if (!filename)
filename = LIB_PARAM_DEFAULT_FILE_LOCATION; #endif if (filename) {
file_dc = PR_OpenFile(filename, PR_RDONLY, 444); if (file_dc) { /* file opened */
PRInt32 len = PR_Available(file_dc);
libParams = PORT_NewArray(char, len + 1); if (libParams) { /* memory allocated */ if (PR_Read(file_dc, libParams, len) == -1) {
PORT_Free(libParams);
libParams = NULL;
} else {
free_mem = PR_TRUE;
libParams[len] = '\0';
}
}
PR_Close(file_dc);
}
}
}
if (libParams == NULL)
libParams = LIB_PARAM_DEFAULT;
} else { /* Use parameters provided with C_Initialize_args */
libParams = (char *)init_args->LibraryParameters;
}
rv = RNG_RNGInit(); /* initialize random number generator */ if (rv != SECSuccess) {
crv = CKR_DEVICE_ERROR; return crv;
}
rv = BL_Init(); /* initialize freebl engine */ if (rv != SECSuccess) {
crv = CKR_DEVICE_ERROR; return crv;
}
/* NOTE: * we should be getting out mutexes from this list, not statically binding * them from NSPR. This should happen before we allow the internal to split * off from the rest on NSS.
*/
/* initialize the key and cert db's */ if (init_args && (!(init_args->flags & CKF_OS_LOCKING_OK))) { if (init_args->CreateMutex && init_args->DestroyMutex &&
init_args->LockMutex && init_args->UnlockMutex) { /* softoken always uses NSPR (ie. OS locking), and doesn't know how * to use the lock functions provided by the application.
*/
crv = CKR_CANT_LOCK; return crv;
} if (init_args->CreateMutex || init_args->DestroyMutex ||
init_args->LockMutex || init_args->UnlockMutex) { /* only some of the lock functions were provided by the * application. This is invalid per PKCS#11 spec.
*/
crv = CKR_ARGUMENTS_BAD; return crv;
}
}
sftk_parameters paramStrings;
/* load and parse the library parameters */
crv = sftk_getParameters(init_args, isFIPS, ¶mStrings); if (crv != CKR_OK) { goto loser;
}
/* if we have a peer already open, have him close his DB's so we
* don't clobber each other. */ if ((isFIPS && nsc_init) || (!isFIPS && nsf_init)) {
sftk_closePeer(isFIPS); if (sftk_audit_enabled) { if (isFIPS && nsc_init) {
sftk_LogAuditMessage(NSS_AUDIT_INFO, NSS_AUDIT_FIPS_STATE, "enabled FIPS mode");
} else {
sftk_LogAuditMessage(NSS_AUDIT_INFO, NSS_AUDIT_FIPS_STATE, "disabled FIPS mode");
}
} /* if we have a peer open, we don't want to destroy the freelist * from under the peer if we fail, the free list will be * destroyed in that case when the C_Finalize is called for
* the peer */
destroy_freelist_on_error = PR_FALSE;
} /* allow us to create objects in SFTK_SlotInit */
sftk_InitFreeLists();
for (i = 0; i < paramStrings.token_count; i++) {
crv = SFTK_SlotInit(paramStrings.configdir,
paramStrings.updatedir, paramStrings.updateID,
¶mStrings.tokens[i], moduleIndex); if (crv != CKR_OK) {
nscFreeAllSlots(moduleIndex); break;
}
}
loser:
sftk_freeParams(¶mStrings);
if (destroy_freelist_on_error && (CKR_OK != crv)) { /* idempotent. If the list are already freed, this is a noop */
sftk_CleanupFreeLists();
}
#ifndef NO_FORK_CHECK if (CKR_OK == crv) { #ifdefined(CHECK_FORK_MIXED) /* Before Solaris 10, fork handlers are not unregistered at dlclose() * time. So, we only use pthread_atfork on Solaris 10 and later. For * earlier versions, we use PID checks.
*/ char buf[200]; int major = 0, minor = 0;
long rv = sysinfo(SI_RELEASE, buf, sizeof(buf)); if (rv > 0 && rv < sizeof(buf)) { if (2 == sscanf(buf, "%d.%d", &major, &minor)) { /* Are we on Solaris 10 or greater ? */ if (major > 5 || (5 == major && minor >= 10)) { /* we are safe to use pthread_atfork */
usePthread_atfork = PR_TRUE;
}
}
} if (usePthread_atfork) {
pthread_atfork(NULL, NULL, ForkedChild);
} else {
myPid = getpid();
}
/* NSC_Finalize indicates that an application is done with the
* Cryptoki library.*/
CK_RV
nsc_CommonFinalize(CK_VOID_PTR pReserved, PRBool isFIPS)
{ /* propagate the fork status to freebl and util */
BL_SetForkState(parentForkedAfterC_Initialize);
UTIL_SetForkState(parentForkedAfterC_Initialize);
/* don't muck with the globals if our peer is still initialized */ if (isFIPS && nsc_init) { return CKR_OK;
} if (!isFIPS && nsf_init) { return CKR_OK;
}
sftk_CleanupFreeLists();
sftkdb_Shutdown();
/* This function does not discard all our previously aquired entropy. */
RNG_RNGShutdown();
/* tell freeBL to clean up after itself */
BL_Cleanup();
/* reset fork status in freebl. We must do this before BL_Unload so that
* this call doesn't force freebl to be reloaded. */
BL_SetForkState(PR_FALSE);
#ifndef NSS_STATIC_SOFTOKEN /* unload freeBL shared library from memory. This may only decrement the
* OS refcount if it's been loaded multiple times, eg. by libssl */
BL_Unload(); #endif
/* clean up the default OID table */
SECOID_Shutdown();
sftk_PBELockShutdown();
/* reset fork status in util */
UTIL_SetForkState(PR_FALSE);
/* NSC_GetSlotList obtains a list of slots in the system. */
CK_RV
nsc_CommonGetSlotList(CK_BBOOL tokenPresent,
CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount, unsignedint moduleIndex)
{
*pulCount = nscSlotCount[moduleIndex]; if (pSlotList != NULL) {
PORT_Memcpy(pSlotList, nscSlotList[moduleIndex],
nscSlotCount[moduleIndex] * sizeof(CK_SLOT_ID));
} return CKR_OK;
}
/* NSC_GetSlotList obtains a list of slots in the system. */
CK_RV
NSC_GetSlotList(CK_BBOOL tokenPresent,
CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount)
{
CHECK_FORK(); return nsc_CommonGetSlotList(tokenPresent, pSlotList, pulCount,
NSC_NON_FIPS_MODULE);
}
/* NSC_GetSlotInfo obtains information about a particular slot in the system. */
CK_RV
NSC_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
{
SFTKSlot *slot = sftk_SlotFromID(slotID, PR_TRUE);
/* all user defined slots are defined as removable */ if (slotID >= SFTK_MIN_USER_SLOT_ID) {
pInfo->flags |= CKF_REMOVABLE_DEVICE;
} else { /* In the case where we are doing a merge update, we need * the DB slot to be removable so the token name can change
* appropriately. */
SFTKDBHandle *handle = sftk_getKeyDB(slot); if (handle) { if (sftkdb_InUpdateMerge(handle)) {
pInfo->flags |= CKF_REMOVABLE_DEVICE;
}
sftk_freeDB(handle);
}
}
/* If there is no key database, this is for example the case when NSS was * initialized with NSS_NoDbInit(), then there won't be any point in * requesting a PIN. Set the CKF_USER_PIN_INITIALIZED bit so that * PK11_NeedUserInit() doesn't indicate that a PIN is needed.
*/ if (slot->keyDB == NULL) {
pInfo->flags |= CKF_USER_PIN_INITIALIZED;
}
/* ok we really should read it out of the keydb file. */ /* pInfo->hardwareVersion.major = NSSLOWKEY_DB_FILE_VERSION; */
pInfo->hardwareVersion.major = SOFTOKEN_VMAJOR;
pInfo->hardwareVersion.minor = SOFTOKEN_VMINOR;
pInfo->firmwareVersion.major = SOFTOKEN_VPATCH;
pInfo->firmwareVersion.minor = SOFTOKEN_VBUILD; return CKR_OK;
}
/* * check the current state of the 'needLogin' flag in case the database has * been changed underneath us.
*/ static PRBool
sftk_checkNeedLogin(SFTKSlot *slot, SFTKDBHandle *keyHandle)
{
PRBool needLogin; if (sftkdb_PWCached(keyHandle) == SECSuccess) {
PZ_Lock(slot->slotLock);
needLogin = slot->needLogin;
PZ_Unlock(slot->slotLock);
} else {
needLogin = (PRBool)!sftk_hasNullPassword(slot, keyHandle);
PZ_Lock(slot->slotLock);
slot->needLogin = needLogin;
PZ_Unlock(slot->slotLock);
} return needLogin;
}
static PRBool
sftk_isBlank(constchar *s, int len)
{ int i; for (i = 0; i < len; i++) { if (s[i] != ' ') { return PR_FALSE;
}
} return PR_TRUE;
}
/* NSC_GetTokenInfo obtains information about a particular token in
* the system. */
CK_RV
NSC_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo)
{
SFTKSlot *slot;
SFTKDBHandle *handle;
CHECK_FORK();
if (!nsc_init && !nsf_init) return CKR_CRYPTOKI_NOT_INITIALIZED;
slot = sftk_SlotFromID(slotID, PR_FALSE); if (slot == NULL) return CKR_SLOT_ID_INVALID;
PORT_Memcpy(pInfo->manufacturerID, manufacturerID, 32);
PORT_Memcpy(pInfo->model, "NSS 3 ", 16);
PORT_Memcpy(pInfo->serialNumber, "0000000000000000", 16);
PORT_Memcpy(pInfo->utcTime, "0000000000000000", 16);
pInfo->ulMaxSessionCount = 0; /* arbitrarily large */
pInfo->ulMaxRwSessionCount = 0; /* arbitarily large */
PZ_Lock(slot->slotLock); /* Protect sessionCount / rwSessioncount */
pInfo->ulSessionCount = slot->sessionCount;
pInfo->ulRwSessionCount = slot->rwSessionCount;
PZ_Unlock(slot->slotLock); /* Unlock before sftk_getKeyDB */
pInfo->firmwareVersion.major = 0;
pInfo->firmwareVersion.minor = 0;
PORT_Memcpy(pInfo->label, slot->tokDescription, sizeof(pInfo->label));
handle = sftk_getKeyDB(slot);
pInfo->flags = CKF_RNG | CKF_DUAL_CRYPTO_OPERATIONS; if (handle == NULL) {
pInfo->flags |= CKF_WRITE_PROTECTED;
pInfo->ulMaxPinLen = 0;
pInfo->ulMinPinLen = 0;
pInfo->ulTotalPublicMemory = 0;
pInfo->ulFreePublicMemory = 0;
pInfo->ulTotalPrivateMemory = 0;
pInfo->ulFreePrivateMemory = 0;
pInfo->hardwareVersion.major = 4;
pInfo->hardwareVersion.minor = 0;
} else { /* * we have three possible states which we may be in: * (1) No DB password has been initialized. This also means we * have no keys in the key db. * (2) Password initialized to NULL. This means we have keys, but * the user has chosen not use a password. * (3) Finally we have an initialized password whicn is not NULL, and * we will need to prompt for it.
*/ if (sftkdb_HasPasswordSet(handle) == SECFailure) {
pInfo->flags |= CKF_LOGIN_REQUIRED;
} elseif (!sftk_checkNeedLogin(slot, handle)) {
pInfo->flags |= CKF_USER_PIN_INITIALIZED;
} else {
pInfo->flags |= CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED; /* * if we are doing a merge style update, and we need to get the password * of our source database (the database we are updating from), make sure we * return a token name that will match the database we are prompting for.
*/ if (sftkdb_NeedUpdateDBPassword(handle)) { /* if we have an update tok description, use it. otherwise
* use the updateID for this database */ if (!sftk_isBlank(slot->updateTokDescription, sizeof(pInfo->label))) {
PORT_Memcpy(pInfo->label, slot->updateTokDescription, sizeof(pInfo->label));
} else { /* build from updateID */ constchar *updateID = sftkdb_GetUpdateID(handle); if (updateID) {
sftk_setStringName(updateID, (char *)pInfo->label, sizeof(pInfo->label), PR_FALSE);
}
}
}
}
pInfo->ulMaxPinLen = SFTK_MAX_PIN;
pInfo->ulMinPinLen = (CK_ULONG)slot->minimumPinLen;
pInfo->ulTotalPublicMemory = 1;
pInfo->ulFreePublicMemory = 1;
pInfo->ulTotalPrivateMemory = 1;
pInfo->ulFreePrivateMemory = 1; #ifdef SHDB_FIXME
pInfo->hardwareVersion.major = CERT_DB_FILE_VERSION;
pInfo->hardwareVersion.minor = handle->version; #else
pInfo->hardwareVersion.major = 0;
pInfo->hardwareVersion.minor = 0; #endif
sftk_freeDB(handle);
} /* * CKF_LOGIN_REQUIRED CKF_USER_PIN_INITIALIZED how CKF_TOKEN_INITIALIZED * should be set * 0 0 1 * 1 0 0 * 0 1 1 * 1 1 1
*/ if (!(pInfo->flags & CKF_LOGIN_REQUIRED) ||
(pInfo->flags & CKF_USER_PIN_INITIALIZED)) {
pInfo->flags |= CKF_TOKEN_INITIALIZED;
} return CKR_OK;
}
/* NSC_GetMechanismList obtains a list of mechanism types
* supported by a token. */
CK_RV
NSC_GetMechanismList(CK_SLOT_ID slotID,
CK_MECHANISM_TYPE_PTR pMechanismList, CK_ULONG_PTR pulCount)
{
CK_ULONG i;
CHECK_FORK();
switch (slotID) { /* default: */ case NETSCAPE_SLOT_ID:
*pulCount = mechanismCount; if (pMechanismList != NULL) { for (i = 0; i < mechanismCount; i++) {
pMechanismList[i] = mechanisms[i].type;
}
} break; default:
*pulCount = 0; for (i = 0; i < mechanismCount; i++) { if (mechanisms[i].privkey) {
(*pulCount)++; if (pMechanismList != NULL) {
*pMechanismList++ = mechanisms[i].type;
}
}
} break;
} return CKR_OK;
}
/* NSC_GetMechanismInfo obtains information about a particular mechanism
* possibly supported by a token. */
CK_RV
NSC_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
CK_MECHANISM_INFO_PTR pInfo)
{
PRBool isPrivateKey;
CK_ULONG i;
CHECK_FORK();
switch (slotID) { case NETSCAPE_SLOT_ID:
isPrivateKey = PR_FALSE; break; default:
isPrivateKey = PR_TRUE; break;
} for (i = 0; i < mechanismCount; i++) { if (type == mechanisms[i].type) { if (isPrivateKey && !mechanisms[i].privkey) { return CKR_MECHANISM_INVALID;
}
PORT_Memcpy(pInfo, &mechanisms[i].info, sizeof(CK_MECHANISM_INFO)); return CKR_OK;
}
} return CKR_MECHANISM_INVALID;
}
/* * If we are using the V2 interface, strip out the message flags
*/ #define SFTK_MESSAGE_FLAGS (CKF_MESSAGE_ENCRYPT | CKF_MESSAGE_DECRYPT | CKF_MESSAGE_SIGN | CKF_MESSAGE_VERIFY)
CK_RV
NSC_GetMechanismInfoV2(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
CK_MECHANISM_INFO_PTR pInfo)
{
CK_RV crv;
crv = NSC_GetMechanismInfo(slotID, type, pInfo); if (crv == CKR_OK) {
pInfo->flags = pInfo->flags & ~SFTK_MESSAGE_FLAGS;
} return crv;
}
/* don't initialize the database if we aren't talking to a token * that uses the key database.
*/ if (slotID == NETSCAPE_SLOT_ID) { return CKR_TOKEN_WRITE_PROTECTED;
}
/* first, delete all our loaded key and cert objects from our
* internal list. */
PZ_Lock(slot->objectLock); for (i = 0; i < slot->sessObjHashSize; i++) { do {
object = slot->sessObjHashTable[i]; /* hand deque */ /* this duplicates function of NSC_close session functions, but * because we know that we are freeing all the sessions, we can
* do more efficient processing */ if (object) {
slot->sessObjHashTable[i] = object->next;
if (object->next)
object->next->prev = NULL;
object->next = object->prev = NULL;
} if (object)
sftk_FreeObject(object);
} while (object != NULL);
}
slot->DB_loaded = PR_FALSE;
PZ_Unlock(slot->objectLock);
/* then clear out the key database */
handle = sftk_getKeyDB(slot); if (handle == NULL) { return CKR_TOKEN_WRITE_PROTECTED;
}
rv = sftkdb_ResetKeyDB(handle); /* clear the password */
sftkdb_ClearPassword(handle); /* update slot->needLogin (should be true now since no password is set) */
sftk_checkNeedLogin(slot, handle);
sftk_freeDB(handle); if (rv != SECSuccess) { return CKR_DEVICE_ERROR;
}
/* change the data base */
rv = sftkdb_ChangePassword(handle, NULL, newPinStr, &tokenRemoved); if (tokenRemoved) {
sftk_CloseAllSessions(slot, PR_FALSE);
}
PORT_Memset(newPinStr, 0, ulPinLen);
sftk_freeDB(handle);
handle = NULL;
/* Now update our local copy of the pin */ if (rv == SECSuccess) { if (ulPinLen == 0) {
PZ_Lock(slot->slotLock);
slot->needLogin = PR_FALSE;
PZ_Unlock(slot->slotLock);
} /* database has been initialized, now force min password in FIPS * mode. NOTE: if we are in level1, we may not have a password, but * forcing it now will prevent an insufficient password from being set.
*/ if ((sftk_GetModuleIndex(slot->slotID) == NSC_FIPS_MODULE) &&
(slot->minimumPinLen < FIPS_MIN_PIN)) {
slot->minimumPinLen = FIPS_MIN_PIN;
} return CKR_OK;
}
crv = CKR_PIN_INCORRECT;
loser: if (sp) {
sftk_FreeSession(sp);
} if (handle) {
sftk_freeDB(handle);
} return crv;
}
/* NSC_SetPIN modifies the PIN of user that is currently logged in. */ /* NOTE: This is only valid for the PRIVATE_KEY_SLOT */
CK_RV
NSC_SetPIN(CK_SESSION_HANDLE hSession, CK_CHAR_PTR pOldPin,
CK_ULONG ulOldLen, CK_CHAR_PTR pNewPin, CK_ULONG ulNewLen)
{
SFTKSession *sp = NULL;
SFTKSlot *slot;
SFTKDBHandle *handle = NULL; char newPinStr[SFTK_MAX_PIN + 1], oldPinStr[SFTK_MAX_PIN + 1];
SECStatus rv;
CK_RV crv = CKR_SESSION_HANDLE_INVALID;
PRBool needLogin;
PRBool tokenRemoved = PR_FALSE;
/* make sure the pins aren't too long */ if ((ulNewLen > SFTK_MAX_PIN) || (ulOldLen > SFTK_MAX_PIN)) {
crv = CKR_PIN_LEN_RANGE; goto loser;
} /* check the length of new pin, unless both old and new passwords
* are empty */ if ((ulNewLen != 0 || ulOldLen != 0) &&
ulNewLen < (CK_ULONG)slot->minimumPinLen) {
crv = CKR_PIN_LEN_RANGE; goto loser;
}
/* NSC_OpenSession opens a session between an application and a token. */
CK_RV
NSC_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags,
CK_VOID_PTR pApplication, CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession)
{
SFTKSlot *slot;
CK_SESSION_HANDLE sessionID;
SFTKSession *session;
SFTKSession *sameID;
CHECK_FORK();
slot = sftk_SlotFromID(slotID, PR_FALSE); if (slot == NULL) return CKR_SLOT_ID_INVALID;
/* new session (we only have serial sessions) */
session = sftk_NewSession(slotID, Notify, pApplication,
flags | CKF_SERIAL_SESSION); if (session == NULL) return CKR_HOST_MEMORY;
if (slot->readOnly && (flags & CKF_RW_SESSION)) { /* NETSCAPE_SLOT_ID is Read ONLY */
session->info.flags &= ~CKF_RW_SESSION;
}
PZ_Lock(slot->slotLock);
++slot->sessionCount;
PZ_Unlock(slot->slotLock); if (session->info.flags & CKF_RW_SESSION) {
(void)PR_ATOMIC_INCREMENT(&slot->rwSessionCount);
}
do {
PZLock *lock; do {
sessionID = (PR_ATOMIC_INCREMENT(&slot->sessionIDCount) & 0xffffff) | (slot->index << 24);
} while (sessionID == CK_INVALID_HANDLE);
lock = SFTK_SESSION_LOCK(slot, sessionID);
PZ_Lock(lock);
sftkqueue_find(sameID, sessionID, slot->head, slot->sessHashSize); if (sameID == NULL) {
session->handle = sessionID;
sftk_update_state(slot, session);
sftkqueue_add(session, sessionID, slot->head, slot->sessHashSize);
} else {
slot->sessionIDConflict++; /* for debugging */
}
PZ_Unlock(lock);
} while (sameID != NULL);
*phSession = sessionID; return CKR_OK;
}
/* NSC_CloseSession closes a session between an application and a token. */
CK_RV
NSC_CloseSession(CK_SESSION_HANDLE hSession)
{
SFTKSlot *slot;
SFTKSession *session;
PRBool sessionFound;
PZLock *lock;
if (sessionFound) {
SFTKDBHandle *handle;
handle = sftk_getKeyDB(slot);
PZ_Lock(slot->slotLock); if (--slot->sessionCount == 0) {
slot->isLoggedIn = PR_FALSE; if (slot->needLogin && handle) {
sftkdb_ClearPassword(handle);
}
}
PZ_Unlock(slot->slotLock); if (handle) {
sftk_freeDB(handle);
} if (session->info.flags & CKF_RW_SESSION) {
(void)PR_ATOMIC_DECREMENT(&slot->rwSessionCount);
}
sftk_DestroySession(session);
session = NULL;
}
return CKR_OK;
}
/* NSC_CloseAllSessions closes all sessions with a token. */
CK_RV
NSC_CloseAllSessions(CK_SLOT_ID slotID)
{
SFTKSlot *slot;
#ifndef NO_FORK_CHECK /* skip fork check if we are being called from C_Initialize or C_Finalize */ if (!parentForkedAfterC_Initialize) {
CHECK_FORK();
} #endif
slot = sftk_SlotFromID(slotID, PR_FALSE); if (slot == NULL) return CKR_SLOT_ID_INVALID;
return sftk_CloseAllSessions(slot, PR_TRUE);
}
/* NSC_GetSessionInfo obtains information about the session. */
CK_RV
NSC_GetSessionInfo(CK_SESSION_HANDLE hSession,
CK_SESSION_INFO_PTR pInfo)
{
SFTKSession *session;
CHECK_FORK();
session = sftk_SessionFromHandle(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID;
/* * Deal with bootstrap. We allow the SSO to login in with a NULL * password if and only if we haven't initialized the KEY DB yet. * We only allow this on a RW session.
*/
rv = sftkdb_HasPasswordSet(handle); if (rv == SECFailure) { /* allow SSO's to log in only if there is not password on the
* key database */ if (((userType == CKU_SO) && (sessionFlags & CKF_RW_SESSION)) /* fips always needs to authenticate, even if there isn't a db */
|| (sftk_isFIPS(slot->slotID))) { /* should this be a fixed password? */ if (ulPinLen == 0) {
sftkdb_ClearPassword(handle);
PZ_Lock(slot->slotLock);
slot->isLoggedIn = PR_TRUE;
slot->ssoLoggedIn = (PRBool)(userType == CKU_SO);
PZ_Unlock(slot->slotLock);
sftk_update_all_states(slot);
crv = CKR_OK; goto done;
}
crv = CKR_PIN_INCORRECT; goto done;
}
crv = CKR_USER_TYPE_INVALID; goto done;
}
/* don't allow the SSO to log in if the user is already initialized */ if (userType != CKU_USER) {
crv = CKR_USER_TYPE_INVALID; goto done;
}
/* build the hashed pins which we pass around */
PR_Lock(slot->pwCheckLock);
rv = sftkdb_CheckPassword(handle, pinStr, &tokenRemoved); if (tokenRemoved) {
sftk_CloseAllSessions(slot, PR_FALSE);
} if ((rv != SECSuccess) && (sftk_isFIPS(slot->slotID))) {
PR_Sleep(loginWaitTime);
}
PR_Unlock(slot->pwCheckLock); if (rv == SECSuccess) {
PZ_Lock(slot->slotLock); /* make sure the login state matches the underlying
* database state */
slot->isLoggedIn = sftkdb_PWCached(handle) == SECSuccess ? PR_TRUE : PR_FALSE;
PZ_Unlock(slot->slotLock);
sftk_freeDB(handle);
handle = NULL;
/* update all sessions */
sftk_update_all_states(slot); return CKR_OK;
}
CK_RV
NSC_LoginUser(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
CK_CHAR_PTR pPin, CK_ULONG ulPinLen, CK_UTF8CHAR_PTR pUsername,
CK_ULONG ulUsernameLen)
{ /* softoken currently does not support additional users */ return CKR_OPERATION_NOT_INITIALIZED;
}
/* NSC_Logout logs a user out from a token. */
CK_RV
NSC_Logout(CK_SESSION_HANDLE hSession)
{
SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
SFTKSession *session;
SFTKDBHandle *handle;
/* * Create or remove a new slot on the fly. * When creating a slot, "slot" is the slot that the request came from. The * resulting slot will live in the same module as "slot". * When removing a slot, "slot" is the slot to be removed. * "object" is the creation object that specifies the module spec for the slot * to add or remove.
*/ static CK_RV
sftk_CreateNewSlot(SFTKSlot *slot, CK_OBJECT_CLASS class,
SFTKObject *object)
{
PRBool isValidUserSlot = PR_FALSE;
PRBool isValidFIPSUserSlot = PR_FALSE;
PRBool isValidSlot = PR_FALSE;
PRBool isFIPS = PR_FALSE; unsignedint moduleIndex = NSC_NON_FIPS_MODULE;
SFTKAttribute *attribute;
sftk_parameters paramStrings; char *paramString;
CK_SLOT_ID slotID = 0;
SFTKSlot *newSlot = NULL;
CK_RV crv = CKR_OK;
/* enforce only one at a time */ if (paramStrings.token_count != 1) {
crv = CKR_ATTRIBUTE_VALUE_INVALID; goto loser;
}
slotID = paramStrings.tokens[0].slotID;
/* stay within the valid ID space */
isValidUserSlot = (slotID >= SFTK_MIN_USER_SLOT_ID &&
slotID <= SFTK_MAX_USER_SLOT_ID);
isValidFIPSUserSlot = (slotID >= SFTK_MIN_FIPS_USER_SLOT_ID &&
slotID <= SFTK_MAX_FIPS_USER_SLOT_ID);
if (class == CKO_NSS_DELSLOT) { if (slot->slotID == slotID) {
isValidSlot = isValidUserSlot || isValidFIPSUserSlot;
}
} else { /* only the crypto or FIPS slots can create new slot objects */ if (slot->slotID == NETSCAPE_SLOT_ID) {
isValidSlot = isValidUserSlot;
moduleIndex = NSC_NON_FIPS_MODULE;
} elseif (slot->slotID == FIPS_SLOT_ID) {
isValidSlot = isValidFIPSUserSlot;
moduleIndex = NSC_FIPS_MODULE;
}
}
if (!isValidSlot) {
crv = CKR_ATTRIBUTE_VALUE_INVALID; goto loser;
}
/* unload any existing slot at this id */
newSlot = sftk_SlotFromID(slotID, PR_TRUE); if (newSlot && newSlot->present) {
crv = SFTK_ShutdownSlot(newSlot); if (crv != CKR_OK) { goto loser;
}
}
/* if we were just planning on deleting the slot, then do so now */ if (class == CKO_NSS_DELSLOT) { /* sort of a unconventional use of this error code, be we are
* overusing CKR_ATTRIBUTE_VALUE_INVALID, and it does apply */
crv = newSlot ? CKR_OK : CKR_SLOT_ID_INVALID; goto loser; /* really exit */
}
/* NSC_CreateObject creates a new object. */
CK_RV
NSC_CreateObject(CK_SESSION_HANDLE hSession,
CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
CK_OBJECT_HANDLE_PTR phObject)
{
SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
SFTKSession *session;
SFTKObject *object; /* make sure class isn't randomly CKO_NSS_NEWSLOT or
* CKO_NETSCPE_DELSLOT. */
CK_OBJECT_CLASS class = CKO_VENDOR_DEFINED;
CK_RV crv; int i;
CHECK_FORK();
*phObject = CK_INVALID_HANDLE;
if (slot == NULL) { return CKR_SESSION_HANDLE_INVALID;
} /* * now lets create an object to hang the attributes off of
*/
object = sftk_NewObject(slot); /* fill in the handle later */ if (object == NULL) { return CKR_HOST_MEMORY;
}
/* * sftk_NewObject will set object->isFIPS to PR_TRUE if the slot is FIPS. * We don't need to worry about that here, as FC_CreateObject will always * disallow the import of secret and private keys, regardless of isFIPS * approval status. Therefore, at this point we know that the key is a * public key, which is acceptable to be imported in plaintext.
*/
/* * load the template values into the object
*/ for (i = 0; i < (int)ulCount; i++) {
crv = sftk_AddAttributeType(object, sftk_attr_expand(&pTemplate[i])); if (crv != CKR_OK) {
sftk_FreeObject(object); return crv;
} if ((pTemplate[i].type == CKA_CLASS) && pTemplate[i].pValue) { class = *(CK_OBJECT_CLASS *)pTemplate[i].pValue;
}
}
/* get the session */
session = sftk_SessionFromHandle(hSession); if (session == NULL) {
sftk_FreeObject(object); return CKR_SESSION_HANDLE_INVALID;
}
/* * handle the base object stuff
*/
crv = sftk_handleObject(object, session);
*phObject = object->handle;
done:
sftk_FreeSession(session);
sftk_FreeObject(object);
return crv;
}
/* NSC_CopyObject copies an object, creating a new object for the copy. */
CK_RV
NSC_CopyObject(CK_SESSION_HANDLE hSession,
CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
CK_OBJECT_HANDLE_PTR phNewObject)
{
SFTKObject *destObject, *srcObject;
SFTKSession *session;
CK_RV crv = CKR_OK;
SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession); int i;
CHECK_FORK();
if (slot == NULL) { return CKR_SESSION_HANDLE_INVALID;
} /* Get srcObject so we can find the class */
session = sftk_SessionFromHandle(hSession); if (session == NULL) { return CKR_SESSION_HANDLE_INVALID;
}
srcObject = sftk_ObjectFromHandle(hObject, session); if (srcObject == NULL) {
sftk_FreeSession(session); return CKR_OBJECT_HANDLE_INVALID;
} /* * create an object to hang the attributes off of
*/
destObject = sftk_NewObject(slot); /* fill in the handle later */ if (destObject == NULL) {
sftk_FreeSession(session);
sftk_FreeObject(srcObject); return CKR_HOST_MEMORY;
}
/* * load the template values into the object
*/ for (i = 0; i < (int)ulCount; i++) { if (sftk_modifyType(pTemplate[i].type, srcObject->objclass) == SFTK_NEVER) {
crv = CKR_ATTRIBUTE_READ_ONLY; break;
}
crv = sftk_AddAttributeType(destObject, sftk_attr_expand(&pTemplate[i])); if (crv != CKR_OK) { break;
}
} if (crv != CKR_OK) {
sftk_FreeSession(session);
sftk_FreeObject(srcObject);
sftk_FreeObject(destObject); return crv;
}
/* sensitive can only be changed to CK_TRUE */ if (sftk_hasAttribute(destObject, CKA_SENSITIVE)) { if (!sftk_isTrue(destObject, CKA_SENSITIVE)) {
sftk_FreeSession(session);
sftk_FreeObject(srcObject);
sftk_FreeObject(destObject); return CKR_ATTRIBUTE_READ_ONLY;
}
}
/* * now copy the old attributes from the new attributes
*/ /* don't create a token object if we aren't in a rw session */ /* we need to hold the lock to copy a consistant version of
* the object. */
crv = sftk_CopyObject(destObject, srcObject);
/* NSC_GetObjectSize gets the size of an object in bytes. */
CK_RV
NSC_GetObjectSize(CK_SESSION_HANDLE hSession,
CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize)
{
CHECK_FORK();
/* don't read a private object if we aren't logged in */ if (!isLoggedIn && needLogin && sftk_isTrue(object, CKA_PRIVATE)) {
sftk_FreeObject(object); return CKR_USER_NOT_LOGGED_IN;
}
crv = CKR_OK;
sensitive = sftk_isTrue(object, CKA_SENSITIVE); for (i = 0; i < (int)ulCount; i++) { /* Make sure that this attribute is retrievable */ if (sensitive && sftk_isSensitive(pTemplate[i].type, object->objclass)) {
crv = CKR_ATTRIBUTE_SENSITIVE;
pTemplate[i].ulValueLen = -1; continue;
}
attribute = sftk_FindAttribute(object, pTemplate[i].type); if (attribute == NULL) {
crv = CKR_ATTRIBUTE_TYPE_INVALID;
pTemplate[i].ulValueLen = -1; continue;
} if (pTemplate[i].pValue != NULL) {
PORT_Memcpy(pTemplate[i].pValue, attribute->attrib.pValue,
attribute->attrib.ulValueLen);
}
pTemplate[i].ulValueLen = attribute->attrib.ulValueLen;
sftk_FreeAttribute(attribute);
}
sftk_FreeObject(object); return crv;
}
/* NSC_SetAttributeValue modifies the value of one or more object attributes */
CK_RV
NSC_SetAttributeValue(CK_SESSION_HANDLE hSession,
CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
SFTKSlot *slot = sftk_SlotFromSessionHandle(hSession);
SFTKSession *session;
SFTKAttribute *attribute;
SFTKObject *object;
PRBool isToken, isLoggedIn, needLogin;
CK_RV crv = CKR_OK;
CK_BBOOL legal; int i;
CHECK_FORK();
if (slot == NULL) { return CKR_SESSION_HANDLE_INVALID;
} /* * make sure we're allowed
*/
session = sftk_SessionFromHandle(hSession); if (session == NULL) { return CKR_SESSION_HANDLE_INVALID;
}
/* don't modify a private object if we aren't logged in */ if (!isLoggedIn && needLogin && sftk_isTrue(object, CKA_PRIVATE)) {
sftk_FreeSession(session);
sftk_FreeObject(object); return CKR_USER_NOT_LOGGED_IN;
}
/* don't modify a token object if we aren't in a rw session */
isToken = sftk_isTrue(object, CKA_TOKEN); if (((session->info.flags & CKF_RW_SESSION) == 0) && isToken) {
sftk_FreeSession(session);
sftk_FreeObject(object); return CKR_SESSION_READ_ONLY;
}
sftk_FreeSession(session);
/* only change modifiable objects */ if (!sftk_isTrue(object, CKA_MODIFIABLE)) {
sftk_FreeObject(object); return CKR_ATTRIBUTE_READ_ONLY;
}
for (i = 0; i < (int)ulCount; i++) { /* Make sure that this attribute is changeable */ switch (sftk_modifyType(pTemplate[i].type, object->objclass)) { case SFTK_NEVER: case SFTK_ONCOPY: default:
crv = CKR_ATTRIBUTE_READ_ONLY; break;
case SFTK_SENSITIVE:
legal = (pTemplate[i].type == CKA_EXTRACTABLE) ? CK_FALSE : CK_TRUE; if ((*(CK_BBOOL *)pTemplate[i].pValue) != legal) {
crv = CKR_ATTRIBUTE_READ_ONLY;
} break; case SFTK_ALWAYS: break;
} if (crv != CKR_OK) break;
/* find the old attribute */
attribute = sftk_FindAttribute(object, pTemplate[i].type); if (attribute == NULL) {
crv = CKR_ATTRIBUTE_TYPE_INVALID; break;
}
sftk_FreeAttribute(attribute);
crv = sftk_forceAttribute(object, sftk_attr_expand(&pTemplate[i])); if (crv != CKR_OK) break;
}
/* softoken used to search the SMimeEntries automatically instead of * doing this in pk11wrap. This code should really be up in * pk11wrap so that it will work with other tokens other than softoken.
*/
CK_RV
sftk_emailhack(SFTKSlot *slot, SFTKDBHandle *handle,
SFTKSearchResults *search, CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount)
{
PRBool isCert = PR_FALSE; int emailIndex = -1; unsignedint i;
SFTKSearchResults smime_search;
CK_ATTRIBUTE smime_template[2];
CK_OBJECT_CLASS smime_class = CKO_NSS_SMIME;
SFTKAttribute *attribute = NULL;
SFTKObject *object = NULL;
CK_RV crv = CKR_OK;
smime_search.handles = NULL; /* paranoia, some one is bound to add a goto
* loser before this gets initialized */
/* see if we are looking for email certs */ for (i = 0; i < ulCount; i++) { if (pTemplate[i].type == CKA_CLASS) { if ((pTemplate[i].ulValueLen != sizeof(CK_OBJECT_CLASS) ||
(*(CK_OBJECT_CLASS *)pTemplate[i].pValue) != CKO_CERTIFICATE)) { /* not a cert, skip out */ break;
}
isCert = PR_TRUE;
} elseif (pTemplate[i].type == CKA_NSS_EMAIL) {
emailIndex = i;
} if (isCert && (emailIndex != -1)) break;
}
if (!isCert || (emailIndex == -1)) { return CKR_OK;
}
/* we are doing a cert and email search, find the SMimeEntry */
smime_template[0].type = CKA_CLASS;
smime_template[0].pValue = &smime_class;
smime_template[0].ulValueLen = sizeof(smime_class);
smime_template[1] = pTemplate[emailIndex];
/* get the SMime subject */
object = sftk_NewTokenObject(slot, NULL, smime_search.handles[0]); if (object == NULL) {
crv = CKR_HOST_MEMORY; /* is there any other reason for this failure? */ goto loser;
}
attribute = sftk_FindAttribute(object, CKA_SUBJECT); if (attribute == NULL) {
crv = CKR_ATTRIBUTE_TYPE_INVALID; goto loser;
}
/* now find the certs with that subject */
pTemplate[emailIndex] = attribute->attrib; /* now add the appropriate certs to the search list */
crv = sftk_searchDatabase(handle, search, pTemplate, ulCount);
pTemplate[emailIndex] = smime_template[1]; /* restore the user's template*/
loser: if (attribute) {
sftk_FreeAttribute(attribute);
} if (object) {
sftk_FreeObject(object);
} if (smime_search.handles) {
PORT_Free(smime_search.handles);
}
// Search over the token object list if the template's CKA_TOKEN attribute is set to // CK_TRUE or if it is not set. if (validTokenAttribute == PR_FALSE || tokenAttributeValue == PR_TRUE) {
crv = sftk_searchTokenList(slot, search, pTemplate, ulCount, isLoggedIn); if (crv != CKR_OK) { goto loser;
}
}
// Search over the session object list if the template's CKA_TOKEN attribute is set to // CK_FALSE or if it is not set. if (validTokenAttribute == PR_FALSE || tokenAttributeValue == PR_FALSE) {
crv = sftk_searchObjectList(search, slot->sessObjHashTable,
slot->sessObjHashSize, slot->objectLock,
pTemplate, ulCount, isLoggedIn); if (crv != CKR_OK) { goto loser;
}
}
loser: if (search) {
sftk_FreeSearch(search);
} if (session) {
sftk_FreeSession(session);
} return crv;
}
/* NSC_FindObjects continues a search for token and session objects
* that match a template, obtaining additional object handles. */
CK_RV
NSC_FindObjects(CK_SESSION_HANDLE hSession,
CK_OBJECT_HANDLE_PTR phObject, CK_ULONG ulMaxObjectCount,
CK_ULONG_PTR pulObjectCount)
{
SFTKSession *session;
SFTKSearchResults *search; int transfer; int left;
CHECK_FORK();
*pulObjectCount = 0;
session = sftk_SessionFromHandle(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; if (session->search == NULL) {
sftk_FreeSession(session); return CKR_OK;
}
search = session->search;
left = session->search->size - session->search->index;
transfer = ((int)ulMaxObjectCount > left) ? left : ulMaxObjectCount; if (transfer > 0) {
PORT_Memcpy(phObject, &search->handles[search->index],
transfer * sizeof(CK_OBJECT_HANDLE));
} else {
*phObject = CK_INVALID_HANDLE;
}
/* first determine what we need to look up */ switch (ulOperationType) { case CKT_NSS_SESSION_CHECK: case CKT_NSS_SESSION_LAST_CHECK:
needSession = PR_TRUE;
needObject = PR_FALSE; break; case CKT_NSS_OBJECT_CHECK:
needSession = PR_FALSE;
needObject = PR_TRUE; break; case CKT_NSS_BOTH_CHECK:
needSession = PR_TRUE;
needObject = PR_TRUE; break; default: return CKR_ARGUMENTS_BAD;
}
/* we always need the session handle, the object handle is only
* meaningful if there is a session */
session = sftk_SessionFromHandle(hSession); if (!session) { return CKR_SESSION_HANDLE_INVALID;
} if (needSession) { if (CKT_NSS_SESSION_LAST_CHECK == ulOperationType) {
sessionState = session->lastOpWasFIPS ? CKS_NSS_FIPS_OK : CKS_NSS_FIPS_NOT_OK;
} else { if (session->enc_context) {
sessionState = session->enc_context->isFIPS ? CKS_NSS_FIPS_OK : CKS_NSS_FIPS_NOT_OK;
} if (sessionState != CKS_NSS_FIPS_NOT_OK && session->hash_context) {
sessionState = session->hash_context->isFIPS ? CKS_NSS_FIPS_OK : CKS_NSS_FIPS_NOT_OK;
} /* sessionState is set to CKS_NSS_UNINITIALIZED if neither
* context exists */
}
}
/* If we didn't fetch the state, then it is uninitialized. * The session state can also be uninitialized if there are no active * crypto operations on the session. Turns out the rules for combining * the states are the same whether or not the state was uninitialzed * because we didn't fetch it or because there wasn't a state to fetch.
*/
/* if the object State is uninitialized, return the state of the session. */ if (objectState == CKS_NSS_UNINITIALIZED) { /* if they are both uninitalized, return CKS_FIPS_NOT_OK */ if (sessionState == CKS_NSS_UNINITIALIZED) { /* *pulFIPSStatus already set to CKS_FIPS_NOT_OK */ return CKR_OK;
}
*pulFIPSStatus = sessionState; return CKR_OK;
} /* objectState is initialized, if sessionState is uninitialized, we can
* just return objectState */ if (sessionState == CKS_NSS_UNINITIALIZED) {
*pulFIPSStatus = objectState; return CKR_OK;
}
/* they are are not equal, one must be CKS_FIPS_NOT_OK, so we return that
* value CKS_FIPS_NOT_OK */ if (objectState != sessionState) { /* *pulFIPSStatus already set to CKS_FIPS_NOT_OK */ return CKR_OK;
}
/* objectState and sessionState or the same, so we can return either */
*pulFIPSStatus = sessionState; return CKR_OK;
}
Messung V0.5 in Prozent
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.153Bemerkung:
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-04-25)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
