/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <security/cryptoki.h>
#include "softGlobal.h"
#include "softSession.h"
#include "softKeys.h"
#include "softOps.h"


CK_RV
C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
    CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phKey)
{

        CK_RV           rv;
        soft_session_t  *session_p;
        boolean_t       lock_held = B_FALSE;

        if (!softtoken_initialized)
                return (CKR_CRYPTOKI_NOT_INITIALIZED);

        /* Obtain the session pointer. */
        rv = handle2session(hSession, &session_p);
        if (rv != CKR_OK)
                return (rv);

        if ((pMechanism == NULL) || (phKey == NULL)) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if ((pTemplate == NULL) && (ulCount != 0)) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        rv = soft_genkey(session_p, pMechanism, pTemplate,
            ulCount, phKey);

clean_exit:
        SES_REFRELE(session_p, lock_held);
        return (rv);

}


CK_RV
C_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;
        soft_session_t  *session_p;
        boolean_t       lock_held = B_FALSE;

        if (!softtoken_initialized)
                return (CKR_CRYPTOKI_NOT_INITIALIZED);

        /* Obtain the session pointer. */
        rv = handle2session(hSession, &session_p);
        if (rv != CKR_OK)
                return (rv);

        if ((pMechanism == NULL) || (phPublicKey == NULL) ||
            (phPrivateKey == NULL)) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if ((pPublicKeyTemplate == NULL) ||
            (ulPublicKeyAttributeCount == 0)) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if ((pPrivateKeyTemplate == NULL) &&
            (ulPrivateKeyAttributeCount != 0)) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        rv = soft_genkey_pair(session_p, pMechanism, pPublicKeyTemplate,
            ulPublicKeyAttributeCount, pPrivateKeyTemplate,
            ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey);

clean_exit:
        SES_REFRELE(session_p, lock_held);
        return (rv);
}

CK_RV
C_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;
        soft_session_t  *session_p;
        soft_object_t   *wrappingkey_p;
        soft_object_t   *hkey_p;
        boolean_t       lock_held = B_FALSE;

        if (!softtoken_initialized)
                return (CKR_CRYPTOKI_NOT_INITIALIZED);

        /* Obtain the session pointer. */
        rv = handle2session(hSession, &session_p);
        if (rv != CKR_OK)
                return (rv);

        if (pMechanism == NULL) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if (pulWrappedKeyLen == NULL) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        /* Obtain the wrapping key object pointer. */
        HANDLE2OBJECT(hWrappingKey, wrappingkey_p, rv);
        if (rv != CKR_OK) {
                rv = CKR_WRAPPING_KEY_HANDLE_INVALID;
                goto clean_exit;
        }

        /* Obtain the to-be-wrapped key object pointer. */
        HANDLE2OBJECT(hKey, hkey_p, rv);
        if (rv != CKR_OK)
                goto clean_exit1;

        /* Check if given wrapping key may be used for wrapping. */
        if (!(wrappingkey_p->bool_attr_mask & WRAP_BOOL_ON)) {
                rv = CKR_WRAPPING_KEY_TYPE_INCONSISTENT;
                goto clean_exit2;
        }

        /* Check if given wrapping key may be used for encryption. */
        if (!(wrappingkey_p->bool_attr_mask & ENCRYPT_BOOL_ON)) {
                rv = CKR_KEY_FUNCTION_NOT_PERMITTED;
                goto clean_exit2;
        }

        /*
         * Check to see if key to be wrapped is extractable.
         * Note: this should always be true for softtoken keys.
         */
        if (!(hkey_p->bool_attr_mask & EXTRACTABLE_BOOL_ON)) {
                rv = CKR_KEY_UNEXTRACTABLE;
                goto clean_exit2;
        }

        (void) pthread_mutex_lock(&session_p->session_mutex);
        lock_held = B_TRUE;

        /*
         * Wrapping key objects requires calling encrypt operations.
         * Check to see if encrypt operation is already active.
         */
        if (session_p->encrypt.flags & CRYPTO_OPERATION_ACTIVE) {
                /* free the memory to avoid memory leak */
                soft_crypt_cleanup(session_p, B_TRUE, lock_held);
        }

        /* This active flag will remain ON while wrapping the key. */
        session_p->encrypt.flags = CRYPTO_OPERATION_ACTIVE;

        (void) pthread_mutex_unlock(&session_p->session_mutex);
        lock_held = B_FALSE;

        rv = soft_wrapkey(session_p, pMechanism, wrappingkey_p,
            hkey_p, pWrappedKey, pulWrappedKeyLen);

        (void) pthread_mutex_lock(&session_p->session_mutex);

        lock_held = B_TRUE;
        session_p->encrypt.flags = 0;

        if ((rv == CKR_OK && pWrappedKey == NULL) ||
            rv == CKR_BUFFER_TOO_SMALL)
                soft_crypt_cleanup(session_p, B_TRUE, lock_held);

