/* 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/. */

/*

 * The following handles the loading, unloading and management of

 * various PCKS #11 modules

 */

#include <ctype.h>

#include <assert.h>

#include "pkcs11.h"

#include "seccomon.h"

#include "secmod.h"

#include "secmodi.h"

#include "secmodti.h"

#include "pki3hack.h"

#include "secerr.h"

#include "nss.h"

#include "utilpars.h"

#include "pk11pub.h"

/* create a new module */

static SECMODModule *

secmod_NewModule(void)

{

    SECMODModule *newMod;

    PLArenaPool *arena;

    /* create an arena in which dllName and commonName can be

     * allocated.

     */

    arena = PORT_NewArena(512);

    if (arena == NULL) {

        return NULL;

    }

    newMod = (SECMODModule *)PORT_ArenaAlloc(arena, sizeof(SECMODModule));

    if (newMod == NULL) {

        PORT_FreeArena(arena, PR_FALSE);

        return NULL;

    }

    /*

     * initialize of the fields of the module

     */

    newMod->arena = arena;

    newMod->internal = PR_FALSE;

    newMod->loaded = PR_FALSE;

    newMod->isFIPS = PR_FALSE;

    newMod->dllName = NULL;

    newMod->commonName = NULL;

    newMod->library = NULL;

    newMod->functionList = NULL;

    newMod->slotCount = 0;

    newMod->slots = NULL;

    newMod->slotInfo = NULL;

    newMod->slotInfoCount = 0;

    newMod->refCount = 1;

    newMod->ssl[0] = 0;

    newMod->ssl[1] = 0;

    newMod->libraryParams = NULL;

    newMod->moduleDBFunc = NULL;

    newMod->parent = NULL;

    newMod->isCritical = PR_FALSE;

    newMod->isModuleDB = PR_FALSE;

    newMod->moduleDBOnly = PR_FALSE;

    newMod->trustOrder = 0;

    newMod->cipherOrder = 0;

    newMod->evControlMask = 0;

    newMod->refLock = PZ_NewLock(nssILockRefLock);

    if (newMod->refLock == NULL) {

        PORT_FreeArena(arena, PR_FALSE);

        return NULL;

    }

    return newMod;

}

/* private flags for isModuleDB (field in SECMODModule). */

/* The meaing of these flags is as follows:

 *

 * SECMOD_FLAG_MODULE_DB_IS_MODULE_DB - This is a module that accesses the

 *   database of other modules to load. Module DBs are loadable modules that

 *   tells NSS which PKCS #11 modules to load and when. These module DBs are

 *   chainable. That is, one module DB can load another one. NSS system init

 *   design takes advantage of this feature. In system NSS, a fixed system

 *   module DB loads the system defined libraries, then chains out to the

 *   traditional module DBs to load any system or user configured modules

 *   (like smart cards). This bit is the same as the already existing meaning

 *   of  isModuleDB = PR_TRUE. None of the other module db flags should be set

 *   if this flag isn't on.

 *

 * SECMOD_FLAG_MODULE_DB_SKIP_FIRST - This flag tells NSS to skip the first

 *   PKCS #11 module presented by a module DB. This allows the OS to load a

 *   softoken from the system module, then ask the existing module DB code to

 *   load the other PKCS #11 modules in that module DB (skipping it's request

 *   to load softoken). This gives the system init finer control over the

 *   configuration of that softoken module.

 *

 * SECMOD_FLAG_MODULE_DB_DEFAULT_MODDB - This flag allows system init to mark a

 *   different module DB as the 'default' module DB (the one in which

 *   'Add module' changes will go). Without this flag NSS takes the first

 *   module as the default Module DB, but in system NSS, that first module

 *   is the system module, which is likely read only (at least to the user).

 *   This  allows system NSS to delegate those changes to the user's module DB,

 *   preserving the user's ability to load new PKCS #11 modules (which only

 *   affect him), from existing applications like Firefox.

 */

#define SECMOD_FLAG_MODULE_DB_IS_MODULE_DB 0x01 /* must be set if any of the \

                                                 *other flags are set */

#define SECMOD_FLAG_MODULE_DB_SKIP_FIRST 0x02

#define SECMOD_FLAG_MODULE_DB_DEFAULT_MODDB 0x04

#define SECMOD_FLAG_MODULE_DB_POLICY_ONLY 0x08

/* private flags for internal (field in SECMODModule). */

/* The meaing of these flags is as follows:

 *

 * SECMOD_FLAG_INTERNAL_IS_INTERNAL - This is a marks the the module is

 *   the internal module (that is, softoken). This bit is the same as the

 *   already existing meaning of internal = PR_TRUE. None of the other

 *   internal flags should be set if this flag isn't on.

 *

 * SECMOD_FLAG_MODULE_INTERNAL_KEY_SLOT - This flag allows system init to mark

 *   a  different slot returned byt PK11_GetInternalKeySlot(). The 'primary'

 *   slot defined by this module will be the new internal key slot.

 */

#define SECMOD_FLAG_INTERNAL_IS_INTERNAL 0x01 /* must be set if any of \

                                               *the other flags are set */

#define SECMOD_FLAG_INTERNAL_KEY_SLOT 0x02

/* private flags for policy check. */

