libpkcs11/common/metaKeys.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2004, 2012, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Key Management Functions
 * (as defined in PKCS#11 spec section 11.14)
 */

#include "metaGlobal.h"


/*
 * meta_GenerateKey
 *
 */
CK_RV
meta_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
    CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phKey)
{
    CK_RV rv;
    meta_session_t *session;
    meta_object_t *key = NULL;

    if (pMechanism == NULL || phKey == NULL)
        return (CKR_ARGUMENTS_BAD);

    rv = meta_handle2session(hSession, &session);
    if (rv != CKR_OK)
        return (rv);


    rv = meta_object_alloc(session, &key);
    if (rv != CKR_OK)
        goto finish;

    rv = meta_generate_keys(session, pMechanism, pTemplate, ulCount, key,
        NULL, 0, NULL);
    if (rv != CKR_OK)
        goto finish;

    meta_object_activate(key);

    *phKey = (CK_OBJECT_HANDLE) key;

finish:
    if (rv != CKR_OK) {
        if (key)
            (void) meta_object_dealloc(session, key, B_TRUE);
    }

    REFRELEASE(session);

    return (rv);
}


/*
 * meta_GenerateKeyPair
 *
 */
CK_RV
meta_GenerateKeyPair(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
    CK_ATTRIBUTE_PTR pPublicKeyTemplate, CK_ULONG ulPublicKeyAttributeCount,
    CK_ATTRIBUTE_PTR pPrivateKeyTemplate, CK_ULONG ulPrivateKeyAttributeCount,
    CK_OBJECT_HANDLE_PTR phPublicKey, CK_OBJECT_HANDLE_PTR phPrivateKey)
{
    CK_RV rv;
    meta_session_t *session;
    meta_object_t *key1 = NULL, *key2 = NULL;

    if (pMechanism == NULL || phPublicKey == NULL || phPrivateKey == NULL)
        return (CKR_ARGUMENTS_BAD);

    rv = meta_handle2session(hSession, &session);
    if (rv != CKR_OK)
        return (rv);


    rv = meta_object_alloc(session, &key1);
    if (rv != CKR_OK)
        goto finish;

    rv = meta_object_alloc(session, &key2);
    if (rv != CKR_OK)
        goto finish;

    rv = meta_generate_keys(session, pMechanism,
        pPublicKeyTemplate, ulPublicKeyAttributeCount, key1,
        pPrivateKeyTemplate, ulPrivateKeyAttributeCount, key2);
    if (rv != CKR_OK)
        goto finish;

    meta_object_activate(key1);
    meta_object_activate(key2);

    *phPublicKey = (CK_OBJECT_HANDLE) key1;
    *phPrivateKey = (CK_OBJECT_HANDLE) key2;

finish:
    if (rv != CKR_OK) {
        if (key1)
            (void) meta_object_dealloc(session, key1, B_TRUE);
        if (key2)
            (void) meta_object_dealloc(session, key2, B_TRUE);
    }

    REFRELEASE(session);

    return (rv);
}


/*
 * meta_WrapKey
 *
 */
CK_RV
meta_WrapKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
    CK_OBJECT_HANDLE hWrappingKey, CK_OBJECT_HANDLE hKey,
    CK_BYTE_PTR pWrappedKey, CK_ULONG_PTR pulWrappedKeyLen)
{
    CK_RV rv;
    meta_session_t *session;
    meta_object_t *wrappingKey, *inputKey;

    if (pMechanism == NULL || pulWrappedKeyLen == NULL)
        return (CKR_ARGUMENTS_BAD);

    rv = meta_handle2session(hSession, &session);
    if (rv != CKR_OK)
        return (rv);

    rv = meta_handle2object(hKey, &inputKey);
    if (rv != CKR_OK) {
        REFRELEASE(session);
        return (rv);
    }

    rv = meta_handle2object(hWrappingKey, &wrappingKey);
    if (rv != CKR_OK) {
        OBJRELEASE(inputKey);
        REFRELEASE(session);
        return (rv);
    }

    rv = meta_wrap_key(session, pMechanism, wrappingKey,
        inputKey, pWrappedKey, pulWrappedKeyLen);

finish:
    OBJRELEASE(inputKey);
    OBJRELEASE(wrappingKey);
    REFRELEASE(session);

    return (rv);
}


/*
 * meta_UnwrapKey
 *
 */
