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

/*
 * Session Management Functions
 * (as defined in PKCS#11 spec spection 11.6)
 */

#include <string.h>
#include "metaGlobal.h"

extern meta_session_t *meta_sessionlist_head;
extern pthread_rwlock_t meta_sessionlist_lock;
extern CK_ULONG num_meta_sessions;
extern CK_ULONG num_rw_meta_sessions;

/*
 * meta_OpenSession
 *
 * NOTES:
 * 1) The pApplication and Notify args are not used, as the metaslot does not
 *    support application callbacks.
 * 2) the slotID argument is not checked or used because this function
 *    is only called from the framework.
 */
/* ARGSUSED */
CK_RV
meta_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication,
    CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession)
{
    meta_session_t *new_session;
    CK_RV rv;

    if (!metaslot_enabled) {
        return (CKR_SLOT_ID_INVALID);
    }

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

    /* Check for any unknown flags. */
    if (flags & ~(CKF_SERIAL_SESSION | CKF_RW_SESSION)) {
        return (CKR_ARGUMENTS_BAD);
    }

    if (!(flags & CKF_SERIAL_SESSION)) {
        return (CKR_SESSION_PARALLEL_NOT_SUPPORTED);
    }

    if (meta_slotManager_token_write_protected() &&
        (flags & CKF_RW_SESSION)) {
        return (CKR_TOKEN_WRITE_PROTECTED);
    }

    rv = meta_session_alloc(&new_session);
    if (rv != CKR_OK)
        return (rv);

    new_session->session_flags = flags;

    rv = meta_session_activate(new_session);
    if (rv != CKR_OK) {
        meta_session_dealloc(new_session);
        return (rv);
    }

    *phSession = (CK_SESSION_HANDLE) new_session;

    num_meta_sessions++;
    if (flags & CKF_RW_SESSION) {
        num_rw_meta_sessions++;
    }

    return (CKR_OK);
}


/*
 * meta_CloseSession
 *
 */
CK_RV
meta_CloseSession(CK_SESSION_HANDLE hSession)
{
    CK_RV rv;
    meta_session_t *session;
    CK_FLAGS flags;

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

    /* save info about session flags before they are destroyed */
    flags = session->session_flags;

    rv = meta_session_deactivate(session, B_FALSE);

    if (rv == CKR_OK)
        meta_session_dealloc(session);

    num_meta_sessions--;
    if (flags & CKF_RW_SESSION) {
        num_rw_meta_sessions--;
    }

    return (rv);
}


/*
 * meta_CloseAllSessions
 *
 * This is a simple loop that closes the sessionlist head (resulting in a
 * new list head) until the list is empty.
 *
 */
CK_RV
meta_CloseAllSessions(CK_SLOT_ID slotID)
{
    CK_RV rv;
    meta_session_t *session;

    if (!metaslot_enabled) {
        return (CKR_SLOT_ID_INVALID);
    }

    if (slotID != METASLOT_SLOTID)
        return (CKR_SLOT_ID_INVALID);

    (void) pthread_rwlock_wrlock(&meta_sessionlist_lock);
    while ((session = meta_sessionlist_head) != NULL) {
        rv = meta_handle2session((CK_SESSION_HANDLE)session, &session);
        if (rv != CKR_OK) {
            /*NOTREACHED*/
            (void) pthread_rwlock_unlock(&meta_sessionlist_lock);
            return (CKR_FUNCTION_FAILED);
        }

        (void) meta_session_deactivate(session, B_TRUE);
        meta_session_dealloc(session);
    }
    (void) pthread_rwlock_unlock(&meta_sessionlist_lock);

    /* All open sessions should be closed, just reset the variables */
    num_meta_sessions = 0;
    num_rw_meta_sessions = 0;

    return (CKR_OK);
}


/*
 * meta_GetSessionInfo
 *
 */
CK_RV
meta_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo)
{
    CK_RV rv;
    meta_session_t *session;

    if (pInfo == NULL)
        return (CKR_ARGUMENTS_BAD);

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

    pInfo->slotID = METASLOT_SLOTID;
    pInfo->flags = session->session_flags;

    if (metaslot_logged_in()) {
        if (IS_READ_ONLY_SESSION(session->session_flags)) {
            pInfo->state = CKS_RO_USER_FUNCTIONS;
        } else {
            pInfo->state = CKS_RW_USER_FUNCTIONS;
        }
    } else {
        if (IS_READ_ONLY_SESSION(session->session_flags)) {
            pInfo->state = CKS_RO_PUBLIC_SESSION;
        } else {
            pInfo->state = CKS_RW_PUBLIC_SESSION;
        }
    }

    pInfo->ulDeviceError = 0;

    REFRELEASE(session);

    return (CKR_OK);
}