clean_exit2:
        OBJ_REFRELE(hkey_p);
clean_exit1:
        OBJ_REFRELE(wrappingkey_p);
clean_exit:
        SES_REFRELE(session_p, lock_held);
        return (rv);
}

CK_RV
C_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;
        soft_session_t  *session_p;
        soft_object_t   *unwrappingkey_p;
        boolean_t       lock_held = B_FALSE;

        if (!softtoken_initialized)
                return (CKR_CRYPTOKI_NOT_INITIALIZED);

        /* Obtain the session pointer. */
        rv = handle2session(hSession, &session_p);
        if (rv != CKR_OK)
                return (rv);

        if (pMechanism == NULL) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if ((pTemplate == NULL) || (ulAttributeCount == 0)) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if ((pWrappedKey == NULL) || (ulWrappedKeyLen == 0)) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if (phKey == NULL) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        /* Obtain the unwrapping key object pointer. */
        HANDLE2OBJECT(hUnwrappingKey, unwrappingkey_p, rv);
        if (rv != CKR_OK) {
                rv = CKR_UNWRAPPING_KEY_HANDLE_INVALID;
                goto clean_exit;
        }

        /* Check if given unwrapping key may be used for unwrapping. */
        if (!(unwrappingkey_p->bool_attr_mask & UNWRAP_BOOL_ON)) {
                rv = CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT;
                goto clean_exit1;
        }

        /* Check if given unwrapping key may be used to decrypt. */
        if (!(unwrappingkey_p->bool_attr_mask & DECRYPT_BOOL_ON)) {
                rv = CKR_KEY_FUNCTION_NOT_PERMITTED;
                goto clean_exit1;
        }

        (void) pthread_mutex_lock(&session_p->session_mutex);
        lock_held = B_TRUE;

        /*
         * Unwrapping key objects requires calling decrypt operations.
         * Check to see if decrypt operation is already active.
         */
        if (session_p->decrypt.flags & CRYPTO_OPERATION_ACTIVE) {
                /* free the memory to avoid memory leak */
                soft_crypt_cleanup(session_p, B_FALSE, lock_held);
        }

        /*
         * This active flag will remain ON until application
         * is done unwrapping the key.
         */
        session_p->decrypt.flags = CRYPTO_OPERATION_ACTIVE;

        (void) pthread_mutex_unlock(&session_p->session_mutex);
        lock_held = B_FALSE;

        rv = soft_unwrapkey(session_p, pMechanism, unwrappingkey_p,
            pWrappedKey, ulWrappedKeyLen, pTemplate, ulAttributeCount,
            phKey);

        (void) pthread_mutex_lock(&session_p->session_mutex);

        if ((rv == CKR_OK && pWrappedKey == NULL) ||
            rv == CKR_BUFFER_TOO_SMALL)
                soft_crypt_cleanup(session_p, B_TRUE, lock_held);

        session_p->decrypt.flags = 0;
        lock_held = B_TRUE;

clean_exit1:
        OBJ_REFRELE(unwrappingkey_p);
clean_exit:
        SES_REFRELE(session_p, lock_held);
        return (rv);
}


CK_RV
C_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;
        soft_session_t  *session_p;
        soft_object_t   *basekey_p;
        boolean_t       lock_held = B_FALSE;

        if (!softtoken_initialized)
                return (CKR_CRYPTOKI_NOT_INITIALIZED);

        /* Obtain the session pointer. */
        rv = handle2session(hSession, &session_p);
        if (rv != CKR_OK)
                return (rv);

        if (pMechanism == NULL) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        if (((pTemplate != NULL) && (ulAttributeCount == 0)) ||
            ((pTemplate == NULL) && (ulAttributeCount != 0))) {
                rv = CKR_ARGUMENTS_BAD;
                goto clean_exit;
        }

        /* Obtain the private key object pointer. */
        HANDLE2OBJECT(hBaseKey, basekey_p, rv);
        if (rv != CKR_OK)
                goto clean_exit;

        /* Check to see if key object allows for derivation. */
        if (!(basekey_p->bool_attr_mask & DERIVE_BOOL_ON)) {
                rv = CKR_KEY_FUNCTION_NOT_PERMITTED;
                goto clean_exit1;
        }

        rv = soft_derivekey(session_p, pMechanism, basekey_p,
            pTemplate, ulAttributeCount, phKey);

clean_exit1:
        OBJ_REFRELE(basekey_p);
clean_exit:
        SES_REFRELE(session_p, lock_held);
        return (rv);
}