CK_RV
meta_UnwrapKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
    CK_OBJECT_HANDLE hUnwrappingKey, CK_BYTE_PTR pWrappedKey,
    CK_ULONG ulWrappedKeyLen, CK_ATTRIBUTE_PTR pTemplate,
    CK_ULONG ulAttributeCount, CK_OBJECT_HANDLE_PTR phKey)
{
    CK_RV rv;
    meta_session_t *session;
    meta_object_t *unwrappingKey, *outputKey = NULL;

    if (pMechanism == NULL || pWrappedKey == NULL || phKey == NULL)
        return (CKR_ARGUMENTS_BAD);

    rv = meta_handle2session(hSession, &session);
    if (rv != CKR_OK)
        return (rv);

    rv = meta_handle2object(hUnwrappingKey, &unwrappingKey);
    if (rv != CKR_OK) {
        REFRELEASE(session);
        return (rv);
    }

    rv = meta_object_alloc(session, &outputKey);
    if (rv != CKR_OK)
        goto finish;

    (void) get_template_boolean(CKA_TOKEN, pTemplate, ulAttributeCount,
        &(outputKey->isToken));

    rv = meta_unwrap_key(session, pMechanism, unwrappingKey,
        pWrappedKey, ulWrappedKeyLen,
        pTemplate, ulAttributeCount, outputKey);
    if (rv != CKR_OK)
        goto finish;

    meta_object_activate(outputKey);

    *phKey = (CK_OBJECT_HANDLE) outputKey;

finish:
    if (rv != CKR_OK) {
        if (outputKey)
            (void) meta_object_dealloc(session, outputKey, B_TRUE);
    }

    OBJRELEASE(unwrappingKey);
    REFRELEASE(session);

    return (rv);
}


/*
 * meta_DeriveKey
 *
 * This function is a bit gross because of PKCS#11 kludges that pass extra
 * object handles in some mechanism parameters. It probably needs to be
 * broken up into more manageable pieces.
 */