#define SECMOD_FLAG_POLICY_CHECK_IDENTIFIER 0x01

#define SECMOD_FLAG_POLICY_CHECK_VALUE 0x02

/*

 * for 3.4 we continue to use the old SECMODModule structure

 */

SECMODModule *

SECMOD_CreateModule(const char *library, const char *moduleName,

                    const char *parameters, const char *nss)

{

    return SECMOD_CreateModuleEx(library, moduleName, parameters, nss, NULL);

}

/*

 * NSS config options format:

 *

 * The specified ciphers will be allowed by policy, but an application

 * may allow more by policy explicitly:

 * config="allow=curve1:curve2:hash1:hash2:rsa-1024..."

 *

 * Only the specified hashes and curves will be allowed:

 * config="disallow=all allow=sha1:sha256:secp256r1:secp384r1"

 *

 * Only the specified hashes and curves will be allowed, and

 *  RSA keys of 2048 or more will be accepted, and DH key exchange

 *  with 1024-bit primes or more:

 * config="disallow=all allow=sha1:sha256:secp256r1:secp384r1:min-rsa=2048:min-dh=1024"

 *

 * A policy that enables the AES ciphersuites and the SECP256/384 curves:

 * config="allow=aes128-cbc:aes128-gcm:TLS1.0:TLS1.2:TLS1.1:HMAC-SHA1:SHA1:SHA256:SHA384:RSA:ECDHE-RSA:SECP256R1:SECP384R1"

 *

 * Disallow values are parsed first, then allow values, independent of the

 * order they appear.

 *

 * flags: turn on the following flags:

 *    policy-lock: turn off the ability for applications to change policy with

 *                 the call NSS_SetAlgorithmPolicy or the other system policy

 *                 calls (SSL_SetPolicy, etc.)

 *    ssl-lock:    turn off the ability to change the ssl defaults.

 *

 * The following only apply to ssl cipher suites (future smime)

 *

 * enable: turn on ciphersuites by default.

 * disable: turn off ciphersuites by default without disallowing them by policy.

 *

 *

 */

typedef struct {

    const char *name;

    unsigned name_size;

    SECOidTag oid;

    PRUint32 val;

} oidValDef;

typedef struct {

    const char *name;

    unsigned name_size;

    PRInt32 option;

} optionFreeDef;

typedef struct {

    const char *name;

    unsigned name_size;

    PRUint32 flag;

} policyFlagDef;

/*

 *  This table should be merged with the SECOID table.

 */

#define CIPHER_NAME(x) x, (sizeof(x) - 1)

static const oidValDef curveOptList[] = {

    /* Curves */

    { CIPHER_NAME("PRIME192V1"), SEC_OID_ANSIX962_EC_PRIME192V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("PRIME192V2"), SEC_OID_ANSIX962_EC_PRIME192V2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("PRIME192V3"), SEC_OID_ANSIX962_EC_PRIME192V3,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("PRIME239V1"), SEC_OID_ANSIX962_EC_PRIME239V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("PRIME239V2"), SEC_OID_ANSIX962_EC_PRIME239V2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("PRIME239V3"), SEC_OID_ANSIX962_EC_PRIME239V3,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("PRIME256V1"), SEC_OID_ANSIX962_EC_PRIME256V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP112R1"), SEC_OID_SECG_EC_SECP112R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP112R2"), SEC_OID_SECG_EC_SECP112R2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP128R1"), SEC_OID_SECG_EC_SECP128R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP128R2"), SEC_OID_SECG_EC_SECP128R2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP160K1"), SEC_OID_SECG_EC_SECP160K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP160R1"), SEC_OID_SECG_EC_SECP160R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP160R2"), SEC_OID_SECG_EC_SECP160R2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP192K1"), SEC_OID_SECG_EC_SECP192K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP192R1"), SEC_OID_ANSIX962_EC_PRIME192V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP224K1"), SEC_OID_SECG_EC_SECP224K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP256K1"), SEC_OID_SECG_EC_SECP256K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP256R1"), SEC_OID_ANSIX962_EC_PRIME256V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP384R1"), SEC_OID_SECG_EC_SECP384R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECP521R1"), SEC_OID_SECG_EC_SECP521R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("CURVE25519"), SEC_OID_CURVE25519,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("XYBER768D00"), SEC_OID_XYBER768D00, 0 },

    { CIPHER_NAME("MLKEM768X25519"), SEC_OID_MLKEM768X25519, 0 },

    /* ANSI X9.62 named elliptic curves (characteristic two field) */

    { CIPHER_NAME("C2PNB163V1"), SEC_OID_ANSIX962_EC_C2PNB163V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2PNB163V2"), SEC_OID_ANSIX962_EC_C2PNB163V2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2PNB163V3"), SEC_OID_ANSIX962_EC_C2PNB163V3,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2PNB176V1"), SEC_OID_ANSIX962_EC_C2PNB176V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB191V1"), SEC_OID_ANSIX962_EC_C2TNB191V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB191V2"), SEC_OID_ANSIX962_EC_C2TNB191V2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB191V3"), SEC_OID_ANSIX962_EC_C2TNB191V3,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2ONB191V4"), SEC_OID_ANSIX962_EC_C2ONB191V4,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2ONB191V5"), SEC_OID_ANSIX962_EC_C2ONB191V5,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2PNB208W1"), SEC_OID_ANSIX962_EC_C2PNB208W1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB239V1"), SEC_OID_ANSIX962_EC_C2TNB239V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB239V2"), SEC_OID_ANSIX962_EC_C2TNB239V2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB239V3"), SEC_OID_ANSIX962_EC_C2TNB239V3,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2ONB239V4"), SEC_OID_ANSIX962_EC_C2ONB239V4,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2ONB239V5"), SEC_OID_ANSIX962_EC_C2ONB239V5,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2PNB272W1"), SEC_OID_ANSIX962_EC_C2PNB272W1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2PNB304W1"), SEC_OID_ANSIX962_EC_C2PNB304W1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB359V1"), SEC_OID_ANSIX962_EC_C2TNB359V1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2PNB368W1"), SEC_OID_ANSIX962_EC_C2PNB368W1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("C2TNB431R1"), SEC_OID_ANSIX962_EC_C2TNB431R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    /* SECG named elliptic curves (characteristic two field) */

    { CIPHER_NAME("SECT113R1"), SEC_OID_SECG_EC_SECT113R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT131R1"), SEC_OID_SECG_EC_SECT113R2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT131R1"), SEC_OID_SECG_EC_SECT131R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT131R2"), SEC_OID_SECG_EC_SECT131R2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT163K1"), SEC_OID_SECG_EC_SECT163K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT163R1"), SEC_OID_SECG_EC_SECT163R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT163R2"), SEC_OID_SECG_EC_SECT163R2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT193R1"), SEC_OID_SECG_EC_SECT193R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT193R2"), SEC_OID_SECG_EC_SECT193R2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT233K1"), SEC_OID_SECG_EC_SECT233K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT233R1"), SEC_OID_SECG_EC_SECT233R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT239K1"), SEC_OID_SECG_EC_SECT239K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT283K1"), SEC_OID_SECG_EC_SECT283K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT283R1"), SEC_OID_SECG_EC_SECT283R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT409K1"), SEC_OID_SECG_EC_SECT409K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT409R1"), SEC_OID_SECG_EC_SECT409R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT571K1"), SEC_OID_SECG_EC_SECT571K1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("SECT571R1"), SEC_OID_SECG_EC_SECT571R1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_CERT_SIGNATURE },

};

