/* 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 contains functions to manage asymetric keys, (public and
 * private keys).
 */
#include <limits.h>
#include <stddef.h>

#include "seccomon.h"
#include "secmod.h"
#include "secmodi.h"
#include "secmodti.h"
#include "pkcs11.h"
#include "pkcs11t.h"
#include "pk11func.h"
#include "cert.h"
#include "keyhi.h"
#include "keyi.h"
#include "secitem.h"
#include "secasn1.h"
#include "secoid.h"
#include "secerr.h"
#include "sechash.h"

#include "secpkcs5.h"
#include "blapit.h"

const SECItem *
PK11_GetPublicValueFromPublicKey(const SECKEYPublicKey *pubKey)
{
    /* set the ID to the public key so we can find it again */
    const SECItem *pubKeyIndex = NULL;
    switch (pubKey->keyType) {
        case rsaKey:
        case rsaPssKey:
        case rsaOaepKey:
            pubKeyIndex = &pubKey->u.rsa.modulus;
            break;
        case dsaKey:
            pubKeyIndex = &pubKey->u.dsa.publicValue;
            break;
        case dhKey:
            pubKeyIndex = &pubKey->u.dh.publicValue;
            break;
        case edKey:
        case ecKey:
        case ecMontKey:
            pubKeyIndex = &pubKey->u.ec.publicValue;
            break;
        case kyberKey:
            pubKeyIndex = &pubKey->u.kyber.publicValue;
            break;
        case mldsaKey:
            pubKeyIndex = &pubKey->u.mldsa.publicValue;
            break;
        /* explicitly put unsupported keys here. The
         * compiler will  tell you when you need to
         * add switch statements */
        case fortezzaKey:
        case keaKey:
        case nullKey:
            return NULL;
    }
    PORT_Assert(pubKeyIndex != NULL);

    return pubKeyIndex;
}

KeyType
pk11_getKeyTypeFromPKCS11KeyType(CK_KEY_TYPE pk11KeyType)
{
    KeyType keyType = nullKey;
    switch (pk11KeyType) {
        case CKK_RSA:
            keyType = rsaKey;
            break;
        case CKK_DSA:
            keyType = dsaKey;
            break;
        case CKK_DH:
            keyType = dhKey;
            break;
        case CKK_EC:
            keyType = ecKey;
            break;
        case CKK_EC_MONTGOMERY:
            keyType = ecMontKey;
            break;
        case CKK_EC_EDWARDS:
            keyType = edKey;
            break;
        case CKK_NSS_KYBER:
        case CKK_NSS_ML_KEM:
        case CKK_ML_KEM:
            keyType = kyberKey;
            break;
        case CKK_ML_DSA:
            keyType = mldsaKey;
            break;
        default:
            PORT_SetError(SEC_ERROR_BAD_KEY);
            break;
    }
    return keyType;
}

CK_KEY_TYPE
pk11_getPKCS11KeyTypeFromKeyType(KeyType keyType)
{
    CK_KEY_TYPE pk11KeyType = CKK_INVALID_KEY_TYPE;
    switch (keyType) {
        case rsaKey:
        case rsaPssKey:
        case rsaOaepKey:
            pk11KeyType = CKK_RSA;
            break;
        case dsaKey:
            pk11KeyType = CKK_DSA;
            break;
        case dhKey:
            pk11KeyType = CKK_DH;
            break;
        case ecKey:
            pk11KeyType = CKK_EC;
            break;
        case ecMontKey:
            pk11KeyType = CKK_EC_MONTGOMERY;
            break;
        case edKey:
            pk11KeyType = CKK_EC_EDWARDS;
            break;
        case kyberKey:
            pk11KeyType = CKK_ML_KEM;
            break;
        case mldsaKey:
            pk11KeyType = CKK_ML_DSA;
            break;
        /* explicitly put unsupported keys here. The
         * compiler will  tell you when you need to
         * add switch statements */
        case fortezzaKey:
        case keaKey:
        case nullKey:
            break;
    }
    if (pk11KeyType == CKK_INVALID_KEY_TYPE) {
        PORT_SetError(SEC_ERROR_BAD_KEY);
    }
    return pk11KeyType;
}

SECItem *
pk11_MakeIDFromPublicKey(const SECKEYPublicKey *pubKey)
{
    /* set the ID to the public key so we can find it again */
    const SECItem *pubKeyIndex = PK11_GetPublicValueFromPublicKey(pubKey);
    PORT_Assert(pubKeyIndex != NULL);

    return PK11_MakeIDFromPubKey(pubKeyIndex);
}

/*
 * import a public key into the desired slot
 *
 * This function takes a public key structure and creates a public key in a
 * given slot. If isToken is set, then a persistant public key is created.
 *
 * Note: it is possible for this function to return a handle for a key which
 * is persistant, even if isToken is not set.
 */