CK_RV
meta_getopstatelen(meta_session_t *session, CK_ULONG *out_length)
{
    CK_RV rv = CKR_OK;
    slot_session_t *slot_session;
    CK_ULONG length;

    *out_length = sizeof (meta_opstate_t);
    if (session->op1.type != 0) {
        slot_session = session->op1.session;
        rv = FUNCLIST(slot_session->fw_st_id)->C_GetOperationState(
            slot_session->hSession, NULL, &length);
        if (rv == CKR_OK)
            *out_length += length;
    }
    return (rv);
}

/*
 * meta_GetOperationState
 *
 */
CK_RV
meta_GetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState,
    CK_ULONG_PTR pulOperationStateLen)
{
    CK_RV rv;
    meta_session_t *session;
    slot_session_t *slot_session = NULL;
    meta_opstate_t opstate;

    if (pulOperationStateLen == NULL)
        return (CKR_ARGUMENTS_BAD);

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

    /*
     * If no operation is active, then bail out.
     */
    if (session->op1.type == 0) {
        rv = CKR_OPERATION_NOT_INITIALIZED;
        goto endgetopstate;
    }

    /*
     * If the caller did not give an OpState buffer,
     * shortcut and just return the size needed to hold
     * a metaslot OpState record later.
     * The actual size of the returned state will be the
     * sizeof(meta_opstate_t) + SIZE (op1 state),
     * so we have to get the size of
     * the operation states now.
     */
    if (pOperationState == NULL) {
        rv = meta_getopstatelen(session, pulOperationStateLen);
        REFRELEASE(session);
        return (rv);
    }

    /*
     * To be here, the caller must have supplied an
     * already initialized meta_opstate_t pointer.
     * Use it to get the real state info from the operation(s).
     *
     * The format of the Metaslot Opstate record:
     * {
     *    struct metaopstate
     *    [ op1 state data ]
     * }
     */

    /*
     * If the buffer is not even big enough for the metaslot
     * opstate data, return error and set the returned
     * state length to indicate the minimum needed.
     */
    if (*pulOperationStateLen < sizeof (meta_opstate_t)) {
        rv = meta_getopstatelen(session, pulOperationStateLen);
        /*
         * Remap the error so the caller knows that they
         * used an invalid buffer size in the first place.
         */
        if (rv == CKR_OK)
            rv = CKR_BUFFER_TOO_SMALL;
        goto endgetopstate;
    }

    (void) memset(&opstate, 0, sizeof (meta_opstate_t));
    opstate.magic_marker = METASLOT_OPSTATE_MAGIC;

    if (session->op1.type != 0) {
        slot_session = session->op1.session;
        opstate.state[0].op_type = session->op1.type;
        opstate.state[0].op_slotnum = slot_session->slotnum;
        opstate.state[0].op_state_len = *pulOperationStateLen -
            sizeof (meta_opstate_t);
        opstate.state[0].op_init_app = session->init.app;
        opstate.state[0].op_init_done = session->init.done;
        rv = FUNCLIST(slot_session->fw_st_id)->C_GetOperationState(
            slot_session->hSession,
            pOperationState + sizeof (meta_opstate_t),
            &(opstate.state[0].op_state_len));

        if (rv == CKR_BUFFER_TOO_SMALL) {
            /*
             * This should not happen, but if it does,
             * recalculate the entire size needed
             * and return the error.
             */
            rv = meta_getopstatelen(session, pulOperationStateLen);
            if (rv == CKR_OK)
                rv = CKR_BUFFER_TOO_SMALL;
        }

        if (rv != CKR_OK)
            goto endgetopstate;
    }

endgetopstate:
    if (rv == CKR_OK && pOperationState != NULL) {
        (void) memcpy(pOperationState, (void *)&opstate,
            sizeof (meta_opstate_t));

        *pulOperationStateLen = sizeof (meta_opstate_t) +
            opstate.state[0].op_state_len;
    }

    REFRELEASE(session);
    return (rv);
}