static const oidValDef hashOptList[] = {

    /* Hashes */

    { CIPHER_NAME("MD2"), SEC_OID_MD2,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("MD4"), SEC_OID_MD4,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("MD5"), SEC_OID_MD5,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA1"), SEC_OID_SHA1,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA224"), SEC_OID_SHA224,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA256"), SEC_OID_SHA256,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA384"), SEC_OID_SHA384,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA512"), SEC_OID_SHA512,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA3-224"), SEC_OID_SHA3_224,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA3-256"), SEC_OID_SHA3_256,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA3-384"), SEC_OID_SHA3_384,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("SHA3-512"), SEC_OID_SHA3_512,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE | NSS_USE_ALG_IN_SMIME |

          NSS_USE_ALG_IN_PKCS12 }

};

static const oidValDef macOptList[] = {

    /* MACs */

    { CIPHER_NAME("HMAC-MD5"), SEC_OID_HMAC_MD5,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA1"), SEC_OID_HMAC_SHA1,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA224"), SEC_OID_HMAC_SHA224,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA256"), SEC_OID_HMAC_SHA256,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA384"), SEC_OID_HMAC_SHA384,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA512"), SEC_OID_HMAC_SHA512,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA3-224"), SEC_OID_HMAC_SHA3_224,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA3-256"), SEC_OID_HMAC_SHA3_256,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA3-384"), SEC_OID_HMAC_SHA3_384,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("HMAC-SHA3-512"), SEC_OID_HMAC_SHA3_512,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

};

static const oidValDef cipherOptList[] = {

    /* Ciphers */

    { CIPHER_NAME("AES128-CBC"), SEC_OID_AES_128_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("AES192-CBC"), SEC_OID_AES_192_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("AES256-CBC"), SEC_OID_AES_256_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("AES128-GCM"), SEC_OID_AES_128_GCM, NSS_USE_ALG_IN_SSL },

    { CIPHER_NAME("AES192-GCM"), SEC_OID_AES_192_GCM, NSS_USE_ALG_IN_SSL },

    { CIPHER_NAME("AES256-GCM"), SEC_OID_AES_256_GCM, NSS_USE_ALG_IN_SSL },

    { CIPHER_NAME("CAMELLIA128-CBC"), SEC_OID_CAMELLIA_128_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("CAMELLIA192-CBC"), SEC_OID_CAMELLIA_192_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("CAMELLIA256-CBC"), SEC_OID_CAMELLIA_256_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("CHACHA20-POLY1305"), SEC_OID_CHACHA20_POLY1305, NSS_USE_ALG_IN_SSL },

    { CIPHER_NAME("SEED-CBC"), SEC_OID_SEED_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("DES-EDE3-CBC"), SEC_OID_DES_EDE3_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("DES-40-CBC"), SEC_OID_DES_40_CBC,

      NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SMIME | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("DES-CBC"), SEC_OID_DES_CBC, NSS_USE_ALG_IN_SSL },

    { CIPHER_NAME("NULL-CIPHER"), SEC_OID_NULL_CIPHER, NSS_USE_ALG_IN_SSL },

    { CIPHER_NAME("RC2"), SEC_OID_RC2_CBC, NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("RC2-40-CBC"), SEC_OID_RC2_40_CBC, NSS_USE_ALG_IN_SMIME },

    { CIPHER_NAME("RC2-64-CBC"), SEC_OID_RC2_64_CBC, NSS_USE_ALG_IN_SMIME },

    { CIPHER_NAME("RC2-128-CBC"), SEC_OID_RC2_128_CBC, NSS_USE_ALG_IN_SMIME },

    { CIPHER_NAME("RC4"), SEC_OID_RC4, NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_PKCS12 },

    { CIPHER_NAME("IDEA"), SEC_OID_IDEA_CBC, NSS_USE_ALG_IN_SSL },

};

