softSessionUtil.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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
* 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 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <md5.h>
#include <pthread.h>
#include <syslog.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <security/cryptoki.h>
#include "softGlobal.h"
#include "softSession.h"
#include "softObject.h"
#include "softOps.h"
#include "softKeystore.h"
#include "softKeystoreUtil.h"
/*
* Delete all the sessions. First, obtain the global session
* list lock. Then start to delete one session at a time.
* Release the global session list lock before returning to
* caller.
*/
{
/* Acquire the global session list lock */
(void) pthread_mutex_lock(&soft_sessionlist_mutex);
/* Delete all the sessions in the session list */
while (session_p) {
/*
* Delete a session by calling soft_delete_session()
* with a session pointer and a boolean arguments.
* Boolean value TRUE is used to indicate that the
* caller holds the lock on the global session list.
*/
/* Record the very first error code */
}
}
/* No session left */
/* Release the global session list lock */
(void) pthread_mutex_unlock(&soft_sessionlist_mutex);
return (rv);
}
/*
* Create a new session struct, and add it to the session linked list.
*
* This function will acquire the global session list lock, and release
* it after adding the session to the session linked list.
*/
{
/* Allocate a new session struct */
return (CKR_HOST_MEMORY);
}
new_sp->ses_refcnt = 0;
new_sp->ses_close_sync = 0;
(void) pthread_mutex_lock(&soft_giant_mutex);
if (soft_slot.authenticated) {
(void) pthread_mutex_unlock(&soft_giant_mutex);
if (flags & CKF_RW_SESSION) {
} else {
}
} else {
(void) pthread_mutex_unlock(&soft_giant_mutex);
if (flags & CKF_RW_SESSION) {
} else {
}
}
/* Initialize the lock for the newly created session */
return (CKR_CANT_LOCK);
}
/* Acquire the global session list lock */
(void) pthread_mutex_lock(&soft_sessionlist_mutex);
/* Insert the new session in front of session list */
if (soft_session_list == NULL) {
} else {
}
/* Type casting the address of a session struct to a session handle */
if (flags & CKF_RW_SESSION)
if (soft_session_cnt == 1)
/*
* This is the first session to be opened, so we can set
* validate the public token objects in token list now.
*/
/* Release the global session list lock */
(void) pthread_mutex_unlock(&soft_sessionlist_mutex);
return (CKR_OK);
}
/*
* This function adds the to-be-freed session to a linked list.
* When the number of sessions queued in the linked list reaches the
* maximum threshold MAX_SES_TO_BE_FREED, it will free the first
* session (FIFO) in the list.
*/
void
{
/* Add the newly deleted session at the end of the list */
} else {
}
/*
* Free the first session in the list only if
* the total count reaches maximum threshold.
*/
}
}
/*
* Delete a session:
* - Remove the session from the session linked list.
* Holding the lock on the global session list is needed to do this.
* - Release all the objects created by the session.
*
* The boolean argument lock_held is used to indicate that whether
* the caller of this function holds the lock on the global session
* list or not.
* - When called by soft_delete_all_sessions(), which is called by
* C_Finalize() or C_CloseAllSessions() -- the lock_held = TRUE.
* - When called by C_CloseSession() -- the lock_held = FALSE.
*
* When the caller does not hold the lock on the global session
* list, this function will acquire that lock in order to proceed,
* and also release that lock before returning to caller.
*/
{
/*
* Check to see if the caller holds the lock on the global
* session list. If not, we need to acquire that lock in
* order to proceed.
*/
if (!lock_held) {
/* Acquire the global session list lock */
(void) pthread_mutex_lock(&soft_sessionlist_mutex);
}
/*
* Remove the session from the session linked list first.
*/
if (soft_session_list == session_p) {
/* Session is the first one in the list */
} else {
/* Session is the only one in the list */
}
} else {
/* Session is not the first one in the list */
/* Session is in the middle of the list */
} else {
/* Session is the last one in the list */
}
}
if (!lock_held) {
/*
* If the global session list lock is obtained by
* this function, then release that lock after
* removing the session from session linked list.
* We want the releasing of the objects of the
* session, and freeing of the session itself to
* be done without holding the global session list
* lock.
*/
(void) pthread_mutex_unlock(&soft_sessionlist_mutex);
}
/* Acquire the individual session lock */
/*
* Make sure another thread hasn't freed the session.
*/
return (CKR_OK);
}
/*
* The deletion of a session must be blocked when the session
* reference count is not zero. This means if any session related
* operation starts prior to the session close operation gets in,
* the session closing thread must wait for the non-closing
* operation to be completed before it can proceed the close
* operation.
*/
while (session_p->ses_refcnt != 0) {
/*
* We set the SESSION_REFCNT_WAITING flag before we put
* this closing thread in a wait state, so other non-closing
* operation thread will signal to wake it up only when
* the session reference count becomes zero and this flag
* is set.
*/
}
/* Mark session as no longer valid. */
session_p->magic_marker = 0;
/*
* Remove all the objects created in this session.
*/
/* In case application did not call Final */
/*
* 1st B_TRUE: encrypt
* 2nd B_TRUE: caller is holding session_mutex.
*/
/*
* 1st B_FALSE: decrypt
* 2nd B_TRUE: caller is holding session_mutex.
*/
}
/* Reset SESSION_IS_CLOSIN flag. */
/* Destroy the individual session lock */
/* Delay freeing the session */
return (CKR_OK);
}
/*
* This function is used to type cast a session handle to a pointer to
* the session struct. Also, it does the following things:
* 1) Check to see if the session struct is tagged with a session
* magic number. This is to detect when an application passes
* a bogus session pointer.
* 2) Acquire the locks on the global session list and on the designated
* session.
* 3) Check to see if the session is in the closing state that another
* thread is performing.
* 4) Increment the session reference count by one. This is to prevent
* this session from being closed by other thread.
* 5) Release the locks held on the designated session and on the global
* session list.
*/
{
(void) pthread_mutex_lock(&soft_sessionlist_mutex);
if (all_sessions_closing) {
(void) pthread_mutex_unlock(&soft_sessionlist_mutex);
return (CKR_SESSION_CLOSED);
}
/*
* We need to free the global session list lock to prevent deadlock
* explicit deletion (C_DestroyObject) after implicit deletion by
* C_CloseSession.
*/
(void) pthread_mutex_unlock(&soft_sessionlist_mutex);
return (CKR_SESSION_HANDLE_INVALID);
}
return (CKR_SESSION_CLOSED);
}
/* Increment session ref count. */
sp->ses_refcnt++;
return (CKR_OK);
}
/*
* The format to be saved in the pOperationState will be:
* 1. internal_op_state_t
* 2. crypto_active_op_t
* 3. actual context of the active operation
*/
{
CK_ULONG op_data_len = 0;
/* Check to see if encrypt operation is active. */
return (CKR_STATE_UNSAVEABLE);
}
/* Check to see if decrypt operation is active. */
return (CKR_STATE_UNSAVEABLE);
}
/* Check to see if sign operation is active. */
return (CKR_STATE_UNSAVEABLE);
}
/* Check to see if verify operation is active. */
return (CKR_STATE_UNSAVEABLE);
}
/* Check to see if digest operation is active. */
op_data_len = sizeof (internal_op_state_t) +
sizeof (crypto_active_op_t);
case CKM_MD5:
op_data_len += sizeof (MD5_CTX);
break;
case CKM_SHA_1:
op_data_len += sizeof (SHA1_CTX);
break;
default:
return (CKR_STATE_UNSAVEABLE);
}
if (pOperationState == NULL_PTR) {
return (CKR_OK);
} else {
if (*pulOperationStateLen < op_data_len) {
return (CKR_BUFFER_TOO_SMALL);
}
}
/* Save internal_op_state_t */
sizeof (internal_op_state_t));
/* Save crypto_active_op_t */
sizeof (internal_op_state_t),
sizeof (crypto_active_op_t));
case CKM_MD5:
/* Save MD5_CTX for the active digest operation */
sizeof (internal_op_state_t) +
sizeof (crypto_active_op_t),
sizeof (MD5_CTX));
break;
case CKM_SHA_1:
/* Save SHA1_CTX for the active digest operation */
sizeof (internal_op_state_t) +
sizeof (crypto_active_op_t),
sizeof (SHA1_CTX));
break;
default:
return (CKR_STATE_UNSAVEABLE);
}
}
return (CKR_OK);
}
/*
* The format to be restored from the pOperationState will be:
* 1. internal_op_state_t
* 2. crypto_active_op_t
* 3. actual context of the saved operation
*/
{
/* Restore internal_op_state_t */
sizeof (internal_op_state_t));
/*
* The supplied session state does not match with
* the saved session state.
*/
return (CKR_SAVED_STATE_INVALID);
}
/*
* The supplied data length does not match with
* the saved data length.
*/
return (CKR_SAVED_STATE_INVALID);
}
offset = sizeof (internal_op_state_t);
sizeof (crypto_active_op_t));
case DIGEST_OP:
if ((hAuthenticationKey != 0) || (hEncryptionKey != 0)) {
return (CKR_KEY_NOT_NEEDED);
}
/*
* If the destination session has the same mechanism
* as the source, we can reuse the memory allocated for
* the crypto context. Otherwise, we free the crypto
* context of the destination session now.
*/
(void) pthread_mutex_lock(&session_p->
(void) pthread_mutex_unlock(&session_p->
}
}
break;
default:
return (CKR_SAVED_STATE_INVALID);
}
/* Restore crypto_active_op_t */
offset += sizeof (crypto_active_op_t);
/*
* Make sure the supplied crypto operation state is valid
*/
case DIGEST_OP:
case CKM_MD5:
(void) pthread_mutex_unlock(
return (CKR_HOST_MEMORY);
}
}
/* Restore MD5_CTX from the saved digest operation */
sizeof (MD5_CTX));
break;
case CKM_SHA_1:
(void) pthread_mutex_unlock(
return (CKR_HOST_MEMORY);
}
}
/* Restore SHA1_CTX from the saved digest operation */
sizeof (SHA1_CTX));
break;
default:
break;
}
break;
default:
break;
}
return (rv);
}
{
/*
* Authenticate the input PIN.
*/
}
void
soft_logout(void)
{
/*
* Delete all the private token objects from the "token_object_list".
*/
return;
}