static CK_RV
meta_set_opstate(slot_session_t *slot_session,
        meta_object_t *meta_enc_key,
        meta_object_t *meta_auth_key,
        struct opstate_data *state,
        CK_BYTE *databuf)
{
    CK_RV rv;
    static CK_ULONG encrypt_optypes = (CKF_ENCRYPT | CKF_DECRYPT);
    static CK_ULONG sign_optypes = (CKF_SIGN | CKF_VERIFY |
        CKF_SIGN_RECOVER | CKF_VERIFY_RECOVER);
    slot_object_t *enc_key_obj = NULL, *auth_key_obj = NULL;

    if (state->op_type & encrypt_optypes) {
        rv = meta_object_get_clone(meta_enc_key, slot_session->slotnum,
            slot_session, &enc_key_obj);
        if (rv != CKR_OK) {
            return (rv);
        }
    }
    if (state->op_type & sign_optypes) {
        rv = meta_object_get_clone(meta_auth_key, slot_session->slotnum,
            slot_session, &auth_key_obj);
        if (rv != CKR_OK) {
            return (rv);
        }
    }

    /*
     * Check to see if the keys are needed to restore the
     * state on the first operation.
     */
    rv = FUNCLIST(slot_session->fw_st_id)->C_SetOperationState(
        slot_session->hSession, databuf, state->op_state_len,
        enc_key_obj ? enc_key_obj->hObject : CK_INVALID_HANDLE,
        auth_key_obj ? auth_key_obj->hObject : CK_INVALID_HANDLE);
    /*
     * If the operation did not need a key, try again.
     */
    if (rv == CKR_KEY_NOT_NEEDED) {
        rv = FUNCLIST(slot_session->fw_st_id)->C_SetOperationState(
            slot_session->hSession, databuf, state->op_state_len,
            CK_INVALID_HANDLE, CK_INVALID_HANDLE);
        /*
         * Strange case... If the first try returned
         * KEY_NOT_NEEDED, and this one returns KEY_NEEDED,
         * we want to remap the return so the caller sees
         * the original "CKR_KEY_NOT_NEEDED" return value.
         * This ensures that a correct caller will retry
         * without the unnecessary key argument and this
         * 2nd attempt will not happen again.
         */
        if (rv == CKR_KEY_NEEDED) {
            rv  = CKR_KEY_NOT_NEEDED;
        }
    }

    return (rv);
}

/*
 * meta_SetOperationState
 *
 */
CK_RV
meta_SetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState,
    CK_ULONG ulOperationStateLen, CK_OBJECT_HANDLE hEncryptionKey,
    CK_OBJECT_HANDLE hAuthenticationKey)
{
    CK_RV rv = CKR_OK;
    meta_session_t *session;
    slot_session_t *slot_session = NULL;
    meta_opstate_t opstate;
    meta_object_t *meta_enc_key = NULL, *meta_auth_key = NULL;

    /*
     * Make sure the opstate info buffer is big enough to be valid.
     */
    if (ulOperationStateLen < sizeof (meta_opstate_t) ||
        pOperationState == NULL)
        return (CKR_ARGUMENTS_BAD);

    /* Copy the opstate info into the structure */
    (void) memcpy(&opstate, pOperationState, sizeof (meta_opstate_t));

    /* verify that a metaslot operation state was supplied */
    if (opstate.magic_marker != METASLOT_OPSTATE_MAGIC)
        return (CKR_SAVED_STATE_INVALID);

    /*
     * Now, check the size again to make sure the "real" state
     * data is present.  Length of state provided must be exact.
     */
    if (ulOperationStateLen != (sizeof (meta_opstate_t) +
        opstate.state[0].op_state_len))
        return (CKR_SAVED_STATE_INVALID);

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

    if (hEncryptionKey != CK_INVALID_HANDLE) {
        rv = meta_handle2object(hEncryptionKey, &meta_enc_key);
        if (rv != CKR_OK)
            goto cleanup;
    }
    if (hAuthenticationKey != CK_INVALID_HANDLE) {
        rv = meta_handle2object(hAuthenticationKey, &meta_auth_key);
        if (rv != CKR_OK)
            goto cleanup;
    }

    if (opstate.state[0].op_type != 0) {
        if (session->op1.type != 0)
            meta_operation_cleanup(session, session->op1.type,
                B_FALSE);

        if (session->op1.session != NULL) {
            slot_session = session->op1.session;
        } else {
            rv = meta_get_slot_session(opstate.state[0].op_slotnum,
                &slot_session, session->session_flags);
            if (rv != CKR_OK)
                goto cleanup;
        }

        session->op1.type = opstate.state[0].op_type;
        session->op1.session = slot_session;
        session->init.app = opstate.state[0].op_init_app;
        session->init.done = opstate.state[0].op_init_done;

        rv = meta_set_opstate(slot_session, meta_enc_key,
            meta_auth_key, &(opstate.state[0]),
            pOperationState + sizeof (meta_opstate_t));

        if (rv != CKR_OK) {
            meta_operation_cleanup(session, session->op1.type,
                FALSE);
            goto cleanup;
        }
    }

cleanup:
    if (meta_enc_key != NULL)
        OBJRELEASE(meta_enc_key);
    if (meta_auth_key != NULL)
        OBJRELEASE(meta_auth_key);
    REFRELEASE(session);
    return (rv);
}