static const oidValDef kxOptList[] = {

    /* Key exchange */

    { CIPHER_NAME("RSA"), SEC_OID_TLS_RSA, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("RSA-EXPORT"), SEC_OID_TLS_RSA_EXPORT, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("DHE-RSA"), SEC_OID_TLS_DHE_RSA, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("DHE-DSS"), SEC_OID_TLS_DHE_DSS, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("DH-RSA"), SEC_OID_TLS_DH_RSA, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("DH-DSS"), SEC_OID_TLS_DH_DSS, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("ECDHE-ECDSA"), SEC_OID_TLS_ECDHE_ECDSA, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("ECDHE-RSA"), SEC_OID_TLS_ECDHE_RSA, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("ECDH-ECDSA"), SEC_OID_TLS_ECDH_ECDSA, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("ECDH-RSA"), SEC_OID_TLS_ECDH_RSA, NSS_USE_ALG_IN_SSL_KX },

    { CIPHER_NAME("TLS-REQUIRE-EMS"), SEC_OID_TLS_REQUIRE_EMS, NSS_USE_ALG_IN_SSL_KX },

};

static const oidValDef smimeKxOptList[] = {

    /* Key exchange */

    { CIPHER_NAME("RSA-PKCS"), SEC_OID_PKCS1_RSA_ENCRYPTION, NSS_USE_ALG_IN_SMIME_KX },

    { CIPHER_NAME("RSA-OAEP"), SEC_OID_PKCS1_RSA_OAEP_ENCRYPTION, NSS_USE_ALG_IN_SMIME_KX },

    { CIPHER_NAME("ECDH"), SEC_OID_ECDH_KEA, NSS_USE_ALG_IN_SMIME_KX },

    { CIPHER_NAME("DH"), SEC_OID_X942_DIFFIE_HELMAN_KEY, NSS_USE_ALG_IN_SMIME_KX },

};

static const oidValDef signOptList[] = {

    /* Signatures */

    { CIPHER_NAME("DSA"), SEC_OID_ANSIX9_DSA_SIGNATURE,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE },

    { CIPHER_NAME("RSA-PKCS"), SEC_OID_PKCS1_RSA_ENCRYPTION,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE },

    { CIPHER_NAME("RSA-PSS"), SEC_OID_PKCS1_RSA_PSS_SIGNATURE,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE },

    { CIPHER_NAME("ECDSA"), SEC_OID_ANSIX962_EC_PUBLIC_KEY,

      NSS_USE_ALG_IN_SSL_KX | NSS_USE_ALG_IN_SIGNATURE },

    { CIPHER_NAME("ED25519"), SEC_OID_ED25519_PUBLIC_KEY,

      NSS_USE_ALG_IN_SIGNATURE },

};

typedef struct {

    const oidValDef *list;

    PRUint32 entries;

    const char *description;

    PRBool allowEmpty;

} algListsDef;

static const algListsDef algOptLists[] = {

    { curveOptList, PR_ARRAY_SIZE(curveOptList), "ECC", PR_FALSE },

    { hashOptList, PR_ARRAY_SIZE(hashOptList), "HASH", PR_FALSE },

    { macOptList, PR_ARRAY_SIZE(macOptList), "MAC", PR_FALSE },

    { cipherOptList, PR_ARRAY_SIZE(cipherOptList), "CIPHER", PR_FALSE },

    { kxOptList, PR_ARRAY_SIZE(kxOptList), "SSL-KX", PR_FALSE },

    { smimeKxOptList, PR_ARRAY_SIZE(smimeKxOptList), "SMIME-KX", PR_TRUE },

    { signOptList, PR_ARRAY_SIZE(signOptList), "OTHER-SIGN", PR_FALSE },

};

static const optionFreeDef sslOptList[] = {

    /* Versions */

    { CIPHER_NAME("SSL2.0"), 0x002 },

    { CIPHER_NAME("SSL3.0"), 0x300 },

    { CIPHER_NAME("SSL3.1"), 0x301 },

    { CIPHER_NAME("TLS1.0"), 0x301 },

    { CIPHER_NAME("TLS1.1"), 0x302 },

    { CIPHER_NAME("TLS1.2"), 0x303 },

    { CIPHER_NAME("TLS1.3"), 0x304 },

    { CIPHER_NAME("DTLS1.0"), 0x302 },

    { CIPHER_NAME("DTLS1.1"), 0x302 },

    { CIPHER_NAME("DTLS1.2"), 0x303 },

    { CIPHER_NAME("DTLS1.3"), 0x304 },

};

