/*
* gnome-keyring
*
* Copyright (C) 2010 Stefan Walter
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see
* .
*/
#include "config.h"
#include "gkm-attributes.h"
#include "gkm-mock.h"
#include "gkm-util.h"
#include "pkcs11/pkcs11.h"
#include "pkcs11/pkcs11i.h"
#include
#include
#define GKM_TEST_SLOT_ONE 52
#define GKM_TEST_SLOT_TWO 134
static gboolean initialized = FALSE;
static gchar *the_pin = NULL;
static gulong n_the_pin = 0;
static gboolean logged_in = FALSE;
static CK_USER_TYPE user_type = 0;
static CK_FUNCTION_LIST functionList;
typedef enum _Operation {
OP_FIND = 1,
OP_CRYPTO
} Operation;
typedef struct _Session {
CK_SESSION_HANDLE handle;
CK_SESSION_INFO info;
GHashTable *objects;
Operation operation;
/* For find operations */
GList *matches;
/* For crypto operations */
CK_OBJECT_HANDLE crypto_key;
CK_ATTRIBUTE_TYPE crypto_method;
CK_MECHANISM_TYPE crypto_mechanism;
CK_BBOOL want_context_login;
/* For 'signing' with CKM_MOCK_PREFIX */
CK_BYTE sign_prefix[128];
CK_ULONG n_sign_prefix;
} Session;
static guint unique_identifier = 100;
static GHashTable *the_sessions = NULL;
static GHashTable *the_objects = NULL;
static GSList *the_objects_list = NULL;
static GArray *the_credential_template = NULL;
enum {
PRIVATE_KEY_CAPITALIZE = 3,
PUBLIC_KEY_CAPITALIZE = 4,
PRIVATE_KEY_PREFIX = 5,
PUBLIC_KEY_PREFIX = 6
};
#define SIGNED_PREFIX "signed-prefix:"
static void
free_session (gpointer data)
{
Session *sess = (Session*)data;
if (sess)
g_hash_table_destroy (sess->objects);
g_free (sess);
}
static GArray*
lookup_object (Session *session, CK_OBJECT_HANDLE hObject)
{
GArray *attrs;
attrs = g_hash_table_lookup (the_objects, GUINT_TO_POINTER (hObject));
if (!attrs)
attrs = g_hash_table_lookup (session->objects, GUINT_TO_POINTER (hObject));
return attrs;
}
typedef struct {
guint handle;
GArray *template; /* owned by the_objects */
} ObjectData;
static gint
list_find_handle (gconstpointer l, gconstpointer r)
{
guint handle;
ObjectData *item;
handle = GPOINTER_TO_UINT (r);
item = (ObjectData *) l;
if (item->handle == handle)
return 0;
return -1;
}
static void
insert_template (guint handle, GArray *template)
{
ObjectData *data;
data = g_new0 (ObjectData, 1);
data->handle = handle;
data->template = template;
g_hash_table_insert (the_objects, GUINT_TO_POINTER (handle), template);
the_objects_list = g_slist_append (the_objects_list, data);
}
CK_OBJECT_HANDLE
gkm_mock_module_take_object (GArray *template)
{
gboolean token;
guint handle;
g_return_val_if_fail (the_objects, 0);
handle = ++unique_identifier;
if (gkm_template_find_boolean (template, CKA_TOKEN, &token))
g_return_val_if_fail (token == TRUE, 0);
else
gkm_template_set_boolean (template, CKA_TOKEN, CK_TRUE);
insert_template (handle, template);
return handle;
}
void
gkm_mock_module_enumerate_objects (CK_SESSION_HANDLE handle, GkmMockEnumerator func,
gpointer user_data)
{
GHashTableIter iter;
gpointer key;
gpointer value;
Session *session;
ObjectData *data;
GSList *l = NULL;
g_assert (the_objects);
g_assert (func);
/* Token objects */
for (l = the_objects_list; l != NULL; l = l->next) {
data = (ObjectData *) l->data;
if (!(func) (data->handle, data->template, user_data))
return;
}
/* session objects */
if (handle) {
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (handle));
if (session) {
g_hash_table_iter_init (&iter, session->objects);
while (g_hash_table_iter_next (&iter, &key, &value)) {
if (!(func) (GPOINTER_TO_UINT (key), value, user_data))
return;
}
}
}
}
typedef struct _FindObject {
CK_ATTRIBUTE_PTR attrs;
CK_ULONG n_attrs;
CK_OBJECT_HANDLE object;
} FindObject;
static gboolean
enumerate_and_find_object (CK_OBJECT_HANDLE object, GArray *template, gpointer user_data)
{
FindObject *ctx = user_data;
CK_ATTRIBUTE_PTR match, attr;
CK_ULONG i;
for (i = 0; i < ctx->n_attrs; ++i) {
match = ctx->attrs + i;
attr = gkm_template_find (template, match->type);
if (!attr)
return TRUE; /* Continue */
if (attr->ulValueLen != match->ulValueLen ||
memcmp (attr->pValue, match->pValue, attr->ulValueLen) != 0)
return TRUE; /* Continue */
}
ctx->object = object;
return FALSE; /* Stop iteration */
}
CK_OBJECT_HANDLE
gkm_mock_module_find_object (CK_SESSION_HANDLE session, CK_ATTRIBUTE_PTR attrs, CK_ULONG n_attrs)
{
FindObject ctx;
ctx.attrs = attrs;
ctx.n_attrs = n_attrs;
ctx.object = 0;
gkm_mock_module_enumerate_objects (session, enumerate_and_find_object, &ctx);
return ctx.object;
}
static gboolean
enumerate_and_count_objects (CK_OBJECT_HANDLE object, GArray *template, gpointer user_data)
{
guint *n_objects = user_data;
++(*n_objects);
return TRUE; /* Continue */
}
guint
gkm_mock_module_count_objects (CK_SESSION_HANDLE session)
{
guint n_objects = 0;
gkm_mock_module_enumerate_objects (session, enumerate_and_count_objects, &n_objects);
return n_objects;
}
void
gkm_mock_module_set_object (CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR attrs,
CK_ULONG n_attrs)
{
CK_ULONG i;
GArray *template;
g_return_if_fail (object != 0);
g_return_if_fail (the_objects);
template = g_hash_table_lookup (the_objects, GUINT_TO_POINTER (object));
g_return_if_fail (template);
for (i = 0; i < n_attrs; ++i)
gkm_template_set (template, attrs + i);
}
void
gkm_mock_module_set_pin (const gchar *password)
{
g_free (the_pin);
the_pin = g_strdup (password);
n_the_pin = strlen (password);
}
CK_RV
gkm_mock_C_Initialize (CK_VOID_PTR pInitArgs)
{
GArray *attrs;
CK_ULONG value;
CK_C_INITIALIZE_ARGS_PTR args;
g_return_val_if_fail (initialized == FALSE, CKR_CRYPTOKI_ALREADY_INITIALIZED);
args = (CK_C_INITIALIZE_ARGS_PTR)pInitArgs;
if (args) {
g_return_val_if_fail(
(args->CreateMutex == NULL && args->DestroyMutex == NULL &&
args->LockMutex == NULL && args->UnlockMutex == NULL) ||
(args->CreateMutex != NULL && args->DestroyMutex != NULL &&
args->LockMutex != NULL && args->UnlockMutex != NULL),
CKR_ARGUMENTS_BAD);
/* Flags should allow OS locking and os threads */
g_return_val_if_fail (args->flags & CKF_OS_LOCKING_OK, CKR_CANT_LOCK);
g_return_val_if_fail (args->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS, CKR_NEED_TO_CREATE_THREADS);
}
the_pin = g_strdup ("booo");
n_the_pin = strlen (the_pin);
the_sessions = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, free_session);
the_objects = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)gkm_template_free);
the_credential_template = gkm_template_new (NULL, 0);
/* Our token object */
attrs = gkm_template_new (NULL, 0);
gkm_template_set_ulong (attrs, CKA_CLASS, CKO_DATA);
gkm_template_set_string (attrs, CKA_LABEL, "TEST LABEL");
insert_template (2, attrs);
/* Private capitalize key */
value = CKM_MOCK_CAPITALIZE;
attrs = gkm_template_new (NULL, 0);
gkm_template_set_ulong (attrs, CKA_CLASS, CKO_PRIVATE_KEY);
gkm_template_set_string (attrs, CKA_LABEL, "Private Capitalize Key");
gkm_template_set_value (attrs, CKA_ALLOWED_MECHANISMS, &value, sizeof (value));
gkm_template_set_boolean (attrs, CKA_DECRYPT, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_PRIVATE, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_WRAP, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_UNWRAP, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_DERIVE, CK_TRUE);
gkm_template_set_string (attrs, CKA_VALUE, "value");
gkm_template_set_string (attrs, CKA_GNOME_UNIQUE, "unique1");
insert_template (PRIVATE_KEY_CAPITALIZE, attrs);
/* Public capitalize key */
value = CKM_MOCK_CAPITALIZE;
attrs = gkm_template_new (NULL, 0);
gkm_template_set_ulong (attrs, CKA_CLASS, CKO_PUBLIC_KEY);
gkm_template_set_string (attrs, CKA_LABEL, "Public Capitalize Key");
gkm_template_set_value (attrs, CKA_ALLOWED_MECHANISMS, &value, sizeof (value));
gkm_template_set_boolean (attrs, CKA_ENCRYPT, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_PRIVATE, CK_FALSE);
gkm_template_set_string (attrs, CKA_VALUE, "value");
gkm_template_set_string (attrs, CKA_GNOME_UNIQUE, "unique2");
insert_template (PUBLIC_KEY_CAPITALIZE, attrs);
/* Private prefix key */
value = CKM_MOCK_PREFIX;
attrs = gkm_template_new (NULL, 0);
gkm_template_set_ulong (attrs, CKA_CLASS, CKO_PRIVATE_KEY);
gkm_template_set_string (attrs, CKA_LABEL, "Private prefix key");
gkm_template_set_value (attrs, CKA_ALLOWED_MECHANISMS, &value, sizeof (value));
gkm_template_set_boolean (attrs, CKA_SIGN, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_PRIVATE, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_ALWAYS_AUTHENTICATE, CK_TRUE);
gkm_template_set_string (attrs, CKA_VALUE, "value");
gkm_template_set_string (attrs, CKA_GNOME_UNIQUE, "unique3");
insert_template (PRIVATE_KEY_PREFIX, attrs);
/* Private prefix key */
value = CKM_MOCK_PREFIX;
attrs = gkm_template_new (NULL, 0);
gkm_template_set_ulong (attrs, CKA_CLASS, CKO_PUBLIC_KEY);
gkm_template_set_string (attrs, CKA_LABEL, "Public prefix key");
gkm_template_set_value (attrs, CKA_ALLOWED_MECHANISMS, &value, sizeof (value));
gkm_template_set_boolean (attrs, CKA_VERIFY, CK_TRUE);
gkm_template_set_boolean (attrs, CKA_PRIVATE, CK_FALSE);
gkm_template_set_string (attrs, CKA_VALUE, "value");
gkm_template_set_string (attrs, CKA_GNOME_UNIQUE, "unique4");
insert_template (PUBLIC_KEY_PREFIX, attrs);
initialized = TRUE;
return CKR_OK;
}
CK_RV
gkm_mock_C_Finalize (CK_VOID_PTR pReserved)
{
g_return_val_if_fail (pReserved == NULL, CKR_ARGUMENTS_BAD);
g_return_val_if_fail (initialized == TRUE, CKR_CRYPTOKI_NOT_INITIALIZED);
initialized = FALSE;
logged_in = FALSE;
g_hash_table_destroy (the_objects);
the_objects = NULL;
g_slist_free_full (the_objects_list, g_free);
the_objects_list = NULL;
g_hash_table_destroy (the_sessions);
the_sessions = NULL;
gkm_template_free (the_credential_template);
the_credential_template = NULL;
g_free (the_pin);
return CKR_OK;
}
static const CK_INFO TEST_INFO = {
{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
"TEST MANUFACTURER ",
0,
"TEST LIBRARY ",
{ 45, 145 }
};
CK_RV
gkm_mock_C_GetInfo (CK_INFO_PTR pInfo)
{
g_assert (pInfo != NULL && "Invalid pointer to GetInfo");
memcpy (pInfo, &TEST_INFO, sizeof (*pInfo));
return CKR_OK;
}
CK_RV
gkm_mock_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
{
if (!list)
return CKR_ARGUMENTS_BAD;
*list = &functionList;
return CKR_OK;
}
/*
* Two slots
* ONE: token present
* TWO: token not present
*/
CK_RV
gkm_mock_C_GetSlotList (CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount)
{
CK_ULONG count;
g_assert (pulCount != NULL && "Invalid pulCount");
count = tokenPresent ? 1 : 2;
/* Application only wants to know the number of slots. */
if (pSlotList == NULL) {
*pulCount = count;
return CKR_OK;
}
if (*pulCount < count) {
g_assert (*pulCount && "Passed in a bad count");
return CKR_BUFFER_TOO_SMALL;
}
*pulCount = count;
pSlotList[0] = GKM_TEST_SLOT_ONE;
if (!tokenPresent)
pSlotList[1] = GKM_TEST_SLOT_TWO;
return CKR_OK;
}
static const CK_SLOT_INFO TEST_INFO_ONE = {
"TEST SLOT ",
"TEST MANUFACTURER ",
CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE,
{ 55, 155 },
{ 65, 165 },
};
static const CK_SLOT_INFO TEST_INFO_TWO = {
"TEST SLOT ",
"TEST MANUFACTURER ",
CKF_REMOVABLE_DEVICE,
{ 55, 155 },
{ 65, 165 },
};
CK_RV
gkm_mock_C_GetSlotInfo (CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
{
g_assert (pInfo != NULL && "Invalid pInfo");
if (slotID == GKM_TEST_SLOT_ONE) {
memcpy (pInfo, &TEST_INFO_ONE, sizeof (*pInfo));
return CKR_OK;
} else if (slotID == GKM_TEST_SLOT_TWO) {
memcpy (pInfo, &TEST_INFO_TWO, sizeof (*pInfo));
return CKR_OK;
} else {
g_assert_not_reached (); /* "Invalid slot id" */
return CKR_SLOT_ID_INVALID;
}
}
static const CK_TOKEN_INFO TEST_TOKEN_ONE = {
"TEST LABEL ",
"TEST MANUFACTURER ",
"TEST MODEL ",
"TEST SERIAL ",
CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED | CKF_CLOCK_ON_TOKEN | CKF_TOKEN_INITIALIZED,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
{ 75, 175 },
{ 85, 185 },
{ '1', '9', '9', '9', '0', '5', '2', '5', '0', '9', '1', '9', '5', '9', '0', '0' }
};
CK_RV
gkm_mock_C_GetTokenInfo (CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo)
{
g_return_val_if_fail (pInfo != NULL, CKR_ARGUMENTS_BAD);
if (slotID == GKM_TEST_SLOT_ONE) {
memcpy (pInfo, &TEST_TOKEN_ONE, sizeof (*pInfo));
return CKR_OK;
} else if (slotID == GKM_TEST_SLOT_TWO) {
return CKR_TOKEN_NOT_PRESENT;
} else {
g_return_val_if_reached (CKR_SLOT_ID_INVALID);
}
}
CK_RV
gkm_mock_fail_C_GetTokenInfo (CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo)
{
return CKR_GENERAL_ERROR;
}
/*
* TWO mechanisms:
* CKM_MOCK_CAPITALIZE
* CKM_MOCK_PREFIX
*/
CK_RV
gkm_mock_C_GetMechanismList (CK_SLOT_ID slotID, CK_MECHANISM_TYPE_PTR pMechanismList,
CK_ULONG_PTR pulCount)
{
g_assert (slotID == GKM_TEST_SLOT_ONE && "Invalid slotID");
g_assert (pulCount != NULL && "Invalid pulCount");
/* Application only wants to know the number of slots. */
if (pMechanismList == NULL) {
*pulCount = 2;
return CKR_OK;
}
if (*pulCount != 2) {
g_assert (*pulCount && "Passed in a bad count");
return CKR_BUFFER_TOO_SMALL;
}
pMechanismList[0] = CKM_MOCK_CAPITALIZE;
pMechanismList[1] = CKM_MOCK_PREFIX;
return CKR_OK;
}
static const CK_MECHANISM_INFO TEST_MECH_CAPITALIZE = {
512, 4096, 0
};
static const CK_MECHANISM_INFO TEST_MECH_PREFIX = {
2048, 2048, 0
};
CK_RV
gkm_mock_C_GetMechanismInfo (CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
CK_MECHANISM_INFO_PTR pInfo)
{
g_assert (slotID == GKM_TEST_SLOT_ONE && "Invalid slotID");
g_assert (pInfo != NULL && "Invalid pInfo");
if (type == CKM_MOCK_CAPITALIZE) {
memcpy (pInfo, &TEST_MECH_CAPITALIZE, sizeof (*pInfo));
return CKR_OK;
} else if (type == CKM_MOCK_PREFIX) {
memcpy (pInfo, &TEST_MECH_PREFIX, sizeof (*pInfo));
return CKR_OK;
} else {
g_assert_not_reached (); /* "Invalid type" */
return CKR_MECHANISM_INVALID;
}
}
CK_RV
gkm_mock_C_InitToken (CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen,
CK_UTF8CHAR_PTR pLabel)
{
g_assert (slotID == GKM_TEST_SLOT_ONE && "Invalid slotID");
g_assert (pPin != NULL && "Invalid pPin");
g_assert (strlen ("TEST PIN") && "Invalid ulPinLen");
g_assert (strncmp ((gchar*)pPin, "TEST PIN", ulPinLen) == 0 && "Invalid pPin string");
g_assert (pLabel != NULL && "Invalid pLabel");
g_assert (strcmp ((gchar*)pPin, "TEST LABEL") == 0 && "Invalid pLabel string");
g_free (the_pin);
the_pin = g_strndup ((gchar*)pPin, ulPinLen);
n_the_pin = ulPinLen;
return CKR_OK;
}
CK_RV
gkm_mock_unsupported_C_WaitForSlotEvent (CK_FLAGS flags, CK_SLOT_ID_PTR pSlot, CK_VOID_PTR pReserved)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_C_OpenSession (CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication,
CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession)
{
Session *sess;
g_return_val_if_fail (slotID == GKM_TEST_SLOT_ONE, CKR_SLOT_ID_INVALID);
g_return_val_if_fail (phSession != NULL, CKR_ARGUMENTS_BAD);
g_return_val_if_fail ((flags & CKF_SERIAL_SESSION) == CKF_SERIAL_SESSION, CKR_SESSION_PARALLEL_NOT_SUPPORTED);
sess = g_new0 (Session, 1);
sess->handle = ++unique_identifier;
sess->info.flags = flags;
sess->info.slotID = slotID;
sess->info.state = 0;
sess->info.ulDeviceError = 1414;
sess->objects = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)gkm_template_free);
*phSession = sess->handle;
g_hash_table_replace (the_sessions, GUINT_TO_POINTER (sess->handle), sess);
return CKR_OK;
}
CK_RV
gkm_mock_fail_C_OpenSession (CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication,
CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession)
{
return CKR_GENERAL_ERROR;
}
CK_RV
gkm_mock_C_CloseSession (CK_SESSION_HANDLE hSession)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
g_hash_table_remove (the_sessions, GUINT_TO_POINTER (hSession));
return CKR_OK;
}
CK_RV
gkm_mock_C_CloseAllSessions (CK_SLOT_ID slotID)
{
g_assert (slotID == GKM_TEST_SLOT_ONE && "Invalid slotID");
g_hash_table_remove_all (the_sessions);
return CKR_OK;
}
CK_RV
gkm_mock_C_GetFunctionStatus (CK_SESSION_HANDLE hSession)
{
return CKR_FUNCTION_NOT_PARALLEL;
}
CK_RV
gkm_mock_C_CancelFunction (CK_SESSION_HANDLE hSession)
{
return CKR_FUNCTION_NOT_PARALLEL;
}
CK_RV
gkm_mock_C_GetSessionInfo (CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo)
{
Session *session;
g_return_val_if_fail (pInfo != NULL, CKR_ARGUMENTS_BAD);
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
if (logged_in) {
if (session->info.flags & CKF_RW_SESSION)
session->info.state = CKS_RW_USER_FUNCTIONS;
else
session->info.state = CKS_RO_USER_FUNCTIONS;
} else {
if (session->info.flags & CKF_RW_SESSION)
session->info.state = CKS_RW_PUBLIC_SESSION;
else
session->info.state = CKS_RO_PUBLIC_SESSION;
}
memcpy (pInfo, &session->info, sizeof (*pInfo));
return CKR_OK;
}
CK_RV
gkm_mock_fail_C_GetSessionInfo (CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo)
{
return CKR_GENERAL_ERROR;
}
CK_RV
gkm_mock_C_InitPIN (CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin,
CK_ULONG ulPinLen)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_return_val_if_fail (session, CKR_SESSION_HANDLE_INVALID);
g_free (the_pin);
the_pin = g_strndup ((gchar*)pPin, ulPinLen);
n_the_pin = ulPinLen;
return CKR_OK;
}
CK_RV
gkm_mock_C_SetPIN (CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin,
CK_ULONG ulOldLen, CK_UTF8CHAR_PTR pNewPin, CK_ULONG ulNewLen)
{
Session *session;
gchar *old;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_return_val_if_fail (session, CKR_SESSION_HANDLE_INVALID);
old = g_strndup ((gchar*)pOldPin, ulOldLen);
if (!old || !g_str_equal (old, the_pin)) {
g_free (old);
return CKR_PIN_INCORRECT;
}
g_free (old);
g_free (the_pin);
the_pin = g_strndup ((gchar*)pNewPin, ulNewLen);
n_the_pin = ulNewLen;
return CKR_OK;
}
CK_RV
gkm_mock_unsupported_C_GetOperationState (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState,
CK_ULONG_PTR pulOperationStateLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_SetOperationState (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState,
CK_ULONG ulOperationStateLen, CK_OBJECT_HANDLE hEncryptionKey,
CK_OBJECT_HANDLE hAuthenticationKey)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_C_Login (CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
CK_UTF8CHAR_PTR pPin, CK_ULONG pPinLen)
{
Session *session;
g_return_val_if_fail (userType == CKU_SO ||
userType == CKU_USER ||
userType == CKU_CONTEXT_SPECIFIC,
CKR_USER_TYPE_INVALID);
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_return_val_if_fail (session != NULL, CKR_SESSION_HANDLE_INVALID);
g_return_val_if_fail (logged_in == FALSE, CKR_USER_ALREADY_LOGGED_IN);
if (!pPin)
return CKR_PIN_INCORRECT;
if (pPinLen != strlen (the_pin))
return CKR_PIN_INCORRECT;
if (strncmp ((gchar*)pPin, the_pin, pPinLen) != 0)
return CKR_PIN_INCORRECT;
if (userType == CKU_CONTEXT_SPECIFIC) {
g_return_val_if_fail (session->want_context_login == TRUE, CKR_OPERATION_NOT_INITIALIZED);
session->want_context_login = CK_FALSE;
} else {
logged_in = TRUE;
user_type = userType;
}
return CKR_OK;
}
CK_RV
gkm_mock_C_Logout (CK_SESSION_HANDLE hSession)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
g_assert (logged_in && "Not logged in");
logged_in = FALSE;
user_type = 0;
return CKR_OK;
}
CK_RV
gkm_mock_C_CreateObject (CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate,
CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phObject)
{
GArray *attrs;
Session *session;
gboolean token, priv;
CK_OBJECT_CLASS klass;
CK_OBJECT_HANDLE object;
CK_ATTRIBUTE_PTR attr;
g_assert (phObject != NULL);
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
attrs = gkm_template_new (pTemplate, ulCount);
if (gkm_template_find_boolean (attrs, CKA_PRIVATE, &priv) && priv) {
if (!logged_in) {
gkm_template_free (attrs);
return CKR_USER_NOT_LOGGED_IN;
}
}
/* In order to create a credential we must check CK_VALUE */
if (gkm_template_find_ulong (attrs, CKA_CLASS, &klass) && klass == CKO_G_CREDENTIAL) {
if (gkm_template_find_ulong (attrs, CKA_G_OBJECT, &object)) {
attr = gkm_template_find (attrs, CKA_VALUE);
if (!attr || attr->ulValueLen != n_the_pin ||
memcmp (attr->pValue, the_pin, attr->ulValueLen) != 0) {
gkm_template_free (attrs);
return CKR_PIN_INCORRECT;
}
}
}
*phObject = ++unique_identifier;
if (gkm_template_find_boolean (attrs, CKA_TOKEN, &token) && token)
insert_template (*phObject, attrs);
else
g_hash_table_insert (session->objects, GUINT_TO_POINTER (*phObject), attrs);
return CKR_OK;
}
CK_RV
gkm_mock_unsupported_C_CopyObject (CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
CK_OBJECT_HANDLE_PTR phNewObject)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_C_DestroyObject (CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject)
{
GArray *attrs;
Session *session;
GSList *list;
gboolean priv;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_return_val_if_fail (session, CKR_SESSION_HANDLE_INVALID);
attrs = lookup_object (session, hObject);
g_return_val_if_fail (attrs, CKR_OBJECT_HANDLE_INVALID);
if (gkm_template_find_boolean (attrs, CKA_PRIVATE, &priv) && priv) {
if (!logged_in)
return CKR_USER_NOT_LOGGED_IN;
}
g_hash_table_remove (the_objects, GUINT_TO_POINTER (hObject));
do {
list = g_slist_find_custom (the_objects_list, GUINT_TO_POINTER (hObject), list_find_handle);
if (list != NULL) {
g_free (list->data);
the_objects_list = g_slist_delete_link (the_objects_list, list);
}
} while (list != NULL);
g_hash_table_remove (session->objects, GUINT_TO_POINTER (hObject));
return CKR_OK;
}
CK_RV
gkm_mock_unsupported_C_GetObjectSize (CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
CK_ULONG_PTR pulSize)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_C_GetAttributeValue (CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
CK_ATTRIBUTE_PTR result;
CK_RV ret = CKR_OK;
GArray *attrs;
CK_ATTRIBUTE_PTR attr;
Session *session;
CK_ULONG i;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
attrs = lookup_object (session, hObject);
if (!attrs) {
g_assert_not_reached (); /* "invalid object handle passed" */
return CKR_OBJECT_HANDLE_INVALID;
}
for (i = 0; i < ulCount; ++i) {
result = pTemplate + i;
if (result->type == CKA_G_CREDENTIAL_TEMPLATE) {
gkm_attribute_set_template (result, the_credential_template);
continue;
}
attr = gkm_template_find (attrs, result->type);
if (!attr) {
result->ulValueLen = (CK_ULONG)-1;
ret = CKR_ATTRIBUTE_TYPE_INVALID;
continue;
}
if (!result->pValue) {
result->ulValueLen = attr->ulValueLen;
continue;
}
if (result->ulValueLen >= attr->ulValueLen) {
memcpy (result->pValue, attr->pValue, attr->ulValueLen);
continue;
}
result->ulValueLen = (CK_ULONG)-1;
ret = CKR_BUFFER_TOO_SMALL;
}
return ret;
}
CK_RV
gkm_mock_C_SetAttributeValue (CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
Session *session;
GArray *attrs;
CK_ULONG i;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
attrs = lookup_object (session, hObject);
if (!attrs) {
g_assert_not_reached (); /* "invalid object handle passed" */
return CKR_OBJECT_HANDLE_INVALID;
}
for (i = 0; i < ulCount; ++i) {
CK_ATTRIBUTE_PTR attr = pTemplate + i;
if (attr->type == CKA_G_CREDENTIAL_TEMPLATE) {
CK_RV rv;
GArray *template;
rv = gkm_attribute_get_template (attr, &template);
if (rv != CKR_OK)
return CKR_OBJECT_HANDLE_INVALID;
gkm_template_free(the_credential_template);
the_credential_template = template;
} else {
gkm_template_set (attrs, attr);
}
}
return CKR_OK;
}
typedef struct _FindObjects {
CK_ATTRIBUTE_PTR template;
CK_ULONG count;
Session *session;
} FindObjects;
static gboolean
enumerate_and_find_objects (CK_OBJECT_HANDLE object, GArray *attrs, gpointer user_data)
{
FindObjects *ctx = user_data;
CK_ATTRIBUTE_PTR match, attr;
CK_ULONG i;
for (i = 0; i < ctx->count; ++i) {
match = ctx->template + i;
attr = gkm_template_find (attrs, match->type);
if (!attr)
return TRUE; /* Continue */
if (attr->ulValueLen != match->ulValueLen ||
memcmp (attr->pValue, match->pValue, attr->ulValueLen) != 0)
return TRUE; /* Continue */
}
ctx->session->matches = g_list_prepend (ctx->session->matches, GUINT_TO_POINTER (object));
return TRUE; /* Continue */
}
CK_RV
gkm_mock_C_FindObjectsInit (CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate,
CK_ULONG ulCount)
{
Session *session;
FindObjects ctx;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_return_val_if_fail (session != NULL, CKR_SESSION_HANDLE_INVALID);
/* Starting an operation, cancels any previous one */
if (session->operation != 0)
session->operation = 0;
session->operation = OP_FIND;
ctx.template = pTemplate;
ctx.count = ulCount;
ctx.session = session;
gkm_mock_module_enumerate_objects (hSession, enumerate_and_find_objects, &ctx);
return CKR_OK;
}
CK_RV
gkm_mock_C_FindObjects (CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phObject,
CK_ULONG ulMaxObjectCount, CK_ULONG_PTR pulObjectCount)
{
Session *session;
g_assert (phObject != NULL);
g_assert (pulObjectCount != NULL);
g_assert (ulMaxObjectCount != 0);
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
if (session->operation != OP_FIND) {
g_assert_not_reached (); /* "invalid call to FindObjects" */
return CKR_OPERATION_NOT_INITIALIZED;
}
*pulObjectCount = 0;
while (ulMaxObjectCount > 0 && session->matches) {
*phObject = GPOINTER_TO_UINT (session->matches->data);
++phObject;
--ulMaxObjectCount;
++(*pulObjectCount);
session->matches = g_list_remove (session->matches, session->matches->data);
}
return CKR_OK;
}
CK_RV
gkm_mock_C_FindObjectsFinal (CK_SESSION_HANDLE hSession)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
if (session->operation != OP_FIND) {
g_assert_not_reached (); /* "invalid call to FindObjectsFinal" */
return CKR_OPERATION_NOT_INITIALIZED;
}
session->operation = 0;
g_list_free (session->matches);
session->matches = NULL;
return CKR_OK;
}
CK_RV
gkm_mock_C_EncryptInit (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE hKey)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
/* Starting an operation, cancels any previous one */
if (session->operation != 0)
session->operation = 0;
g_assert (pMechanism);
g_assert (pMechanism->mechanism == CKM_MOCK_CAPITALIZE);
g_assert (hKey == PUBLIC_KEY_CAPITALIZE);
session->operation = OP_CRYPTO;
session->crypto_method = CKA_ENCRYPT;
session->crypto_mechanism = CKM_MOCK_CAPITALIZE;
session->crypto_key = hKey;
return CKR_OK;
}
CK_RV
gkm_mock_C_Encrypt (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen)
{
Session *session;
CK_ULONG i;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
if (session->operation != OP_CRYPTO) {
g_assert_not_reached (); /* "invalid call to Encrypt" */
return CKR_OPERATION_NOT_INITIALIZED;
}
g_assert (pData);
g_assert (pulEncryptedDataLen);
g_assert (session->crypto_method == CKA_ENCRYPT);
g_assert (session->crypto_mechanism == CKM_MOCK_CAPITALIZE);
g_assert (session->crypto_key == PUBLIC_KEY_CAPITALIZE);
if (!pEncryptedData) {
*pulEncryptedDataLen = ulDataLen;
return CKR_OK;
}
if (*pulEncryptedDataLen < ulDataLen) {
*pulEncryptedDataLen = ulDataLen;
return CKR_BUFFER_TOO_SMALL;
}
for (i = 0; i < ulDataLen; ++i)
pEncryptedData[i] = g_ascii_toupper (pData[i]);
*pulEncryptedDataLen = ulDataLen;
session->operation = 0;
session->crypto_method = 0;
session->crypto_mechanism = 0;
session->crypto_key = 0;
return CKR_OK;
}
CK_RV
gkm_mock_unsupported_C_EncryptUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart,
CK_ULONG_PTR pulEncryptedPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_EncryptFinal (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastEncryptedPart,
CK_ULONG_PTR pulLastEncryptedPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_C_DecryptInit (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE hKey)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
/* Starting an operation, cancels any previous one */
if (session->operation != 0)
session->operation = 0;
g_assert (pMechanism);
g_assert (pMechanism->mechanism == CKM_MOCK_CAPITALIZE);
g_assert (hKey == PRIVATE_KEY_CAPITALIZE);
session->operation = OP_CRYPTO;
session->crypto_method = CKA_DECRYPT;
session->crypto_mechanism = CKM_MOCK_CAPITALIZE;
session->crypto_key = hKey;
return CKR_OK;
}
CK_RV
gkm_mock_C_Decrypt (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData,
CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
{
Session *session;
CK_ULONG i;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
if (session->operation != OP_CRYPTO) {
g_assert_not_reached (); /* "invalid call to Encrypt" */
return CKR_OPERATION_NOT_INITIALIZED;
}
g_assert (pEncryptedData);
g_assert (pulDataLen);
g_assert (session->crypto_method == CKA_DECRYPT);
g_assert (session->crypto_mechanism == CKM_MOCK_CAPITALIZE);
g_assert (session->crypto_key == PRIVATE_KEY_CAPITALIZE);
if (!pData) {
*pulDataLen = ulEncryptedDataLen;
return CKR_OK;
}
if (*pulDataLen < ulEncryptedDataLen) {
*pulDataLen = ulEncryptedDataLen;
return CKR_BUFFER_TOO_SMALL;
}
for (i = 0; i < ulEncryptedDataLen; ++i)
pData[i] = g_ascii_tolower (pEncryptedData[i]);
*pulDataLen = ulEncryptedDataLen;
session->operation = 0;
session->crypto_method = 0;
session->crypto_mechanism = 0;
session->crypto_key = 0;
return CKR_OK;
}
CK_RV
gkm_mock_unsupported_C_DecryptUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart,
CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DecryptFinal (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart,
CK_ULONG_PTR pulLastPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DigestInit (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_Digest (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DigestUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DigestKey (CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DigestFinal (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest,
CK_ULONG_PTR pulDigestLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_C_SignInit (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE hKey)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
/* Starting an operation, cancels any previous one */
if (session->operation != 0)
session->operation = 0;
g_assert (pMechanism);
g_assert (pMechanism->mechanism == CKM_MOCK_PREFIX);
g_assert (hKey == PRIVATE_KEY_PREFIX);
session->operation = OP_CRYPTO;
session->crypto_method = CKA_SIGN;
session->crypto_mechanism = CKM_MOCK_PREFIX;
session->crypto_key = hKey;
if (pMechanism->pParameter) {
g_assert (pMechanism->ulParameterLen < sizeof (session->sign_prefix));
memcpy (session->sign_prefix, pMechanism->pParameter, pMechanism->ulParameterLen);
session->n_sign_prefix = pMechanism->ulParameterLen;
} else {
g_assert (strlen (SIGNED_PREFIX) + 1 < sizeof (session->sign_prefix));
strcpy ((gchar*)session->sign_prefix, SIGNED_PREFIX);
session->n_sign_prefix = strlen (SIGNED_PREFIX);
}
/* The private key has CKA_ALWAYS_AUTHENTICATE above */
session->want_context_login = CK_TRUE;
return CKR_OK;
}
CK_RV
gkm_mock_C_Sign (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
{
Session *session;
CK_ULONG length;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
if (session->operation != OP_CRYPTO) {
g_assert_not_reached (); /* "invalid call to Encrypt" */
return CKR_OPERATION_NOT_INITIALIZED;
}
if (session->want_context_login)
return CKR_USER_NOT_LOGGED_IN;
g_assert (pData);
g_assert (pulSignatureLen);
g_assert (session->crypto_method == CKA_SIGN);
g_assert (session->crypto_mechanism == CKM_MOCK_PREFIX);
g_assert (session->crypto_key == PRIVATE_KEY_PREFIX);
length = session->n_sign_prefix + ulDataLen;
if (!pSignature) {
*pulSignatureLen = length;
return CKR_OK;
}
if (*pulSignatureLen < length) {
*pulSignatureLen = length;
return CKR_BUFFER_TOO_SMALL;
}
memcpy (pSignature, session->sign_prefix, session->n_sign_prefix);
memcpy (pSignature + session->n_sign_prefix, pData, ulDataLen);
*pulSignatureLen = length;
session->operation = 0;
session->crypto_method = 0;
session->crypto_mechanism = 0;
session->crypto_key = 0;
return CKR_OK;
}
CK_RV
gkm_mock_unsupported_C_SignUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_SignFinal (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
CK_ULONG_PTR pulSignatureLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_SignRecoverInit (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE hKey)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_SignRecover (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_C_VerifyInit (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE hKey)
{
Session *session;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
/* Starting an operation, cancels any previous one */
if (session->operation != 0)
session->operation = 0;
g_assert (pMechanism);
g_assert (pMechanism->mechanism == CKM_MOCK_PREFIX);
g_assert (hKey == PUBLIC_KEY_PREFIX);
session->operation = OP_CRYPTO;
session->crypto_method = CKA_VERIFY;
session->crypto_mechanism = CKM_MOCK_PREFIX;
session->crypto_key = hKey;
if (pMechanism->pParameter) {
g_assert (pMechanism->ulParameterLen < sizeof (session->sign_prefix));
memcpy (session->sign_prefix, pMechanism->pParameter, pMechanism->ulParameterLen);
session->n_sign_prefix = pMechanism->ulParameterLen;
} else {
g_assert (strlen (SIGNED_PREFIX) + 1 < sizeof (session->sign_prefix));
strcpy ((gchar*)session->sign_prefix, SIGNED_PREFIX);
session->n_sign_prefix = strlen (SIGNED_PREFIX);
}
return CKR_OK;
}
CK_RV
gkm_mock_C_Verify (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
{
Session *session;
CK_ULONG length;
session = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (hSession));
g_assert (session != NULL && "No such session found");
if (!session)
return CKR_SESSION_HANDLE_INVALID;
if (session->operation != OP_CRYPTO) {
g_assert_not_reached (); /* "invalid call to Encrypt" */
return CKR_OPERATION_NOT_INITIALIZED;
}
g_assert (pData);
g_assert (pSignature);
g_assert (session->crypto_method == CKA_VERIFY);
g_assert (session->crypto_mechanism == CKM_MOCK_PREFIX);
g_assert (session->crypto_key == PUBLIC_KEY_PREFIX);
length = session->n_sign_prefix + ulDataLen;
if (ulSignatureLen < length) {
g_assert (FALSE);
return CKR_SIGNATURE_LEN_RANGE;
}
if (memcmp (pSignature, session->sign_prefix, session->n_sign_prefix) == 0 &&
memcmp (pSignature + session->n_sign_prefix, pData, ulDataLen) == 0)
return CKR_OK;
return CKR_SIGNATURE_INVALID;
}
CK_RV
gkm_mock_unsupported_C_VerifyUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_VerifyFinal (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
CK_ULONG pulSignatureLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_VerifyRecoverInit (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE hKey)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_VerifyRecover (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
CK_ULONG pulSignatureLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DigestEncryptUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart,
CK_ULONG_PTR ulEncryptedPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DecryptDigestUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart,
CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart,
CK_ULONG_PTR pulPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_SignEncryptUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart,
CK_ULONG_PTR ulEncryptedPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DecryptVerifyUpdate (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart,
CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart,
CK_ULONG_PTR pulPartLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_GenerateKey (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
CK_OBJECT_HANDLE_PTR phKey)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_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)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_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)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_UnwrapKey (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE pUnwrappingKey, CK_BYTE_PTR pWrappedKey,
CK_ULONG pulWrappedKeyLen, CK_ATTRIBUTE_PTR pTemplate,
CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phKey)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_DeriveKey (CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
CK_OBJECT_HANDLE hBaseKey, CK_ATTRIBUTE_PTR pTemplate,
CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phKey)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_SeedRandom (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, CK_ULONG ulSeedLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV
gkm_mock_unsupported_C_GenerateRandom (CK_SESSION_HANDLE hSession, CK_BYTE_PTR pRandomData,
CK_ULONG ulRandomLen)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
static CK_FUNCTION_LIST functionList = {
{ 2, 11 }, /* version */
gkm_mock_C_Initialize,
gkm_mock_C_Finalize,
gkm_mock_C_GetInfo,
gkm_mock_C_GetFunctionList,
gkm_mock_C_GetSlotList,
gkm_mock_C_GetSlotInfo,
gkm_mock_C_GetTokenInfo,
gkm_mock_C_GetMechanismList,
gkm_mock_C_GetMechanismInfo,
gkm_mock_C_InitToken,
gkm_mock_C_InitPIN,
gkm_mock_C_SetPIN,
gkm_mock_C_OpenSession,
gkm_mock_C_CloseSession,
gkm_mock_C_CloseAllSessions,
gkm_mock_C_GetSessionInfo,
gkm_mock_unsupported_C_GetOperationState,
gkm_mock_unsupported_C_SetOperationState,
gkm_mock_C_Login,
gkm_mock_C_Logout,
gkm_mock_C_CreateObject,
gkm_mock_unsupported_C_CopyObject,
gkm_mock_C_DestroyObject,
gkm_mock_unsupported_C_GetObjectSize,
gkm_mock_C_GetAttributeValue,
gkm_mock_C_SetAttributeValue,
gkm_mock_C_FindObjectsInit,
gkm_mock_C_FindObjects,
gkm_mock_C_FindObjectsFinal,
gkm_mock_C_EncryptInit,
gkm_mock_C_Encrypt,
gkm_mock_unsupported_C_EncryptUpdate,
gkm_mock_unsupported_C_EncryptFinal,
gkm_mock_C_DecryptInit,
gkm_mock_C_Decrypt,
gkm_mock_unsupported_C_DecryptUpdate,
gkm_mock_unsupported_C_DecryptFinal,
gkm_mock_unsupported_C_DigestInit,
gkm_mock_unsupported_C_Digest,
gkm_mock_unsupported_C_DigestUpdate,
gkm_mock_unsupported_C_DigestKey,
gkm_mock_unsupported_C_DigestFinal,
gkm_mock_C_SignInit,
gkm_mock_C_Sign,
gkm_mock_unsupported_C_SignUpdate,
gkm_mock_unsupported_C_SignFinal,
gkm_mock_unsupported_C_SignRecoverInit,
gkm_mock_unsupported_C_SignRecover,
gkm_mock_C_VerifyInit,
gkm_mock_C_Verify,
gkm_mock_unsupported_C_VerifyUpdate,
gkm_mock_unsupported_C_VerifyFinal,
gkm_mock_unsupported_C_VerifyRecoverInit,
gkm_mock_unsupported_C_VerifyRecover,
gkm_mock_unsupported_C_DigestEncryptUpdate,
gkm_mock_unsupported_C_DecryptDigestUpdate,
gkm_mock_unsupported_C_SignEncryptUpdate,
gkm_mock_unsupported_C_DecryptVerifyUpdate,
gkm_mock_unsupported_C_GenerateKey,
gkm_mock_unsupported_C_GenerateKeyPair,
gkm_mock_unsupported_C_WrapKey,
gkm_mock_unsupported_C_UnwrapKey,
gkm_mock_unsupported_C_DeriveKey,
gkm_mock_unsupported_C_SeedRandom,
gkm_mock_unsupported_C_GenerateRandom,
gkm_mock_C_GetFunctionStatus,
gkm_mock_C_CancelFunction,
gkm_mock_unsupported_C_WaitForSlotEvent
};