CK_RV
meta_DeriveKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
    CK_OBJECT_HANDLE hBaseKey, CK_ATTRIBUTE_PTR pTemplate,
    CK_ULONG ulAttributeCount, CK_OBJECT_HANDLE_PTR phKey)
{
    CK_RV rv;
    CK_MECHANISM *pMech = pMechanism;
    meta_session_t *session;
    meta_object_t *basekey1 = NULL, *basekey2 = NULL;
    meta_object_t *newKey1 = NULL, *newKey2 = NULL, *newKey3 = NULL,
        *newKey4 = NULL;
    boolean_t ssl_keys = B_FALSE;
    boolean_t tlsprf = B_FALSE;

    CK_MECHANISM metaMech;
    CK_OBJECT_HANDLE *phBaseKey2 = NULL;
    CK_X9_42_DH2_DERIVE_PARAMS x942_params, *x9_tmpptr;
    CK_ECDH2_DERIVE_PARAMS ecdh_params, *ec_tmpptr;
    CK_SSL3_KEY_MAT_OUT *ssl_key_mat;
    CK_SSL3_KEY_MAT_PARAMS *keyparams;

    if (pMech == NULL) {
        return (CKR_ARGUMENTS_BAD);
    }

    /*
     * Special case: Normally, the caller must always provide storage
     * for the derived key handle at phKey. Two (related) mechanisms
     * are special, in that multiple keys are instead returned via
     * pMech->pParameter. In these cases the spec says (see 12.38.4
     * and 12.39.4) that phKey should be a NULL pointer, as it is not used.
     */
    switch (pMech->mechanism) {
    case CKM_SSL3_KEY_AND_MAC_DERIVE:
    case CKM_TLS_KEY_AND_MAC_DERIVE:
        keyparams = (CK_SSL3_KEY_MAT_PARAMS*)pMech->pParameter;

        if ((keyparams == NULL) || (pMech->ulParameterLen
            != sizeof (CK_SSL3_KEY_MAT_PARAMS)))
            return (CKR_ARGUMENTS_BAD);

        ssl_key_mat = keyparams->pReturnedKeyMaterial;
        if (ssl_key_mat == NULL)
            return (CKR_ARGUMENTS_BAD);

        ssl_keys = B_TRUE;
        break;

    case CKM_TLS_PRF:
        tlsprf = B_TRUE;
        break;

    default:
        if (phKey == NULL)
            return (CKR_ARGUMENTS_BAD);
    };

    rv = meta_handle2session(hSession, &session);
    if (rv != CKR_OK)
        return (rv);

    rv = meta_handle2object(hBaseKey, &basekey1);
    if (rv != CKR_OK)
        goto finish;


    /*
     * A few oddball mechanisms pass a 2nd object handle in the parameters.
     * Here we validate that handle, and create a duplicate copy of the
     * mechanism and parameters. This is done because the application
     * does not expect these values to be changing, and could be using the
     * same data in multiple threads (eg concurrent calls to C_DeriveKey).
     * We copy the data to make sure there are no MT-Safe problems.
     */
    switch (pMech->mechanism) {

    case CKM_ECMQV_DERIVE:
        /* uses CK_ECDH2_DERIVE_PARAMS struct as the parameter */

        if ((pMech->pParameter == NULL) || (pMech->ulParameterLen
            != sizeof (CK_ECDH2_DERIVE_PARAMS))) {
            rv = CKR_ARGUMENTS_BAD;
            goto finish;
        }

        /* Duplicate the mechanism and parameters */
        ec_tmpptr = (CK_ECDH2_DERIVE_PARAMS *)pMech->pParameter;
        ecdh_params = *ec_tmpptr;
        metaMech = *pMech;
        metaMech.pParameter = &ecdh_params;
        pMech = &metaMech;

        /* Get the key the application is providing */
        phBaseKey2 = &ecdh_params.hPrivateData;
        break;

    case CKM_X9_42_DH_HYBRID_DERIVE:
    case CKM_X9_42_MQV_DERIVE:
        /* both use CK_X9_42_DH2_DERIVE_PARAMS as the parameter */

        if ((pMech->pParameter == NULL) || (pMech->ulParameterLen
            != sizeof (CK_X9_42_DH2_DERIVE_PARAMS))) {
            rv = CKR_ARGUMENTS_BAD;
            goto finish;
        }

        /* Duplicate the mechanism and parameters */
        x9_tmpptr = (CK_X9_42_DH2_DERIVE_PARAMS *)pMech->pParameter;
        x942_params = *x9_tmpptr;
        metaMech = *pMech;
        metaMech.pParameter  = &x942_params;
        pMech = &metaMech;

        /* Get the key the application is providing */
        phBaseKey2 = &x942_params.hPrivateData;
        break;

    case CKM_CONCATENATE_BASE_AND_KEY:
        /* uses a CK_OBJECT_HANDLE as the parameter */

        if ((pMech->pParameter == NULL) || (pMech->ulParameterLen
            != sizeof (CK_OBJECT_HANDLE))) {
            rv = CKR_ARGUMENTS_BAD;
            goto finish;
        }

        /* Duplicate the mechanism and parameters */
        metaMech = *pMech;
        pMech = &metaMech;

        /* Get the key the application is providing */
        phBaseKey2 = (CK_OBJECT_HANDLE *) &metaMech.pParameter;
        break;

    default:
        /* nothing special to do. */
        break;
    }

    if (phBaseKey2) {
        rv = meta_handle2object(*phBaseKey2, &basekey2);
        if (rv != CKR_OK)
            goto finish;
    }

    /*
     * Allocate meta objects to store the derived key(s). Normally just
     * a single key is created, but the SSL/TLS mechanisms generate four.
     */
    rv = meta_object_alloc(session, &newKey1);
    if (rv != CKR_OK)
        goto finish;

    if (ssl_keys) {
        rv = meta_object_alloc(session, &newKey2);
        if (rv != CKR_OK)
            goto finish;
        rv = meta_object_alloc(session, &newKey3);
        if (rv != CKR_OK)
            goto finish;
        rv = meta_object_alloc(session, &newKey4);
        if (rv != CKR_OK)
            goto finish;
    }


    /* Perform the actual key derive operation. */
    rv = meta_derive_key(session, pMech, basekey1, basekey2, phBaseKey2,
        pTemplate, ulAttributeCount, newKey1, newKey2, newKey3, newKey4);
    if (rv != CKR_OK)
        goto finish;

    if (tlsprf) {
        (void) meta_object_dealloc(session, newKey1, B_TRUE);
        newKey1 = NULL;
        /* phKey isn't used (is NULL) for mechanism CKM_TLS_PRF. */

    } else {
        /* Make derived key(s) active and visible to other threads. */
        meta_object_activate(newKey1);
        if (ssl_keys) {
            meta_object_activate(newKey2);
            meta_object_activate(newKey3);
            meta_object_activate(newKey4);

            ssl_key_mat->hClientMacSecret
                = (CK_OBJECT_HANDLE) newKey1;
            ssl_key_mat->hServerMacSecret
                = (CK_OBJECT_HANDLE) newKey2;
            ssl_key_mat->hClientKey = (CK_OBJECT_HANDLE) newKey3;
            ssl_key_mat->hServerKey = (CK_OBJECT_HANDLE) newKey4;
            /* phKey isn't used (is NULL) for these SSL/TLS mechs */

        } else {
            *phKey = (CK_OBJECT_HANDLE) newKey1;
        }
    }

finish:
    if (rv != CKR_OK) {
        if (newKey1)
            (void) meta_object_dealloc(session, newKey1, B_TRUE);
        if (newKey2)
            (void) meta_object_dealloc(session, newKey2, B_TRUE);
        if (newKey3)
            (void) meta_object_dealloc(session, newKey3, B_TRUE);
        if (newKey4)
            (void) meta_object_dealloc(session, newKey4, B_TRUE);
    }

    if (basekey1)
        OBJRELEASE(basekey1);
    if (basekey2)
        OBJRELEASE(basekey2);
    REFRELEASE(session);

    return (rv);
}