static const optionFreeDef keySizeFlagsList[] = {

    { CIPHER_NAME("KEY-SIZE-SSL"), NSS_KEY_SIZE_POLICY_SSL_FLAG },

    { CIPHER_NAME("KEY-SIZE-SIGN"), NSS_KEY_SIZE_POLICY_SIGN_FLAG },

    { CIPHER_NAME("KEY-SIZE-VERIFY"), NSS_KEY_SIZE_POLICY_VERIFY_FLAG },

    { CIPHER_NAME("KEY-SIZE-SMIME"), NSS_KEY_SIZE_POLICY_SMIME_FLAG },

    { CIPHER_NAME("KEY-SIZE-ALL"), NSS_KEY_SIZE_POLICY_ALL_FLAGS },

};

static const optionFreeDef freeOptList[] = {

    /* Restrictions for asymetric keys */

    { CIPHER_NAME("RSA-MIN"), NSS_RSA_MIN_KEY_SIZE },

    { CIPHER_NAME("DH-MIN"), NSS_DH_MIN_KEY_SIZE },

    { CIPHER_NAME("DSA-MIN"), NSS_DSA_MIN_KEY_SIZE },

    { CIPHER_NAME("ECC-MIN"), NSS_ECC_MIN_KEY_SIZE },

    /* what operations doe the key size apply to */

    { CIPHER_NAME("KEY-SIZE-FLAGS"), NSS_KEY_SIZE_POLICY_FLAGS },

    /* constraints on SSL Protocols */

    { CIPHER_NAME("TLS-VERSION-MIN"), NSS_TLS_VERSION_MIN_POLICY },

    { CIPHER_NAME("TLS-VERSION-MAX"), NSS_TLS_VERSION_MAX_POLICY },

    /* constraints on DTLS Protocols */

    { CIPHER_NAME("DTLS-VERSION-MIN"), NSS_DTLS_VERSION_MIN_POLICY },

    { CIPHER_NAME("DTLS-VERSION-MAX"), NSS_DTLS_VERSION_MAX_POLICY }

};

static const policyFlagDef policyFlagList[] = {

    { CIPHER_NAME("SSL"), NSS_USE_ALG_IN_SSL },

    { CIPHER_NAME("SSL-KEY-EXCHANGE"), NSS_USE_ALG_IN_SSL_KX },

    /* add other key exhanges in the future */

    { CIPHER_NAME("KEY-EXCHANGE"), NSS_USE_ALG_IN_KEY_EXCHANGE },

    { CIPHER_NAME("CERT-SIGNATURE"), NSS_USE_ALG_IN_CERT_SIGNATURE },

    { CIPHER_NAME("CMS-SIGNATURE"), NSS_USE_ALG_IN_SMIME_SIGNATURE },

    { CIPHER_NAME("SMIME-SIGNATURE"), NSS_USE_ALG_IN_SMIME_SIGNATURE },

    { CIPHER_NAME("ALL-SIGNATURE"), NSS_USE_ALG_IN_SIGNATURE },

    { CIPHER_NAME("PKCS12"), NSS_USE_ALG_IN_PKCS12 },

    /* only use in allow */

    { CIPHER_NAME("PKCS12-LEGACY"), NSS_USE_ALG_IN_PKCS12_DECRYPT },

    /* only use in disallow */

    { CIPHER_NAME("PKCS12-ENCRYPT"), NSS_USE_ALG_IN_PKCS12_ENCRYPT },

    { CIPHER_NAME("SMIME"), NSS_USE_ALG_IN_SMIME },

    /* only use in allow, enable */

    { CIPHER_NAME("SMIME-LEGACY"), NSS_USE_ALG_IN_SMIME_LEGACY },

    /* only use in disallow, disable */

    { CIPHER_NAME("SMIME-ENCRYPT"), NSS_USE_ALG_IN_SMIME_ENCRYPT },

    { CIPHER_NAME("SMIME-KEY-EXCHANGE"), NSS_USE_ALG_IN_SMIME_KX },

    /* only use in allow */

    { CIPHER_NAME("SMIME-KEY-EXCHANGE-LEGACY"), NSS_USE_ALG_IN_SMIME_KX_LEGACY },

    /* only use in disallow */

    { CIPHER_NAME("SMIME-KEY-EXCHANGE-ENCRYPT"), NSS_USE_ALG_IN_SMIME_KX_ENCRYPT },

    /* sign turns off all signatures, but doesn't change the

     * allowance for specific signatures... for example:

     *     disallow=sha256/all allow=sha256/signature

     * doesn't allow cert-signatures or sime-signatures, where

     *     disallow=sha256/all allow=sha256/all-signature

     * does. however,

     *     disallow=sha256/signature

     * and

     *     disallow=sha256/all-signature

     * are equivalent in effect */

    { CIPHER_NAME("SIGNATURE"), NSS_USE_ALG_IN_ANY_SIGNATURE },

    /* enable/allow algorithms for legacy (read/verify)operations */

    { CIPHER_NAME("LEGACY"), NSS_USE_ALG_IN_PKCS12_DECRYPT |

                                 NSS_USE_ALG_IN_SMIME_LEGACY |

                                 NSS_USE_ALG_IN_SMIME_KX_LEGACY },

    /* enable/disable everything */

    { CIPHER_NAME("ALL"), NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SSL_KX |

                              NSS_USE_ALG_IN_PKCS12 | NSS_USE_ALG_IN_SMIME |

                              NSS_USE_ALG_IN_SIGNATURE |

                              NSS_USE_ALG_IN_SMIME_KX },

    { CIPHER_NAME("NONE"), 0 }

};