/*
 * meta_Login
 *
 * This allows the user to login to the object token. The metaslot itself
 * does not have any kind of PIN.
 *
 */
CK_RV
meta_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
    CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
{
    CK_RV rv;
    meta_session_t *session;
    slot_session_t *login_session = NULL;
    CK_TOKEN_INFO token_info;
    CK_SLOT_ID true_id, fw_st_id;

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

    if (metaslot_logged_in()) {
        rv = CKR_USER_ALREADY_LOGGED_IN;
        goto finish;
    }

    /* Note: CKU_SO is not supported. */
    if (userType != CKU_USER) {
        rv = CKR_USER_TYPE_INVALID;
        goto finish;
    }

    rv = meta_get_slot_session(get_keystore_slotnum(), &login_session,
        session->session_flags);
    if (rv != CKR_OK)
        goto finish;


    fw_st_id = login_session->fw_st_id;
    rv = FUNCLIST(fw_st_id)->C_Login(login_session->hSession, userType,
        pPin, ulPinLen);

    if (rv != CKR_OK) {
        goto finish;
    }

    /*
     * Note:
     *
     * For some slots (eg: the pkcs11_softtoken.so), C_Login()
     * returning OK don't mean that the login is truely
     * successful.  For pkcs11_softtoken.so, the CKF_USER_PIN_TO_BE_CHANGED
     * is set to indicate that the pin needs to be changed, and
     * the login is not really successful.  We will check
     * that flag for this special condition.  Checking for
     * this flag shouldn't be harmful for other slots that doesn't
     * behave like pkcs11_softtoken.so.
     */

    true_id = TRUEID(fw_st_id);
    rv = FUNCLIST(fw_st_id)->C_GetTokenInfo(true_id, &token_info);
    if (rv != CKR_OK) {
        goto finish;
    }

    metaslot_set_logged_in_flag(B_TRUE);
    if (token_info.flags & CKF_USER_PIN_TO_BE_CHANGED) {
        metaslot_set_logged_in_flag(B_FALSE);
    }
finish:
    if (login_session)
        meta_release_slot_session(login_session);

    REFRELEASE(session);

    return (rv);
}

/*
 * meta_Logout
 *
 */
CK_RV
meta_Logout(CK_SESSION_HANDLE hSession)
{
    CK_RV rv = CKR_OK;
    meta_session_t *session;
    slot_session_t *logout_session = NULL;

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

    if (!metaslot_logged_in()) {
        rv = CKR_USER_NOT_LOGGED_IN;
        goto finish;
    }

    rv = meta_get_slot_session(get_keystore_slotnum(), &logout_session,
        session->session_flags);
    if (rv != CKR_OK)
        goto finish;

    rv = FUNCLIST(logout_session->fw_st_id)->C_Logout(
        logout_session->hSession);

    /* If the C_Logout fails, just ignore the error. */
    metaslot_set_logged_in_flag(B_FALSE);
    (void) meta_token_object_deactivate(PRIVATE_TOKEN);

finish:
    if (logout_session)
        meta_release_slot_session(logout_session);

    REFRELEASE(session);

    return (rv);
}