CK_OBJECT_HANDLE
PK11_ImportPublicKey(PK11SlotInfo *slot, SECKEYPublicKey *pubKey,
                     PRBool isToken)
{
    CK_BBOOL cktrue = CK_TRUE;
    CK_BBOOL ckfalse = CK_FALSE;
    CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
    CK_KEY_TYPE keyType = CKK_GENERIC_SECRET;
    CK_OBJECT_HANDLE objectID;
    CK_ATTRIBUTE theTemplate[11];
    CK_ATTRIBUTE *signedattr = NULL;
    CK_ATTRIBUTE *attrs = theTemplate;
    CK_NSS_KEM_PARAMETER_SET_TYPE kemParams;
    SECItem *ckaId = NULL;
    SECItem *pubValue = NULL;
    int signedcount = 0;
    unsigned int templateCount = 0;
    SECStatus rv;
    CK_ML_DSA_PARAMETER_SET_TYPE paramSet;

    /* if we already have an object in the desired slot, use it */
    if (!isToken && pubKey->pkcs11Slot == slot) {
        return pubKey->pkcs11ID;
    }

    /* free the existing key */
    if (pubKey->pkcs11Slot != NULL) {
        PK11SlotInfo *oSlot = pubKey->pkcs11Slot;
        if (!PK11_IsPermObject(pubKey->pkcs11Slot, pubKey->pkcs11ID)) {
            PK11_EnterSlotMonitor(oSlot);
            (void)PK11_GETTAB(oSlot)->C_DestroyObject(oSlot->session,
                                                      pubKey->pkcs11ID);
            PK11_ExitSlotMonitor(oSlot);
        }
        PK11_FreeSlot(oSlot);
        pubKey->pkcs11Slot = NULL;
    }
    PK11_SETATTRS(attrs, CKA_CLASS, &keyClass, sizeof(keyClass));
    attrs++;
    PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(keyType));
    attrs++;
    PK11_SETATTRS(attrs, CKA_TOKEN, isToken ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    attrs++;
    if (isToken) {
        ckaId = pk11_MakeIDFromPublicKey(pubKey);
        if (ckaId == NULL) {
            PORT_SetError(SEC_ERROR_BAD_KEY);
            return CK_INVALID_HANDLE;
        }
        PK11_SETATTRS(attrs, CKA_ID, ckaId->data, ckaId->len);
        attrs++;
    }

    /* now import the key */
    {
        switch (pubKey->keyType) {
            case rsaKey:
                keyType = CKK_RSA;
                PK11_SETATTRS(attrs, CKA_WRAP, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                PK11_SETATTRS(attrs, CKA_ENCRYPT, &cktrue,
                              sizeof(CK_BBOOL));
                attrs++;
                PK11_SETATTRS(attrs, CKA_VERIFY, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                signedattr = attrs;
                PK11_SETATTRS(attrs, CKA_MODULUS, pubKey->u.rsa.modulus.data,
                              pubKey->u.rsa.modulus.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_PUBLIC_EXPONENT,
                              pubKey->u.rsa.publicExponent.data,
                              pubKey->u.rsa.publicExponent.len);
                attrs++;
                break;
            case dsaKey:
                keyType = CKK_DSA;
                PK11_SETATTRS(attrs, CKA_VERIFY, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                signedattr = attrs;
                PK11_SETATTRS(attrs, CKA_PRIME, pubKey->u.dsa.params.prime.data,
                              pubKey->u.dsa.params.prime.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_SUBPRIME, pubKey->u.dsa.params.subPrime.data,
                              pubKey->u.dsa.params.subPrime.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_BASE, pubKey->u.dsa.params.base.data,
                              pubKey->u.dsa.params.base.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_VALUE, pubKey->u.dsa.publicValue.data,
                              pubKey->u.dsa.publicValue.len);
                attrs++;
                break;
            case fortezzaKey:
                keyType = CKK_DSA;
                PK11_SETATTRS(attrs, CKA_VERIFY, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                signedattr = attrs;
                PK11_SETATTRS(attrs, CKA_PRIME, pubKey->u.fortezza.params.prime.data,
                              pubKey->u.fortezza.params.prime.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_SUBPRIME,
                              pubKey->u.fortezza.params.subPrime.data,
                              pubKey->u.fortezza.params.subPrime.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_BASE, pubKey->u.fortezza.params.base.data,
                              pubKey->u.fortezza.params.base.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_VALUE, pubKey->u.fortezza.DSSKey.data,
                              pubKey->u.fortezza.DSSKey.len);
                attrs++;
                break;
            case dhKey:
                keyType = CKK_DH;
                PK11_SETATTRS(attrs, CKA_DERIVE, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                signedattr = attrs;
                PK11_SETATTRS(attrs, CKA_PRIME, pubKey->u.dh.prime.data,
                              pubKey->u.dh.prime.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_BASE, pubKey->u.dh.base.data,
                              pubKey->u.dh.base.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_VALUE, pubKey->u.dh.publicValue.data,
                              pubKey->u.dh.publicValue.len);
                attrs++;
                break;
            case edKey:
                keyType = CKK_EC_EDWARDS;
                PK11_SETATTRS(attrs, CKA_VERIFY, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                PK11_SETATTRS(attrs, CKA_EC_PARAMS,
                              pubKey->u.ec.DEREncodedParams.data,
                              pubKey->u.ec.DEREncodedParams.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_EC_POINT,
                              pubKey->u.ec.publicValue.data,
                              pubKey->u.ec.publicValue.len);
                attrs++;
                break;
            case ecMontKey:
                keyType = CKK_EC_MONTGOMERY;
                PK11_SETATTRS(attrs, CKA_DERIVE, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                PK11_SETATTRS(attrs, CKA_EC_PARAMS,
                              pubKey->u.ec.DEREncodedParams.data,
                              pubKey->u.ec.DEREncodedParams.len);
                attrs++;
                PK11_SETATTRS(attrs, CKA_EC_POINT,
                              pubKey->u.ec.publicValue.data,
                              pubKey->u.ec.publicValue.len);
                attrs++;
                break;
            case ecKey:
                keyType = CKK_EC;
                PK11_SETATTRS(attrs, CKA_VERIFY, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                PK11_SETATTRS(attrs, CKA_DERIVE, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                PK11_SETATTRS(attrs, CKA_EC_PARAMS,
                              pubKey->u.ec.DEREncodedParams.data,
                              pubKey->u.ec.DEREncodedParams.len);
                attrs++;
                if (PR_GetEnvSecure("NSS_USE_DECODED_CKA_EC_POINT")) {
                    PK11_SETATTRS(attrs, CKA_EC_POINT,
                                  pubKey->u.ec.publicValue.data,
                                  pubKey->u.ec.publicValue.len);
                    attrs++;
                } else {
                    pubValue = SEC_ASN1EncodeItem(NULL, NULL,
                                                  &pubKey->u.ec.publicValue,
                                                  SEC_ASN1_GET(SEC_OctetStringTemplate));
                    if (pubValue == NULL) {
                        if (ckaId) {
                            SECITEM_FreeItem(ckaId, PR_TRUE);
                        }
                        return CK_INVALID_HANDLE;
                    }
                    PK11_SETATTRS(attrs, CKA_EC_POINT,
                                  pubValue->data, pubValue->len);
                    attrs++;
                }
                break;
            case kyberKey:
                keyType = CKK_ML_KEM;
#ifndef NSS_DISABLE_KYBER
                if ((pubKey->u.kyber.params == params_kyber768_round3) ||
                    (pubKey->u.kyber.params == params_kyber768_round3_test_mode)) {
                    keyType = CKK_NSS_KYBER;
                }
#endif
                PK11_SETATTRS(attrs, CKA_ENCAPSULATE, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                kemParams = seckey_GetMLKEMPkcs11ParamsByKyberParams(
                    pubKey->u.kyber.params);
                PK11_SETATTRS(attrs, CKA_PARAMETER_SET,
                              &kemParams,
                              sizeof(CK_NSS_KEM_PARAMETER_SET_TYPE));
                attrs++;
                PK11_SETATTRS(attrs, CKA_VALUE, pubKey->u.kyber.publicValue.data,
                              pubKey->u.kyber.publicValue.len);
                attrs++;
                break;
            case mldsaKey:
                keyType = CKK_ML_DSA;
                PK11_SETATTRS(attrs, CKA_VERIFY, &cktrue, sizeof(CK_BBOOL));
                attrs++;
                paramSet = SECKEY_GetMLDSAPkcs11ParamSetByOidTag(pubKey->u.mldsa.paramSet);
                if (paramSet == CKP_INVALID_ID) {
                    PORT_SetError(SEC_ERROR_BAD_KEY);
                    return CK_INVALID_HANDLE;
                }
                PK11_SETATTRS(attrs, CKA_PARAMETER_SET, &paramSet,
                              sizeof(CK_ML_DSA_PARAMETER_SET_TYPE));
                attrs++;
                PK11_SETATTRS(attrs, CKA_VALUE, pubKey->u.mldsa.publicValue.data,
                              pubKey->u.mldsa.publicValue.len);
                attrs++;
                break;
            default:
                if (ckaId) {
                    SECITEM_FreeItem(ckaId, PR_TRUE);
                }
                PORT_SetError(SEC_ERROR_BAD_KEY);
                return CK_INVALID_HANDLE;
        }
        templateCount = attrs - theTemplate;
        PORT_Assert(templateCount <= (sizeof(theTemplate) / sizeof(CK_ATTRIBUTE)));
        if (signedattr) {
            signedcount = attrs - signedattr;
            for (attrs = signedattr; signedcount; attrs++, signedcount--) {
                pk11_SignedToUnsigned(attrs);
            }
        }
        rv = PK11_CreateNewObject(slot, CK_INVALID_HANDLE, theTemplate,
                                  templateCount, isToken, &objectID);
        if (ckaId) {
            SECITEM_FreeItem(ckaId, PR_TRUE);
        }
        if (pubValue) {
            SECITEM_FreeItem(pubValue, PR_TRUE);
        }
        if (rv != SECSuccess) {
            return CK_INVALID_HANDLE;
        }
    }

    pubKey->pkcs11ID = objectID;
    pubKey->pkcs11Slot = PK11_ReferenceSlot(slot);

    return objectID;
}

/*
 * take an attribute and copy it into a secitem
 */
static CK_RV
pk11_Attr2SecItem(PLArenaPool *arena, const CK_ATTRIBUTE *attr, SECItem *item)
{
    item->data = NULL;

    (void)SECITEM_AllocItem(arena, item, attr->ulValueLen);
    if (item->data == NULL) {
        return CKR_HOST_MEMORY;
    }
    PORT_Memcpy(item->data, attr->pValue, item->len);
    return CKR_OK;
}

/*
 * get a curve length from a set of ecParams.
 *
 * We need this so we can reliably determine if the ecPoint passed to us
 * was encoded or not. With out this, for many curves, we would incorrectly
 * identify an unencoded curve as an encoded curve 1 in 65536 times, and for
 * a few we would make that same mistake 1 in 32768 times. These are bad
 * numbers since they are rare enough to pass tests, but common enough to
 * be tripped over in the field.
 *
 * This function will only work for curves we recognized as of March 2009.
 * The assumption is curves in use after March of 2009 would be supplied by
 * PKCS #11 modules that already pass the correct encoding to us.
 *
 * Point length = (Roundup(curveLenInBits/8)*2+1)
 */
static int
pk11_get_EC_PointLenInBytes(PLArenaPool *arena, const SECItem *ecParams,
                            PRBool *plain)
{
    SECItem oid;
    SECOidTag tag;
    SECStatus rv;

    /* decode the OID tag */
    rv = SEC_QuickDERDecodeItem(arena, &oid,
                                SEC_ASN1_GET(SEC_ObjectIDTemplate), ecParams);
    if (rv != SECSuccess) {
        /* could be explict curves, allow them to work if the
         * PKCS #11 module support them. If we try to parse the
         * explicit curve value in the future, we may return -1 here
         * to indicate an invalid parameter if the explicit curve
         * decode fails. */
        return 0;
    }

    *plain = PR_FALSE;
    tag = SECOID_FindOIDTag(&oid);
    switch (tag) {
        case SEC_OID_SECG_EC_SECP112R1:
        case SEC_OID_SECG_EC_SECP112R2:
            return 29; /* curve len in bytes = 14 bytes */
        case SEC_OID_SECG_EC_SECT113R1:
        case SEC_OID_SECG_EC_SECT113R2:
            return 31; /* curve len in bytes = 15 bytes */
        case SEC_OID_SECG_EC_SECP128R1:
        case SEC_OID_SECG_EC_SECP128R2:
            return 33; /* curve len in bytes = 16 bytes */
        case SEC_OID_SECG_EC_SECT131R1:
        case SEC_OID_SECG_EC_SECT131R2:
            return 35; /* curve len in bytes = 17 bytes */
        case SEC_OID_SECG_EC_SECP160K1:
        case SEC_OID_SECG_EC_SECP160R1:
        case SEC_OID_SECG_EC_SECP160R2:
            return 41; /* curve len in bytes = 20 bytes */
        case SEC_OID_SECG_EC_SECT163K1:
        case SEC_OID_SECG_EC_SECT163R1:
        case SEC_OID_SECG_EC_SECT163R2:
        case SEC_OID_ANSIX962_EC_C2PNB163V1:
        case SEC_OID_ANSIX962_EC_C2PNB163V2:
        case SEC_OID_ANSIX962_EC_C2PNB163V3:
            return 43; /* curve len in bytes = 21 bytes */
        case SEC_OID_ANSIX962_EC_C2PNB176V1:
            return 45; /* curve len in bytes = 22 bytes */
        case SEC_OID_ANSIX962_EC_C2TNB191V1:
        case SEC_OID_ANSIX962_EC_C2TNB191V2:
        case SEC_OID_ANSIX962_EC_C2TNB191V3:
        case SEC_OID_SECG_EC_SECP192K1:
        case SEC_OID_ANSIX962_EC_PRIME192V1:
        case SEC_OID_ANSIX962_EC_PRIME192V2:
        case SEC_OID_ANSIX962_EC_PRIME192V3:
            return 49; /*curve len in bytes = 24 bytes */
        case SEC_OID_SECG_EC_SECT193R1:
        case SEC_OID_SECG_EC_SECT193R2:
            return 51; /*curve len in bytes = 25 bytes */
        case SEC_OID_ANSIX962_EC_C2PNB208W1:
            return 53; /*curve len in bytes = 26 bytes */
        case SEC_OID_SECG_EC_SECP224K1:
        case SEC_OID_SECG_EC_SECP224R1:
            return 57; /*curve len in bytes = 28 bytes */
        case SEC_OID_SECG_EC_SECT233K1:
        case SEC_OID_SECG_EC_SECT233R1:
        case SEC_OID_SECG_EC_SECT239K1:
        case SEC_OID_ANSIX962_EC_PRIME239V1:
        case SEC_OID_ANSIX962_EC_PRIME239V2:
        case SEC_OID_ANSIX962_EC_PRIME239V3:
        case SEC_OID_ANSIX962_EC_C2TNB239V1:
        case SEC_OID_ANSIX962_EC_C2TNB239V2:
        case SEC_OID_ANSIX962_EC_C2TNB239V3:
            return 61; /*curve len in bytes = 30 bytes */
        case SEC_OID_ANSIX962_EC_PRIME256V1:
        case SEC_OID_SECG_EC_SECP256K1:
            return 65; /*curve len in bytes = 32 bytes */
        case SEC_OID_ANSIX962_EC_C2PNB272W1:
            return 69; /*curve len in bytes = 34 bytes */
        case SEC_OID_SECG_EC_SECT283K1:
        case SEC_OID_SECG_EC_SECT283R1:
            return 73; /*curve len in bytes = 36 bytes */
        case SEC_OID_ANSIX962_EC_C2PNB304W1:
            return 77; /*curve len in bytes = 38 bytes */
        case SEC_OID_ANSIX962_EC_C2TNB359V1:
            return 91; /*curve len in bytes = 45 bytes */
        case SEC_OID_ANSIX962_EC_C2PNB368W1:
            return 93; /*curve len in bytes = 46 bytes */
        case SEC_OID_SECG_EC_SECP384R1:
            return 97; /*curve len in bytes = 48 bytes */
        case SEC_OID_SECG_EC_SECT409K1:
        case SEC_OID_SECG_EC_SECT409R1:
            return 105; /*curve len in bytes = 52 bytes */
        case SEC_OID_ANSIX962_EC_C2TNB431R1:
            return 109; /*curve len in bytes = 54 bytes */
        case SEC_OID_SECG_EC_SECP521R1:
            return 133; /*curve len in bytes = 66 bytes */
        case SEC_OID_SECG_EC_SECT571K1:
        case SEC_OID_SECG_EC_SECT571R1:
            return 145; /*curve len in bytes = 72 bytes */
        case SEC_OID_X25519:
        case SEC_OID_CURVE25519:
        case SEC_OID_ED25519_PUBLIC_KEY:
            *plain = PR_TRUE;
            return 32; /* curve len in bytes = 32 bytes (only X) */
        /* unknown or unrecognized OIDs. return unknown length */
        default:
            break;
    }
    return 0;
}

/*
 * returns the decoded point. In some cases the point may already be decoded.
 * this function tries to detect those cases and return the point in
 * publicKeyValue. In other cases it's DER encoded. In those cases the point
 * is first decoded and returned. Space for the point is allocated out of
 * the passed in arena.
 */
static CK_RV
pk11_get_Decoded_ECPoint(PLArenaPool *arena, const SECItem *ecParams,
                         const CK_ATTRIBUTE *ecPoint, SECItem *publicKeyValue)
{
    SECItem encodedPublicValue;
    SECStatus rv;
    int keyLen;
    PRBool plain = PR_FALSE;

    if (ecPoint->ulValueLen == 0) {
        return CKR_ATTRIBUTE_VALUE_INVALID;
    }

    /*
     * The PKCS #11 spec requires ecPoints to be encoded as a DER OCTET String.
     * NSS has mistakenly passed unencoded values, and some PKCS #11 vendors
     * followed that mistake. Now we need to detect which encoding we were
     * passed in. The task is made more complicated by the fact the the
     * DER encoding byte (SEC_ASN_OCTET_STRING) is the same as the
     * EC_POINT_FORM_UNCOMPRESSED byte (0x04), so we can't use that to
     * determine which curve we are using.
     */

    /* get the expected key length for the passed in curve.
     * pk11_get_EC_PointLenInBytes only returns valid values for curves
     * NSS has traditionally recognized. If the curve is not recognized,
     * it will return '0', and we have to figure out if the key was
     * encoded or not heuristically. If the ecParams are invalid, it
     * will return -1 for the keyLen.
     */
    keyLen = pk11_get_EC_PointLenInBytes(arena, ecParams, &plain);
    if (keyLen < 0) {
        return CKR_ATTRIBUTE_VALUE_INVALID;
    }

    /*
     * Some curves are not encoded but we don't have the name here.
     * Instead, pk11_get_EC_PointLenInBytes returns true plain if this is the
     * case.
     */
    if (plain && ecPoint->ulValueLen == (unsigned int)keyLen) {
        return pk11_Attr2SecItem(arena, ecPoint, publicKeyValue);
    }

    /* If the point is uncompressed and the lengths match, it
     * must be an unencoded point */
    if ((*((char *)ecPoint->pValue) == EC_POINT_FORM_UNCOMPRESSED) &&
        (ecPoint->ulValueLen == (unsigned int)keyLen)) {
        return pk11_Attr2SecItem(arena, ecPoint, publicKeyValue);
    }

    /* now assume the key passed to us was encoded and decode it */
    if (*((char *)ecPoint->pValue) == SEC_ASN1_OCTET_STRING) {
        /* OK, now let's try to decode it and see if it's valid */
        encodedPublicValue.data = ecPoint->pValue;
        encodedPublicValue.len = ecPoint->ulValueLen;
        rv = SEC_QuickDERDecodeItem(arena, publicKeyValue,
                                    SEC_ASN1_GET(SEC_OctetStringTemplate), &encodedPublicValue);

        /* it coded correctly & we know the key length (and they match)
         * then we are done, return the results. */
        if (keyLen && rv == SECSuccess && publicKeyValue->len == (unsigned int)keyLen) {
            return CKR_OK;
        }

        /* if we know the key length, one of the above tests should have
         * succeded. If it doesn't the module gave us bad data */
        if (keyLen) {
            return CKR_ATTRIBUTE_VALUE_INVALID;
        }

        /* We don't know the key length, so we don't know deterministically
         * which encoding was used. We now will try to pick the most likely
         * form that's correct, with a preference for the encoded form if we
         * can't determine for sure. We do this by checking the key we got
         * back from SEC_QuickDERDecodeItem for defects. If no defects are
         * found, we assume the encoded parameter was was passed to us.
         * our defect tests include:
         *   1) it didn't decode.
         *   2) The decode key had an invalid length (must be odd).
         *   3) The decoded key wasn't an UNCOMPRESSED key.
         *   4) The decoded key didn't include the entire encoded block
         *   except the DER encoding values. (fixing DER length to one
         *   particular value).
         */
        if ((rv != SECSuccess) || ((publicKeyValue->len & 1) != 1) ||
            (publicKeyValue->data[0] != EC_POINT_FORM_UNCOMPRESSED) ||
            (PORT_Memcmp(&encodedPublicValue.data[encodedPublicValue.len - publicKeyValue->len],
                         publicKeyValue->data,
                         publicKeyValue->len) != 0)) {
            /* The decoded public key was flawed, the original key must have
             * already been in decoded form. Do a quick sanity check then
             * return the original key value.
             */
            if ((encodedPublicValue.len & 1) == 0) {
                return CKR_ATTRIBUTE_VALUE_INVALID;
            }
            return pk11_Attr2SecItem(arena, ecPoint, publicKeyValue);
        }

        /* as best we can figure, the passed in key was encoded, and we've
         * now decoded it. Note: there is a chance this could be wrong if the
         * following conditions hold:
         *  1) The first byte or bytes of the X point looks like a valid length
         * of precisely the right size (2*curveSize -1). this means for curves
         * less than 512 bits (64 bytes), this will happen 1 in 256 times*.
         * for curves between 512 and 1024, this will happen 1 in 65,536 times*
         * for curves between 1024 and 256K this will happen 1 in 16 million*
         *  2) The length of the 'DER length field' is odd
         * (making both the encoded and decode
         * values an odd length. this is true of all curves less than 512,
         * as well as curves between 1024 and 256K).
         *  3) The X[length of the 'DER length field'] == 0x04, 1 in 256.
         *
         *  (* assuming all values are equally likely in the first byte,
         * This isn't true if the curve length is not a multiple of 8. In these
         * cases, if the DER length is possible, it's more likely,
         * if it's not possible, then we have no false decodes).
         *
         * For reference here are the odds for the various curves we currently
         * have support for (and the only curves SSL will negotiate at this
         * time). NOTE: None of the supported curves will show up here
         * because we return a valid length for all of these curves.
         * The only way to get here is to have some application (not SSL)
         * which supports some unknown curve and have some vendor supplied
         * PKCS #11 module support that curve. NOTE: in this case, one
         * presumes that that pkcs #11 module is likely to be using the
         * correct encodings.
         *
         * Prime Curves (GFp):
         *   Bit    False       Odds of
         *  Size    DER Len  False Decode Positive
         *  112     27     1 in 65536
         *  128     31     1 in 65536
         *  160     39     1 in 65536
         *  192     47     1 in 65536
         *  224     55     1 in 65536
         *  239     59     1 in 32768 (top byte can only be 0-127)
         *  256     63     1 in 65536
         *  521     129,131      0        (decoded value would be even)
         *
         * Binary curves (GF2m).
         *   Bit    False       Odds of
         *  Size    DER Len  False Decode Positive
         *  131     33       0        (top byte can only be 0-7)
         *  163     41       0        (top byte can only be 0-7)
         *  176     43     1 in 65536
         *  191     47     1 in 32768 (top byte can only be 0-127)
         *  193     49       0        (top byte can only be 0-1)
         *  208     51     1 in 65536
         *  233     59       0        (top byte can only be 0-1)
         *  239     59     1 in 32768 (top byte can only be 0-127)
         *  272     67     1 in 65536
         *  283     71       0        (top byte can only be 0-7)
         *  304     75     1 in 65536
         *  359     89     1 in 32768 (top byte can only be 0-127)
         *  368     91     1 in 65536
         *  409     103      0        (top byte can only be 0-1)
         *  431     107    1 in 32768 (top byte can only be 0-127)
         *  571     129,143      0        (decoded value would be even)
         *
         */

        return CKR_OK;
    }

    /* In theory, we should handle the case where the curve == 0 and
     * the first byte is EC_POINT_FORM_UNCOMPRESSED, (which would be
     * handled by doing a santity check on the key length and returning
     * pk11_Attr2SecItem() to copy the ecPoint to the publicKeyValue).
     *
     * This test is unnecessary, however, due to the fact that
     * EC_POINT_FORM_UNCOMPRESSED == SEC_ASIN1_OCTET_STRING, that case is
     * handled in the above if. That means if we get here, the initial
     * byte of our ecPoint value was invalid, so we can safely return.
     * invalid attribute.
     */

    return CKR_ATTRIBUTE_VALUE_INVALID;
}

/*
 * extract a public key from a slot and id
 */
SECKEYPublicKey *
PK11_ExtractPublicKey(PK11SlotInfo *slot, KeyType keyType, CK_OBJECT_HANDLE id)
{
    CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
    PLArenaPool *arena;
    PLArenaPool *tmp_arena;
    SECKEYPublicKey *pubKey;
    unsigned int templateCount = 0;
    CK_KEY_TYPE pk11KeyType;
    CK_RV crv;
    CK_ATTRIBUTE template[8];
    CK_ATTRIBUTE *attrs = template;
    CK_ATTRIBUTE *modulus, *exponent, *base, *prime, *subprime, *value;
    CK_ATTRIBUTE *ecparams, *kemParams, *mldsaParams;

    /* if we didn't know the key type, get it */
    if (keyType == nullKey) {
        pk11KeyType = PK11_ReadULongAttribute(slot, id, CKA_KEY_TYPE);
        if (pk11KeyType == CK_UNAVAILABLE_INFORMATION) {
            return NULL;
        }
        keyType = pk11_getKeyTypeFromPKCS11KeyType(pk11KeyType);
        if (keyType == nullKey) {
            return NULL;
        }
    }

    /* now we need to create space for the public key */
    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    if (arena == NULL)
        return NULL;
    tmp_arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    if (tmp_arena == NULL) {
        PORT_FreeArena(arena, PR_FALSE);
        return NULL;
    }

    pubKey = (SECKEYPublicKey *)
        PORT_ArenaZAlloc(arena, sizeof(SECKEYPublicKey));
    if (pubKey == NULL) {
        PORT_FreeArena(arena, PR_FALSE);
        PORT_FreeArena(tmp_arena, PR_FALSE);
        return NULL;
    }

    pubKey->arena = arena;
    pubKey->keyType = keyType;
    pubKey->pkcs11Slot = PK11_ReferenceSlot(slot);
    pubKey->pkcs11ID = id;
    PK11_SETATTRS(attrs, CKA_CLASS, &keyClass,
                  sizeof(keyClass));
    attrs++;
    PK11_SETATTRS(attrs, CKA_KEY_TYPE, &pk11KeyType,
                  sizeof(pk11KeyType));
    attrs++;
    switch (pubKey->keyType) {
        case rsaKey:
            modulus = attrs;
            PK11_SETATTRS(attrs, CKA_MODULUS, NULL, 0);
            attrs++;
            exponent = attrs;
            PK11_SETATTRS(attrs, CKA_PUBLIC_EXPONENT, NULL, 0);
            attrs++;

            templateCount = attrs - template;
            PR_ASSERT(templateCount <= sizeof(template) / sizeof(CK_ATTRIBUTE));
            crv = PK11_GetAttributes(tmp_arena, slot, id, template, templateCount);
            if (crv != CKR_OK)
                break;

            if ((keyClass != CKO_PUBLIC_KEY) || (pk11KeyType != CKK_RSA)) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }
            crv = pk11_Attr2SecItem(arena, modulus, &pubKey->u.rsa.modulus);
            if (crv != CKR_OK)
                break;
            crv = pk11_Attr2SecItem(arena, exponent, &pubKey->u.rsa.publicExponent);
            if (crv != CKR_OK)
                break;
            break;
        case dsaKey:
            prime = attrs;
            PK11_SETATTRS(attrs, CKA_PRIME, NULL, 0);
            attrs++;
            subprime = attrs;
            PK11_SETATTRS(attrs, CKA_SUBPRIME, NULL, 0);
            attrs++;
            base = attrs;
            PK11_SETATTRS(attrs, CKA_BASE, NULL, 0);
            attrs++;
            value = attrs;
            PK11_SETATTRS(attrs, CKA_VALUE, NULL, 0);
            attrs++;
            templateCount = attrs - template;
            PR_ASSERT(templateCount <= sizeof(template) / sizeof(CK_ATTRIBUTE));
            crv = PK11_GetAttributes(tmp_arena, slot, id, template, templateCount);
            if (crv != CKR_OK)
                break;

            if ((keyClass != CKO_PUBLIC_KEY) || (pk11KeyType != CKK_DSA)) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }
            crv = pk11_Attr2SecItem(arena, prime, &pubKey->u.dsa.params.prime);
            if (crv != CKR_OK)
                break;
            crv = pk11_Attr2SecItem(arena, subprime, &pubKey->u.dsa.params.subPrime);
            if (crv != CKR_OK)
                break;
            crv = pk11_Attr2SecItem(arena, base, &pubKey->u.dsa.params.base);
            if (crv != CKR_OK)
                break;
            crv = pk11_Attr2SecItem(arena, value, &pubKey->u.dsa.publicValue);
            if (crv != CKR_OK)
                break;
            break;
        case dhKey:
            prime = attrs;
            PK11_SETATTRS(attrs, CKA_PRIME, NULL, 0);
            attrs++;
            base = attrs;
            PK11_SETATTRS(attrs, CKA_BASE, NULL, 0);
            attrs++;
            value = attrs;
            PK11_SETATTRS(attrs, CKA_VALUE, NULL, 0);
            attrs++;
            templateCount = attrs - template;
            PR_ASSERT(templateCount <= sizeof(template) / sizeof(CK_ATTRIBUTE));
            crv = PK11_GetAttributes(tmp_arena, slot, id, template, templateCount);
            if (crv != CKR_OK)
                break;

            if ((keyClass != CKO_PUBLIC_KEY) || (pk11KeyType != CKK_DH)) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }
            crv = pk11_Attr2SecItem(arena, prime, &pubKey->u.dh.prime);
            if (crv != CKR_OK)
                break;
            crv = pk11_Attr2SecItem(arena, base, &pubKey->u.dh.base);
            if (crv != CKR_OK)
                break;
            crv = pk11_Attr2SecItem(arena, value, &pubKey->u.dh.publicValue);
            if (crv != CKR_OK)
                break;
            break;
        case edKey:
        case ecKey:
        case ecMontKey:
            pubKey->u.ec.size = 0;
            ecparams = attrs;
            PK11_SETATTRS(attrs, CKA_EC_PARAMS, NULL, 0);
            attrs++;
            value = attrs;
            PK11_SETATTRS(attrs, CKA_EC_POINT, NULL, 0);
            attrs++;
            templateCount = attrs - template;
            PR_ASSERT(templateCount <= sizeof(template) / sizeof(CK_ATTRIBUTE));
            crv = PK11_GetAttributes(arena, slot, id, template, templateCount);
            if (crv != CKR_OK)
                break;

            if ((keyClass != CKO_PUBLIC_KEY) ||
                (pubKey->keyType == ecKey && pk11KeyType != CKK_EC) ||
                (pubKey->keyType == edKey && pk11KeyType != CKK_EC_EDWARDS) ||
                (pubKey->keyType == ecMontKey && pk11KeyType != CKK_EC_MONTGOMERY)) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }

            crv = pk11_Attr2SecItem(arena, ecparams,
                                    &pubKey->u.ec.DEREncodedParams);
            if (crv != CKR_OK)
                break;
            pubKey->u.ec.encoding = ECPoint_Undefined;
            crv = pk11_get_Decoded_ECPoint(arena,
                                           &pubKey->u.ec.DEREncodedParams, value,
                                           &pubKey->u.ec.publicValue);
            break;
        case mldsaKey:
            value = attrs;
            PK11_SETATTRS(attrs, CKA_VALUE, NULL, 0);
            attrs++;
            mldsaParams = attrs;
            PK11_SETATTRS(attrs, CKA_PARAMETER_SET, NULL, 0);
            attrs++;
            templateCount = attrs - template;
            PR_ASSERT(templateCount <= sizeof(template) / sizeof(CK_ATTRIBUTE));
            crv = PK11_GetAttributes(tmp_arena, slot, id, template, templateCount);
            if (crv != CKR_OK)
                break;

            if ((keyClass != CKO_PUBLIC_KEY) || (pk11KeyType != CKK_ML_DSA)) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }

            if (mldsaParams->ulValueLen != sizeof(CK_ML_DSA_PARAMETER_SET_TYPE)) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }
            pubKey->u.mldsa.paramSet = SECKEY_GetMLDSAOidTagByPkcs11ParamSet(
                *(CK_ML_DSA_PARAMETER_SET_TYPE *)mldsaParams->pValue);

            crv = pk11_Attr2SecItem(arena, value, &pubKey->u.mldsa.publicValue);
            if (crv != CKR_OK)
                break;
            break;
        case kyberKey:
            value = attrs;
            PK11_SETATTRS(attrs, CKA_VALUE, NULL, 0);
            attrs++;
            kemParams = attrs;
            PK11_SETATTRS(attrs, CKA_PARAMETER_SET, NULL, 0);
            attrs++;
            templateCount = attrs - template;
            PR_ASSERT(templateCount <= sizeof(template) / sizeof(CK_ATTRIBUTE));

            crv = PK11_GetAttributes(arena, slot, id, template, templateCount);
            if (crv != CKR_OK) {
                kemParams->type = CKA_NSS_PARAMETER_SET;
                crv = PK11_GetAttributes(arena, slot, id, template,
                                         templateCount);
                if (crv != CKR_OK) {
                    break;
                }
            }

            if (keyClass != CKO_PUBLIC_KEY) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }

            switch (pk11KeyType) {
#ifndef NSS_DISABLE_KYBER
                case CKK_NSS_KYBER:
#endif
                case CKK_NSS_ML_KEM:
                case CKK_ML_KEM:
                    break;
                default:
                    crv = CKR_OBJECT_HANDLE_INVALID;
                    break;
            }
            if (crv != CKR_OK) {
                break;
            }

            if (kemParams->ulValueLen != sizeof(CK_NSS_KEM_PARAMETER_SET_TYPE)) {
                crv = CKR_OBJECT_HANDLE_INVALID;
                break;
            }
            CK_NSS_KEM_PARAMETER_SET_TYPE *pPK11Params = kemParams->pValue;
            pubKey->u.kyber.params = seckey_GetKyberParamsByPkcs11ParamSet(
                *pPK11Params);
            crv = pk11_Attr2SecItem(arena, value, &pubKey->u.kyber.publicValue);
            break;
        case fortezzaKey:
        case nullKey:
        default:
            crv = CKR_OBJECT_HANDLE_INVALID;
            break;
    }

    PORT_FreeArena(tmp_arena, PR_FALSE);

    if (crv != CKR_OK) {
        PORT_FreeArena(arena, PR_FALSE);
        PK11_FreeSlot(slot);
        PORT_SetError(PK11_MapError(crv));
        return NULL;
    }

    return pubKey;
}

/*
 * Build a Private Key structure from raw PKCS #11 information.
 */
SECKEYPrivateKey *
pk11_MakePrivKey(PK11SlotInfo *slot, KeyType keyType,
                 PRBool isOwner, CK_OBJECT_HANDLE privID, void *wincx)
{
    PLArenaPool *arena;
    SECKEYPrivateKey *privKey;
    PRBool isPrivate;
    SECStatus rv;
    PRBool isTemp = isOwner;

    /* don't know? look it up */
    if (keyType == nullKey) {
        CK_KEY_TYPE pk11Type = CKK_RSA;

        pk11Type = PK11_ReadULongAttribute(slot, privID, CKA_KEY_TYPE);
        isTemp = (PRBool)!PK11_HasAttributeSet(slot, privID, CKA_TOKEN, PR_FALSE);
        /* we can never own a perm key, make sure we don't set owner if
         * the key isn't a temp key */
        isOwner = isOwner && isTemp;
        keyType = pk11_getKeyTypeFromPKCS11KeyType(pk11Type);
        if (keyType == nullKey) {
            return NULL;
        }
    }

    /* if the key is private, make sure we are authenticated to the
     * token before we try to use it */
    isPrivate = (PRBool)PK11_HasAttributeSet(slot, privID, CKA_PRIVATE, PR_FALSE);
    if (isPrivate) {
        rv = PK11_Authenticate(slot, PR_TRUE, wincx);
        if (rv != SECSuccess) {
            return NULL;
        }
    }

    /* now we need to create space for the private key */
    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    if (arena == NULL)
        return NULL;

    privKey = (SECKEYPrivateKey *)
        PORT_ArenaZAlloc(arena, sizeof(SECKEYPrivateKey));
    if (privKey == NULL) {
        PORT_FreeArena(arena, PR_FALSE);
        return NULL;
    }

    privKey->arena = arena;
    privKey->keyType = keyType;
    privKey->pkcs11Slot = PK11_ReferenceSlot(slot);
    privKey->pkcs11ID = privID;
    privKey->pkcs11IsTemp = 0;
    SECKEYPRIVATEKEY_SET_TEMP(privKey, isTemp);
    SECKEYPRIVATEKEY_SET_OWNED(privKey, isOwner);
    privKey->wincx = wincx;

    return privKey;
}

PK11SlotInfo *
PK11_GetSlotFromPrivateKey(SECKEYPrivateKey *key)
{
    PK11SlotInfo *slot = key->pkcs11Slot;
    slot = PK11_ReferenceSlot(slot);
    return slot;
}

/*
 * Get the modulus length for raw parsing
 */
int
PK11_GetPrivateModulusLen(SECKEYPrivateKey *key)
{
    CK_ATTRIBUTE theTemplate = { CKA_MODULUS, NULL, 0 };
    PK11SlotInfo *slot = key->pkcs11Slot;
    CK_RV crv;
    int length;

    switch (key->keyType) {
        case rsaKey:
            crv = PK11_GetAttributes(NULL, slot, key->pkcs11ID, &theTemplate, 1);
            if (crv != CKR_OK) {
                PORT_SetError(PK11_MapError(crv));
                return -1;
            }
            if (theTemplate.pValue == NULL) {
                PORT_SetError(PK11_MapError(CKR_ATTRIBUTE_VALUE_INVALID));
                return -1;
            }
            length = theTemplate.ulValueLen;
            if (*(unsigned char *)theTemplate.pValue == 0) {
                length--;
            }
            PORT_Free(theTemplate.pValue);
            return (int)length;
        default:
            break;
    }
    if (theTemplate.pValue != NULL)
        PORT_Free(theTemplate.pValue);
    PORT_SetError(SEC_ERROR_INVALID_KEY);
    return -1;
}

/*
 * take a private key in one pkcs11 module and load it into another:
 *  NOTE: the source private key is a rare animal... it can't be sensitive.
 *  This is used to do a key gen using one pkcs11 module and storing the
 *  result into another.
 */
static SECKEYPrivateKey *
pk11_loadPrivKeyWithFlags(PK11SlotInfo *slot, SECKEYPrivateKey *privKey,
                          SECKEYPublicKey *pubKey, PK11AttrFlags attrFlags)
{
    CK_ATTRIBUTE privTemplate[] = {
        /* class must be first */
        { CKA_CLASS, NULL, 0 },
        { CKA_KEY_TYPE, NULL, 0 },
        { CKA_ID, NULL, 0 },
        /* RSA - the attributes below will be replaced for other
         *       key types.
         */
        { CKA_MODULUS, NULL, 0 },
        { CKA_PRIVATE_EXPONENT, NULL, 0 },
        { CKA_PUBLIC_EXPONENT, NULL, 0 },
        { CKA_PRIME_1, NULL, 0 },
        { CKA_PRIME_2, NULL, 0 },
        { CKA_EXPONENT_1, NULL, 0 },
        { CKA_EXPONENT_2, NULL, 0 },
        { CKA_COEFFICIENT, NULL, 0 },
        { CKA_DECRYPT, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_SIGN, NULL, 0 },
        { CKA_SIGN_RECOVER, NULL, 0 },
        { CKA_UNWRAP, NULL, 0 },
        { CKA_DECAPSULATE, NULL, 0 },
        /* reserve space for the attributes that may be
         * specified in attrFlags */
        { CKA_TOKEN, NULL, 0 },
        { CKA_PRIVATE, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_SENSITIVE, NULL, 0 },
        { CKA_EXTRACTABLE, NULL, 0 },
        { CKA_PARAMETER_SET, NULL, 0 },
        { CKA_SEED, NULL, 0 },
#define NUM_RESERVED_ATTRS 5 /* number of reserved attributes above */
    };
    CK_BBOOL cktrue = CK_TRUE;
    CK_BBOOL ckfalse = CK_FALSE;
    CK_ATTRIBUTE *attrs = NULL, *ap;
    const int templateSize = sizeof(privTemplate) / sizeof(privTemplate[0]);
    PLArenaPool *arena;
    CK_OBJECT_HANDLE objectID;
    int i, count = 0;
    int extra_count = 0; /* count of signed attributes */
    CK_RV crv;
    SECStatus rv;
    PRBool token = ((attrFlags & PK11_ATTR_TOKEN) != 0);

    if (pk11_BadAttrFlags(attrFlags)) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return NULL;
    }

    for (i = 0; i < templateSize; i++) {
        if (privTemplate[i].type == CKA_MODULUS) {
            attrs = &privTemplate[i];
            count = i;
            break;
        }
    }
    PORT_Assert(attrs != NULL);
    if (attrs == NULL) {
        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
        return NULL;
    }

    ap = attrs;

    switch (privKey->keyType) {
        case rsaKey:
            count = templateSize - NUM_RESERVED_ATTRS;
            extra_count = count - (attrs - privTemplate);
            break;
        case dsaKey:
            ap->type = CKA_PRIME;
            ap++;
            count++;
            extra_count++;
            ap->type = CKA_SUBPRIME;
            ap++;
            count++;
            extra_count++;
            ap->type = CKA_BASE;
            ap++;
            count++;
            extra_count++;
            ap->type = CKA_VALUE;
            ap++;
            count++;
            extra_count++;
            ap->type = CKA_SIGN;
            ap++;
            count++;
            extra_count++;
            break;
        case dhKey:
            ap->type = CKA_PRIME;
            ap++;
            count++;
            extra_count++;
            ap->type = CKA_BASE;
            ap++;
            count++;
            extra_count++;
            ap->type = CKA_VALUE;
            ap++;
            count++;
            extra_count++;
            ap->type = CKA_DERIVE;
            ap++;
            count++;
            extra_count++;
            break;
        case mldsaKey:
            ap->type = CKA_PARAMETER_SET;
            ap++;
            count++;
            ap->type = CKA_SEED;
            ap++;
            count++;
            ap->type = CKA_VALUE;
            ap++;
            count++;
            ap->type = CKA_SIGN;
            ap++;
            count++;
            break;
        case kyberKey:
            ap->type = CKA_PARAMETER_SET;
            ap++;
            count++;
            ap->type = CKA_SEED;
            ap++;
            count++;
            ap->type = CKA_VALUE;
            ap++;
            count++;
            ap->type = CKA_DECAPSULATE;
            ap++;
            count++;
            break;
        case ecKey:
        case edKey:
        case ecMontKey:
            ap->type = CKA_EC_PARAMS;
            ap++;
            count++;
            ap->type = CKA_VALUE;
            ap++;
            count++;
            if (privKey->keyType == ecKey) {
                ap->type = CKA_DERIVE;
                ap++;
                count++;
            }

            ap->type = CKA_SIGN;
            ap++;
            count++;
            break;
        default:
            count = 0;
            extra_count = 0;
            break;
    }

    if (count == 0) {
        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
        return NULL;
    }

    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    if (arena == NULL)
        return NULL;
    /*
     * read out the old attributes.
     */
    crv = PK11_GetAttributes(arena, privKey->pkcs11Slot, privKey->pkcs11ID,
                             privTemplate, count);
    if (crv != CKR_OK) {
        PORT_SetError(PK11_MapError(crv));
        PORT_FreeArena(arena, PR_TRUE);
        return NULL;
    }

    /* Set token, private, modifiable, sensitive, and extractable */
    count += pk11_AttrFlagsToAttributes(attrFlags, &privTemplate[count],
                                        &cktrue, &ckfalse);

    /* Not everyone can handle zero padded key values, give
     * them the raw data as unsigned. Where the values are encoded or
     * zero-preserving per-RFC5915. NOTE Most new algorithms are
     * OCTET strings, not signed integers, so this conversion
     * isn't necessary for them. */
    if (extra_count) {
        for (ap = attrs; extra_count; ap++, extra_count--) {
            pk11_SignedToUnsigned(ap);
        }
    }

    /* now Store the puppies */
    rv = PK11_CreateNewObject(slot, CK_INVALID_HANDLE, privTemplate,
                              count, token, &objectID);
    PORT_FreeArena(arena, PR_TRUE);
    if (rv != SECSuccess) {
        return NULL;
    }

    /* try loading the public key */
    if (pubKey) {
        PK11_ImportPublicKey(slot, pubKey, token);
        if (pubKey->pkcs11Slot) {
            PK11_FreeSlot(pubKey->pkcs11Slot);
            pubKey->pkcs11Slot = NULL;
            pubKey->pkcs11ID = CK_INVALID_HANDLE;
        }
    }

    /* build new key structure */
    return pk11_MakePrivKey(slot, privKey->keyType, !token,
                            objectID, privKey->wincx);
}

static SECKEYPrivateKey *
pk11_loadPrivKey(PK11SlotInfo *slot, SECKEYPrivateKey *privKey,
                 SECKEYPublicKey *pubKey, PRBool token, PRBool sensitive)
{
    PK11AttrFlags attrFlags = 0;
    if (token) {
        attrFlags |= (PK11_ATTR_TOKEN | PK11_ATTR_PRIVATE);
    } else {
        attrFlags |= (PK11_ATTR_SESSION | PK11_ATTR_PUBLIC);
    }
    if (sensitive) {
        attrFlags |= PK11_ATTR_SENSITIVE;
    } else {
        attrFlags |= PK11_ATTR_INSENSITIVE;
    }
    return pk11_loadPrivKeyWithFlags(slot, privKey, pubKey, attrFlags);
}

/*
 * export this for PSM
 */
SECKEYPrivateKey *
PK11_LoadPrivKey(PK11SlotInfo *slot, SECKEYPrivateKey *privKey,
                 SECKEYPublicKey *pubKey, PRBool token, PRBool sensitive)
{
    return pk11_loadPrivKey(slot, privKey, pubKey, token, sensitive);
}

/*
 * Use the token to generate a key pair.
 */
SECKEYPrivateKey *
PK11_GenerateKeyPairWithOpFlags(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                                void *param, SECKEYPublicKey **pubKey, PK11AttrFlags attrFlags,
                                CK_FLAGS opFlags, CK_FLAGS opFlagsMask, void *wincx)
{
    /* we have to use these native types because when we call PKCS 11 modules
     * we have to make sure that we are using the correct sizes for all the
     * parameters. */
    CK_BBOOL ckfalse = CK_FALSE;
    CK_BBOOL cktrue = CK_TRUE;
    CK_ULONG modulusBits;
    CK_BYTE publicExponent[4];
    CK_ULONG pubTemplateSize = 0;
    CK_ATTRIBUTE privTemplate[] = {
        { CKA_SENSITIVE, NULL, 0 },
        { CKA_TOKEN, NULL, 0 },
        { CKA_PRIVATE, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_UNWRAP, NULL, 0 },
        { CKA_SIGN, NULL, 0 },
        { CKA_DECRYPT, NULL, 0 },
        { CKA_EXTRACTABLE, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_DECAPSULATE, NULL, 0 },
    };
    CK_ATTRIBUTE rsaPubTemplate[] = {
        { CKA_MODULUS_BITS, NULL, 0 },
        { CKA_PUBLIC_EXPONENT, NULL, 0 },
        { CKA_TOKEN, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_WRAP, NULL, 0 },
        { CKA_VERIFY, NULL, 0 },
        { CKA_VERIFY_RECOVER, NULL, 0 },
        { CKA_ENCRYPT, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_ENCAPSULATE, NULL, 0 },
    };
    CK_ATTRIBUTE dsaPubTemplate[] = {
        { CKA_PRIME, NULL, 0 },
        { CKA_SUBPRIME, NULL, 0 },
        { CKA_BASE, NULL, 0 },
        { CKA_TOKEN, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_WRAP, NULL, 0 },
        { CKA_VERIFY, NULL, 0 },
        { CKA_VERIFY_RECOVER, NULL, 0 },
        { CKA_ENCRYPT, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_ENCAPSULATE, NULL, 0 },
    };
    CK_ATTRIBUTE dhPubTemplate[] = {
        { CKA_PRIME, NULL, 0 },
        { CKA_BASE, NULL, 0 },
        { CKA_TOKEN, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_WRAP, NULL, 0 },
        { CKA_VERIFY, NULL, 0 },
        { CKA_VERIFY_RECOVER, NULL, 0 },
        { CKA_ENCRYPT, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_ENCAPSULATE, NULL, 0 },
    };
    CK_ATTRIBUTE ecPubTemplate[] = {
        { CKA_EC_PARAMS, NULL, 0 },
        { CKA_TOKEN, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_WRAP, NULL, 0 },
        { CKA_VERIFY, NULL, 0 },
        { CKA_VERIFY_RECOVER, NULL, 0 },
        { CKA_ENCRYPT, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_ENCAPSULATE, NULL, 0 },
    };
    SECKEYECParams *ecParams;

    CK_ATTRIBUTE mlDsaPubTemplate[] = {
        { CKA_PARAMETER_SET, NULL, 0 },
        { CKA_TOKEN, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_WRAP, NULL, 0 },
        { CKA_VERIFY, NULL, 0 },
        { CKA_VERIFY_RECOVER, NULL, 0 },
        { CKA_ENCRYPT, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_ENCAPSULATE, NULL, 0 },
    };
    CK_ATTRIBUTE kyberPubTemplate[] = {
        { CKA_PARAMETER_SET, NULL, 0 },
        { CKA_TOKEN, NULL, 0 },
        { CKA_DERIVE, NULL, 0 },
        { CKA_WRAP, NULL, 0 },
        { CKA_VERIFY, NULL, 0 },
        { CKA_VERIFY_RECOVER, NULL, 0 },
        { CKA_ENCRYPT, NULL, 0 },
        { CKA_MODIFIABLE, NULL, 0 },
        { CKA_ENCAPSULATE, NULL, 0 },
    };

    /*CK_ULONG key_size = 0;*/
    CK_ATTRIBUTE *pubTemplate;
    int privCount = 0;
    int pubCount = 0;
    PK11RSAGenParams *rsaParams;
    SECKEYPQGParams *dsaParams;
    SECKEYDHParams *dhParams;
    CK_NSS_KEM_PARAMETER_SET_TYPE *kemParams;
    CK_ML_DSA_PARAMETER_SET_TYPE *mldsaParams;
    CK_MECHANISM mechanism;
    CK_MECHANISM test_mech;
    CK_MECHANISM test_mech2;
    CK_SESSION_HANDLE session_handle;
    CK_RV crv;
    CK_OBJECT_HANDLE privID, pubID;
    SECKEYPrivateKey *privKey;
    KeyType keyType;
    PRBool restore;
    int peCount, i;
    CK_ATTRIBUTE *attrs;
    CK_ATTRIBUTE *privattrs;
    CK_ATTRIBUTE setTemplate;
    CK_MECHANISM_INFO mechanism_info;
    CK_OBJECT_CLASS keyClass;
    SECItem *cka_id;
    PRBool haslock = PR_FALSE;
    PRBool pubIsToken = PR_FALSE;
    PRBool token = ((attrFlags & PK11_ATTR_TOKEN) != 0);
    /* subset of attrFlags applicable to the public key */
    PK11AttrFlags pubKeyAttrFlags = attrFlags &
                                    (PK11_ATTR_TOKEN | PK11_ATTR_SESSION | PK11_ATTR_MODIFIABLE | PK11_ATTR_UNMODIFIABLE);

    if (pk11_BadAttrFlags(attrFlags)) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return NULL;
    }

    if (!param) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return NULL;
    }

    /*
     * The opFlags and opFlagMask parameters allow us to control the
     * settings of the key usage attributes (CKA_ENCRYPT and friends).
     * opFlagMask is set to one if the flag is specified in opFlags and
     *  zero if it is to take on a default value calculated by
     *  PK11_GenerateKeyPairWithOpFlags.
     * opFlags specifies the actual value of the flag 1 or 0.
     *   Bits not corresponding to one bits in opFlagMask should be zero.
     */

    /* if we are trying to turn on a flag, it better be in the mask */
    PORT_Assert((opFlags & ~opFlagsMask) == 0);
    opFlags &= opFlagsMask;

    PORT_Assert(slot != NULL);
    if (slot == NULL) {
        PORT_SetError(SEC_ERROR_NO_MODULE);
        return NULL;
    }

    /* if our slot really doesn't do this mechanism, Generate the key
     * in our internal token and write it out */
    if (!PK11_DoesMechanism(slot, type)) {
        PK11SlotInfo *int_slot = PK11_GetInternalSlot();

        /* don't loop forever looking for a slot */
        if (slot == int_slot) {
            PK11_FreeSlot(int_slot);
            /* if we don't have support in softoken, then the mechanism
             * just isnt' supported */
            PORT_SetError(SEC_ERROR_INVALID_ALGORITHM);
            return NULL;
        }

        /* if there isn't a suitable slot, then we can't do the keygen */
        if (int_slot == NULL) {
            PORT_SetError(SEC_ERROR_NO_MODULE);
            return NULL;
        }

        /* generate the temporary key to load */
        privKey = PK11_GenerateKeyPair(int_slot, type, param, pubKey, PR_FALSE,
                                       PR_FALSE, wincx);
        PK11_FreeSlot(int_slot);

        /* if successful, load the temp key into the new token */
        if (privKey != NULL) {
            SECKEYPrivateKey *newPrivKey = pk11_loadPrivKeyWithFlags(slot,
                                                                     privKey, *pubKey, attrFlags);
            SECKEY_DestroyPrivateKey(privKey);
            if (newPrivKey == NULL) {
                SECKEY_DestroyPublicKey(*pubKey);
                *pubKey = NULL;
            }
            return newPrivKey;
        }
        return NULL;
    }

    mechanism.mechanism = type;
    mechanism.pParameter = NULL;
    mechanism.ulParameterLen = 0;
    test_mech.pParameter = NULL;
    test_mech.ulParameterLen = 0;
    test_mech2.mechanism = CKM_INVALID_MECHANISM;
    test_mech2.pParameter = NULL;
    test_mech2.ulParameterLen = 0;

    /* set up the private key template */
    privattrs = privTemplate;
    privattrs += pk11_AttrFlagsToAttributes(attrFlags, privattrs,
                                            &cktrue, &ckfalse);

    /* set up the mechanism specific info */
    switch (type) {
        case CKM_RSA_PKCS_KEY_PAIR_GEN:
        case CKM_RSA_X9_31_KEY_PAIR_GEN:
            rsaParams = (PK11RSAGenParams *)param;
            if (rsaParams->pe == 0) {
                PORT_SetError(SEC_ERROR_INVALID_ARGS);
                return NULL;
            }
            modulusBits = rsaParams->keySizeInBits;
            peCount = 0;

            /* convert pe to a PKCS #11 string */
            for (i = 0; i < 4; i++) {
                if (peCount || (rsaParams->pe &
                                ((unsigned long)0xff000000L >> (i * 8)))) {
                    publicExponent[peCount] =
                        (CK_BYTE)((rsaParams->pe >> (3 - i) * 8) & 0xff);
                    peCount++;
                }
            }
            PORT_Assert(peCount != 0);
            attrs = rsaPubTemplate;
            PK11_SETATTRS(attrs, CKA_MODULUS_BITS,
                          &modulusBits, sizeof(modulusBits));
            attrs++;
            PK11_SETATTRS(attrs, CKA_PUBLIC_EXPONENT,
                          publicExponent, peCount);
            attrs++;
            pubTemplate = rsaPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(rsaPubTemplate);
            keyType = rsaKey;
            test_mech.mechanism = CKM_RSA_PKCS;
            break;
        case CKM_DSA_KEY_PAIR_GEN:
            dsaParams = (SECKEYPQGParams *)param;
            attrs = dsaPubTemplate;
            PK11_SETATTRS(attrs, CKA_PRIME, dsaParams->prime.data,
                          dsaParams->prime.len);
            attrs++;
            PK11_SETATTRS(attrs, CKA_SUBPRIME, dsaParams->subPrime.data,
                          dsaParams->subPrime.len);
            attrs++;
            PK11_SETATTRS(attrs, CKA_BASE, dsaParams->base.data,
                          dsaParams->base.len);
            attrs++;
            pubTemplate = dsaPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(dsaPubTemplate);
            keyType = dsaKey;
            test_mech.mechanism = CKM_DSA;
            break;
        case CKM_DH_PKCS_KEY_PAIR_GEN:
            dhParams = (SECKEYDHParams *)param;
            attrs = dhPubTemplate;
            PK11_SETATTRS(attrs, CKA_PRIME, dhParams->prime.data,
                          dhParams->prime.len);
            attrs++;
            PK11_SETATTRS(attrs, CKA_BASE, dhParams->base.data,
                          dhParams->base.len);
            attrs++;
            pubTemplate = dhPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(dhPubTemplate);
            keyType = dhKey;
            test_mech.mechanism = CKM_DH_PKCS_DERIVE;
            break;
        case CKM_EC_KEY_PAIR_GEN:
        case CKM_NSS_ECDHE_NO_PAIRWISE_CHECK_KEY_PAIR_GEN:
            ecParams = (SECKEYECParams *)param;
            attrs = ecPubTemplate;
            PK11_SETATTRS(attrs, CKA_EC_PARAMS, ecParams->data,
                          ecParams->len);
            attrs++;
            pubTemplate = ecPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(ecPubTemplate);
            keyType = ecKey;
            /*
             * ECC supports 2 different mechanism types (unlike RSA, which
             * supports different usages with the same mechanism).
             * We may need to query both mechanism types and or the results
             * together -- but we only do that if either the user has
             * requested both usages, or not specified any usages.
             */
            if ((opFlags & (CKF_SIGN | CKF_DERIVE)) == (CKF_SIGN | CKF_DERIVE)) {
                /* We've explicitly turned on both flags, use both mechanism */
                test_mech.mechanism = CKM_ECDH1_DERIVE;
                test_mech2.mechanism = CKM_ECDSA;
            } else if (opFlags & CKF_SIGN) {
                /* just do signing */
                test_mech.mechanism = CKM_ECDSA;
            } else if (opFlags & CKF_DERIVE) {
                /* just do ECDH */
                test_mech.mechanism = CKM_ECDH1_DERIVE;
            } else {
                /* neither was specified default to both */
                test_mech.mechanism = CKM_ECDH1_DERIVE;
                test_mech2.mechanism = CKM_ECDSA;
            }
            break;
#ifndef NSS_DISABLE_KYBER
        case CKM_NSS_KYBER_KEY_PAIR_GEN:
#endif
        case CKM_NSS_ML_KEM_KEY_PAIR_GEN:
        case CKM_ML_KEM_KEY_PAIR_GEN:
            kemParams = (CK_NSS_KEM_PARAMETER_SET_TYPE *)param;
            attrs = kyberPubTemplate;
            PK11_SETATTRS(attrs, CKA_PARAMETER_SET,
                          kemParams,
                          sizeof(CK_NSS_KEM_PARAMETER_SET_TYPE));
            attrs++;
            pubTemplate = kyberPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(kyberPubTemplate);
            keyType = kyberKey;
            test_mech.mechanism = CKM_ML_KEM;
            break;
        case CKM_EC_MONTGOMERY_KEY_PAIR_GEN:
            ecParams = (SECKEYECParams *)param;
            attrs = ecPubTemplate;
            PK11_SETATTRS(attrs, CKA_EC_PARAMS, ecParams->data,
                          ecParams->len);
            attrs++;
            pubTemplate = ecPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(ecPubTemplate);
            keyType = ecMontKey;
            test_mech.mechanism = CKM_ECDH1_DERIVE;
            break;
        case CKM_EC_EDWARDS_KEY_PAIR_GEN:
            ecParams = (SECKEYECParams *)param;
            attrs = ecPubTemplate;
            PK11_SETATTRS(attrs, CKA_EC_PARAMS, ecParams->data,
                          ecParams->len);
            attrs++;
            pubTemplate = ecPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(ecPubTemplate);
            keyType = edKey;
            test_mech.mechanism = CKM_EDDSA;
            break;
        case CKM_ML_DSA_KEY_PAIR_GEN:
            mldsaParams = (CK_ML_DSA_PARAMETER_SET_TYPE *)param;
            attrs = mlDsaPubTemplate;
            PK11_SETATTRS(attrs,
                          CKA_PARAMETER_SET,
                          mldsaParams,
                          sizeof(CK_ML_DSA_PARAMETER_SET_TYPE));
            attrs++;
            pubTemplate = mlDsaPubTemplate;
            pubTemplateSize = PR_ARRAY_SIZE(mlDsaPubTemplate);
            keyType = mldsaKey;
            test_mech.mechanism = CKM_ML_DSA;
            break;
        default:
            PORT_SetError(SEC_ERROR_BAD_KEY);
            return NULL;
    }

    /* now query the slot to find out how "good" a key we can generate */
    if (!slot->isThreadSafe)
        PK11_EnterSlotMonitor(slot);
    crv = PK11_GETTAB(slot)->C_GetMechanismInfo(slot->slotID,
                                                test_mech.mechanism, &mechanism_info);
    /*
     * EC keys are used in multiple different types of mechanism, if we
     * are using dual use keys, we need to query the second mechanism
     * as well.
     */
    if (test_mech2.mechanism != CKM_INVALID_MECHANISM) {
        CK_MECHANISM_INFO mechanism_info2;
        CK_RV crv2;

        if (crv != CKR_OK) {
            /* the first failed, make sure there is no trash in the
             * mechanism flags when we or it below */
            mechanism_info.flags = 0;
        }
        crv2 = PK11_GETTAB(slot)->C_GetMechanismInfo(slot->slotID,
                                                     test_mech2.mechanism, &mechanism_info2);
        if (crv2 == CKR_OK) {
            crv = CKR_OK; /* succeed if either mechnaism info succeeds */
            /* combine the 2 sets of mechnanism flags */
            mechanism_info.flags |= mechanism_info2.flags;
        }
    }
    if (!slot->isThreadSafe)
        PK11_ExitSlotMonitor(slot);
    if ((crv != CKR_OK) || (mechanism_info.flags == 0)) {
        /* must be old module... guess what it should be... */
        switch (test_mech.mechanism) {
            case CKM_RSA_PKCS:
                mechanism_info.flags = (CKF_SIGN | CKF_DECRYPT |
                                        CKF_WRAP | CKF_VERIFY_RECOVER | CKF_ENCRYPT | CKF_WRAP);
                break;
            case CKM_DSA:
            case CKM_ECDSA:
            case CKM_EDDSA:
            case CKM_ML_DSA:
                mechanism_info.flags = CKF_SIGN | CKF_VERIFY;
                break;
            case CKM_DH_PKCS_DERIVE:
                mechanism_info.flags = CKF_DERIVE;
                break;
            case CKM_ECDH1_DERIVE:
                mechanism_info.flags = CKF_DERIVE;
                if (test_mech2.mechanism == CKM_ECDSA) {
                    mechanism_info.flags |= CKF_SIGN | CKF_VERIFY;
                }
                break;
            case CKM_NSS_KYBER:
            case CKM_NSS_ML_KEM:
            case CKM_ML_KEM:
                mechanism_info.flags = CKF_ENCAPSULATE | CKF_DECAPSULATE;
                break;
            default:
                break;
        }
    }
    /* now adjust our flags according to the user's key usage passed to us */
    mechanism_info.flags = (mechanism_info.flags & (~opFlagsMask)) | opFlags;
    /* set the public key attributes */
    attrs += pk11_AttrFlagsToAttributes(pubKeyAttrFlags, attrs,
                                        &cktrue, &ckfalse);
    PK11_SETATTRS(attrs, CKA_DERIVE,
                  mechanism_info.flags & CKF_DERIVE ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    attrs++;
    PK11_SETATTRS(attrs, CKA_WRAP,
                  mechanism_info.flags & CKF_WRAP ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    attrs++;
    PK11_SETATTRS(attrs, CKA_VERIFY,
                  mechanism_info.flags & CKF_VERIFY ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    attrs++;
    PK11_SETATTRS(attrs, CKA_VERIFY_RECOVER,
                  mechanism_info.flags & CKF_VERIFY_RECOVER ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    attrs++;
    PK11_SETATTRS(attrs, CKA_ENCRYPT,
                  mechanism_info.flags & CKF_ENCRYPT ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    attrs++;
    /* only set encapsulate if it's requested and shows up in the mechanism
     * list, that way we don't confuse pre-3.2 PKCS #11 modules */
    if (mechanism_info.flags & CKF_ENCAPSULATE) {
        PK11_SETATTRS(attrs, CKA_ENCAPSULATE, &cktrue, sizeof(CK_BBOOL));
        attrs++;
    }

    /* set the private key attributes */
    PK11_SETATTRS(privattrs, CKA_DERIVE,
                  mechanism_info.flags & CKF_DERIVE ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    privattrs++;
    PK11_SETATTRS(privattrs, CKA_UNWRAP,
                  mechanism_info.flags & CKF_UNWRAP ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    privattrs++;
    PK11_SETATTRS(privattrs, CKA_SIGN,
                  mechanism_info.flags & CKF_SIGN ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    privattrs++;
    PK11_SETATTRS(privattrs, CKA_DECRYPT,
                  mechanism_info.flags & CKF_DECRYPT ? &cktrue : &ckfalse,
                  sizeof(CK_BBOOL));
    privattrs++;
    /* only set it if the attribute exists so we don't confuse old modules */
    if (mechanism_info.flags & CKF_DECAPSULATE) {
        PK11_SETATTRS(privattrs, CKA_DECAPSULATE, &cktrue, sizeof(CK_BBOOL));
        privattrs++;
    }

    if (token) {
        session_handle = PK11_GetRWSession(slot);
        haslock = PK11_RWSessionHasLock(slot, session_handle);
        restore = PR_TRUE;
    } else {
        session_handle = slot->session;
        if (session_handle != CK_INVALID_HANDLE)
            PK11_EnterSlotMonitor(slot);
        restore = PR_FALSE;
        haslock = PR_TRUE;
    }

    if (session_handle == CK_INVALID_HANDLE) {
        PORT_SetError(SEC_ERROR_BAD_DATA);
        return NULL;
    }
    privCount = privattrs - privTemplate;
    PORT_Assert(privCount <= PR_ARRAY_SIZE(privTemplate));
    if (privCount > PR_ARRAY_SIZE(privTemplate)) {
        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
        return NULL;
    }
    pubCount = attrs - pubTemplate;
    PORT_Assert(pubCount <= pubTemplateSize);
    if (pubCount > pubTemplateSize) {
        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
        return NULL;
    }
    crv = PK11_GETTAB(slot)->C_GenerateKeyPair(session_handle, &mechanism,
                                               pubTemplate, pubCount, privTemplate, privCount, &pubID, &privID);

    if (crv != CKR_OK) {
        if (restore) {
            PK11_RestoreROSession(slot, session_handle);
        } else
            PK11_ExitSlotMonitor(slot);
        PORT_SetError(PK11_MapError(crv));
        return NULL;
    }
    /* This locking code is dangerous and needs to be more thought
     * out... the real problem is that we're holding the mutex open this long
     */
    if (haslock) {
        PK11_ExitSlotMonitor(slot);
    }

    /* swap around the ID's for older PKCS #11 modules */
    keyClass = PK11_ReadULongAttribute(slot, pubID, CKA_CLASS);
    if (keyClass != CKO_PUBLIC_KEY) {
        CK_OBJECT_HANDLE tmp = pubID;
        pubID = privID;
        privID = tmp;
    }

    *pubKey = PK11_ExtractPublicKey(slot, keyType, pubID);
    if (*pubKey == NULL) {
        if (restore) {
            /* we may have to restore the mutex so it get's exited properly
             * in RestoreROSession */
            if (haslock)
                PK11_EnterSlotMonitor(slot);
            PK11_RestoreROSession(slot, session_handle);
        }
        PK11_DestroyObject(slot, pubID);
        PK11_DestroyObject(slot, privID);
        return NULL;
    }

    /* set the ID to the public key so we can find it again */
    cka_id = pk11_MakeIDFromPublicKey(*pubKey);
    pubIsToken = (PRBool)PK11_HasAttributeSet(slot, pubID, CKA_TOKEN, PR_FALSE);

    PK11_SETATTRS(&setTemplate, CKA_ID, cka_id->data, cka_id->len);

    if (haslock) {
        PK11_EnterSlotMonitor(slot);
    }
    crv = PK11_GETTAB(slot)->C_SetAttributeValue(session_handle, privID,
                                                 &setTemplate, 1);

    if (crv == CKR_OK && pubIsToken) {
        crv = PK11_GETTAB(slot)->C_SetAttributeValue(session_handle, pubID,
                                                     &setTemplate, 1);
    }

    if (restore) {
        PK11_RestoreROSession(slot, session_handle);
    } else {
        PK11_ExitSlotMonitor(slot);
    }
    SECITEM_FreeItem(cka_id, PR_TRUE);

    if (crv != CKR_OK) {
        /* SECKEY_DestroyPublicKey frees *pubKey and destroys the underlying
         * PKCS #11 object, but only for session objects; a freshly generated
         * token object must be removed explicitly. */
        SECKEY_DestroyPublicKey(*pubKey);
        if (pubIsToken) {
            PK11_DestroyObject(slot, pubID);
        }
        PK11_DestroyObject(slot, privID);
        PORT_SetError(PK11_MapError(crv));
        *pubKey = NULL;
        return NULL;
    }

    privKey = pk11_MakePrivKey(slot, keyType, !token, privID, wincx);
    if (privKey == NULL) {
        SECKEY_DestroyPublicKey(*pubKey);
        if (pubIsToken) {
            PK11_DestroyObject(slot, pubID);
        }
        PK11_DestroyObject(slot, privID);
        *pubKey = NULL;
        return NULL;
    }

    return privKey;
}

SECKEYPrivateKey *
PK11_GenerateKeyPairWithFlags(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                              void *param, SECKEYPublicKey **pubKey, PK11AttrFlags attrFlags, void *wincx)
{
    return PK11_GenerateKeyPairWithOpFlags(slot, type, param, pubKey, attrFlags,
                                           0, 0, wincx);
}

/*
 * Use the token to generate a key pair.
 */
SECKEYPrivateKey *
PK11_GenerateKeyPair(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                     void *param, SECKEYPublicKey **pubKey, PRBool token,
                     PRBool sensitive, void *wincx)
{
    PK11AttrFlags attrFlags = 0;

    if (token) {
        attrFlags |= PK11_ATTR_TOKEN;
    } else {
        attrFlags |= PK11_ATTR_SESSION;
    }
    if (sensitive) {
        attrFlags |= (PK11_ATTR_SENSITIVE | PK11_ATTR_PRIVATE);
    } else {
        attrFlags |= (PK11_ATTR_INSENSITIVE | PK11_ATTR_PUBLIC);
    }
    return PK11_GenerateKeyPairWithFlags(slot, type, param, pubKey,
                                         attrFlags, wincx);
}

/* build a public KEA key from the public value */
SECKEYPublicKey *
PK11_MakeKEAPubKey(unsigned char *keyData, int length)
{
    SECKEYPublicKey *pubk;
    SECItem pkData;
    SECStatus rv;
    PLArenaPool *arena;

    pkData.data = keyData;
    pkData.len = length;
    pkData.type = siBuffer;

    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    if (arena == NULL)
        return NULL;

    pubk = (SECKEYPublicKey *)PORT_ArenaZAlloc(arena, sizeof(SECKEYPublicKey));
    if (pubk == NULL) {
        PORT_FreeArena(arena, PR_FALSE);
        return NULL;
    }

    pubk->arena = arena;
    pubk->pkcs11Slot = 0;
    pubk->pkcs11ID = CK_INVALID_HANDLE;
    pubk->keyType = fortezzaKey;
    rv = SECITEM_CopyItem(arena, &pubk->u.fortezza.KEAKey, &pkData);
    if (rv != SECSuccess) {
        PORT_FreeArena(arena, PR_FALSE);
        return NULL;
    }
    return pubk;
}

SECStatus
SECKEY_SetPublicValue(SECKEYPrivateKey *privKey, const SECItem *publicValue)
{
    SECStatus rv;
    SECKEYPublicKey pubKey;
    PLArenaPool *arena;
    PK11SlotInfo *slot;
    CK_OBJECT_HANDLE privKeyID;
    CK_ULONG paramSet;

    if (privKey == NULL || publicValue == NULL ||
        publicValue->data == NULL || publicValue->len == 0) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    pubKey.arena = NULL;
    pubKey.keyType = privKey->keyType;
    pubKey.pkcs11Slot = NULL;
    pubKey.pkcs11ID = CK_INVALID_HANDLE;
    /* can't use PORT_InitCheapArena here becase SECKEY_DestroyPublic is used
     * to free it, and it uses PORT_FreeArena which not only frees the
     * underlying arena, it also frees the allocated arena struct. */
    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    pubKey.arena = arena;
    if (arena == NULL) {
        return SECFailure;
    }

    slot = privKey->pkcs11Slot;
    privKeyID = privKey->pkcs11ID;
    rv = SECFailure;
    switch (privKey->keyType) {
        default:
            /* error code already set to SECFailure */
            break;
        case rsaKey:
            pubKey.u.rsa.modulus = *publicValue;
            rv = PK11_ReadAttribute(slot, privKeyID, CKA_PUBLIC_EXPONENT,
                                    arena, &pubKey.u.rsa.publicExponent);
            break;
        case dsaKey:
            pubKey.u.dsa.publicValue = *publicValue;
            rv = PK11_ReadAttribute(slot, privKeyID, CKA_PRIME,
                                    arena, &pubKey.u.dsa.params.prime);
            if (rv != SECSuccess) {
                break;
            }
            rv = PK11_ReadAttribute(slot, privKeyID, CKA_SUBPRIME,
                                    arena, &pubKey.u.dsa.params.subPrime);
            if (rv != SECSuccess) {
                break;
            }
            rv = PK11_ReadAttribute(slot, privKeyID, CKA_BASE,
                                    arena, &pubKey.u.dsa.params.base);
            break;
        case dhKey:
            pubKey.u.dh.publicValue = *publicValue;
            rv = PK11_ReadAttribute(slot, privKeyID, CKA_PRIME,
                                    arena, &pubKey.u.dh.prime);
            if (rv != SECSuccess) {
                break;
            }
            rv = PK11_ReadAttribute(slot, privKeyID, CKA_BASE,
                                    arena, &pubKey.u.dh.base);
            break;
        case ecKey:
        case edKey:
        case ecMontKey:
            pubKey.u.ec.publicValue = *publicValue;
            pubKey.u.ec.encoding = ECPoint_Undefined;
            pubKey.u.ec.size = 0;
            rv = PK11_ReadAttribute(slot, privKeyID, CKA_EC_PARAMS,
                                    arena, &pubKey.u.ec.DEREncodedParams);
            break;
        case mldsaKey:
            pubKey.u.mldsa.publicValue = *publicValue;
            paramSet = PK11_ReadULongAttribute(slot, privKeyID,
                                               CKA_PARAMETER_SET);
            if (paramSet == CK_UNAVAILABLE_INFORMATION) {
                PORT_SetError(SEC_ERROR_BAD_KEY);
                break;
            }
            pubKey.u.mldsa.paramSet = SECKEY_GetMLDSAPkcs11ParamSetByOidTag(paramSet);
            if (pubKey.u.mldsa.paramSet == SEC_OID_UNKNOWN) {
                PORT_SetError(SEC_ERROR_BAD_KEY);
                break;
            }
            rv = SECSuccess;
            break;
        case kyberKey:
            pubKey.u.kyber.publicValue = *publicValue;
            paramSet = PK11_ReadULongAttribute(slot, privKeyID,
                                               CKA_PARAMETER_SET);
            if (paramSet == CK_UNAVAILABLE_INFORMATION) {
                PORT_SetError(SEC_ERROR_BAD_KEY);
                break;
            }
            pubKey.u.kyber.params = seckey_GetKyberParamsByPkcs11ParamSet(
                paramSet);
            if (pubKey.u.kyber.params == params_kyber_invalid) {
                PORT_SetError(SEC_ERROR_BAD_KEY);
                break;
            }
            rv = SECSuccess;
            break;
    }
    if (rv == SECSuccess) {
        CK_OBJECT_HANDLE pubID = PK11_ImportPublicKey(slot, &pubKey, PR_TRUE);
        if (pubID == CK_INVALID_HANDLE) {
            rv = SECFailure;
        }
    }
    /* Even though pubKey is stored on the stack, we've allocated
     * some of it's data from the arena. SECKEY_DestroyPublicKey
     * destroys keys by freeing the arena, so this will clean up all
     * the data we allocated specifically for the key above. It will
     * also free any slot references which we may have picked up in
     * PK11_ImportPublicKey. It won't delete the underlying key if
     * its a Token/Permanent key (which it will be if
     * PK11_ImportPublicKey succeeds). */
    SECKEY_DestroyPublicKey(&pubKey);

    return rv;
}

/*
 * NOTE: This function doesn't return a SECKEYPrivateKey struct to represent
 * the new private key object.  If it were to create a session object that
 * could later be looked up by its nickname, it would leak a SECKEYPrivateKey.
 * So isPerm must be true.
 */
SECStatus
PK11_ImportEncryptedPrivateKeyInfo(PK11SlotInfo *slot,
                                   SECKEYEncryptedPrivateKeyInfo *epki, SECItem *pwitem,
                                   SECItem *nickname, const SECItem *publicValue, PRBool isPerm,
                                   PRBool isPrivate, KeyType keyType,
                                   unsigned int keyUsage, void *wincx)
{
    if (!isPerm) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }
    return PK11_ImportEncryptedPrivateKeyInfoAndReturnKey(slot, epki,
                                                          pwitem, nickname, publicValue, isPerm, isPrivate, keyType,
                                                          keyUsage, NULL, wincx);
}

SECStatus
PK11_ImportEncryptedPrivateKeyInfoAndReturnKey(PK11SlotInfo *slot,
                                               SECKEYEncryptedPrivateKeyInfo *epki, SECItem *pwitem,
                                               SECItem *nickname, const SECItem *publicValue, PRBool isPerm,
                                               PRBool isPrivate, KeyType keyType,
                                               unsigned int keyUsage, SECKEYPrivateKey **privk,
                                               void *wincx)
{
    CK_MECHANISM_TYPE pbeMechType;
    SECItem *crypto_param = NULL;
    PK11SymKey *key = NULL;
    SECStatus rv = SECSuccess;
    CK_MECHANISM_TYPE cryptoMechType;
    SECKEYPrivateKey *privKey = NULL;
    PRBool faulty3DES = PR_FALSE;
    if ((epki == NULL) || (pwitem == NULL))
        return SECFailure;

    pbeMechType = PK11_AlgtagToMechanism(SECOID_FindOIDTag(
        &epki->algorithm.algorithm));

try_faulty_3des:

    key = PK11_PBEKeyGen(slot, &epki->algorithm, pwitem, faulty3DES, wincx);
    if (key == NULL) {
        rv = SECFailure;
        goto done;
    }
    cryptoMechType = pk11_GetPBECryptoMechanism(&epki->algorithm,
                                                &crypto_param, pwitem, faulty3DES);
    if (cryptoMechType == CKM_INVALID_MECHANISM) {
        rv = SECFailure;
        goto done;
    }

    cryptoMechType = PK11_GetPadMechanism(cryptoMechType);

    privKey = PK11_UnwrapPrivKeyByKeyType(slot, key, cryptoMechType,
                                          crypto_param, &epki->encryptedData,
                                          nickname, publicValue, isPerm,
                                          isPrivate, keyType, keyUsage, wincx);
    if (privKey) {
        rv = SECSuccess;
        goto done;
    }

    /* if we are unable to import the key and the pbeMechType is
     * CKM_NSS_PBE_SHA1_TRIPLE_DES_CBC, then it is possible that
     * the encrypted blob was created with a buggy key generation method
     * which is described in the PKCS 12 implementation notes.  So we
     * need to try importing via that method.
     */
    if ((pbeMechType == CKM_NSS_PBE_SHA1_TRIPLE_DES_CBC) && (!faulty3DES)) {
        /* clean up after ourselves before redoing the key generation. */

        PK11_FreeSymKey(key);
        key = NULL;

        if (crypto_param) {
            SECITEM_ZfreeItem(crypto_param, PR_TRUE);
            crypto_param = NULL;
        }

        faulty3DES = PR_TRUE;
        goto try_faulty_3des;
    }

    /* key import really did fail */
    rv = SECFailure;

done:
    if ((rv == SECSuccess) && isPerm) {
        /* If we are importing a token object,
         * create the corresponding public key.
         * If this fails, just continue as the target
         * token simply might not support persistant
         * public keys. Such tokens are usable, but
         * need to be authenticated before searching
         * for user certs. */
        (void)SECKEY_SetPublicValue(privKey, publicValue);
    }

    if (privKey) {
        if (privk) {
            *privk = privKey;
        } else {
            SECKEY_DestroyPrivateKey(privKey);
        }
        privKey = NULL;
    }
    if (crypto_param != NULL) {
        SECITEM_ZfreeItem(crypto_param, PR_TRUE);
    }

    if (key != NULL) {
        PK11_FreeSymKey(key);
    }

    return rv;
}

SECKEYPrivateKeyInfo *
PK11_ExportPrivateKeyInfo(CERTCertificate *cert, void *wincx)
{
    SECKEYPrivateKeyInfo *pki = NULL;
    SECKEYPrivateKey *pk = PK11_FindKeyByAnyCert(cert, wincx);
    if (pk != NULL) {
        pki = PK11_ExportPrivKeyInfo(pk, wincx);
        SECKEY_DestroyPrivateKey(pk);
    }
    return pki;
}

/* V2 refers to PKCS #5 V2 here. If a PKCS #5 v1 or PKCS #12 pbe is passed
 * for pbeTag, then encTag and hashTag are ignored. If pbe is an encryption
 * algorithm, then PKCS #5 V2 is used with prfTag for the prf. If prfTag isn't
 * supplied prf will be SEC_OID_HMAC_SHA1 */
SECKEYEncryptedPrivateKeyInfo *
PK11_ExportEncryptedPrivKeyInfoV2(
    PK11SlotInfo *slot,   /* optional, encrypt key in this slot */
    SECOidTag pbeAlg,     /* PBE algorithm to encrypt the with key */
    SECOidTag encAlg,     /* Encryption algorithm to Encrypt the key with */
    SECOidTag prfAlg,     /* Hash algorithm for PRF */
    SECItem *pwitem,      /* password for PBE encryption */
    SECKEYPrivateKey *pk, /* encrypt this private key */
    int iteration,        /* interations for PBE alg */
    void *pwArg)          /* context for password callback */
{
    SECKEYEncryptedPrivateKeyInfo *epki = NULL;
    PLArenaPool *arena = NULL;
    SECAlgorithmID *algid;
    SECOidTag pbeAlgTag = SEC_OID_UNKNOWN;
    SECItem *crypto_param = NULL;
    PK11SymKey *key = NULL;
    SECKEYPrivateKey *tmpPK = NULL;
    SECStatus rv = SECSuccess;
    CK_RV crv;
    CK_ULONG encBufLen;
    CK_MECHANISM_TYPE pbeMechType;
    CK_MECHANISM_TYPE cryptoMechType;
    CK_MECHANISM cryptoMech;

    if (!pwitem || !pk) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return NULL;
    }

    algid = sec_pkcs5CreateAlgorithmID(pbeAlg, encAlg, prfAlg,
                                       &pbeAlgTag, 0, NULL, iteration);
    if (algid == NULL) {
        return NULL;
    }

    arena = PORT_NewArena(2048);
    if (arena)
        epki = PORT_ArenaZNew(arena, SECKEYEncryptedPrivateKeyInfo);
    if (epki == NULL) {
        rv = SECFailure;
        goto loser;
    }
    epki->arena = arena;

    /* if we didn't specify a slot, use the slot the private key was in */
    if (!slot) {
        slot = pk->pkcs11Slot;
    }

    /* if we specified a different slot, and the private key slot can do the
     * pbe key gen, generate the key in the private key slot so we don't have
     * to move it later */
    pbeMechType = PK11_AlgtagToMechanism(pbeAlgTag);
    if (slot != pk->pkcs11Slot) {
        if (PK11_DoesMechanism(pk->pkcs11Slot, pbeMechType)) {
            slot = pk->pkcs11Slot;
        }
    }
    key = PK11_PBEKeyGen(slot, algid, pwitem, PR_FALSE, pwArg);
    if (key == NULL) {
        rv = SECFailure;
        goto loser;
    }

    cryptoMechType = PK11_GetPBECryptoMechanism(algid, &crypto_param, pwitem);
    if (cryptoMechType == CKM_INVALID_MECHANISM) {
        rv = SECFailure;
        goto loser;
    }

    cryptoMech.mechanism = PK11_GetPadMechanism(cryptoMechType);
    cryptoMech.pParameter = crypto_param ? crypto_param->data : NULL;
    cryptoMech.ulParameterLen = crypto_param ? crypto_param->len : 0;

    /* If the key isn't in the private key slot, move it */
    if (key->slot != pk->pkcs11Slot) {
        PK11SymKey *newkey = pk11_CopyToSlot(pk->pkcs11Slot,
                                             key->type, CKA_WRAP, key);
        if (newkey == NULL) {
            /* couldn't import the wrapping key, try exporting the
             * private key */
            tmpPK = pk11_loadPrivKey(key->slot, pk, NULL, PR_FALSE, PR_TRUE);
            if (tmpPK == NULL) {
                rv = SECFailure;
                goto loser;
            }
            pk = tmpPK;
        } else {
            /* free the old key and use the new key */
            PK11_FreeSymKey(key);
            key = newkey;
        }
    }

    /* we are extracting an encrypted privateKey structure.
     * which needs to be freed along with the buffer into which it is
     * returned.  eventually, we should retrieve an encrypted key using
     * pkcs8/pkcs5.
     */
    encBufLen = 0;
    PK11_EnterSlotMonitor(pk->pkcs11Slot);
    crv = PK11_GETTAB(pk->pkcs11Slot)->C_WrapKey(pk->pkcs11Slot->session, &cryptoMech, key->objectID, pk->pkcs11ID, NULL, &encBufLen);
    PK11_ExitSlotMonitor(pk->pkcs11Slot);
    if (crv != CKR_OK) {
        rv = SECFailure;
        goto loser;
    }
    epki->encryptedData.data = PORT_ArenaAlloc(arena, encBufLen);
    if (!epki->encryptedData.data) {
        rv = SECFailure;
        goto loser;
    }
    PK11_EnterSlotMonitor(pk->pkcs11Slot);
    crv = PK11_GETTAB(pk->pkcs11Slot)->C_WrapKey(pk->pkcs11Slot->session, &cryptoMech, key->objectID, pk->pkcs11ID, epki->encryptedData.data, &encBufLen);
    PK11_ExitSlotMonitor(pk->pkcs11Slot);
    epki->encryptedData.len = (unsigned int)encBufLen;
    if (crv != CKR_OK) {
        rv = SECFailure;
        goto loser;
    }

    if (!epki->encryptedData.len) {
        rv = SECFailure;
        goto loser;
    }

    rv = SECOID_CopyAlgorithmID(arena, &epki->algorithm, algid);

loser:
    if (crypto_param != NULL) {
        SECITEM_ZfreeItem(crypto_param, PR_TRUE);
        crypto_param = NULL;
    }

    if (key != NULL) {
        PK11_FreeSymKey(key);
    }
    if (tmpPK != NULL) {
        SECKEY_DestroyPrivateKey(tmpPK);
    }
    SECOID_DestroyAlgorithmID(algid, PR_TRUE);

    if (rv == SECFailure) {
        if (arena != NULL) {
            PORT_FreeArena(arena, PR_TRUE);
        }
        epki = NULL;
    }

    return epki;
}

SECKEYEncryptedPrivateKeyInfo *
PK11_ExportEncryptedPrivKeyInfo(
    PK11SlotInfo *slot,   /* optional, encrypt key in this slot */
    SECOidTag algTag,     /* PBE algorithm to encrypt the with key */
    SECItem *pwitem,      /* password for PBE encryption */
    SECKEYPrivateKey *pk, /* encrypt this private key */
    int iteration,        /* interations for PBE alg */
    void *pwArg)          /* context for password callback */
{
    return PK11_ExportEncryptedPrivKeyInfoV2(slot, algTag, SEC_OID_UNKNOWN,
                                             SEC_OID_UNKNOWN, pwitem, pk,
                                             iteration, pwArg);
}

/* V2 refers to PKCS #5 V2 here. If a PKCS #5 v1 or PKCS #12 pbe is passed
 * for pbeTag, then encTag and hashTag are ignored. If pbe is an encryption
 * algorithm, then PKCS #5 V2 is used with prfTag for the prf. If prfTag isn't
 * supplied prf will be SEC_OID_HMAC_SHA1 */
SECKEYEncryptedPrivateKeyInfo *
PK11_ExportEncryptedPrivateKeyInfoV2(
    PK11SlotInfo *slot,    /* optional, encrypt key in this slot */
    SECOidTag pbeAlg,      /* PBE algorithm to encrypt the with key */
    SECOidTag encAlg,      /* Encryption algorithm to Encrypt the key with */
    SECOidTag prfAlg,      /* HMAC algorithm for PRF*/
    SECItem *pwitem,       /* password for PBE encryption */
    CERTCertificate *cert, /* wrap priv key for this user cert */
    int iteration,         /* interations for PBE alg */
    void *pwArg)           /* context for password callback */
{
    SECKEYEncryptedPrivateKeyInfo *epki = NULL;
    SECKEYPrivateKey *pk = PK11_FindKeyByAnyCert(cert, pwArg);
    if (pk != NULL) {
        epki = PK11_ExportEncryptedPrivKeyInfoV2(slot, pbeAlg, encAlg, prfAlg,
                                                 pwitem, pk, iteration,
                                                 pwArg);
        SECKEY_DestroyPrivateKey(pk);
    }
    return epki;
}

SECKEYEncryptedPrivateKeyInfo *
PK11_ExportEncryptedPrivateKeyInfo(
    PK11SlotInfo *slot,    /* optional, encrypt key in this slot */
    SECOidTag algTag,      /* encrypt key with this algorithm */
    SECItem *pwitem,       /* password for PBE encryption */
    CERTCertificate *cert, /* wrap priv key for this user cert */
    int iteration,         /* interations for PBE alg */
    void *pwArg)           /* context for password callback */
{
    return PK11_ExportEncryptedPrivateKeyInfoV2(slot, algTag, SEC_OID_UNKNOWN,
                                                SEC_OID_UNKNOWN, pwitem, cert,
                                                iteration, pwArg);
}

SECItem *
PK11_DEREncodePublicKey(const SECKEYPublicKey *pubk)
{
    return SECKEY_EncodeDERSubjectPublicKeyInfo(pubk);
}

char *
PK11_GetPrivateKeyNickname(SECKEYPrivateKey *privKey)
{
    return PK11_GetObjectNickname(privKey->pkcs11Slot, privKey->pkcs11ID);
}

char *
PK11_GetPublicKeyNickname(SECKEYPublicKey *pubKey)
{
    return PK11_GetObjectNickname(pubKey->pkcs11Slot, pubKey->pkcs11ID);
}

SECStatus
PK11_SetPrivateKeyNickname(SECKEYPrivateKey *privKey, const char *nickname)
{
    return PK11_SetObjectNickname(privKey->pkcs11Slot,
                                  privKey->pkcs11ID, nickname);
}

SECStatus
PK11_SetPublicKeyNickname(SECKEYPublicKey *pubKey, const char *nickname)
{
    return PK11_SetObjectNickname(pubKey->pkcs11Slot,
                                  pubKey->pkcs11ID, nickname);
}

SECKEYPQGParams *
PK11_GetPQGParamsFromPrivateKey(SECKEYPrivateKey *privKey)
{
    CK_ATTRIBUTE pTemplate[] = {
        { CKA_PRIME, NULL, 0 },
        { CKA_SUBPRIME, NULL, 0 },
        { CKA_BASE, NULL, 0 },
    };
    int pTemplateLen = sizeof(pTemplate) / sizeof(pTemplate[0]);
    PLArenaPool *arena = NULL;
    SECKEYPQGParams *params;
    CK_RV crv;

    arena = PORT_NewArena(2048);
    if (arena == NULL) {
        goto loser;
    }
    params = (SECKEYPQGParams *)PORT_ArenaZAlloc(arena, sizeof(SECKEYPQGParams));
    if (params == NULL) {
        goto loser;
    }

    crv = PK11_GetAttributes(arena, privKey->pkcs11Slot, privKey->pkcs11ID,
                             pTemplate, pTemplateLen);
    if (crv != CKR_OK) {
        PORT_SetError(PK11_MapError(crv));
        goto loser;
    }

    params->arena = arena;
    params->prime.data = pTemplate[0].pValue;
    params->prime.len = pTemplate[0].ulValueLen;
    params->subPrime.data = pTemplate[1].pValue;
    params->subPrime.len = pTemplate[1].ulValueLen;
    params->base.data = pTemplate[2].pValue;
    params->base.len = pTemplate[2].ulValueLen;

    return params;

loser:
    if (arena != NULL) {
        PORT_FreeArena(arena, PR_FALSE);
    }
    return NULL;
}

SECKEYPrivateKey *
PK11_CopyTokenPrivKeyToSessionPrivKey(PK11SlotInfo *destSlot,
                                      SECKEYPrivateKey *privKey)
{
    CK_RV crv;
    CK_OBJECT_HANDLE newKeyID;

    static const CK_BBOOL ckfalse = CK_FALSE;
    static const CK_ATTRIBUTE template[1] = {
        { CKA_TOKEN, (CK_BBOOL *)&ckfalse, sizeof ckfalse }
    };

    if (destSlot && destSlot != privKey->pkcs11Slot) {
        SECKEYPrivateKey *newKey =
            pk11_loadPrivKey(destSlot,
                             privKey,
                             NULL,      /* pubKey    */
                             PR_FALSE,  /* token     */
                             PR_FALSE); /* sensitive */
        if (newKey)
            return newKey;
    }
    destSlot = privKey->pkcs11Slot;
    PK11_Authenticate(destSlot, PR_TRUE, privKey->wincx);
    PK11_EnterSlotMonitor(destSlot);
    crv = PK11_GETTAB(destSlot)->C_CopyObject(destSlot->session,
                                              privKey->pkcs11ID,
                                              (CK_ATTRIBUTE *)template,
                                              1, &newKeyID);
    PK11_ExitSlotMonitor(destSlot);

    if (crv != CKR_OK) {
        PORT_SetError(PK11_MapError(crv));
        return NULL;
    }

    return pk11_MakePrivKey(destSlot, privKey->keyType, PR_TRUE /*isOwner*/,
                            newKeyID, privKey->wincx);
}

SECKEYPrivateKey *
PK11_ConvertSessionPrivKeyToTokenPrivKey(SECKEYPrivateKey *privk, void *wincx)
{
    PK11SlotInfo *slot = privk->pkcs11Slot;
    CK_ATTRIBUTE template[1];
    CK_ATTRIBUTE *attrs = template;
    CK_BBOOL cktrue = CK_TRUE;
    CK_RV crv;
    CK_OBJECT_HANDLE newKeyID;
    CK_SESSION_HANDLE rwsession;

    PK11_SETATTRS(attrs, CKA_TOKEN, &cktrue, sizeof(cktrue));
    attrs++;

    PK11_Authenticate(slot, PR_TRUE, wincx);
    rwsession = PK11_GetRWSession(slot);
    if (rwsession == CK_INVALID_HANDLE) {
        PORT_SetError(SEC_ERROR_BAD_DATA);
        return NULL;
    }
    crv = PK11_GETTAB(slot)->C_CopyObject(rwsession, privk->pkcs11ID,
                                          template, 1, &newKeyID);
    PK11_RestoreROSession(slot, rwsession);

    if (crv != CKR_OK) {
        PORT_SetError(PK11_MapError(crv));
        return NULL;
    }

    return pk11_MakePrivKey(slot, nullKey /*KeyType*/, PR_FALSE /*isOwner*/,
                            newKeyID, NULL /*wincx*/);
}

/*
 * destroy a private key if there are no matching certs.
 * this function also frees the privKey structure.
 */
SECStatus
PK11_DeleteTokenPrivateKey(SECKEYPrivateKey *privKey, PRBool force)
{
    CERTCertificate *cert = PK11_GetCertFromPrivateKey(privKey);
    SECStatus rv = SECWouldBlock;

    if (!cert || force) {
        /* now, then it's safe for the key to go away */
        rv = PK11_DestroyTokenObject(privKey->pkcs11Slot, privKey->pkcs11ID);
    }
    if (cert) {
        CERT_DestroyCertificate(cert);
    }
    SECKEY_DestroyPrivateKey(privKey);
    return rv;
}

/*
 * destroy a private key if there are no matching certs.
 * this function also frees the privKey structure.
 */
SECStatus
PK11_DeleteTokenPublicKey(SECKEYPublicKey *pubKey)
{
    /* now, then it's safe for the key to go away */
    if (pubKey->pkcs11Slot == NULL) {
        return SECFailure;
    }
    PK11_DestroyTokenObject(pubKey->pkcs11Slot, pubKey->pkcs11ID);
    SECKEY_DestroyPublicKey(pubKey);
    return SECSuccess;
}

/*
 * key call back structure.
 */
typedef struct pk11KeyCallbackStr {
    SECStatus (*callback)(SECKEYPrivateKey *, void *);
    void *callbackArg;
    void *wincx;
} pk11KeyCallback;

/*
 * callback to map Object Handles to Private Keys;
 */
SECStatus
pk11_DoKeys(PK11SlotInfo *slot, CK_OBJECT_HANDLE keyHandle, void *arg)
{
    SECStatus rv = SECSuccess;
    SECKEYPrivateKey *privKey;
    pk11KeyCallback *keycb = (pk11KeyCallback *)arg;
    if (!arg) {
        return SECFailure;
    }

    privKey = pk11_MakePrivKey(slot, nullKey, PR_FALSE, keyHandle, keycb->wincx);

    if (privKey == NULL) {
        return SECFailure;
    }

    if (keycb->callback) {
        rv = (*keycb->callback)(privKey, keycb->callbackArg);
    }

    SECKEY_DestroyPrivateKey(privKey);
    return rv;
}

/***********************************************************************
 * PK11_TraversePrivateKeysInSlot
 *
 * Traverses all the private keys on a slot.
 *
 * INPUTS
 *      slot
 *          The PKCS #11 slot whose private keys you want to traverse.
 *      callback
 *          A callback function that will be called for each key.
 *      arg
 *          An argument that will be passed to the callback function.
 */
SECStatus
PK11_TraversePrivateKeysInSlot(PK11SlotInfo *slot,
                               SECStatus (*callback)(SECKEYPrivateKey *, void *), void *arg)
{
    pk11KeyCallback perKeyCB;
    pk11TraverseSlot perObjectCB;
    CK_OBJECT_CLASS privkClass = CKO_PRIVATE_KEY;
    CK_BBOOL ckTrue = CK_TRUE;
    CK_ATTRIBUTE theTemplate[2];
    int templateSize = 2;

    theTemplate[0].type = CKA_CLASS;
    theTemplate[0].pValue = &privkClass;
    theTemplate[0].ulValueLen = sizeof(privkClass);
    theTemplate[1].type = CKA_TOKEN;
    theTemplate[1].pValue = &ckTrue;
    theTemplate[1].ulValueLen = sizeof(ckTrue);

    if (slot == NULL) {
        return SECSuccess;
    }

    perObjectCB.callback = pk11_DoKeys;
    perObjectCB.callbackArg = &perKeyCB;
    perObjectCB.findTemplate = theTemplate;
    perObjectCB.templateCount = templateSize;
    perKeyCB.callback = callback;
    perKeyCB.callbackArg = arg;
    perKeyCB.wincx = NULL;

    return PK11_TraverseSlot(slot, &perObjectCB);
}

/*
 * return the private key with the given ID
 */
CK_OBJECT_HANDLE
pk11_FindPrivateKeyFromCertID(PK11SlotInfo *slot, SECItem *keyID)
{
    CK_OBJECT_CLASS privKey = CKO_PRIVATE_KEY;
    CK_ATTRIBUTE theTemplate[] = {
        { CKA_ID, NULL, 0 },
        { CKA_CLASS, NULL, 0 },
    };
    /* if you change the array, change the variable below as well */
    int tsize = sizeof(theTemplate) / sizeof(theTemplate[0]);
    CK_ATTRIBUTE *attrs = theTemplate;

    PK11_SETATTRS(attrs, CKA_ID, keyID->data, keyID->len);
    attrs++;
    PK11_SETATTRS(attrs, CKA_CLASS, &privKey, sizeof(privKey));

    return pk11_FindObjectByTemplate(slot, theTemplate, tsize);
}

SECKEYPrivateKey *
PK11_FindKeyByKeyID(PK11SlotInfo *slot, SECItem *keyID, void *wincx)
{
    CK_OBJECT_HANDLE keyHandle;
    SECKEYPrivateKey *privKey;

    keyHandle = pk11_FindPrivateKeyFromCertID(slot, keyID);
    if (keyHandle == CK_INVALID_HANDLE) {
        return NULL;
    }
    privKey = pk11_MakePrivKey(slot, nullKey, PR_FALSE, keyHandle, wincx);
    return privKey;
}

/*
 * Create a SECKEYPrivateKey directly from a PKCS #11 private key template.
 *
 * The template must fully describe a private key object (at minimum CKA_CLASS =
 * CKO_PRIVATE_KEY, CKA_KEY_TYPE, and the key material). The object is created
 * as a session (non-token) object on 'slot'. The returned SECKEYPrivateKey owns
 * the underlying PKCS #11 object and destroys it when the key is freed with
 * SECKEY_DestroyPrivateKey.
 */
SECKEYPrivateKey *
PK11_CreatePrivateKeyFromTemplate(PK11SlotInfo *slot,
                                  const CK_ATTRIBUTE *theTemplate,
                                  unsigned int count, void *wincx)
{
    CK_OBJECT_HANDLE keyHandle;
    SECKEYPrivateKey *privKey;
    SECStatus rv;

    /* PK11_CreateNewObject takes the count as an int, so guard against a
     * value that would overflow when narrowed. */
    if (slot == NULL || theTemplate == NULL || count == 0 || count > INT_MAX) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return NULL;
    }

    rv = PK11_CreateNewObject(slot, CK_INVALID_HANDLE, theTemplate, count,
                              PR_FALSE, &keyHandle);
    if (rv != SECSuccess) {
        return NULL;
    }

    /* Pass isOwner = PR_TRUE so the returned key owns the session object we
     * just created and destroys it on cleanup. */
    privKey = pk11_MakePrivKey(slot, nullKey, PR_TRUE, keyHandle, wincx);
    if (privKey == NULL) {
        /* Don't leak the object we created if wrapping it failed. */
        (void)PK11_DestroyObject(slot, keyHandle);
        return NULL;
    }

    return privKey;
}

/*
 * Generate a CKA_ID from the relevant public key data. The CKA_ID is generated
 * from the pubKeyData by SHA1_Hashing it to produce a smaller CKA_ID (to make
 * smart cards happy.
 */
SECItem *
PK11_MakeIDFromPubKey(const SECItem *pubKeyData)
{
    PK11Context *context;
    SECItem *certCKA_ID;
    SECStatus rv;

    if (pubKeyData->len <= SHA1_LENGTH) {
        /* probably an already hashed value. The strongest known public
         * key values <= 160 bits would be less than 40 bit symetric in
         * strength. Don't hash them, just return the value. There are
         * none at the time of this writing supported by previous versions
         * of NSS, so change is binary compatible safe */
        return SECITEM_DupItem(pubKeyData);
    }

    context = PK11_CreateDigestContext(SEC_OID_SHA1);
    if (context == NULL) {
        return NULL;
    }

    rv = PK11_DigestBegin(context);
    if (rv == SECSuccess) {
        rv = PK11_DigestOp(context, pubKeyData->data, pubKeyData->len);
    }
    if (rv != SECSuccess) {
        PK11_DestroyContext(context, PR_TRUE);
        return NULL;
    }

    certCKA_ID = (SECItem *)PORT_Alloc(sizeof(SECItem));
    if (certCKA_ID == NULL) {
        PK11_DestroyContext(context, PR_TRUE);
        return NULL;
    }

    certCKA_ID->len = SHA1_LENGTH;
    certCKA_ID->data = (unsigned char *)PORT_Alloc(certCKA_ID->len);
    if (certCKA_ID->data == NULL) {
        PORT_Free(certCKA_ID);
        PK11_DestroyContext(context, PR_TRUE);
        return NULL;
    }

    rv = PK11_DigestFinal(context, certCKA_ID->data, &certCKA_ID->len,
                          SHA1_LENGTH);
    PK11_DestroyContext(context, PR_TRUE);
    if (rv != SECSuccess) {
        SECITEM_FreeItem(certCKA_ID, PR_TRUE);
        return NULL;
    }

    return certCKA_ID;
}

/* Looking for PK11_GetKeyIDFromPrivateKey?
 * Call PK11_GetLowLevelKeyIDForPrivateKey instead.
 */

SECItem *
PK11_GetLowLevelKeyIDForPrivateKey(SECKEYPrivateKey *privKey)
{
    return pk11_GetLowLevelKeyFromHandle(privKey->pkcs11Slot, privKey->pkcs11ID);
}

static SECStatus
privateKeyListCallback(SECKEYPrivateKey *key, void *arg)
{
    SECKEYPrivateKeyList *list = (SECKEYPrivateKeyList *)arg;
    return SECKEY_AddPrivateKeyToListTail(list, SECKEY_CopyPrivateKey(key));
}

SECKEYPrivateKeyList *
PK11_ListPrivateKeysInSlot(PK11SlotInfo *slot)
{
    SECStatus status;
    SECKEYPrivateKeyList *keys;

    keys = SECKEY_NewPrivateKeyList();
    if (keys == NULL)
        return NULL;

    status = PK11_TraversePrivateKeysInSlot(slot, privateKeyListCallback,
                                            (void *)keys);

    if (status != SECSuccess) {
        SECKEY_DestroyPrivateKeyList(keys);
        keys = NULL;
    }

    return keys;
}

SECKEYPublicKeyList *
PK11_ListPublicKeysInSlot(PK11SlotInfo *slot, char *nickname)
{
    CK_ATTRIBUTE findTemp[4];
    CK_ATTRIBUTE *attrs;
    CK_BBOOL ckTrue = CK_TRUE;
    CK_OBJECT_CLASS keyclass = CKO_PUBLIC_KEY;
    size_t tsize = 0;
    int objCount = 0;
    CK_OBJECT_HANDLE *key_ids;
    SECKEYPublicKeyList *keys;
    int i, len;

    attrs = findTemp;
    PK11_SETATTRS(attrs, CKA_CLASS, &keyclass, sizeof(keyclass));
    attrs++;
    PK11_SETATTRS(attrs, CKA_TOKEN, &ckTrue, sizeof(ckTrue));
    attrs++;
    if (nickname) {
        len = PORT_Strlen(nickname);
        PK11_SETATTRS(attrs, CKA_LABEL, nickname, len);
        attrs++;
    }
    tsize = attrs - findTemp;
    PORT_Assert(tsize <= sizeof(findTemp) / sizeof(CK_ATTRIBUTE));

    key_ids = pk11_FindObjectsByTemplate(slot, findTemp, tsize, &objCount);
    if (key_ids == NULL) {
        return NULL;
    }
    keys = SECKEY_NewPublicKeyList();
    if (keys == NULL) {
        PORT_Free(key_ids);
        return NULL;
    }

    for (i = 0; i < objCount; i++) {
        SECKEYPublicKey *pubKey =
            PK11_ExtractPublicKey(slot, nullKey, key_ids[i]);
        if (pubKey) {
            SECKEY_AddPublicKeyToListTail(keys, pubKey);
        }
    }

    PORT_Free(key_ids);
    return keys;
}

SECKEYPrivateKeyList *
PK11_ListPrivKeysInSlot(PK11SlotInfo *slot, char *nickname, void *wincx)
{
    CK_ATTRIBUTE findTemp[4];
    CK_ATTRIBUTE *attrs;
    CK_BBOOL ckTrue = CK_TRUE;
    CK_OBJECT_CLASS keyclass = CKO_PRIVATE_KEY;
    size_t tsize = 0;
    int objCount = 0;
    CK_OBJECT_HANDLE *key_ids;
    SECKEYPrivateKeyList *keys;
    int i, len;

    attrs = findTemp;
    PK11_SETATTRS(attrs, CKA_CLASS, &keyclass, sizeof(keyclass));
    attrs++;
    PK11_SETATTRS(attrs, CKA_TOKEN, &ckTrue, sizeof(ckTrue));
    attrs++;
    if (nickname) {
        len = PORT_Strlen(nickname);
        PK11_SETATTRS(attrs, CKA_LABEL, nickname, len);
        attrs++;
    }
    tsize = attrs - findTemp;
    PORT_Assert(tsize <= sizeof(findTemp) / sizeof(CK_ATTRIBUTE));

    key_ids = pk11_FindObjectsByTemplate(slot, findTemp, tsize, &objCount);
    if (key_ids == NULL) {
        return NULL;
    }
    keys = SECKEY_NewPrivateKeyList();
    if (keys == NULL) {
        PORT_Free(key_ids);
        return NULL;
    }

    for (i = 0; i < objCount; i++) {
        SECKEYPrivateKey *privKey =
            pk11_MakePrivKey(slot, nullKey, PR_FALSE, key_ids[i], wincx);
        SECKEY_AddPrivateKeyToListTail(keys, privKey);
    }

    PORT_Free(key_ids);
    return keys;
}