/*

 *  Get the next cipher on the list. point to the next one in 'next'.

 *  return the length;

 */

static const char *

secmod_ArgGetSubValue(const char *cipher, char sep1, char sep2,

                      int *len, const char **next)

{

    const char *start = cipher;

    if (start == NULL) {

        *len = 0;

        *next = NULL;

        return start;

    }

    for (; *cipher && *cipher != sep2; cipher++) {

        if (*cipher == sep1) {

            *next = cipher + 1;

            *len = cipher - start;

            return start;

        }

    }

    *next = NULL;

    *len = cipher - start;

    return start;

}

static PRUint32

secmod_parsePolicyValue(const char *policyFlags, int policyLength,

                        PRBool printPolicyFeedback, PRUint32 policyCheckFlags)

{

    const char *flag, *currentString;

    PRUint32 flags = 0;

    int i;

    for (currentString = policyFlags; currentString &&

                                      currentString < policyFlags + policyLength;) {

        int length;

        PRBool unknown = PR_TRUE;

        flag = secmod_ArgGetSubValue(currentString, ',', ':', &length,

                                     &currentString);

        if (length == 0) {

            continue;

        }

        for (i = 0; i < PR_ARRAY_SIZE(policyFlagList); i++) {

            const policyFlagDef *policy = &policyFlagList[i];

            unsigned name_size = policy->name_size;

            if ((policy->name_size == length) &&

                PORT_Strncasecmp(policy->name, flag, name_size) == 0) {

                flags |= policy->flag;

                unknown = PR_FALSE;

                break;

            }

        }

        if (unknown && printPolicyFeedback &&

            (policyCheckFlags & SECMOD_FLAG_POLICY_CHECK_VALUE)) {

            PR_SetEnv("NSS_POLICY_FAIL=1");

            fprintf(stderr, "NSS-POLICY-FAIL %.*s: unknown value: %.*s\n",

                    policyLength, policyFlags, length, flag);

        }

    }

    return flags;

}

/* allow symbolic names for values. The only ones currently defines or

 * SSL protocol versions. */

static SECStatus

secmod_getPolicyOptValue(const char *policyValue, int policyValueLength,

                         PRInt32 *result)

{

    PRInt32 val = atoi(policyValue);

    int i;

    if ((val != 0) || (*policyValue == '0')) {

        *result = val;

        return SECSuccess;

    }

    if (policyValueLength == 0) {

        return SECFailure;

    }

    /* handle any ssl strings */

    for (i = 0; i < PR_ARRAY_SIZE(sslOptList); i++) {

        if (policyValueLength == sslOptList[i].name_size &&

            PORT_Strncasecmp(sslOptList[i].name, policyValue,

                             sslOptList[i].name_size) == 0) {

            *result = sslOptList[i].option;

            return SECSuccess;

        }

    }

    /* handle key_size flags. Each flag represents a bit, which

     * gets or'd together. They can be separated by , | or + */

    val = 0;

    while (policyValueLength > 0) {

        PRBool found = PR_FALSE;

        for (i = 0; i < PR_ARRAY_SIZE(keySizeFlagsList); i++) {

            if (PORT_Strncasecmp(keySizeFlagsList[i].name, policyValue,

                                 keySizeFlagsList[i].name_size) == 0) {

                val |= keySizeFlagsList[i].option;

                found = PR_TRUE;

                policyValue += keySizeFlagsList[i].name_size;

                policyValueLength -= keySizeFlagsList[i].name_size;

                break;

            }

        }

        if (!found) {

            return SECFailure;

        }

        if (*policyValue == ',' || *policyValue == '|' || *policyValue == '+') {

            policyValue++;

            policyValueLength--;

        }

    }

    *result = val;

    return SECSuccess;

}

/* Policy operations:

 *     Disallow: operation is disallowed by policy. Implies disabled.

 *     Allow: operation is allowed by policy (but could be disabled).

 *     Disable: operation is turned off by default (but could be allowed).

 *     Enable: operation is enabled by default. Implies allowed.

 */

typedef enum {

    NSS_DISALLOW,

    NSS_ALLOW,

    NSS_DISABLE,

    NSS_ENABLE

} NSSPolicyOperation;

/* Enable/Disable only apply to SSL cipher suites and S/MIME symetric algorithms.

 * Enable/Disable is implemented by clearing the DEFAULT_NOT_VALID

 * flag, then setting the NSS_USE_DEFAULT_SSL_ENABLE and

 * NSS_USE_DEFAULT_SMIME_ENABLE flags to the correct value. The ssl

 * policy code will then sort out what to set based on ciphers and

 * cipher suite values and the smime policy code will sort

 * out which ciphers to include in capabilities based on these values */

