summaryrefslogtreecommitdiff
path: root/common/mock.c
diff options
context:
space:
mode:
authorStef Walter <stefw@redhat.com>2016-11-29 13:30:55 +0100
committerStef Walter <stefw@redhat.com>2016-11-29 13:32:23 +0100
commit561ee23f218c7a68a2ef46525502f978e56fc1bb (patch)
tree8deb8569f109a0e9dea11736f56ad5e47f42dc11 /common/mock.c
parenta96f354c3068edb6c8ac80ae6d9a6611651145d7 (diff)
downloadp11-kit-561ee23f218c7a68a2ef46525502f978e56fc1bb.tar.gz
MOVED TO: https://github.com/p11-glue/p11-kitHEADmaster
This repository has moved to GitHub to allow further contributions and more flexibility who can merge changes. More details here: https://lists.freedesktop.org/archives/p11-glue/2016-November/000626.html
Diffstat (limited to 'common/mock.c')
-rw-r--r--common/mock.c3975
1 files changed, 0 insertions, 3975 deletions
diff --git a/common/mock.c b/common/mock.c
deleted file mode 100644
index c3f2503..0000000
--- a/common/mock.c
+++ /dev/null
@@ -1,3975 +0,0 @@
-/*
- * Copyright (c) 2011, Collabora Ltd.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above
- * copyright notice, this list of conditions and the
- * following disclaimer.
- * * Redistributions in binary form must reproduce the
- * above copyright notice, this list of conditions and
- * the following disclaimer in the documentation and/or
- * other materials provided with the distribution.
- * * The names of contributors to this software may not be
- * used to endorse or promote products derived from this
- * software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- *
- * Author: Stef Walter <stefw@collabora.co.uk>
- */
-
-#include "config.h"
-
-#include "debug.h"
-#define CRYPTOKI_EXPORTS
-#include "pkcs11.h"
-#include "message.h"
-
-#include "mock.h"
-
-#include "attrs.h"
-#define P11_DEBUG_FLAG P11_DEBUG_LIB
-#include "debug.h"
-#include "dict.h"
-#include "array.h"
-#include "library.h"
-
-#include <assert.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-/* -------------------------------------------------------------------
- * GLOBALS and SUPPORT STUFF
- */
-
-/* Various mutexes */
-static p11_mutex_t init_mutex;
-
-/* Whether we've been initialized, and on what process id it happened */
-static bool pkcs11_initialized = false;
-static pid_t pkcs11_initialized_pid = 0;
-
-static CK_UTF8CHAR *the_pin = NULL;
-static CK_ULONG n_the_pin = 0;
-
-static bool logged_in = false;
-static CK_USER_TYPE the_user_type = 0;
-
-typedef struct _Session {
- CK_SESSION_HANDLE handle;
- p11_dict *objects;
- CK_SESSION_INFO info;
-
- /* For find operations */
- bool finding;
- p11_array *matches;
-
- bool want_context_login;
-
- /* For encrypt, decrypt operations */
- CK_OBJECT_HANDLE crypto_key;
- CK_ATTRIBUTE_TYPE crypto_method;
- CK_MECHANISM_TYPE crypto_mechanism;
-
- /* For sign, verify, digest, CKM_MOCK_COUNT */
- CK_MECHANISM_TYPE hash_mechanism;
- CK_ATTRIBUTE_TYPE hash_method;
- CK_OBJECT_HANDLE hash_key;
- CK_ULONG hash_count;
-
- /* For 'signing' with CKM_MOCK_PREFIX */
- CK_BYTE sign_prefix[128];
- CK_ULONG n_sign_prefix;
-
- /* The random seed */
- CK_BYTE random_seed[128];
- CK_ULONG random_seed_len;
-} Session;
-
-static unsigned int unique_identifier = 100;
-static p11_dict *the_sessions = NULL;
-static p11_dict *the_objects = NULL;
-
-#define SIGNED_PREFIX "signed-prefix:"
-
-#define handle_to_pointer(handle) \
- ((void *)(size_t)(handle))
-
-#define pointer_to_handle(pointer) \
- ((CK_ULONG)(size_t)(pointer))
-
-static void
-free_session (void *data)
-{
- Session *sess = (Session *)data;
- if (sess) {
- p11_dict_free (sess->objects);
- p11_array_free (sess->matches);
- }
- free (sess);
-}
-
-static CK_RV
-lookup_object (Session *sess,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE **attrs,
- p11_dict **table)
-{
- CK_BBOOL priv;
-
- *attrs = p11_dict_get (the_objects, handle_to_pointer (object));
- if (*attrs) {
- if (table)
- *table = the_objects;
- } else {
- *attrs = p11_dict_get (sess->objects, handle_to_pointer (object));
- if (*attrs) {
- if (table)
- *table = sess->objects;
- }
- }
-
- if (!*attrs)
- return CKR_OBJECT_HANDLE_INVALID;
- else if (!logged_in && p11_attrs_find_bool (*attrs, CKA_PRIVATE, &priv) && priv)
- return CKR_USER_NOT_LOGGED_IN;
-
- return CKR_OK;
-}
-
-void
-mock_module_add_object (CK_SLOT_ID slot_id,
- const CK_ATTRIBUTE *attrs)
-{
- CK_ATTRIBUTE *copy;
-
- return_if_fail (slot_id == MOCK_SLOT_ONE_ID);
- return_if_fail (attrs != NULL);
-
- copy = p11_attrs_dup (attrs);
- return_if_fail (copy != NULL);
-
- mock_module_take_object (slot_id, copy);
-}
-
-void
-mock_module_take_object (CK_SLOT_ID slot_id,
- CK_ATTRIBUTE *attrs)
-{
- CK_OBJECT_HANDLE object;
-
- return_if_fail (slot_id == MOCK_SLOT_ONE_ID);
- return_if_fail (attrs != NULL);
-
- object = ++unique_identifier;
- if (!p11_dict_set (the_objects, handle_to_pointer (object), attrs))
- return_if_reached ();
-}
-
-static void
-module_reset_objects (CK_SLOT_ID slot_id)
-{
- return_if_fail (slot_id == MOCK_SLOT_ONE_ID);
-
- if (!the_objects) {
- the_objects = p11_dict_new (p11_dict_direct_hash,
- p11_dict_direct_equal,
- NULL, p11_attrs_free);
- return_if_fail (the_objects != NULL);
- }
-
- p11_dict_clear (the_objects);
-
- /* Our token object */
- {
- CK_OBJECT_CLASS klass = CKO_DATA;
- char *label = "TEST LABEL";
- CK_ATTRIBUTE attrs[] = {
- { CKA_CLASS, &klass, sizeof (klass) },
- { CKA_LABEL, label, strlen (label) },
- { CKA_INVALID, NULL, 0 },
- };
- p11_dict_set (the_objects, handle_to_pointer (MOCK_DATA_OBJECT), p11_attrs_dup (attrs));
- }
-
- /* Private capitalize key */
- {
- CK_OBJECT_CLASS klass = CKO_PRIVATE_KEY;
- char *label = "Private Capitalize Key";
- char *value = "value";
- CK_MECHANISM_TYPE type = CKM_MOCK_CAPITALIZE;
- CK_BBOOL btrue = CK_TRUE;
- CK_ATTRIBUTE attrs[] = {
- { CKA_CLASS, &klass, sizeof (klass) },
- { CKA_LABEL, label, strlen (label) },
- { CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
- { CKA_DECRYPT, &btrue, sizeof (btrue) },
- { CKA_PRIVATE, &btrue, sizeof (btrue) },
- { CKA_WRAP, &btrue, sizeof (btrue) },
- { CKA_UNWRAP, &btrue, sizeof (btrue) },
- { CKA_DERIVE, &btrue, sizeof (btrue) },
- { CKA_VALUE, value, strlen (value) },
- { CKA_INVALID, NULL, 0 },
- };
- p11_dict_set (the_objects, handle_to_pointer (MOCK_PRIVATE_KEY_CAPITALIZE), p11_attrs_dup (attrs));
-
- }
-
- {
- CK_OBJECT_CLASS klass = CKO_PUBLIC_KEY;
- char *label = "Public Capitalize Key";
- char *value = "value";
- CK_MECHANISM_TYPE type = CKM_MOCK_CAPITALIZE;
- CK_BBOOL btrue = CK_TRUE;
- CK_BBOOL bfalse = CK_FALSE;
- CK_ATTRIBUTE attrs[] = {
- { CKA_CLASS, &klass, sizeof (klass) },
- { CKA_LABEL, label, strlen (label) },
- { CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
- { CKA_ENCRYPT, &btrue, sizeof (btrue) },
- { CKA_PRIVATE, &bfalse, sizeof (bfalse) },
- { CKA_VALUE, value, strlen (value) },
- { CKA_INVALID, NULL, 0 },
- };
- p11_dict_set (the_objects, handle_to_pointer (MOCK_PUBLIC_KEY_CAPITALIZE), p11_attrs_dup (attrs));
-
- }
-
- {
- CK_OBJECT_CLASS klass = CKO_PRIVATE_KEY;
- char *label = "Private prefix key";
- char *value = "value";
- CK_MECHANISM_TYPE type = CKM_MOCK_PREFIX;
- CK_BBOOL btrue = CK_TRUE;
- CK_ATTRIBUTE attrs[] = {
- { CKA_CLASS, &klass, sizeof (klass) },
- { CKA_LABEL, label, strlen (label) },
- { CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
- { CKA_SIGN, &btrue, sizeof (btrue) },
- { CKA_PRIVATE, &btrue, sizeof (btrue) },
- { CKA_ALWAYS_AUTHENTICATE, &btrue, sizeof (btrue) },
- { CKA_VALUE, value, strlen (value) },
- { CKA_INVALID, NULL, 0 },
- };
- p11_dict_set (the_objects, handle_to_pointer (MOCK_PRIVATE_KEY_PREFIX), p11_attrs_dup (attrs));
-
- }
-
- {
- CK_OBJECT_CLASS klass = CKO_PUBLIC_KEY;
- char *label = "Public prefix key";
- char *value = "value";
- CK_MECHANISM_TYPE type = CKM_MOCK_PREFIX;
- CK_BBOOL btrue = CK_TRUE;
- CK_BBOOL bfalse = CK_FALSE;
- CK_ATTRIBUTE attrs[] = {
- { CKA_CLASS, &klass, sizeof (klass) },
- { CKA_LABEL, label, strlen (label) },
- { CKA_ALLOWED_MECHANISMS, &type, sizeof (type) },
- { CKA_VERIFY, &btrue, sizeof (btrue) },
- { CKA_PRIVATE, &bfalse, sizeof (bfalse) },
- { CKA_ALWAYS_AUTHENTICATE, &btrue, sizeof (btrue) },
- { CKA_VALUE, value, strlen (value) },
- { CKA_INVALID, NULL, 0 },
- };
- p11_dict_set (the_objects, handle_to_pointer (MOCK_PUBLIC_KEY_PREFIX), p11_attrs_dup (attrs));
-
- }
-}
-
-static void
-module_finalize (void)
-{
- p11_mutex_lock (&init_mutex);
-
- /* This should stop all other calls in */
- pkcs11_initialized = false;
- pkcs11_initialized_pid = 0;
-
- if (the_objects)
- p11_dict_free (the_objects);
- the_objects = NULL;
-
- if (the_sessions)
- p11_dict_free (the_sessions);
- the_sessions = NULL;
- logged_in = false;
- the_user_type = 0;
-
- free (the_pin);
- the_pin = NULL;
- n_the_pin = 0;
-
- p11_mutex_unlock (&init_mutex);
-}
-
-bool
-mock_module_initialized (void)
-{
- return pkcs11_initialized;
-}
-void
-mock_module_reset (void)
-{
- module_finalize ();
- module_reset_objects (MOCK_SLOT_ONE_ID);
-
-}
-
-void
-mock_module_enumerate_objects (CK_SESSION_HANDLE handle,
- mock_enumerator func,
- void *user_data)
-{
- p11_dictiter iter;
- void *key;
- void *value;
- Session *sess;
-
- assert (the_objects != NULL);
- assert (func != NULL);
-
- /* Token objects */
- p11_dict_iterate (the_objects, &iter);
- while (p11_dict_next (&iter, &key, &value)) {
- if (!(func) (pointer_to_handle (key), value, user_data))
- return;
- }
-
- /* session objects */
- if (handle) {
- sess = p11_dict_get (the_sessions, handle_to_pointer (handle));
- if (sess) {
- p11_dict_iterate (sess->objects, &iter);
- while (p11_dict_next (&iter, &key, &value)) {
- if (!(func) (pointer_to_handle (key), value, user_data))
- return;
- }
- }
- }
-}
-
-/* -------------------------------------------------------------------
- * INITIALIZATION and 'GLOBAL' CALLS
- */
-
-CK_RV
-mock_C_Initialize (CK_VOID_PTR init_args)
-{
- CK_C_INITIALIZE_ARGS_PTR args = NULL;
- CK_RV ret = CKR_OK;
- pid_t pid;
-
- p11_mutex_lock (&init_mutex);
-
- if (init_args != NULL) {
- int supplied_ok;
-
- /* pReserved must be NULL */
- args = init_args;
-
- /* ALL supplied function pointers need to have the value either NULL or non-NULL. */
- supplied_ok = (args->CreateMutex == NULL && args->DestroyMutex == NULL &&
- args->LockMutex == NULL && args->UnlockMutex == NULL) ||
- (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
- args->LockMutex != NULL && args->UnlockMutex != NULL);
- if (!supplied_ok) {
- p11_debug_precond ("invalid set of mutex calls supplied\n");
- ret = CKR_ARGUMENTS_BAD;
- goto done;
- }
-
- /*
- * When the CKF_OS_LOCKING_OK flag isn't set return an error.
- * We must be able to use our pthread functionality.
- */
- if (!(args->flags & CKF_OS_LOCKING_OK)) {
- p11_debug_precond ("can't do without os locking\n");
- ret = CKR_CANT_LOCK;
- goto done;
- }
- }
-
- pid = getpid ();
- if (pkcs11_initialized) {
-
- /* This process has called C_Initialize already */
- if (pid == pkcs11_initialized_pid) {
- p11_debug_precond ("p11-kit: C_Initialize called twice for same process\n");
- ret = CKR_CRYPTOKI_ALREADY_INITIALIZED;
- goto done;
- }
- }
-
- /* We store CK_ULONG as pointers here, so verify that they fit */
- assert (sizeof (CK_ULONG) <= sizeof (void *));
-
- free (the_pin);
- the_pin = (CK_UTF8CHAR_PTR)strdup ("booo");
- n_the_pin = 4;
-
- if (the_sessions)
- p11_dict_free (the_sessions);
- the_sessions = p11_dict_new (p11_dict_direct_hash,
- p11_dict_direct_equal,
- NULL, free_session);
-
- module_reset_objects (MOCK_SLOT_ONE_ID);
-
-done:
- /* Mark us as officially initialized */
- if (ret == CKR_OK) {
- pkcs11_initialized = true;
- pkcs11_initialized_pid = pid;
- } else if (ret != CKR_CRYPTOKI_ALREADY_INITIALIZED) {
- pkcs11_initialized = false;
- pkcs11_initialized_pid = 0;
- }
-
- p11_mutex_unlock (&init_mutex);
-
- return ret;
-}
-
-CK_RV
-mock_X_Initialize (CK_X_FUNCTION_LIST *self,
- CK_VOID_PTR init_args)
-{
- return mock_C_Initialize (init_args);
-}
-
-CK_RV
-mock_C_Initialize__fails (CK_VOID_PTR init_args)
-{
- return CKR_FUNCTION_FAILED;
-}
-
-CK_RV
-mock_X_Initialize__fails (CK_X_FUNCTION_LIST *self,
- CK_VOID_PTR init_args)
-{
- return mock_C_Initialize__fails (init_args);
-}
-
-CK_RV
-mock_C_Finalize (CK_VOID_PTR reserved)
-{
- return_val_if_fail (pkcs11_initialized, CKR_CRYPTOKI_NOT_INITIALIZED);
- return_val_if_fail (reserved == NULL, CKR_ARGUMENTS_BAD);
-
- module_finalize ();
- return CKR_OK;
-}
-
-CK_RV
-mock_X_Finalize (CK_X_FUNCTION_LIST *self,
- CK_VOID_PTR reserved)
-{
- return mock_C_Finalize (reserved);
-}
-
-CK_RV
-mock_C_GetInfo (CK_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- memcpy (info, &MOCK_INFO, sizeof (*info));
- return CKR_OK;
-}
-
-CK_RV
-mock_X_GetInfo (CK_X_FUNCTION_LIST *self,
- CK_INFO_PTR info)
-{
- return mock_C_GetInfo (info);
-}
-
-CK_RV
-mock_C_GetFunctionList_not_supported (CK_FUNCTION_LIST_PTR_PTR list)
-{
- /* This would be a strange call to receive, should be overridden */
- return_val_if_reached (CKR_FUNCTION_NOT_SUPPORTED);
-}
-
-CK_RV
-mock_C_GetSlotList (CK_BBOOL token_present,
- CK_SLOT_ID_PTR slot_list,
- CK_ULONG_PTR count)
-{
- CK_ULONG num;
-
- return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
- num = token_present ? 1 : 2;
-
- /* Application only wants to know the number of slots. */
- if (slot_list == NULL) {
- *count = num;
- return CKR_OK;
- }
-
- if (*count < num)
- return_val_if_reached (CKR_BUFFER_TOO_SMALL);
-
- *count = num;
- slot_list[0] = MOCK_SLOT_ONE_ID;
- if (!token_present)
- slot_list[1] = MOCK_SLOT_TWO_ID;
-
- return CKR_OK;
-
-}
-
-CK_RV
-mock_C_GetSlotList__no_tokens (CK_BBOOL token_present,
- CK_SLOT_ID_PTR slot_list,
- CK_ULONG_PTR count)
-{
- return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
- /* No tokens */
- *count = 0;
- return CKR_OK;
-}
-
-CK_RV
-mock_X_GetSlotList__no_tokens (CK_X_FUNCTION_LIST *self,
- CK_BBOOL token_present,
- CK_SLOT_ID_PTR slot_list,
- CK_ULONG_PTR count)
-{
- return mock_C_GetSlotList__no_tokens (token_present,
- slot_list,
- count);
-;
-}
-
-/* Update mock-module.h URIs when updating this */
-
-static const CK_SLOT_INFO MOCK_INFO_ONE = {
- "TEST SLOT ",
- "TEST MANUFACTURER ",
- CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE,
- { 55, 155 },
- { 65, 165 },
-};
-
-/* Update mock-module.h URIs when updating this */
-
-static const CK_SLOT_INFO MOCK_INFO_TWO = {
- "TEST SLOT ",
- "TEST MANUFACTURER ",
- CKF_REMOVABLE_DEVICE,
- { 55, 155 },
- { 65, 165 },
-};
-
-CK_RV
-mock_C_GetSlotInfo (CK_SLOT_ID slot_id,
- CK_SLOT_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- if (slot_id == MOCK_SLOT_ONE_ID) {
- memcpy (info, &MOCK_INFO_ONE, sizeof (*info));
- return CKR_OK;
- } else if (slot_id == MOCK_SLOT_TWO_ID) {
- memcpy (info, &MOCK_INFO_TWO, sizeof (*info));
- return CKR_OK;
- } else {
- return CKR_SLOT_ID_INVALID;
- }
-}
-
-CK_RV
-mock_C_GetSlotList__fail_first (CK_BBOOL token_present,
- CK_SLOT_ID_PTR slot_list,
- CK_ULONG_PTR count)
-{
- return CKR_VENDOR_DEFINED;
-}
-
-CK_RV
-mock_C_GetSlotList__fail_late (CK_BBOOL token_present,
- CK_SLOT_ID_PTR slot_list,
- CK_ULONG_PTR count)
-{
- if (!slot_list)
- return mock_C_GetSlotList (token_present, slot_list, count);
- return CKR_VENDOR_DEFINED;
-}
-
-CK_RV
-mock_C_GetSlotInfo__invalid_slotid (CK_SLOT_ID id,
- CK_SLOT_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_X_GetSlotInfo__invalid_slotid (CK_X_FUNCTION_LIST *self,
- CK_SLOT_ID id,
- CK_SLOT_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-/* Update gck-mock.h URIs when updating this */
-
-static const CK_TOKEN_INFO MOCK_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
-mock_C_GetTokenInfo (CK_SLOT_ID slot_id,
- CK_TOKEN_INFO_PTR info)
-{
- return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
-
- if (slot_id == MOCK_SLOT_ONE_ID) {
- memcpy (info, &MOCK_TOKEN_ONE, sizeof (*info));
- return CKR_OK;
- } else if (slot_id == MOCK_SLOT_TWO_ID) {
- return CKR_TOKEN_NOT_PRESENT;
- } else {
- return CKR_SLOT_ID_INVALID;
- }
-}
-
-CK_RV
-mock_C_GetTokenInfo__invalid_slotid (CK_SLOT_ID slot_id,
- CK_TOKEN_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_X_GetTokenInfo__invalid_slotid (CK_X_FUNCTION_LIST *self,
- CK_SLOT_ID slot_id,
- CK_TOKEN_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-/*
- * TWO mechanisms:
- * CKM_MOCK_CAPITALIZE
- * CKM_MOCK_PREFIX
- */
-
-CK_RV
-mock_C_GetMechanismList (CK_SLOT_ID slot_id,
- CK_MECHANISM_TYPE_PTR mechanism_list,
- CK_ULONG_PTR count)
-{
- return_val_if_fail (count != NULL, CKR_ARGUMENTS_BAD);
-
- if (slot_id == MOCK_SLOT_TWO_ID)
- return CKR_TOKEN_NOT_PRESENT;
- else if (slot_id != MOCK_SLOT_ONE_ID)
- return CKR_SLOT_ID_INVALID;
-
- /* Application only wants to know the number of slots. */
- if (mechanism_list == NULL) {
- *count = 2;
- return CKR_OK;
- }
-
- if (*count < 2)
- return_val_if_reached (CKR_BUFFER_TOO_SMALL);
-
- mechanism_list[0] = CKM_MOCK_CAPITALIZE;
- mechanism_list[1] = CKM_MOCK_PREFIX;
- *count = 2;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_GetTokenInfo__not_initialized (CK_SLOT_ID slot_id,
- CK_TOKEN_INFO_PTR info)
-{
- CK_RV rv;
-
- rv = mock_C_GetTokenInfo (slot_id, info);
- if (rv == CKR_OK)
- info->flags &= ~ CKF_TOKEN_INITIALIZED;
-
- return rv;
-}
-
-/*
- * TWO mechanisms:
- * CKM_MOCK_CAPITALIZE
- * CKM_MOCK_PREFIX
- */
-
-CK_RV
-mock_C_GetMechanismList__invalid_slotid (CK_SLOT_ID id,
- CK_MECHANISM_TYPE_PTR mechanism_list,
- CK_ULONG_PTR count)
-{
- return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_X_GetMechanismList__invalid_slotid (CK_X_FUNCTION_LIST *self,
- CK_SLOT_ID id,
- CK_MECHANISM_TYPE_PTR mechanism_list,
- CK_ULONG_PTR count)
-{
- return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-static const CK_MECHANISM_INFO MOCK_MECH_CAPITALIZE = {
- 512, 4096, CKF_ENCRYPT | CKF_DECRYPT
-};
-
-static const CK_MECHANISM_INFO MOCK_MECH_PREFIX = {
- 2048, 2048, CKF_SIGN | CKF_VERIFY
-};
-
-CK_RV
-mock_C_GetMechanismInfo (CK_SLOT_ID slot_id,
- CK_MECHANISM_TYPE type,
- CK_MECHANISM_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- if (slot_id == MOCK_SLOT_TWO_ID)
- return CKR_TOKEN_NOT_PRESENT;
- else if (slot_id != MOCK_SLOT_ONE_ID)
- return CKR_SLOT_ID_INVALID;
-
- if (type == CKM_MOCK_CAPITALIZE) {
- memcpy (info, &MOCK_MECH_CAPITALIZE, sizeof (*info));
- return CKR_OK;
- } else if (type == CKM_MOCK_PREFIX) {
- memcpy (info, &MOCK_MECH_PREFIX, sizeof (*info));
- return CKR_OK;
- } else {
- return CKR_MECHANISM_INVALID;
- }
-}
-
-CK_RV
-mock_C_GetMechanismInfo__invalid_slotid (CK_SLOT_ID slot_id,
- CK_MECHANISM_TYPE type,
- CK_MECHANISM_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_X_GetMechanismInfo__invalid_slotid (CK_X_FUNCTION_LIST *self,
- CK_SLOT_ID slot_id,
- CK_MECHANISM_TYPE type,
- CK_MECHANISM_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_InitToken__specific_args (CK_SLOT_ID slot_id,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len,
- CK_UTF8CHAR_PTR label)
-{
- return_val_if_fail (pin != NULL, CKR_ARGUMENTS_BAD);
- return_val_if_fail (label != NULL, CKR_ARGUMENTS_BAD);
-
- if (slot_id == MOCK_SLOT_TWO_ID)
- return CKR_TOKEN_NOT_PRESENT;
- else if (slot_id != MOCK_SLOT_ONE_ID)
- return CKR_SLOT_ID_INVALID;
-
- if (strlen ("TEST PIN") != pin_len ||
- strncmp ((char *)pin, "TEST PIN", pin_len) != 0)
- return CKR_PIN_INVALID;
- if (strcmp ((char *)label, "TEST LABEL") != 0)
- return CKR_ARGUMENTS_BAD;
-
- free (the_pin);
- the_pin = memdup (pin, pin_len);
- return_val_if_fail (the_pin != NULL, CKR_HOST_MEMORY);
- n_the_pin = pin_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_InitToken__invalid_slotid (CK_SLOT_ID slot_id,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len,
- CK_UTF8CHAR_PTR label)
-{
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_X_InitToken__invalid_slotid (CK_X_FUNCTION_LIST *self,
- CK_SLOT_ID slot_id,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len,
- CK_UTF8CHAR_PTR label)
-{
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_WaitForSlotEvent (CK_FLAGS flags,
- CK_SLOT_ID_PTR slot,
- CK_VOID_PTR reserved)
-{
- return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
-
- if (flags & CKF_DONT_BLOCK)
- return CKR_NO_EVENT;
-
- *slot = MOCK_SLOT_TWO_ID;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_WaitForSlotEvent__no_event (CK_FLAGS flags,
- CK_SLOT_ID_PTR slot,
- CK_VOID_PTR reserved)
-{
- return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
-
- return CKR_NO_EVENT;
-}
-
-CK_RV
-mock_X_WaitForSlotEvent__no_event (CK_X_FUNCTION_LIST *self,
- CK_FLAGS flags,
- CK_SLOT_ID_PTR slot,
- CK_VOID_PTR reserved)
-{
- return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
-
- return CKR_NO_EVENT;
-}
-
-CK_RV
-mock_C_OpenSession (CK_SLOT_ID slot_id,
- CK_FLAGS flags,
- CK_VOID_PTR user_data,
- CK_NOTIFY callback,
- CK_SESSION_HANDLE_PTR session)
-{
- Session *sess;
-
- return_val_if_fail (session, CKR_ARGUMENTS_BAD);
-
- if (slot_id == MOCK_SLOT_TWO_ID)
- return CKR_TOKEN_NOT_PRESENT;
- else if (slot_id != MOCK_SLOT_ONE_ID)
- return CKR_SLOT_ID_INVALID;
- if ((flags & CKF_SERIAL_SESSION) != CKF_SERIAL_SESSION)
- return CKR_SESSION_PARALLEL_NOT_SUPPORTED;
-
- sess = calloc (1, sizeof (Session));
- sess->handle = ++unique_identifier;
- sess->info.flags = flags;
- sess->info.slotID = slot_id;
- sess->info.state = 0;
- sess->info.ulDeviceError = 1414;
- sess->objects = p11_dict_new (p11_dict_direct_hash, p11_dict_direct_equal,
- NULL, p11_attrs_free);
- *session = sess->handle;
-
- memcpy (sess->random_seed, "random", 6);
- sess->random_seed_len = 6;
-
- p11_dict_set (the_sessions, handle_to_pointer (sess->handle), sess);
- return CKR_OK;
-}
-
-CK_RV
-mock_C_OpenSession__invalid_slotid (CK_SLOT_ID slot_id,
- CK_FLAGS flags,
- CK_VOID_PTR user_data,
- CK_NOTIFY callback,
- CK_SESSION_HANDLE_PTR session)
-{
- return_val_if_fail (session, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_X_OpenSession__invalid_slotid (CK_X_FUNCTION_LIST *self,
- CK_SLOT_ID slot_id,
- CK_FLAGS flags,
- CK_VOID_PTR user_data,
- CK_NOTIFY callback,
- CK_SESSION_HANDLE_PTR session)
-{
- return_val_if_fail (session, CKR_ARGUMENTS_BAD);
-
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_OpenSession__fails (CK_SLOT_ID slot_id,
- CK_FLAGS flags,
- CK_VOID_PTR user_data,
- CK_NOTIFY callback,
- CK_SESSION_HANDLE_PTR session)
-{
- return_val_if_fail (session, CKR_ARGUMENTS_BAD);
-
- return CKR_DEVICE_ERROR;
-}
-
-CK_RV
-mock_C_CloseSession (CK_SESSION_HANDLE session)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- p11_dict_remove (the_sessions, handle_to_pointer (session));
- return CKR_OK;
-}
-
-CK_RV
-mock_C_CloseSession__invalid_handle (CK_SESSION_HANDLE session)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_CloseSession__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_CloseAllSessions (CK_SLOT_ID slot_id)
-{
- if (slot_id == MOCK_SLOT_TWO_ID)
- return CKR_TOKEN_NOT_PRESENT;
- else if (slot_id != MOCK_SLOT_ONE_ID)
- return CKR_SLOT_ID_INVALID;
-
- p11_dict_clear (the_sessions);
- return CKR_OK;
-}
-
-CK_RV
-mock_C_CloseAllSessions__invalid_slotid (CK_SLOT_ID slot_id)
-{
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_X_CloseAllSessions__invalid_slotid (CK_X_FUNCTION_LIST *self,
- CK_SLOT_ID slot_id)
-{
- return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_GetFunctionStatus (CK_SESSION_HANDLE session)
-{
- if (!p11_dict_get (the_sessions, handle_to_pointer (session)))
- return CKR_SESSION_HANDLE_INVALID;
- return CKR_FUNCTION_NOT_PARALLEL;
-}
-
-CK_RV
-mock_C_GetFunctionStatus__not_parallel (CK_SESSION_HANDLE session)
-{
- return CKR_FUNCTION_NOT_PARALLEL;
-}
-
-CK_RV
-mock_C_CancelFunction (CK_SESSION_HANDLE session)
-{
- if (!p11_dict_get (the_sessions, handle_to_pointer (session)))
- return CKR_SESSION_HANDLE_INVALID;
- return CKR_FUNCTION_NOT_PARALLEL;
-}
-
-CK_RV
-mock_C_CancelFunction__not_parallel (CK_SESSION_HANDLE session)
-{
- return CKR_FUNCTION_NOT_PARALLEL;
-}
-
-CK_RV
-mock_C_GetSessionInfo (CK_SESSION_HANDLE session,
- CK_SESSION_INFO_PTR info)
-{
- Session *sess;
-
- return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (logged_in) {
- if (sess->info.flags & CKF_RW_SESSION)
- sess->info.state = CKS_RW_USER_FUNCTIONS;
- else
- sess->info.state = CKS_RO_USER_FUNCTIONS;
- } else {
- if (sess->info.flags & CKF_RW_SESSION)
- sess->info.state = CKS_RW_PUBLIC_SESSION;
- else
- sess->info.state = CKS_RO_PUBLIC_SESSION;
- }
-
- memcpy (info, &sess->info, sizeof (*info));
- return CKR_OK;
-}
-
-CK_RV
-mock_C_GetSessionInfo__invalid_handle (CK_SESSION_HANDLE session,
- CK_SESSION_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_GetSessionInfo__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_SESSION_INFO_PTR info)
-{
- return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_InitPIN__specific_args (CK_SESSION_HANDLE session,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (strlen ("TEST PIN") != pin_len ||
- strncmp ((char *)pin, "TEST PIN", pin_len) != 0)
- return CKR_PIN_INVALID;
-
- free (the_pin);
- the_pin = memdup (pin, pin_len);
- return_val_if_fail (the_pin != NULL, CKR_HOST_MEMORY);
- n_the_pin = pin_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_InitPIN__invalid_handle (CK_SESSION_HANDLE session,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_InitPIN__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SetPIN__specific_args (CK_SESSION_HANDLE session,
- CK_UTF8CHAR_PTR old_pin,
- CK_ULONG old_pin_len,
- CK_UTF8CHAR_PTR new_pin,
- CK_ULONG new_pin_len)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (old_pin_len != n_the_pin)
- return CKR_PIN_INCORRECT;
- if (memcmp (old_pin, the_pin, n_the_pin) != 0)
- return CKR_PIN_INCORRECT;
-
- if (strlen ("TEST PIN") != new_pin_len ||
- strncmp ((char *)new_pin, "TEST PIN", new_pin_len) != 0)
- return CKR_PIN_INVALID;
-
- free (the_pin);
- the_pin = memdup (new_pin, new_pin_len);
- return_val_if_fail (the_pin != NULL, CKR_HOST_MEMORY);
- n_the_pin = new_pin_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_SetPIN__invalid_handle (CK_SESSION_HANDLE session,
- CK_UTF8CHAR_PTR old_pin,
- CK_ULONG old_pin_len,
- CK_UTF8CHAR_PTR new_pin,
- CK_ULONG new_pin_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SetPIN__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_UTF8CHAR_PTR old_pin,
- CK_ULONG old_pin_len,
- CK_UTF8CHAR_PTR new_pin,
- CK_ULONG new_pin_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GetOperationState (CK_SESSION_HANDLE session,
- CK_BYTE_PTR operation_state,
- CK_ULONG_PTR operation_state_len)
-{
- Session *sess;
-
- return_val_if_fail (operation_state_len, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!operation_state) {
- *operation_state_len = sizeof (sess);
- return CKR_OK;
- }
-
- if (*operation_state_len < sizeof (sess))
- return CKR_BUFFER_TOO_SMALL;
-
- memcpy (operation_state, &sess, sizeof (sess));
- *operation_state_len = sizeof (sess);
- return CKR_OK;
-}
-
-CK_RV
-mock_C_GetOperationState__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR operation_state,
- CK_ULONG_PTR operation_state_len)
-{
- return CKR_FUNCTION_NOT_SUPPORTED;
-}
-
-CK_RV
-mock_X_GetOperationState__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR operation_state,
- CK_ULONG_PTR operation_state_len)
-{
- return CKR_FUNCTION_NOT_SUPPORTED;
-}
-
-CK_RV
-mock_C_SetOperationState (CK_SESSION_HANDLE session,
- CK_BYTE_PTR operation_state,
- CK_ULONG operation_state_len,
- CK_OBJECT_HANDLE encryption_key,
- CK_OBJECT_HANDLE authentication_key)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!operation_state || operation_state_len != sizeof (sess))
- return CKR_ARGUMENTS_BAD;
-
- /* Yes, just arbitrary numbers, to make sure they got through */
- if (encryption_key != 355 || authentication_key != 455)
- return CKR_KEY_HANDLE_INVALID;
- if (memcmp (operation_state, &sess, sizeof (sess)) != 0)
- return CKR_SAVED_STATE_INVALID;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_SetOperationState__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR operation_state,
- CK_ULONG operation_state_len,
- CK_OBJECT_HANDLE encryption_key,
- CK_OBJECT_HANDLE authentication_key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SetOperationState__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR operation_state,
- CK_ULONG operation_state_len,
- CK_OBJECT_HANDLE encryption_key,
- CK_OBJECT_HANDLE authentication_key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Login (CK_SESSION_HANDLE session,
- CK_USER_TYPE user_type,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len)
-{
- Session *sess;
-
- return_val_if_fail (user_type == CKU_SO ||
- user_type == CKU_USER ||
- user_type == CKU_CONTEXT_SPECIFIC,
- CKR_USER_TYPE_INVALID);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (logged_in && user_type != CKU_CONTEXT_SPECIFIC)
- return CKR_USER_ALREADY_LOGGED_IN;
-
- if (!pin)
- return CKR_PIN_INCORRECT;
-
- if (pin_len != n_the_pin)
- return CKR_PIN_INCORRECT;
- if (strncmp ((char *)pin, (char *)the_pin, pin_len) != 0)
- return CKR_PIN_INCORRECT;
-
- if (user_type == CKU_CONTEXT_SPECIFIC) {
- return_val_if_fail (sess->want_context_login, CKR_OPERATION_NOT_INITIALIZED);
- sess->want_context_login = false;
- } else {
- logged_in = true;
- the_user_type = user_type;
- }
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_Login__invalid_handle (CK_SESSION_HANDLE session,
- CK_USER_TYPE user_type,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_Login__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_USER_TYPE user_type,
- CK_UTF8CHAR_PTR pin,
- CK_ULONG pin_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Logout (CK_SESSION_HANDLE session)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!logged_in)
- return CKR_USER_NOT_LOGGED_IN;
-
- logged_in = false;
- the_user_type = 0;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_Logout__invalid_handle (CK_SESSION_HANDLE session)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_Logout__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_CreateObject (CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR object)
-{
- CK_ATTRIBUTE *attrs;
- Session *sess;
- CK_BBOOL token, priv;
-
- return_val_if_fail (object, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- attrs = p11_attrs_buildn (NULL, template, count);
-
- if (p11_attrs_find_bool (attrs, CKA_PRIVATE, &priv) && priv) {
- if (!logged_in) {
- p11_attrs_free (attrs);
- return CKR_USER_NOT_LOGGED_IN;
- }
- }
-
- *object = ++unique_identifier;
- if (p11_attrs_find_bool (attrs, CKA_TOKEN, &token) && token)
- p11_dict_set (the_objects, handle_to_pointer (*object), attrs);
- else
- p11_dict_set (sess->objects, handle_to_pointer (*object), attrs);
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_CreateObject__invalid_handle (CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR new_object)
-{
- return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_CreateObject__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR new_object)
-{
- return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_CopyObject (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR new_object)
-{
- CK_ATTRIBUTE *attrs;
- Session *sess;
- CK_BBOOL token, priv;
- CK_RV rv;
-
- return_val_if_fail (object, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, object, &attrs, NULL);
- if (rv != CKR_OK)
- return rv;
-
- if (p11_attrs_find_bool (attrs, CKA_PRIVATE, &priv) && priv) {
- if (!logged_in)
- return CKR_USER_NOT_LOGGED_IN;
- }
-
- attrs = p11_attrs_buildn (p11_attrs_dup (attrs), template, count);
-
- *new_object = ++unique_identifier;
- if (p11_attrs_find_bool (attrs, CKA_TOKEN, &token) && token)
- p11_dict_set (the_objects, handle_to_pointer (*new_object), attrs);
- else
- p11_dict_set (sess->objects, handle_to_pointer (*new_object), attrs);
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_CopyObject__invalid_handle (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR new_object)
-{
- return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-
-CK_RV
-mock_X_CopyObject__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR new_object)
-{
- return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DestroyObject (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object)
-{
- CK_ATTRIBUTE *attrs;
- Session *sess;
- p11_dict *table;
- CK_RV rv;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, object, &attrs, &table);
- if (rv != CKR_OK)
- return rv;
-
- p11_dict_remove (table, handle_to_pointer (object));
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DestroyObject__invalid_handle (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DestroyObject__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GetObjectSize (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ULONG_PTR size)
-{
- CK_ATTRIBUTE *attrs;
- Session *sess;
- CK_RV rv;
- CK_ULONG i;
-
- return_val_if_fail (size != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, object, &attrs, NULL);
- if (rv != CKR_OK)
- return rv;
-
- *size = 0;
- for (i = 0; !p11_attrs_terminator (attrs + i); i++) {
- if (attrs[i].ulValueLen != (CK_ULONG)-1)
- *size += attrs[i].ulValueLen;
- }
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_GetObjectSize__invalid_handle (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ULONG_PTR size)
-{
- return_val_if_fail (size, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_GetObjectSize__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ULONG_PTR size)
-{
- return_val_if_fail (size, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GetAttributeValue (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- CK_ATTRIBUTE *result;
- CK_RV ret = CKR_OK;
- CK_ATTRIBUTE *attrs;
- CK_ATTRIBUTE *attr;
- Session *sess;
- CK_ULONG i;
- CK_RV rv;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, object, &attrs, NULL);
- if (rv != CKR_OK)
- return rv;
-
- for (i = 0; i < count; ++i) {
- result = template + i;
- attr = p11_attrs_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);
- result->ulValueLen = attr->ulValueLen;
- continue;
- }
-
- result->ulValueLen = (CK_ULONG)-1;
- ret = CKR_BUFFER_TOO_SMALL;
- }
-
- return ret;
-}
-
-CK_RV
-mock_C_GetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_GetAttributeValue__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GetAttributeValue__fail_first (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_FUNCTION_REJECTED;
-}
-
-CK_RV
-mock_C_GetAttributeValue__fail_late (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- CK_ULONG i;
-
- for (i = 0; i < count; i++) {
- if (template[i].pValue)
- return CKR_FUNCTION_FAILED;
- }
- return mock_C_GetAttributeValue (session, object, template, count);
-}
-
-CK_RV
-mock_C_SetAttributeValue (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- Session *sess;
- CK_ATTRIBUTE *attrs;
- p11_dict *table;
- CK_RV rv;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, object, &attrs, &table);
- if (rv != CKR_OK)
- return rv;
-
- p11_dict_steal (table, handle_to_pointer (object), NULL, (void **)&attrs);
- attrs = p11_attrs_buildn (attrs, template, count);
- p11_dict_set (table, handle_to_pointer (object), attrs);
- return CKR_OK;
-}
-
-CK_RV
-mock_C_SetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SetAttributeValue__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-typedef struct _FindObjects {
- CK_ATTRIBUTE *template;
- CK_ULONG count;
- Session *sess;
-} FindObjects;
-
-static bool
-enumerate_and_find_objects (CK_OBJECT_HANDLE object,
- CK_ATTRIBUTE *attrs,
- void *user_data)
-{
- FindObjects *ctx = user_data;
- CK_ATTRIBUTE *match;
- CK_ATTRIBUTE *attr;
- CK_BBOOL private;
- CK_ULONG i;
-
- if (!logged_in) {
- if (p11_attrs_find_bool (attrs, CKA_PRIVATE, &private) && private)
- return 1; /* Continue */
- }
-
- for (i = 0; i < ctx->count; ++i) {
- match = ctx->template + i;
- attr = p11_attrs_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 */
- }
-
- p11_array_push (ctx->sess->matches, handle_to_pointer (object));
- return true; /* Continue */
-}
-
-static int
-compar_handles (const void *one,
- const void *two)
-{
- void **p1 = (void **)one;
- void **p2 = (void **)two;
- return pointer_to_handle (*p2) - pointer_to_handle (*p1);
-}
-
-CK_RV
-mock_C_FindObjectsInit (CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- Session *sess;
- FindObjects ctx;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- /* Starting an operation, cancels any previous one */
- sess->crypto_mechanism = 0;
- sess->hash_mechanism = 0;
-
- sess->finding = true;
- p11_array_free (sess->matches);
- sess->matches = p11_array_new (NULL);
-
- ctx.template = template;
- ctx.count = count;
- ctx.sess = sess;
-
- mock_module_enumerate_objects (session, enumerate_and_find_objects, &ctx);
- qsort (sess->matches->elem, sess->matches->num, sizeof (void *), compar_handles);
- return CKR_OK;
-}
-
-CK_RV
-mock_C_FindObjectsInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_FindObjectsInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_FindObjectsInit__fails (CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count)
-{
- return CKR_DEVICE_MEMORY;
-}
-
-CK_RV
-mock_C_FindObjects (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE_PTR objects,
- CK_ULONG max_object_count,
- CK_ULONG_PTR object_count)
-{
- Session *sess;
-
- return_val_if_fail (objects, CKR_ARGUMENTS_BAD);
- return_val_if_fail (object_count, CKR_ARGUMENTS_BAD);
- return_val_if_fail (max_object_count != 0, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
- if (!sess->finding)
- return CKR_OPERATION_NOT_INITIALIZED;
-
- *object_count = 0;
- while (max_object_count > 0) {
- if (sess->matches->num == 0)
- break;
- *objects = pointer_to_handle (sess->matches->elem[sess->matches->num - 1]);
- ++objects;
- --max_object_count;
- ++(*object_count);
- p11_array_remove (sess->matches, sess->matches->num - 1);
- }
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_FindObjects__invalid_handle (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE_PTR objects,
- CK_ULONG max_count,
- CK_ULONG_PTR count)
-{
- return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_FindObjects__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE_PTR objects,
- CK_ULONG max_count,
- CK_ULONG_PTR count)
-{
- return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_FindObjects__fails (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE_PTR objects,
- CK_ULONG max_count,
- CK_ULONG_PTR count)
-{
- return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
- return CKR_DEVICE_REMOVED;
-}
-
-CK_RV
-mock_C_FindObjectsFinal (CK_SESSION_HANDLE session)
-{
-
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (sess == NULL)
- return CKR_SESSION_HANDLE_INVALID;
- if (!sess->finding)
- return CKR_OPERATION_NOT_INITIALIZED;
-
- sess->finding = false;
- p11_array_free (sess->matches);
- sess->matches = NULL;
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_FindObjectsFinal__invalid_handle (CK_SESSION_HANDLE session)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_FindObjectsFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_EncryptInit (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- Session *sess;
-
- return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- /* Starting an operation, cancels any previous one */
- sess->finding = CK_FALSE;
-
- if (mechanism->mechanism != CKM_MOCK_CAPITALIZE)
- return CKR_MECHANISM_INVALID;
- if (key != MOCK_PUBLIC_KEY_CAPITALIZE)
- return CKR_KEY_HANDLE_INVALID;
-
- sess->crypto_method = CKA_ENCRYPT;
- sess->crypto_mechanism = CKM_MOCK_CAPITALIZE;
- sess->crypto_key = key;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_EncryptInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_EncryptInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Encrypt (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR encrypted_data,
- CK_ULONG_PTR encrypted_data_len)
-{
- CK_ULONG last = 0;
- CK_RV rv;
- rv = mock_C_EncryptUpdate (session, data, data_len, encrypted_data, encrypted_data_len);
- if (rv == CKR_OK)
- rv = mock_C_EncryptFinal (session, encrypted_data, &last);
- return rv;
-}
-
-CK_RV
-mock_C_Encrypt__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR encrypted_data,
- CK_ULONG_PTR encrypted_data_len)
-{
- return_val_if_fail (encrypted_data_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_Encrypt__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR encrypted_data,
- CK_ULONG_PTR encrypted_data_len)
-{
- return_val_if_fail (encrypted_data_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_EncryptUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG_PTR encrypted_part_len)
-{
- Session *sess;
- CK_ULONG i;
-
- return_val_if_fail (part != NULL, CKR_DATA_INVALID);
- return_val_if_fail (encrypted_part_len != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!sess->crypto_mechanism)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->crypto_method != CKA_ENCRYPT)
- return CKR_OPERATION_NOT_INITIALIZED;
- assert (sess->crypto_mechanism == CKM_MOCK_CAPITALIZE);
- assert (sess->crypto_key == MOCK_PUBLIC_KEY_CAPITALIZE);
-
- if (!encrypted_part) {
- *encrypted_part_len = part_len;
- return CKR_OK;
- }
-
- if (*encrypted_part_len < part_len) {
- *encrypted_part_len = part_len;
- return CKR_BUFFER_TOO_SMALL;
- }
-
- for (i = 0; i < part_len; ++i)
- encrypted_part[i] = toupper (part[i]);
- *encrypted_part_len = part_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_EncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG_PTR encrypted_part_len)
-{
- return_val_if_fail (encrypted_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_EncryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG_PTR encrypted_part_len)
-{
- return_val_if_fail (encrypted_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_EncryptFinal (CK_SESSION_HANDLE session,
- CK_BYTE_PTR last_encrypted_part,
- CK_ULONG_PTR last_encrypted_part_len)
-{
- Session *sess;
-
- return_val_if_fail (last_encrypted_part_len != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!sess->crypto_mechanism)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->crypto_method != CKA_ENCRYPT)
- return CKR_OPERATION_NOT_INITIALIZED;
-
- *last_encrypted_part_len = 0;
-
- sess->crypto_method = 0;
- sess->crypto_mechanism = 0;
- sess->crypto_key = 0;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_EncryptFinal__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR last_part,
- CK_ULONG_PTR last_part_len)
-{
- return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_EncryptFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR last_part,
- CK_ULONG_PTR last_part_len)
-{
- return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptInit (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- Session *sess;
-
- return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- /* Starting an operation, cancels any previous one */
- sess->finding = false;
-
- if (mechanism->mechanism != CKM_MOCK_CAPITALIZE)
- return CKR_MECHANISM_INVALID;
- if (key != MOCK_PRIVATE_KEY_CAPITALIZE)
- return CKR_KEY_HANDLE_INVALID;
-
- sess->crypto_method = CKA_DECRYPT;
- sess->crypto_mechanism = CKM_MOCK_CAPITALIZE;
- sess->crypto_key = key;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DecryptInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DecryptInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Decrypt (CK_SESSION_HANDLE session,
- CK_BYTE_PTR encrypted_data,
- CK_ULONG encrypted_data_len,
- CK_BYTE_PTR data,
- CK_ULONG_PTR data_len)
-{
- CK_ULONG last = 0;
- CK_RV rv;
- rv = mock_C_DecryptUpdate (session, encrypted_data, encrypted_data_len, data, data_len);
- if (rv == CKR_OK)
- rv = mock_C_DecryptFinal (session, data, &last);
- return rv;
-}
-
-CK_RV
-mock_C_Decrypt__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_data,
- CK_ULONG enc_data_len,
- CK_BYTE_PTR data,
- CK_ULONG_PTR data_len)
-{
- return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_Decrypt__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_data,
- CK_ULONG enc_data_len,
- CK_BYTE_PTR data,
- CK_ULONG_PTR data_len)
-{
- return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG encrypted_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- Session *sess;
- CK_ULONG i;
-
- return_val_if_fail (encrypted_part, CKR_ENCRYPTED_DATA_INVALID);
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!sess->crypto_mechanism)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->crypto_method != CKA_DECRYPT)
- return CKR_OPERATION_NOT_INITIALIZED;
- assert (sess->crypto_mechanism == CKM_MOCK_CAPITALIZE);
- assert (sess->crypto_key == MOCK_PRIVATE_KEY_CAPITALIZE);
-
- if (!part) {
- *part_len = encrypted_part_len;
- return CKR_OK;
- }
-
- if (*part_len < encrypted_part_len) {
- *part_len = encrypted_part_len;
- return CKR_BUFFER_TOO_SMALL;
- }
-
- for (i = 0; i < encrypted_part_len; ++i)
- part[i] = tolower (encrypted_part[i]);
- *part_len = encrypted_part_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DecryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_part,
- CK_ULONG enc_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DecryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_part,
- CK_ULONG enc_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptFinal (CK_SESSION_HANDLE session,
- CK_BYTE_PTR last_part,
- CK_ULONG_PTR last_part_len)
-{
- Session *sess;
-
- return_val_if_fail (last_part_len != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!sess->crypto_mechanism)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->crypto_method != CKA_DECRYPT)
- return CKR_OPERATION_NOT_INITIALIZED;
-
- *last_part_len = 0;
-
- sess->crypto_method = 0;
- sess->crypto_mechanism = 0;
- sess->crypto_key = 0;
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DecryptFinal__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR last_part,
- CK_ULONG_PTR last_part_len)
-{
- return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DecryptFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR last_part,
- CK_ULONG_PTR last_part_len)
-{
- return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestInit (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism)
-{
- Session *sess;
-
- return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- /* Starting an operation, cancels any previous one */
- sess->finding = false;
-
- if (mechanism->mechanism != CKM_MOCK_COUNT)
- return CKR_MECHANISM_INVALID;
-
- sess->hash_mechanism = CKM_MOCK_COUNT;
- sess->hash_method = (CK_ULONG)-1;
- sess->hash_count = 0;
- sess->hash_key = 0;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DigestInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DigestInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Digest (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR digest,
- CK_ULONG_PTR digest_len)
-{
- CK_RV rv;
-
- return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
-
- rv = mock_C_DigestUpdate (session, data, data_len);
- if (rv == CKR_OK)
- rv = mock_C_DigestFinal (session, digest, digest_len);
- return rv;
-}
-
-CK_RV
-mock_C_Digest__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR digest,
- CK_ULONG_PTR digest_len)
-{
- return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_Digest__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR digest,
- CK_ULONG_PTR digest_len)
-{
- return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!sess->hash_mechanism)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->hash_method != (CK_ULONG)-1)
- return CKR_OPERATION_NOT_INITIALIZED;
- assert (sess->hash_mechanism == CKM_MOCK_COUNT);
-
- sess->hash_count += part_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DigestUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestKey (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE key)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!sess->hash_mechanism)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->hash_method != (CK_ULONG)-1)
- return CKR_OPERATION_NOT_INITIALIZED;
- assert (sess->hash_mechanism == CKM_MOCK_COUNT);
-
- sess->hash_count += key;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DigestKey__invalid_handle (CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DigestKey__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestFinal (CK_SESSION_HANDLE session,
- CK_BYTE_PTR digest,
- CK_ULONG_PTR digest_len)
-{
- char buffer[32];
- Session *sess;
- int len;
-
- return_val_if_fail (digest_len != NULL, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (!sess->hash_mechanism)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->hash_method != (CK_ULONG)-1)
- return CKR_OPERATION_NOT_INITIALIZED;
- assert (sess->hash_mechanism == CKM_MOCK_COUNT);
-
- len = snprintf (buffer, sizeof (buffer), "%lu", sess->hash_count);
-
- if (!digest) {
- *digest_len = len;
- return CKR_OK;
- } else if (*digest_len < len) {
- *digest_len = len;
- return CKR_BUFFER_TOO_SMALL;
- }
-
- memcpy (digest, &buffer, len);
- *digest_len = len;
-
- sess->hash_count = 0;
- sess->hash_mechanism = 0;
- sess->hash_key = 0;
- sess->hash_method = 0;
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DigestFinal__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR digest,
- CK_ULONG_PTR digest_len)
-{
- return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DigestFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR digest,
- CK_ULONG_PTR digest_len)
-{
- return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-static CK_RV
-prefix_mechanism_init (CK_SESSION_HANDLE session,
- CK_ATTRIBUTE_TYPE method,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- Session *sess;
- CK_ATTRIBUTE *attrs;
- CK_ATTRIBUTE *value;
- CK_BYTE_PTR param;
- CK_ULONG n_param;
- CK_ULONG length;
- CK_RV rv;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (mechanism->mechanism != CKM_MOCK_PREFIX)
- return CKR_MECHANISM_INVALID;
- if (method == CKA_SIGN || method == CKA_SIGN_RECOVER) {
- if (key != MOCK_PRIVATE_KEY_PREFIX)
- return CKR_KEY_HANDLE_INVALID;
- } else if (method == CKA_VERIFY || method == CKA_VERIFY_RECOVER) {
- if (key != MOCK_PUBLIC_KEY_PREFIX)
- return CKR_KEY_HANDLE_INVALID;
- } else {
- assert_not_reached ();
- }
-
- rv = lookup_object (sess, key, &attrs, NULL);
- if (rv != CKR_OK)
- return rv;
-
- value = p11_attrs_find_valid (attrs, CKA_VALUE);
- if (value == NULL)
- return CKR_KEY_TYPE_INCONSISTENT;
-
- if (mechanism->pParameter) {
- param = mechanism->pParameter;
- n_param = mechanism->ulParameterLen;
- } else {
- param = (CK_BYTE_PTR)SIGNED_PREFIX;
- n_param = strlen (SIGNED_PREFIX) + 1;
- }
-
- length = value->ulValueLen + n_param;
- if (length > sizeof (sess->sign_prefix))
- return CKR_KEY_SIZE_RANGE;
-
- /* Starting an operation, cancels any finding */
- sess->finding = false;
-
- sess->hash_mechanism = CKM_MOCK_PREFIX;
- sess->hash_method = method;
- sess->hash_key = key;
- sess->hash_count = 0;
-
- memcpy (sess->sign_prefix, param, n_param);
- memcpy (sess->sign_prefix + n_param, value->pValue, value->ulValueLen);
- sess->n_sign_prefix = length;
-
- /* The private key has CKA_ALWAYS_AUTHENTICATE above */
- if (method == CKA_SIGN || method == CKA_SIGN_RECOVER)
- sess->want_context_login = true;
-
- return CKR_OK;
-
-}
-
-CK_RV
-mock_C_SignInit (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
- return prefix_mechanism_init (session, CKA_SIGN, mechanism, key);
-}
-
-CK_RV
-mock_C_SignInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SignInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Sign (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- CK_RV rv;
-
- rv = mock_C_SignUpdate (session, data, data_len);
- if (rv == CKR_OK)
- rv = mock_C_SignFinal (session, signature, signature_len);
-
- return rv;
-}
-
-CK_RV
-mock_C_Sign__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_Sign__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
- if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
- sess->hash_method != CKA_SIGN)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->want_context_login)
- return CKR_USER_NOT_LOGGED_IN;
-
- sess->hash_count += part_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_SignUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SignUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignFinal (CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- char buffer[32];
- Session *sess;
- CK_ULONG length;
- int len;
-
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
- if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
- sess->hash_method != CKA_SIGN)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->want_context_login)
- return CKR_USER_NOT_LOGGED_IN;
-
- len = snprintf (buffer, sizeof (buffer), "%lu", sess->hash_count);
- length = sess->n_sign_prefix + len;
-
- if (!signature) {
- *signature_len = length;
- return CKR_OK;
- }
-
- if (*signature_len < length) {
- *signature_len = length;
- return CKR_BUFFER_TOO_SMALL;
- }
-
- memcpy (signature, sess->sign_prefix, sess->n_sign_prefix);
- memcpy (signature + sess->n_sign_prefix, buffer, len);
- *signature_len = length;
-
- sess->hash_mechanism = 0;
- sess->hash_method = 0;
- sess->hash_count = 0;
- sess->hash_key = 0;
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_SignFinal__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SignFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignRecoverInit (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
- return prefix_mechanism_init (session, CKA_SIGN_RECOVER, mechanism, key);
-}
-
-CK_RV
-mock_C_SignRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SignRecoverInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignRecover (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- Session *sess;
- CK_ULONG length;
-
- return_val_if_fail (data, CKR_DATA_INVALID);
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
- if (sess->hash_method != CKA_SIGN_RECOVER ||
- sess->hash_mechanism != CKM_MOCK_PREFIX)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->want_context_login)
- return CKR_USER_NOT_LOGGED_IN;
-
- length = sess->n_sign_prefix + data_len;
-
- if (!signature) {
- *signature_len = length;
- return CKR_OK;
- }
-
- if (*signature_len < length) {
- *signature_len = length;
- return CKR_BUFFER_TOO_SMALL;
- }
-
- memcpy (signature, sess->sign_prefix, sess->n_sign_prefix);
- memcpy (signature + sess->n_sign_prefix, data, data_len);
- *signature_len = length;
-
- sess->hash_method = 0;
- sess->hash_mechanism = 0;
- sess->hash_key = 0;
- sess->hash_count = 0;
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_SignRecover__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SignRecover__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG_PTR signature_len)
-{
- return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyInit (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
- return prefix_mechanism_init (session, CKA_VERIFY, mechanism, key);
-}
-
-CK_RV
-mock_C_VerifyInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_VerifyInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Verify (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len)
-{
- CK_RV rv;
-
- rv = mock_C_VerifyUpdate (session, data, data_len);
- if (rv == CKR_OK)
- rv = mock_C_VerifyFinal (session, signature, signature_len);
-
- return rv;
-}
-
-CK_RV
-mock_C_Verify__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_Verify__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR data,
- CK_ULONG data_len,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
- if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
- sess->hash_method != CKA_VERIFY)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->want_context_login)
- return CKR_USER_NOT_LOGGED_IN;
-
- sess->hash_count += part_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_VerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_VerifyUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyFinal (CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len)
-{
- char buffer[32];
- Session *sess;
- CK_ULONG length;
- int len;
-
- return_val_if_fail (signature, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
- if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
- sess->hash_method != CKA_VERIFY)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->want_context_login)
- return CKR_USER_NOT_LOGGED_IN;
-
- len = snprintf (buffer, sizeof (buffer), "%lu", sess->hash_count);
- length = sess->n_sign_prefix + len;
-
- if (signature_len != length)
- return CKR_SIGNATURE_LEN_RANGE;
-
- if (memcmp (signature, sess->sign_prefix, sess->n_sign_prefix) != 0 ||
- memcmp (signature + sess->n_sign_prefix, buffer, len) != 0)
- return CKR_SIGNATURE_INVALID;
-
- sess->hash_mechanism = 0;
- sess->hash_method = 0;
- sess->hash_count = 0;
- sess->hash_key = 0;
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_VerifyFinal__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_VerifyFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyRecoverInit (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return_val_if_fail (mechanism != NULL, CKR_ARGUMENTS_BAD);
- return prefix_mechanism_init (session, CKA_VERIFY_RECOVER, mechanism, key);
-}
-
-CK_RV
-mock_C_VerifyRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_VerifyRecoverInit__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyRecover (CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len,
- CK_BYTE_PTR data,
- CK_ULONG_PTR data_len)
-{
- Session *sess;
- CK_ULONG length;
-
- return_val_if_fail (signature, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
- if (sess->hash_mechanism != CKM_MOCK_PREFIX ||
- sess->hash_method != CKA_VERIFY_RECOVER)
- return CKR_OPERATION_NOT_INITIALIZED;
- if (sess->want_context_login)
- return CKR_USER_NOT_LOGGED_IN;
-
- if (signature_len < sess->n_sign_prefix)
- return CKR_SIGNATURE_LEN_RANGE;
- if (memcmp (signature, sess->sign_prefix, sess->n_sign_prefix) != 0)
- return CKR_SIGNATURE_INVALID;
-
- length = signature_len - sess->n_sign_prefix;
- if (!data) {
- *data_len = length;
- return CKR_OK;
- }
-
- if (*data_len < length) {
- *data_len = length;
- return CKR_BUFFER_TOO_SMALL;
- }
-
- *data_len = length;
- memcpy (data, signature + sess->n_sign_prefix, length);
- return CKR_OK;
-}
-
-CK_RV
-mock_C_VerifyRecover__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len,
- CK_BYTE_PTR data,
- CK_ULONG_PTR data_len)
-{
- return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_VerifyRecover__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR signature,
- CK_ULONG signature_len,
- CK_BYTE_PTR data,
- CK_ULONG_PTR data_len)
-{
- return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestEncryptUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG_PTR encrypted_part_len)
-{
- CK_RV rv;
-
- rv = mock_C_EncryptUpdate (session, part, part_len, encrypted_part, encrypted_part_len);
- if (rv == CKR_OK)
- rv = mock_C_DigestUpdate (session, part, part_len);
-
- return rv;
-}
-
-CK_RV
-mock_C_DigestEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR enc_part,
- CK_ULONG_PTR enc_part_len)
-{
- return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DigestEncryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR enc_part,
- CK_ULONG_PTR enc_part_len)
-{
- return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptDigestUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG encrypted_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- CK_RV rv;
-
- rv = mock_C_DecryptUpdate (session, encrypted_part, encrypted_part_len, part, part_len);
- if (rv == CKR_OK)
- rv = mock_C_DigestUpdate (session, part, *part_len);
-
- return rv;
-}
-
-CK_RV
-mock_C_DecryptDigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_part,
- CK_ULONG enc_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DecryptDigestUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_part,
- CK_ULONG enc_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignEncryptUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG_PTR encrypted_part_len)
-{
- CK_RV rv;
-
- rv = mock_C_EncryptUpdate (session, part, part_len, encrypted_part, encrypted_part_len);
- if (rv == CKR_OK)
- rv = mock_C_SignUpdate (session, part, part_len);
-
- return rv;
-}
-
-CK_RV
-mock_C_SignEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR enc_part,
- CK_ULONG_PTR enc_part_len)
-{
- return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SignEncryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR part,
- CK_ULONG part_len,
- CK_BYTE_PTR enc_part,
- CK_ULONG_PTR enc_part_len)
-{
- return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptVerifyUpdate (CK_SESSION_HANDLE session,
- CK_BYTE_PTR encrypted_part,
- CK_ULONG encrypted_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- CK_RV rv;
-
- rv = mock_C_DecryptUpdate (session, encrypted_part, encrypted_part_len, part, part_len);
- if (rv == CKR_OK)
- rv = mock_C_VerifyUpdate (session, part, *part_len);
-
- return rv;
-}
-
-CK_RV
-mock_C_DecryptVerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_part,
- CK_ULONG enc_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DecryptVerifyUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR enc_part,
- CK_ULONG enc_part_len,
- CK_BYTE_PTR part,
- CK_ULONG_PTR part_len)
-{
- return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GenerateKey (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- CK_ATTRIBUTE *attrs;
- CK_ATTRIBUTE value;
- Session *sess;
- CK_BBOOL token;
-
- return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
- return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (count, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (key, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (mechanism->mechanism != CKM_MOCK_GENERATE)
- return CKR_MECHANISM_INVALID;
-
- if (!mechanism->pParameter || mechanism->ulParameterLen != 9 ||
- memcmp (mechanism->pParameter, "generate", 9) != 0)
- return CKR_MECHANISM_PARAM_INVALID;
-
- value.type = CKA_VALUE;
- value.pValue = "generated";
- value.ulValueLen = strlen (value.pValue);
-
- attrs = p11_attrs_buildn (NULL, template, count);
- attrs = p11_attrs_buildn (attrs, &value, 1);
-
- *key = ++unique_identifier;
- if (p11_attrs_find_bool (attrs, CKA_TOKEN, &token) && token)
- p11_dict_set (the_objects, handle_to_pointer (*key), attrs);
- else
- p11_dict_set (sess->objects, handle_to_pointer (*key), attrs);
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_GenerateKey__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_GenerateKey__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GenerateKeyPair (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_ATTRIBUTE_PTR public_key_template,
- CK_ULONG public_key_count,
- CK_ATTRIBUTE_PTR private_key_template,
- CK_ULONG private_key_count,
- CK_OBJECT_HANDLE_PTR public_key,
- CK_OBJECT_HANDLE_PTR private_key)
-{
- CK_ATTRIBUTE *attrs;
- CK_ATTRIBUTE value;
- Session *sess;
- CK_BBOOL token;
-
- return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
- return_val_if_fail (public_key_template, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (public_key_count, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (private_key_template, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (private_key_count, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (public_key, CKR_ARGUMENTS_BAD);
- return_val_if_fail (private_key, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (mechanism->mechanism != CKM_MOCK_GENERATE)
- return CKR_MECHANISM_INVALID;
-
- if (!mechanism->pParameter || mechanism->ulParameterLen != 9 ||
- memcmp (mechanism->pParameter, "generate", 9) != 0)
- return CKR_MECHANISM_PARAM_INVALID;
-
- value.type = CKA_VALUE;
- value.pValue = "generated";
- value.ulValueLen = strlen (value.pValue);
-
- attrs = p11_attrs_buildn (NULL, public_key_template, public_key_count);
- attrs = p11_attrs_buildn (attrs, &value, 1);
-
- *public_key = ++unique_identifier;
- if (p11_attrs_find_bool (attrs, CKA_TOKEN, &token) && token)
- p11_dict_set (the_objects, handle_to_pointer (*public_key), attrs);
- else
- p11_dict_set (sess->objects, handle_to_pointer (*public_key), attrs);
-
- attrs = p11_attrs_buildn (NULL, private_key_template, private_key_count);
- attrs = p11_attrs_buildn (attrs, &value, 1);
-
- *private_key = ++unique_identifier;
- if (p11_attrs_find_bool (attrs, CKA_TOKEN, &token) && token)
- p11_dict_set (the_objects, handle_to_pointer (*private_key), attrs);
- else
- p11_dict_set (sess->objects, handle_to_pointer (*private_key), attrs);
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_GenerateKeyPair__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_ATTRIBUTE_PTR pub_template,
- CK_ULONG pub_count,
- CK_ATTRIBUTE_PTR priv_template,
- CK_ULONG priv_count,
- CK_OBJECT_HANDLE_PTR pub_key,
- CK_OBJECT_HANDLE_PTR priv_key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_GenerateKeyPair__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_ATTRIBUTE_PTR pub_template,
- CK_ULONG pub_count,
- CK_ATTRIBUTE_PTR priv_template,
- CK_ULONG priv_count,
- CK_OBJECT_HANDLE_PTR pub_key,
- CK_OBJECT_HANDLE_PTR priv_key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_WrapKey (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE wrapping_key,
- CK_OBJECT_HANDLE key,
- CK_BYTE_PTR wrapped_key,
- CK_ULONG_PTR wrapped_key_len)
-{
- CK_ATTRIBUTE *attrs;
- CK_ATTRIBUTE *attr;
- Session *sess;
- CK_RV rv;
-
- return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
- return_val_if_fail (wrapping_key, CKR_OBJECT_HANDLE_INVALID);
- return_val_if_fail (key, CKR_OBJECT_HANDLE_INVALID);
- return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, wrapping_key, &attrs, NULL);
- if (rv == CKR_OBJECT_HANDLE_INVALID)
- return CKR_WRAPPING_KEY_HANDLE_INVALID;
- else if (rv != CKR_OK)
- return rv;
-
- rv = lookup_object (sess, key, &attrs, NULL);
- if (rv == CKR_OBJECT_HANDLE_INVALID)
- return CKR_WRAPPING_KEY_HANDLE_INVALID;
- else if (rv != CKR_OK)
- return rv;
-
- if (mechanism->mechanism != CKM_MOCK_WRAP)
- return CKR_MECHANISM_INVALID;
-
- if (mechanism->pParameter == NULL ||
- mechanism->ulParameterLen != 4 ||
- memcmp (mechanism->pParameter, "wrap", 4) != 0) {
- return CKR_MECHANISM_PARAM_INVALID;
- }
-
- attr = p11_attrs_find_valid (attrs, CKA_VALUE);
- if (attr == NULL)
- return CKR_WRAPPED_KEY_INVALID;
-
- if (!wrapped_key) {
- *wrapped_key_len = attr->ulValueLen;
- return CKR_OK;
- }
-
- if (*wrapped_key_len < attr->ulValueLen) {
- *wrapped_key_len = attr->ulValueLen;
- return CKR_BUFFER_TOO_SMALL;
- }
-
- memcpy (wrapped_key, attr->pValue, attr->ulValueLen);
- *wrapped_key_len = attr->ulValueLen;
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_WrapKey__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE wrapping_key,
- CK_OBJECT_HANDLE key,
- CK_BYTE_PTR wrapped_key,
- CK_ULONG_PTR wrapped_key_len)
-{
- return_val_if_fail (wrapped_key_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_WrapKey__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE wrapping_key,
- CK_OBJECT_HANDLE key,
- CK_BYTE_PTR wrapped_key,
- CK_ULONG_PTR wrapped_key_len)
-{
- return_val_if_fail (wrapped_key_len, CKR_ARGUMENTS_BAD);
-
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_UnwrapKey (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE unwrapping_key,
- CK_BYTE_PTR wrapped_key,
- CK_ULONG wrapped_key_len,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- CK_ATTRIBUTE *attrs;
- CK_ATTRIBUTE value;
- Session *sess;
- CK_BBOOL token;
- CK_RV rv;
-
- return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
- return_val_if_fail (unwrapping_key, CKR_WRAPPING_KEY_HANDLE_INVALID);
- return_val_if_fail (wrapped_key, CKR_WRAPPED_KEY_INVALID);
- return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
- return_val_if_fail (key, CKR_ARGUMENTS_BAD);
- return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (count, CKR_TEMPLATE_INCONSISTENT);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, unwrapping_key, &attrs, NULL);
- if (rv == CKR_OBJECT_HANDLE_INVALID)
- return CKR_WRAPPING_KEY_HANDLE_INVALID;
- else if (rv != CKR_OK)
- return rv;
-
- if (mechanism->mechanism != CKM_MOCK_WRAP)
- return CKR_MECHANISM_INVALID;
-
- if (mechanism->pParameter == NULL ||
- mechanism->ulParameterLen != 4 ||
- memcmp (mechanism->pParameter, "wrap", 4) != 0) {
- return CKR_MECHANISM_PARAM_INVALID;
- }
-
- value.type = CKA_VALUE;
- value.pValue = wrapped_key;
- value.ulValueLen = wrapped_key_len;
-
- attrs = p11_attrs_buildn (NULL, template, count);
- attrs = p11_attrs_buildn (attrs, &value, 1);
-
- *key = ++unique_identifier;
- if (p11_attrs_find_bool (attrs, CKA_TOKEN, &token) && token)
- p11_dict_set (the_objects, handle_to_pointer (*key), attrs);
- else
- p11_dict_set (sess->objects, handle_to_pointer (*key), attrs);
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_UnwrapKey__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE unwrapping_key,
- CK_BYTE_PTR wrapped_key,
- CK_ULONG wrapped_key_len,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_UnwrapKey__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE unwrapping_key,
- CK_BYTE_PTR wrapped_key,
- CK_ULONG wrapped_key_len,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DeriveKey (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE base_key,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- CK_ATTRIBUTE *attrs, *copy;
- CK_ATTRIBUTE value;
- Session *sess;
- CK_BBOOL token;
- CK_RV rv;
-
- return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
- return_val_if_fail (count, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
- return_val_if_fail (key, CKR_ARGUMENTS_BAD);
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- rv = lookup_object (sess, base_key, &attrs, NULL);
- if (rv == CKR_OBJECT_HANDLE_INVALID)
- return CKR_KEY_HANDLE_INVALID;
- else if (rv != CKR_OK)
- return rv;
-
- if (mechanism->mechanism != CKM_MOCK_DERIVE)
- return CKR_MECHANISM_INVALID;
-
- if (mechanism->pParameter == NULL ||
- mechanism->ulParameterLen != 6 ||
- memcmp (mechanism->pParameter, "derive", 6) != 0) {
- return CKR_MECHANISM_PARAM_INVALID;
- }
-
- value.type = CKA_VALUE;
- value.pValue = "derived";
- value.ulValueLen = strlen (value.pValue);
-
- copy = p11_attrs_buildn (NULL, template, count);
- copy = p11_attrs_buildn (copy, &value, 1);
-
- *key = ++unique_identifier;
- if (p11_attrs_find_bool (copy, CKA_TOKEN, &token) && token)
- p11_dict_set (the_objects, handle_to_pointer (*key), copy);
- else
- p11_dict_set (sess->objects, handle_to_pointer (*key), copy);
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_DeriveKey__invalid_handle (CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE base_key,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_DeriveKey__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_MECHANISM_PTR mechanism,
- CK_OBJECT_HANDLE base_key,
- CK_ATTRIBUTE_PTR template,
- CK_ULONG count,
- CK_OBJECT_HANDLE_PTR key)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SeedRandom (CK_SESSION_HANDLE session,
- CK_BYTE_PTR seed,
- CK_ULONG seed_len)
-{
- Session *sess;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- if (seed_len > sizeof (sess->random_seed))
- return CKR_RANDOM_SEED_NOT_SUPPORTED;
-
- memcpy (sess->random_seed, seed, seed_len);
- sess->random_seed_len = seed_len;
- return CKR_OK;
-}
-
-CK_RV
-mock_C_SeedRandom__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR seed,
- CK_ULONG seed_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_SeedRandom__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR seed,
- CK_ULONG seed_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GenerateRandom (CK_SESSION_HANDLE session,
- CK_BYTE_PTR random_data,
- CK_ULONG random_len)
-{
- Session *sess;
- CK_ULONG block;
-
- sess = p11_dict_get (the_sessions, handle_to_pointer (session));
- if (!sess)
- return CKR_SESSION_HANDLE_INVALID;
-
- while (random_len > 0) {
- block = sess->random_seed_len;
- if (block > random_len)
- block = random_len;
- memcpy (random_data, sess->random_seed, block);
- random_data += block;
- random_len -= block;
- }
-
- return CKR_OK;
-}
-
-CK_RV
-mock_C_GenerateRandom__invalid_handle (CK_SESSION_HANDLE session,
- CK_BYTE_PTR random_data,
- CK_ULONG random_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_X_GenerateRandom__invalid_handle (CK_X_FUNCTION_LIST *self,
- CK_SESSION_HANDLE session,
- CK_BYTE_PTR random_data,
- CK_ULONG random_len)
-{
- return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_FUNCTION_LIST mock_module_no_slots = {
- { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, /* version */
- mock_C_Initialize,
- mock_C_Finalize,
- mock_C_GetInfo,
- mock_C_GetFunctionList_not_supported,
- mock_C_GetSlotList__no_tokens,
- mock_C_GetSlotInfo__invalid_slotid,
- mock_C_GetTokenInfo__invalid_slotid,
- mock_C_GetMechanismList__invalid_slotid,
- mock_C_GetMechanismInfo__invalid_slotid,
- mock_C_InitToken__invalid_slotid,
- mock_C_InitPIN__invalid_handle,
- mock_C_SetPIN__invalid_handle,
- mock_C_OpenSession__invalid_slotid,
- mock_C_CloseSession__invalid_handle,
- mock_C_CloseAllSessions__invalid_slotid,
- mock_C_GetSessionInfo__invalid_handle,
- mock_C_GetOperationState__invalid_handle,
- mock_C_SetOperationState__invalid_handle,
- mock_C_Login__invalid_handle,
- mock_C_Logout__invalid_handle,
- mock_C_CreateObject__invalid_handle,
- mock_C_CopyObject__invalid_handle,
- mock_C_DestroyObject__invalid_handle,
- mock_C_GetObjectSize__invalid_handle,
- mock_C_GetAttributeValue__invalid_handle,
- mock_C_SetAttributeValue__invalid_handle,
- mock_C_FindObjectsInit__invalid_handle,
- mock_C_FindObjects__invalid_handle,
- mock_C_FindObjectsFinal__invalid_handle,
- mock_C_EncryptInit__invalid_handle,
- mock_C_Encrypt__invalid_handle,
- mock_C_EncryptUpdate__invalid_handle,
- mock_C_EncryptFinal__invalid_handle,
- mock_C_DecryptInit__invalid_handle,
- mock_C_Decrypt__invalid_handle,
- mock_C_DecryptUpdate__invalid_handle,
- mock_C_DecryptFinal__invalid_handle,
- mock_C_DigestInit__invalid_handle,
- mock_C_Digest__invalid_handle,
- mock_C_DigestUpdate__invalid_handle,
- mock_C_DigestKey__invalid_handle,
- mock_C_DigestFinal__invalid_handle,
- mock_C_SignInit__invalid_handle,
- mock_C_Sign__invalid_handle,
- mock_C_SignUpdate__invalid_handle,
- mock_C_SignFinal__invalid_handle,
- mock_C_SignRecoverInit__invalid_handle,
- mock_C_SignRecover__invalid_handle,
- mock_C_VerifyInit__invalid_handle,
- mock_C_Verify__invalid_handle,
- mock_C_VerifyUpdate__invalid_handle,
- mock_C_VerifyFinal__invalid_handle,
- mock_C_VerifyRecoverInit__invalid_handle,
- mock_C_VerifyRecover__invalid_handle,
- mock_C_DigestEncryptUpdate__invalid_handle,
- mock_C_DecryptDigestUpdate__invalid_handle,
- mock_C_SignEncryptUpdate__invalid_handle,
- mock_C_DecryptVerifyUpdate__invalid_handle,
- mock_C_GenerateKey__invalid_handle,
- mock_C_GenerateKeyPair__invalid_handle,
- mock_C_WrapKey__invalid_handle,
- mock_C_UnwrapKey__invalid_handle,
- mock_C_DeriveKey__invalid_handle,
- mock_C_SeedRandom__invalid_handle,
- mock_C_GenerateRandom__invalid_handle,
- mock_C_GetFunctionStatus__not_parallel,
- mock_C_CancelFunction__not_parallel,
- mock_C_WaitForSlotEvent__no_event,
-};
-
-CK_X_FUNCTION_LIST mock_x_module_no_slots = {
- { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, /* version */
- mock_X_Initialize,
- mock_X_Finalize,
- mock_X_GetInfo,
- mock_X_GetSlotList__no_tokens,
- mock_X_GetSlotInfo__invalid_slotid,
- mock_X_GetTokenInfo__invalid_slotid,
- mock_X_GetMechanismList__invalid_slotid,
- mock_X_GetMechanismInfo__invalid_slotid,
- mock_X_InitToken__invalid_slotid,
- mock_X_InitPIN__invalid_handle,
- mock_X_SetPIN__invalid_handle,
- mock_X_OpenSession__invalid_slotid,
- mock_X_CloseSession__invalid_handle,
- mock_X_CloseAllSessions__invalid_slotid,
- mock_X_GetSessionInfo__invalid_handle,
- mock_X_GetOperationState__invalid_handle,
- mock_X_SetOperationState__invalid_handle,
- mock_X_Login__invalid_handle,
- mock_X_Logout__invalid_handle,
- mock_X_CreateObject__invalid_handle,
- mock_X_CopyObject__invalid_handle,
- mock_X_DestroyObject__invalid_handle,
- mock_X_GetObjectSize__invalid_handle,
- mock_X_GetAttributeValue__invalid_handle,
- mock_X_SetAttributeValue__invalid_handle,
- mock_X_FindObjectsInit__invalid_handle,
- mock_X_FindObjects__invalid_handle,
- mock_X_FindObjectsFinal__invalid_handle,
- mock_X_EncryptInit__invalid_handle,
- mock_X_Encrypt__invalid_handle,
- mock_X_EncryptUpdate__invalid_handle,
- mock_X_EncryptFinal__invalid_handle,
- mock_X_DecryptInit__invalid_handle,
- mock_X_Decrypt__invalid_handle,
- mock_X_DecryptUpdate__invalid_handle,
- mock_X_DecryptFinal__invalid_handle,
- mock_X_DigestInit__invalid_handle,
- mock_X_Digest__invalid_handle,
- mock_X_DigestUpdate__invalid_handle,
- mock_X_DigestKey__invalid_handle,
- mock_X_DigestFinal__invalid_handle,
- mock_X_SignInit__invalid_handle,
- mock_X_Sign__invalid_handle,
- mock_X_SignUpdate__invalid_handle,
- mock_X_SignFinal__invalid_handle,
- mock_X_SignRecoverInit__invalid_handle,
- mock_X_SignRecover__invalid_handle,
- mock_X_VerifyInit__invalid_handle,
- mock_X_Verify__invalid_handle,
- mock_X_VerifyUpdate__invalid_handle,
- mock_X_VerifyFinal__invalid_handle,
- mock_X_VerifyRecoverInit__invalid_handle,
- mock_X_VerifyRecover__invalid_handle,
- mock_X_DigestEncryptUpdate__invalid_handle,
- mock_X_DecryptDigestUpdate__invalid_handle,
- mock_X_SignEncryptUpdate__invalid_handle,
- mock_X_DecryptVerifyUpdate__invalid_handle,
- mock_X_GenerateKey__invalid_handle,
- mock_X_GenerateKeyPair__invalid_handle,
- mock_X_WrapKey__invalid_handle,
- mock_X_UnwrapKey__invalid_handle,
- mock_X_DeriveKey__invalid_handle,
- mock_X_SeedRandom__invalid_handle,
- mock_X_GenerateRandom__invalid_handle,
- mock_X_WaitForSlotEvent__no_event,
-};
-
-CK_FUNCTION_LIST mock_module = {
- { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, /* version */
- mock_C_Initialize,
- mock_C_Finalize,
- mock_C_GetInfo,
- mock_C_GetFunctionList_not_supported,
- mock_C_GetSlotList,
- mock_C_GetSlotInfo,
- mock_C_GetTokenInfo,
- mock_C_GetMechanismList,
- mock_C_GetMechanismInfo,
- mock_C_InitToken__specific_args,
- mock_C_InitPIN__specific_args,
- mock_C_SetPIN__specific_args,
- mock_C_OpenSession,
- mock_C_CloseSession,
- mock_C_CloseAllSessions,
- mock_C_GetSessionInfo,
- mock_C_GetOperationState,
- mock_C_SetOperationState,
- mock_C_Login,
- mock_C_Logout,
- mock_C_CreateObject,
- mock_C_CopyObject,
- mock_C_DestroyObject,
- mock_C_GetObjectSize,
- mock_C_GetAttributeValue,
- mock_C_SetAttributeValue,
- mock_C_FindObjectsInit,
- mock_C_FindObjects,
- mock_C_FindObjectsFinal,
- mock_C_EncryptInit,
- mock_C_Encrypt,
- mock_C_EncryptUpdate,
- mock_C_EncryptFinal,
- mock_C_DecryptInit,
- mock_C_Decrypt,
- mock_C_DecryptUpdate,
- mock_C_DecryptFinal,
- mock_C_DigestInit,
- mock_C_Digest,
- mock_C_DigestUpdate,
- mock_C_DigestKey,
- mock_C_DigestFinal,
- mock_C_SignInit,
- mock_C_Sign,
- mock_C_SignUpdate,
- mock_C_SignFinal,
- mock_C_SignRecoverInit,
- mock_C_SignRecover,
- mock_C_VerifyInit,
- mock_C_Verify,
- mock_C_VerifyUpdate,
- mock_C_VerifyFinal,
- mock_C_VerifyRecoverInit,
- mock_C_VerifyRecover,
- mock_C_DigestEncryptUpdate,
- mock_C_DecryptDigestUpdate,
- mock_C_SignEncryptUpdate,
- mock_C_DecryptVerifyUpdate,
- mock_C_GenerateKey,
- mock_C_GenerateKeyPair,
- mock_C_WrapKey,
- mock_C_UnwrapKey,
- mock_C_DeriveKey,
- mock_C_SeedRandom,
- mock_C_GenerateRandom,
- mock_C_GetFunctionStatus,
- mock_C_CancelFunction,
- mock_C_WaitForSlotEvent,
-};
-
-void
-mock_module_init (void)
-{
- static bool initialized = false;
- if (!initialized) {
- p11_mutex_init (&init_mutex);
- initialized = true;
- }
-}