static SECStatus

secmod_setDefault(SECOidTag oid, NSSPolicyOperation operation,

                  PRUint32 value)

{

    SECStatus rv = SECSuccess;

    PRUint32 policy;

    PRUint32 useDefault = 0;

    PRUint32 set = 0;

    /* we always clear the default not valid flag as this operation will

     * make the defaults valid */

    PRUint32 clear = NSS_USE_DEFAULT_NOT_VALID;

    /* what values are we trying to change */

    /* if either SSL or SSL_KX is set, enable SSL */

    if (value & (NSS_USE_ALG_IN_SSL | NSS_USE_ALG_IN_SSL_KX)) {

        useDefault |= NSS_USE_DEFAULT_SSL_ENABLE;

    }

    /* only bulk ciphers are configured as enable in S/MIME, only

     * enable them if both SMIME bits are set */

    if ((value & NSS_USE_ALG_IN_SMIME) == NSS_USE_ALG_IN_SMIME) {

        useDefault |= NSS_USE_DEFAULT_SMIME_ENABLE;

    }

    /* on disable we clear, on enable we set */

    if (operation == NSS_DISABLE) {

        clear |= useDefault;

    } else {

        /* we also turn the cipher on by policy if we enable it,

         * so include the policy bits */

        set |= value | useDefault;

    }

    /* if we haven't set the not valid flag yet, then we need to

     * clear any of the other bits we aren't actually setting as well.

     */

    rv = NSS_GetAlgorithmPolicy(oid, &policy);

    if (rv != SECSuccess) {

        return rv;

    }

    if (policy & NSS_USE_DEFAULT_NOT_VALID) {

        clear |= ((NSS_USE_DEFAULT_SSL_ENABLE | NSS_USE_DEFAULT_SMIME_ENABLE) &

                  ~set);

    }

    return NSS_SetAlgorithmPolicy(oid, set, clear);

}

/* apply the operator specific policy */

SECStatus

secmod_setPolicyOperation(SECOidTag oid, NSSPolicyOperation operation,

                          PRUint32 value)

{

    SECStatus rv = SECSuccess;

    switch (operation) {

        case NSS_DISALLOW:

            /* clear the requested policy bits */

            rv = NSS_SetAlgorithmPolicy(oid, 0, value);

            break;

        case NSS_ALLOW:

            /* set the requested policy bits */

            rv = NSS_SetAlgorithmPolicy(oid, value, 0);

            break;

        case NSS_DISABLE:

        case NSS_ENABLE:

            rv = secmod_setDefault(oid, operation, value);

            break;

        default:

            PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);

            rv = SECFailure;

            break;

    }

    return rv;

}

const char *

secmod_getOperationString(NSSPolicyOperation operation)

{

    switch (operation) {

        case NSS_DISALLOW:

            return "disallow";

        case NSS_ALLOW:

            return "allow";

        case NSS_DISABLE:

            return "disable";

        case NSS_ENABLE:

            return "enable";

        default:

            break;

    }

    return "invalid";

}

/* Allow external applications fetch the policy oid based on the internal

 * string mapping used by the configuration system. The search can be

 * narrowed by supplying the name of the table (list) that the policy

 * is on. The value 'Any' allows the policy to be searched on all lists */

SECOidTag

SECMOD_PolicyStringToOid(const char *policy, const char *list)

{

    PRBool any = (PORT_Strcasecmp(list, "Any") == 0) ? PR_TRUE : PR_FALSE;

    int len = PORT_Strlen(policy);

    int i, j;

    for (i = 0; i < PR_ARRAY_SIZE(algOptLists); i++) {

        const algListsDef *algOptList = &algOptLists[i];

        if (any || (PORT_Strcasecmp(algOptList->description, list) == 0)) {

            for (j = 0; j < algOptList->entries; j++) {

                const oidValDef *algOpt = &algOptList->list[j];

                unsigned name_size = algOpt->name_size;

                if (len == name_size &&

                    PORT_Strcasecmp(algOpt->name, policy) == 0) {

                    return algOpt->oid;

                }

            }

        }

    }

    return SEC_OID_UNKNOWN;

}

/* Allow external applications fetch the NSS option based on the internal

 * string mapping used by the configuration system. */

PRUint32

SECMOD_PolicyStringToOpt(const char *policy)

{

    int len = PORT_Strlen(policy);

    int i;

    for (i = 0; i < PR_ARRAY_SIZE(freeOptList); i++) {

        const optionFreeDef *freeOpt = &freeOptList[i];

        unsigned name_size = freeOpt->name_size;

        if (len == name_size &&

            PORT_Strcasecmp(freeOpt->name, policy) == 0) {

            return freeOpt->option;

        }

    }

    return 0;

}

/* Allow external applications map policy flags to their string equivalance.

 * Some strings represent more than one flag. If more than one flag is included

 * the returned string is the string that contains any of the

 * supplied flags unless exact is specified. If exact is specified, then the

 * returned value matches all the included flags and only those flags. For

 * Example: 'ALL-SIGNATURE' has the bits NSS_USE_ALG_IN_CERTSIGNATURE|

 * NSS_USE_ALG_IN_SMIME_SIGNATURE|NSS_USE_ALG_IN_ANY_SIGNATURE. If you ask for

 * NSS_USE_ALG_IN_CERT_SIGNATURE|NSS_USE_ALG_IN_SMIME_SIGNATURE and don't set

 * exact, this function will return 'ALL-SIGNATURE' if you do set exact, you must

 * include all three bits in value to get 'All-SIGNATURE'*/

const char *

SECMOD_FlagsToPolicyString(PRUint32 val, PRBool exact)

{

    int i;

    for (i = 0; i < PR_ARRAY_SIZE(policyFlagList); i++) {

        const policyFlagDef *policy = &policyFlagList[i];

        if (exact && (policy->flag == val)) {

            return policy->name;

        }

        if (!exact && ((policy->flag & val) == policy->flag)) {

            return policy->name;

        }

    }

    return NULL;

}

static SECStatus

secmod_applyCryptoPolicy(const char *policyString, NSSPolicyOperation operation,

                         PRBool printPolicyFeedback, PRUint32 policyCheckFlags)

{

    const char *cipher, *currentString;

    unsigned i, j;

    SECStatus rv = SECSuccess;

    PRBool unknown;

    if (policyString == NULL || policyString[0] == 0) {

        return SECSuccess; /* do nothing */

    }

    /* if we change any of these, make sure it gets applied in ssl as well */

    NSS_SetAlgorithmPolicy(SEC_OID_APPLY_SSL_POLICY, NSS_USE_POLICY_IN_SSL, 0);

    for (currentString = policyString; currentString;) {

        int length;

        PRBool newValue = PR_FALSE;

        cipher = secmod_ArgGetSubValue(currentString, ':', 0, &length,

                                       &currentString);

        unknown = PR_TRUE;

        if (length >= 3 && cipher[3] == '/') {

            newValue = PR_TRUE;

        }

        if ((newValue || (length == 3)) && PORT_Strncasecmp(cipher, "all", 3) == 0) {

            /* disable or enable all options by default */

            PRUint32 value = 0;

            if (newValue) {

                value = secmod_parsePolicyValue(&cipher[3] + 1, length - 3 - 1, printPolicyFeedback, policyCheckFlags);

            }

            for (i = 0; i < PR_ARRAY_SIZE(algOptLists); i++) {

                const algListsDef *algOptList = &algOptLists[i];

                for (j = 0; j < algOptList->entries; j++) {

                    if (!newValue) {

                        value = algOptList->list[j].val;

                    }

                    secmod_setPolicyOperation(algOptList->list[j].oid, operation, value);

                }

            }

            continue;

        }

        for (i = 0; i < PR_ARRAY_SIZE(algOptLists); i++) {

            const algListsDef *algOptList = &algOptLists[i];

            for (j = 0; j < algOptList->entries; j++) {

                const oidValDef *algOpt = &algOptList->list[j];

                unsigned name_size = algOpt->name_size;

                PRBool newOption = PR_FALSE;

                if ((length >= name_size) && (cipher[name_size] == '/')) {

                    newOption = PR_TRUE;

                }

                if ((newOption || algOpt->name_size == length) &&

                    PORT_Strncasecmp(algOpt->name, cipher, name_size) == 0) {

                    PRUint32 value = algOpt->val;

                    if (newOption) {

                        value = secmod_parsePolicyValue(&cipher[name_size] + 1,

                                                        length - name_size - 1,

                                                        printPolicyFeedback,

                                                        policyCheckFlags);

                    }

                    rv = secmod_setPolicyOperation(algOptList->list[j].oid, operation, value);

                    if (rv != SECSuccess) {

                        /* could not enable option */

                        /* NSS_SetAlgorithPolicy should have set the error code */

                        return SECFailure;

                    }

                    unknown = PR_FALSE;

                    break;

                }

            }

        }

        if (!unknown) {

            continue;

        }

        for (i = 0; i < PR_ARRAY_SIZE(freeOptList); i++) {

            const optionFreeDef *freeOpt = &freeOptList[i];

            unsigned name_size = freeOpt->name_size;

            if ((length > name_size) && cipher[name_size] == '=' &&

                PORT_Strncasecmp(freeOpt->name, cipher, name_size) == 0) {

                PRInt32 val;

                const char *policyValue = &cipher[name_size + 1];

                int policyValueLength = length - name_size - 1;

                rv = secmod_getPolicyOptValue(policyValue, policyValueLength,

                                              &val);

                if (rv != SECSuccess) {

                    if (printPolicyFeedback &&

                        (policyCheckFlags & SECMOD_FLAG_POLICY_CHECK_VALUE)) {

                        PR_SetEnv("NSS_POLICY_FAIL=1");

                        fprintf(stderr, "NSS-POLICY-FAIL %.*s: unknown value: %.*s\n",

                                length, cipher, policyValueLength, policyValue);

                    }

                    return SECFailure;

                }

                rv = NSS_OptionSet(freeOpt->option, val);

                if (rv != SECSuccess) {

                    /* could not enable option */

                    /* NSS_OptionSet should have set the error code */

                    return SECFailure;

                }

                /* to allow the policy to expand in the future. ignore ciphers

                 * we don't understand */

                unknown = PR_FALSE;

                break;

            }

        }

        if (unknown && printPolicyFeedback &&