2 * Copyright (C) 2010 Stefan Walter
3 * Copyright (C) 2011 Collabora Ltd.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General License as
7 * published by the Free Software Foundation; either version 2.1 of
8 * the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * License along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 #include "mock-pkcs11.h"
29 * This is *NOT* how you'd want to implement a PKCS#11 module. This
30 * fake module simply provides enough for gnutls-pkcs11 backend to test against.
31 * It doesn't pass any tests, or behave as expected from a PKCS#11 module.
34 static gboolean initialized = FALSE;
40 static CK_OBJECT_HANDLE unique_identifier = 100;
41 static GHashTable *the_sessions = NULL;
42 static GHashTable *the_certificates = NULL;
43 static GHashTable *the_assertions = NULL;
47 CK_ULONG assertion_type;
53 free_assertion (gpointer data)
55 Assertion *assertion = data;
56 g_clear_object (&assertion->cert);
57 g_free (assertion->purpose);
58 g_free (assertion->peer);
63 CK_SESSION_HANDLE handle;
68 /* For find operations */
73 free_session (gpointer data)
75 Session *sess = (Session*)data;
76 g_list_free (sess->matches);
81 mock_module_add_certificate (GcrCertificate *cert)
83 CK_OBJECT_HANDLE handle;
85 g_return_val_if_fail (GCR_IS_CERTIFICATE (cert), 0);
87 handle = unique_identifier++;
88 g_hash_table_insert (the_certificates, GUINT_TO_POINTER (handle), g_object_ref (cert));
93 mock_module_add_assertion (GcrCertificate *cert,
94 CK_X_ASSERTION_TYPE assertion_type,
99 CK_OBJECT_HANDLE handle;
101 g_return_val_if_fail (GCR_IS_CERTIFICATE (cert), 0);
103 assertion = g_new0 (Assertion, 1);
104 assertion->cert = g_object_ref (cert);
105 assertion->assertion_type = assertion_type;
106 assertion->purpose = g_strdup (purpose);
107 assertion->peer = g_strdup (peer);
109 handle = unique_identifier++;
110 g_hash_table_insert (the_assertions, GUINT_TO_POINTER (handle), assertion);
115 mock_C_Initialize (CK_VOID_PTR init_args)
117 CK_C_INITIALIZE_ARGS_PTR args;
119 g_return_val_if_fail (initialized == FALSE, CKR_CRYPTOKI_ALREADY_INITIALIZED);
121 args = (CK_C_INITIALIZE_ARGS_PTR)init_args;
124 g_return_val_if_fail(
125 (args->CreateMutex == NULL && args->DestroyMutex == NULL &&
126 args->LockMutex == NULL && args->UnlockMutex == NULL) ||
127 (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
128 args->LockMutex != NULL && args->UnlockMutex != NULL),
131 /* Flags should allow OS locking and os threads */
132 g_return_val_if_fail ((args->flags & CKF_OS_LOCKING_OK), CKR_CANT_LOCK);
133 g_return_val_if_fail ((args->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS) == 0, CKR_NEED_TO_CREATE_THREADS);
136 the_sessions = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, free_session);
137 the_certificates = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)g_object_unref);
138 the_assertions = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, free_assertion);
145 mock_C_Finalize (CK_VOID_PTR reserved)
147 g_return_val_if_fail (reserved == NULL, CKR_ARGUMENTS_BAD);
148 g_return_val_if_fail (initialized == TRUE, CKR_CRYPTOKI_NOT_INITIALIZED);
152 g_hash_table_destroy (the_certificates);
153 the_certificates = NULL;
155 g_hash_table_destroy (the_assertions);
156 the_assertions = NULL;
158 g_hash_table_destroy (the_sessions);
164 static const CK_INFO TEST_INFO = {
165 { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
166 "TEST MANUFACTURER ",
173 mock_C_GetInfo (CK_INFO_PTR info)
175 g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
176 memcpy (info, &TEST_INFO, sizeof (*info));
181 mock_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
183 g_return_val_if_fail (list, CKR_ARGUMENTS_BAD);
184 *list = &mock_default_functions;
189 mock_C_GetSlotList (CK_BBOOL token_present,
190 CK_SLOT_ID_PTR slot_list,
195 g_return_val_if_fail (count, CKR_ARGUMENTS_BAD);
197 /* Application only wants to know the number of slots. */
198 if (slot_list == NULL)
205 g_return_val_if_reached (CKR_BUFFER_TOO_SMALL);
208 slot_list[0] = MOCK_SLOT_ONE_ID;
212 /* Update mock-pkcs11.h URIs when updating this */
214 static const CK_SLOT_INFO MOCK_INFO_ONE = {
216 "MOCK MANUFACTURER ",
217 CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE,
223 mock_C_GetSlotInfo (CK_SLOT_ID slot_id,
224 CK_SLOT_INFO_PTR info)
226 g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
228 if (slot_id == MOCK_SLOT_ONE_ID)
230 memcpy (info, &MOCK_INFO_ONE, sizeof (*info));
235 g_return_val_if_reached (CKR_SLOT_ID_INVALID);
239 /* Update mock-pkcs11.h URIs when updating this */
241 static const CK_TOKEN_INFO MOCK_TOKEN_ONE = {
243 "MOCK MANUFACTURER ",
246 CKF_TOKEN_INITIALIZED | CKF_WRITE_PROTECTED,
259 { '1', '9', '9', '9', '0', '5', '2', '5', '0', '9', '1', '9', '5', '9', '0', '0' }
263 mock_C_GetTokenInfo (CK_SLOT_ID slot_id,
264 CK_TOKEN_INFO_PTR info)
266 g_return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
268 if (slot_id == MOCK_SLOT_ONE_ID)
270 memcpy (info, &MOCK_TOKEN_ONE, sizeof (*info));
275 g_return_val_if_reached (CKR_SLOT_ID_INVALID);
280 mock_C_GetMechanismList (CK_SLOT_ID slot_id,
281 CK_MECHANISM_TYPE_PTR mechanism_list,
284 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
285 g_return_val_if_fail (count, CKR_ARGUMENTS_BAD);
287 /* Application only wants to know the number of slots. */
288 if (mechanism_list == NULL)
298 mock_C_GetMechanismInfo (CK_SLOT_ID slot_id,
299 CK_MECHANISM_TYPE type,
300 CK_MECHANISM_INFO_PTR info)
302 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
303 g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
305 g_return_val_if_reached (CKR_MECHANISM_INVALID);
309 mock_unsupported_C_InitToken (CK_SLOT_ID slot_id,
312 CK_UTF8CHAR_PTR label)
314 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
315 return CKR_FUNCTION_NOT_SUPPORTED;
319 mock_unsupported_C_WaitForSlotEvent (CK_FLAGS flags,
320 CK_SLOT_ID_PTR slot_id,
321 CK_VOID_PTR reserved)
323 return CKR_FUNCTION_NOT_SUPPORTED;
327 mock_C_OpenSession (CK_SLOT_ID slot_id,
329 CK_VOID_PTR application,
331 CK_SESSION_HANDLE_PTR session)
335 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
336 g_return_val_if_fail (session != NULL, CKR_ARGUMENTS_BAD);
337 g_return_val_if_fail ((flags & CKF_SERIAL_SESSION) == CKF_SERIAL_SESSION, CKR_SESSION_PARALLEL_NOT_SUPPORTED);
339 if (flags & CKF_RW_SESSION)
340 return CKR_TOKEN_WRITE_PROTECTED;
342 sess = g_new0 (Session, 1);
343 sess->handle = ++unique_identifier;
344 sess->info.flags = flags;
345 sess->info.slotID = slot_id;
346 sess->info.state = CKS_RO_PUBLIC_SESSION;
347 sess->info.ulDeviceError = 0;
348 *session = sess->handle;
350 g_hash_table_replace (the_sessions, GUINT_TO_POINTER (sess->handle), sess);
355 mock_C_CloseSession (CK_SESSION_HANDLE session)
359 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
360 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
362 g_hash_table_remove (the_sessions, GUINT_TO_POINTER (sess));
367 mock_C_CloseAllSessions (CK_SLOT_ID slot_id)
369 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
371 g_hash_table_remove_all (the_sessions);
376 mock_C_GetFunctionStatus (CK_SESSION_HANDLE session)
378 return CKR_FUNCTION_NOT_PARALLEL;
382 mock_C_CancelFunction (CK_SESSION_HANDLE session)
384 return CKR_FUNCTION_NOT_PARALLEL;
388 mock_C_GetSessionInfo (CK_SESSION_HANDLE session,
389 CK_SESSION_INFO_PTR info)
393 g_return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
395 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
396 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
398 memcpy (info, &sess->info, sizeof (*info));
403 mock_unsupported_C_InitPIN (CK_SESSION_HANDLE session,
407 return CKR_FUNCTION_NOT_SUPPORTED;
411 mock_unsupported_C_SetPIN (CK_SESSION_HANDLE session,
412 CK_UTF8CHAR_PTR old_pin,
414 CK_UTF8CHAR_PTR new_pin,
417 return CKR_FUNCTION_NOT_SUPPORTED;
421 mock_unsupported_C_GetOperationState (CK_SESSION_HANDLE session,
422 CK_BYTE_PTR operation_state,
423 CK_ULONG_PTR operation_state_len)
425 return CKR_FUNCTION_NOT_SUPPORTED;
429 mock_unsupported_C_SetOperationState (CK_SESSION_HANDLE session,
430 CK_BYTE_PTR operation_state,
431 CK_ULONG operation_state_len,
432 CK_OBJECT_HANDLE encryption_key,
433 CK_OBJECT_HANDLE authentication_key)
435 return CKR_FUNCTION_NOT_SUPPORTED;
439 mock_unsupported_C_Login (CK_SESSION_HANDLE session,
440 CK_USER_TYPE user_type,
444 return CKR_FUNCTION_NOT_SUPPORTED;
448 mock_unsupported_C_Logout (CK_SESSION_HANDLE session)
450 return CKR_FUNCTION_NOT_SUPPORTED;
454 mock_readonly_C_CreateObject (CK_SESSION_HANDLE session,
455 CK_ATTRIBUTE_PTR template,
457 CK_OBJECT_HANDLE_PTR object)
461 g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
463 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
464 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
466 return CKR_TOKEN_WRITE_PROTECTED;
470 mock_unsupported_C_CopyObject (CK_SESSION_HANDLE session,
471 CK_OBJECT_HANDLE object,
472 CK_ATTRIBUTE_PTR template,
474 CK_OBJECT_HANDLE_PTR new_object)
476 return CKR_FUNCTION_NOT_SUPPORTED;
480 mock_readonly_C_DestroyObject (CK_SESSION_HANDLE session,
481 CK_OBJECT_HANDLE object)
485 g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
487 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
488 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
490 return CKR_TOKEN_WRITE_PROTECTED;
494 mock_unsupported_C_GetObjectSize (CK_SESSION_HANDLE session,
495 CK_OBJECT_HANDLE object,
496 CK_ULONG_PTR pulSize)
498 return CKR_FUNCTION_NOT_SUPPORTED;
502 fill_data_attribute (CK_ATTRIBUTE *attr,
507 attr->ulValueLen = length;
509 } else if (attr->ulValueLen < length) {
510 attr->ulValueLen = length;
511 return CKR_BUFFER_TOO_SMALL;
513 memcpy (attr->pValue, data, length);
514 attr->ulValueLen = length;
520 fill_check_value_attribute (CK_ATTRIBUTE *attr,
521 GcrCertificate *cert)
527 data = gcr_certificate_get_fingerprint (cert, G_CHECKSUM_SHA1, &length);
528 rv = fill_data_attribute (attr, data, 3);
535 fill_subject_attribute (CK_ATTRIBUTE *attr,
536 GcrCertificate *cert)
542 data = gcr_certificate_get_subject_raw (cert, &length);
543 rv = fill_data_attribute (attr, data, length);
550 fill_issuer_attribute (CK_ATTRIBUTE *attr,
551 GcrCertificate *cert)
557 data = gcr_certificate_get_issuer_raw (cert, &length);
558 rv = fill_data_attribute (attr, data, length);
565 fill_serial_attribute (CK_ATTRIBUTE *attr,
566 GcrCertificate *cert)
572 data = gcr_certificate_get_serial_number (cert, &length);
573 rv = fill_data_attribute (attr, data, length);
580 fill_string_attribute (CK_ATTRIBUTE *attr,
583 return fill_data_attribute (attr, data, strlen (data));
587 fill_id_attribute (CK_ATTRIBUTE *attr,
588 GcrCertificate *cert)
593 data = g_strdup_printf ("%p", cert);
594 rv = fill_string_attribute (attr, data);
601 fill_value_attribute (CK_ATTRIBUTE *attr,
602 GcrCertificate *cert)
607 data = gcr_certificate_get_der_data (cert, &length);
608 return fill_data_attribute (attr, data, length);
612 fill_ulong_attribute (CK_ATTRIBUTE *attr,
615 return fill_data_attribute (attr, &value, sizeof (value));
619 fill_bool_attribute (CK_ATTRIBUTE *attr,
622 return fill_data_attribute (attr, &value, sizeof (value));
626 fill_certificate_attribute (CK_ATTRIBUTE *attr,
627 GcrCertificate *cert)
632 return fill_ulong_attribute (attr, CKO_CERTIFICATE);
634 return fill_bool_attribute (attr, CK_TRUE);
638 return fill_bool_attribute (attr, CK_FALSE);
640 return fill_string_attribute (attr, "Certificate");
641 case CKA_CERTIFICATE_TYPE:
642 return fill_ulong_attribute (attr, CKC_X_509);
643 case CKA_CERTIFICATE_CATEGORY:
644 return fill_ulong_attribute (attr, 2);
645 case CKA_CHECK_VALUE:
646 return fill_check_value_attribute (attr, cert);
649 return fill_data_attribute (attr, "", 0);
651 return fill_subject_attribute (attr, cert);
653 return fill_id_attribute (attr, cert);
655 return fill_issuer_attribute (attr, cert);
656 case CKA_SERIAL_NUMBER:
657 return fill_serial_attribute (attr, cert);
659 return fill_value_attribute (attr, cert);
661 case CKA_HASH_OF_SUBJECT_PUBLIC_KEY:
662 case CKA_HASH_OF_ISSUER_PUBLIC_KEY:
663 case CKA_JAVA_MIDP_SECURITY_DOMAIN:
665 return CKR_ATTRIBUTE_TYPE_INVALID;
670 fill_assertion_attribute (CK_ATTRIBUTE *attr,
671 Assertion *assertion)
678 return fill_ulong_attribute (attr, CKO_X_TRUST_ASSERTION);
680 return fill_bool_attribute (attr, CK_TRUE);
684 return fill_bool_attribute (attr, CK_FALSE);
686 return fill_string_attribute (attr, "Assertion");
687 case CKA_X_ASSERTION_TYPE:
688 return fill_ulong_attribute (attr, assertion->assertion_type);
690 return fill_string_attribute (attr, assertion->purpose);
692 if (!assertion->peer)
693 return CKR_ATTRIBUTE_TYPE_INVALID;
694 return fill_string_attribute (attr, assertion->peer);
695 case CKA_SERIAL_NUMBER:
697 return fill_certificate_attribute (attr, assertion->cert);
698 case CKA_X_CERTIFICATE_VALUE:
699 attr->type = CKA_VALUE;
700 rv = fill_certificate_attribute (attr, assertion->cert);
701 attr->type = CKA_X_CERTIFICATE_VALUE;
705 return CKR_ATTRIBUTE_TYPE_INVALID;
710 mock_C_GetAttributeValue (CK_SESSION_HANDLE session,
711 CK_OBJECT_HANDLE object,
712 CK_ATTRIBUTE_PTR template,
715 CK_RV rv, ret = CKR_OK;
716 GcrCertificate *cert;
717 Assertion *assertion;
721 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
722 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
724 cert = g_hash_table_lookup (the_certificates, GUINT_TO_POINTER (object));
725 assertion = g_hash_table_lookup (the_assertions, GUINT_TO_POINTER (object));
728 for (i = 0; i < count; i++) {
729 rv = fill_certificate_attribute (template + i, cert);
731 template[i].ulValueLen = (CK_ULONG)-1;
735 } else if (assertion != NULL) {
736 for (i = 0; i < count; i++) {
737 rv = fill_assertion_attribute (template + i, assertion);
739 template[i].ulValueLen = (CK_ULONG)-1;
744 ret = CKR_OBJECT_HANDLE_INVALID;
751 mock_readonly_C_SetAttributeValue (CK_SESSION_HANDLE session,
752 CK_OBJECT_HANDLE object,
753 CK_ATTRIBUTE_PTR template,
758 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
759 g_return_val_if_fail (sess, CKR_SESSION_HANDLE_INVALID);
761 return CKR_TOKEN_WRITE_PROTECTED;
765 match_object_attributes (CK_SESSION_HANDLE session,
767 CK_ATTRIBUTE_PTR template,
770 CK_ATTRIBUTE_PTR values;
771 gboolean mismatch = FALSE;
775 values = g_new0 (CK_ATTRIBUTE, count);
776 for (i = 0; i < count; i++) {
777 values[i].type = template[i].type;
778 if (template[i].ulValueLen != 0 &&
779 template[i].ulValueLen != (CK_ULONG)-1)
780 values[i].pValue = g_malloc (template[i].ulValueLen);
781 values[i].ulValueLen = template[i].ulValueLen;
784 rv = mock_C_GetAttributeValue (session, object, values, count);
787 for (i = 0; i < count; i++) {
788 if (gcr_comparable_memcmp (values[i].pValue, values[i].ulValueLen,
789 template[i].pValue, template[i].ulValueLen) != 0) {
796 for (i = 0; i < count; i++)
797 g_free (values[i].pValue);
807 mock_C_FindObjectsInit (CK_SESSION_HANDLE session,
808 CK_ATTRIBUTE_PTR template,
811 GList *objects = NULL, *l;
814 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
815 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
817 /* Starting an operation, cancels any previous one */
818 if (sess->operation != 0)
821 sess->operation = OP_FIND;
822 g_list_free (sess->matches);
823 sess->matches = NULL;
825 objects = g_list_concat (objects, g_hash_table_get_keys (the_certificates));
826 objects = g_list_concat (objects, g_hash_table_get_keys (the_assertions));
828 for (l = objects; l != NULL; l = g_list_next (l)) {
829 if (match_object_attributes (session, GPOINTER_TO_UINT (l->data), template, count))
830 sess->matches = g_list_prepend (sess->matches, l->data);
833 g_list_free (objects);
838 mock_C_FindObjects (CK_SESSION_HANDLE session,
839 CK_OBJECT_HANDLE_PTR object,
840 CK_ULONG max_object_count,
841 CK_ULONG_PTR object_count)
845 g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
846 g_return_val_if_fail (object_count, CKR_ARGUMENTS_BAD);
847 g_return_val_if_fail (max_object_count != 0, CKR_ARGUMENTS_BAD);
849 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
850 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
851 g_return_val_if_fail (sess->operation == OP_FIND, CKR_OPERATION_NOT_INITIALIZED);
854 while (max_object_count > 0 && sess->matches)
856 *object = GPOINTER_TO_UINT (sess->matches->data);
860 sess->matches = g_list_remove (sess->matches, sess->matches->data);
867 mock_C_FindObjectsFinal (CK_SESSION_HANDLE session)
871 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
872 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
873 g_return_val_if_fail (sess->operation == OP_FIND, CKR_OPERATION_NOT_INITIALIZED);
876 g_list_free (sess->matches);
877 sess->matches = NULL;
883 mock_no_mechanisms_C_EncryptInit (CK_SESSION_HANDLE session,
884 CK_MECHANISM_PTR mechanism,
885 CK_OBJECT_HANDLE key)
889 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
890 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
892 return CKR_MECHANISM_INVALID;
896 mock_not_initialized_C_Encrypt (CK_SESSION_HANDLE session,
899 CK_BYTE_PTR encrypted_data,
900 CK_ULONG_PTR encrypted_data_len)
902 return CKR_OPERATION_NOT_INITIALIZED;
906 mock_unsupported_C_EncryptUpdate (CK_SESSION_HANDLE session,
909 CK_BYTE_PTR encrypted_part,
910 CK_ULONG_PTR encrypted_part_len)
912 return CKR_FUNCTION_NOT_SUPPORTED;
916 mock_unsupported_C_EncryptFinal (CK_SESSION_HANDLE session,
917 CK_BYTE_PTR last_encrypted_part,
918 CK_ULONG_PTR last_encrypted_part_len)
920 return CKR_FUNCTION_NOT_SUPPORTED;
924 mock_no_mechanisms_C_DecryptInit (CK_SESSION_HANDLE session,
925 CK_MECHANISM_PTR mechanism,
926 CK_OBJECT_HANDLE key)
930 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
931 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
933 return CKR_MECHANISM_INVALID;
937 mock_not_initialized_C_Decrypt (CK_SESSION_HANDLE session,
938 CK_BYTE_PTR encrypted_data,
939 CK_ULONG encrypted_data_len,
941 CK_ULONG_PTR data_len)
943 return CKR_OPERATION_NOT_INITIALIZED;
947 mock_unsupported_C_DecryptUpdate (CK_SESSION_HANDLE session,
948 CK_BYTE_PTR encrypted_part,
949 CK_ULONG encrypted_key_len,
951 CK_ULONG_PTR part_len)
953 return CKR_FUNCTION_NOT_SUPPORTED;
957 mock_unsupported_C_DecryptFinal (CK_SESSION_HANDLE session,
958 CK_BYTE_PTR last_part,
959 CK_ULONG_PTR last_part_len)
961 return CKR_FUNCTION_NOT_SUPPORTED;
965 mock_unsupported_C_DigestInit (CK_SESSION_HANDLE session,
966 CK_MECHANISM_PTR mechanism)
968 return CKR_FUNCTION_NOT_SUPPORTED;
972 mock_unsupported_C_Digest (CK_SESSION_HANDLE session,
976 CK_ULONG_PTR digest_len)
978 return CKR_FUNCTION_NOT_SUPPORTED;
982 mock_unsupported_C_DigestUpdate (CK_SESSION_HANDLE session,
986 return CKR_FUNCTION_NOT_SUPPORTED;
990 mock_unsupported_C_DigestKey (CK_SESSION_HANDLE session,
991 CK_OBJECT_HANDLE key)
993 return CKR_FUNCTION_NOT_SUPPORTED;
997 mock_unsupported_C_DigestFinal (CK_SESSION_HANDLE session,
999 CK_ULONG_PTR digest_len)
1001 return CKR_FUNCTION_NOT_SUPPORTED;
1005 mock_no_mechanisms_C_SignInit (CK_SESSION_HANDLE session,
1006 CK_MECHANISM_PTR mechanism,
1007 CK_OBJECT_HANDLE key)
1011 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1012 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1014 return CKR_MECHANISM_INVALID;
1018 mock_not_initialized_C_Sign (CK_SESSION_HANDLE session,
1021 CK_BYTE_PTR signature,
1022 CK_ULONG_PTR signature_len)
1024 return CKR_OPERATION_NOT_INITIALIZED;
1028 mock_unsupported_C_SignUpdate (CK_SESSION_HANDLE session,
1032 return CKR_FUNCTION_NOT_SUPPORTED;
1036 mock_unsupported_C_SignFinal (CK_SESSION_HANDLE session,
1037 CK_BYTE_PTR signature,
1038 CK_ULONG_PTR signature_len)
1040 return CKR_FUNCTION_NOT_SUPPORTED;
1044 mock_unsupported_C_SignRecoverInit (CK_SESSION_HANDLE session,
1045 CK_MECHANISM_PTR mechanism,
1046 CK_OBJECT_HANDLE key)
1048 return CKR_FUNCTION_NOT_SUPPORTED;
1052 mock_unsupported_C_SignRecover (CK_SESSION_HANDLE session,
1055 CK_BYTE_PTR signature,
1056 CK_ULONG_PTR signature_len)
1058 return CKR_FUNCTION_NOT_SUPPORTED;
1062 mock_no_mechanisms_C_VerifyInit (CK_SESSION_HANDLE session,
1063 CK_MECHANISM_PTR mechanism,
1064 CK_OBJECT_HANDLE key)
1068 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1069 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1071 return CKR_MECHANISM_INVALID;
1075 mock_not_initialized_C_Verify (CK_SESSION_HANDLE session,
1078 CK_BYTE_PTR signature,
1079 CK_ULONG signature_len)
1081 return CKR_OPERATION_NOT_INITIALIZED;
1085 mock_unsupported_C_VerifyUpdate (CK_SESSION_HANDLE session,
1089 return CKR_FUNCTION_NOT_SUPPORTED;
1093 mock_unsupported_C_VerifyFinal (CK_SESSION_HANDLE session,
1094 CK_BYTE_PTR signature,
1095 CK_ULONG signature_len)
1097 return CKR_FUNCTION_NOT_SUPPORTED;
1101 mock_unsupported_C_VerifyRecoverInit (CK_SESSION_HANDLE session,
1102 CK_MECHANISM_PTR mechanism,
1103 CK_OBJECT_HANDLE key)
1105 return CKR_FUNCTION_NOT_SUPPORTED;
1109 mock_unsupported_C_VerifyRecover (CK_SESSION_HANDLE session,
1110 CK_BYTE_PTR signature,
1111 CK_ULONG signature_len,
1113 CK_ULONG_PTR data_len)
1115 return CKR_FUNCTION_NOT_SUPPORTED;
1119 mock_unsupported_C_DigestEncryptUpdate (CK_SESSION_HANDLE session,
1122 CK_BYTE_PTR encrypted_part,
1123 CK_ULONG_PTR encrypted_key_len)
1125 return CKR_FUNCTION_NOT_SUPPORTED;
1129 mock_unsupported_C_DecryptDigestUpdate (CK_SESSION_HANDLE session,
1130 CK_BYTE_PTR encrypted_part,
1131 CK_ULONG encrypted_key_len,
1133 CK_ULONG_PTR part_len)
1135 return CKR_FUNCTION_NOT_SUPPORTED;
1139 mock_unsupported_C_SignEncryptUpdate (CK_SESSION_HANDLE session,
1142 CK_BYTE_PTR encrypted_part,
1143 CK_ULONG_PTR encrypted_key_len)
1145 return CKR_FUNCTION_NOT_SUPPORTED;
1149 mock_unsupported_C_DecryptVerifyUpdate (CK_SESSION_HANDLE session,
1150 CK_BYTE_PTR encrypted_part,
1151 CK_ULONG encrypted_key_len,
1153 CK_ULONG_PTR part_len)
1155 return CKR_FUNCTION_NOT_SUPPORTED;
1159 mock_unsupported_C_GenerateKey (CK_SESSION_HANDLE session,
1160 CK_MECHANISM_PTR mechanism,
1161 CK_ATTRIBUTE_PTR template,
1163 CK_OBJECT_HANDLE_PTR key)
1165 return CKR_FUNCTION_NOT_SUPPORTED;
1169 mock_no_mechanisms_C_GenerateKeyPair (CK_SESSION_HANDLE session,
1170 CK_MECHANISM_PTR mechanism,
1171 CK_ATTRIBUTE_PTR public_key_template,
1172 CK_ULONG public_key_attribute_count,
1173 CK_ATTRIBUTE_PTR private_key_template,
1174 CK_ULONG private_key_attribute_count,
1175 CK_OBJECT_HANDLE_PTR public_key,
1176 CK_OBJECT_HANDLE_PTR private_key)
1180 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1181 g_return_val_if_fail (public_key_template, CKR_TEMPLATE_INCOMPLETE);
1182 g_return_val_if_fail (public_key_attribute_count, CKR_TEMPLATE_INCOMPLETE);
1183 g_return_val_if_fail (private_key_template, CKR_TEMPLATE_INCOMPLETE);
1184 g_return_val_if_fail (private_key_attribute_count, CKR_TEMPLATE_INCOMPLETE);
1185 g_return_val_if_fail (public_key, CKR_ARGUMENTS_BAD);
1186 g_return_val_if_fail (private_key, CKR_ARGUMENTS_BAD);
1188 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1189 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1191 return CKR_MECHANISM_INVALID;
1195 mock_no_mechanisms_C_WrapKey (CK_SESSION_HANDLE session,
1196 CK_MECHANISM_PTR mechanism,
1197 CK_OBJECT_HANDLE wrapping_key,
1198 CK_OBJECT_HANDLE key,
1199 CK_BYTE_PTR wrapped_key,
1200 CK_ULONG_PTR wrapped_key_len)
1204 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1205 g_return_val_if_fail (wrapping_key, CKR_OBJECT_HANDLE_INVALID);
1206 g_return_val_if_fail (key, CKR_OBJECT_HANDLE_INVALID);
1207 g_return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
1209 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1210 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1212 return CKR_MECHANISM_INVALID;
1216 mock_no_mechanisms_C_UnwrapKey (CK_SESSION_HANDLE session,
1217 CK_MECHANISM_PTR mechanism,
1218 CK_OBJECT_HANDLE unwrapping_key,
1219 CK_BYTE_PTR wrapped_key,
1220 CK_ULONG wrapped_key_len,
1221 CK_ATTRIBUTE_PTR template,
1223 CK_OBJECT_HANDLE_PTR key)
1227 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1228 g_return_val_if_fail (unwrapping_key, CKR_WRAPPING_KEY_HANDLE_INVALID);
1229 g_return_val_if_fail (wrapped_key, CKR_WRAPPED_KEY_INVALID);
1230 g_return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
1231 g_return_val_if_fail (key, CKR_ARGUMENTS_BAD);
1232 g_return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
1233 g_return_val_if_fail (count, CKR_TEMPLATE_INCONSISTENT);
1235 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1236 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1238 return CKR_MECHANISM_INVALID;
1242 mock_no_mechanisms_C_DeriveKey (CK_SESSION_HANDLE session,
1243 CK_MECHANISM_PTR mechanism,
1244 CK_OBJECT_HANDLE base_key,
1245 CK_ATTRIBUTE_PTR template,
1247 CK_OBJECT_HANDLE_PTR key)
1251 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1252 g_return_val_if_fail (count, CKR_TEMPLATE_INCOMPLETE);
1253 g_return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
1254 g_return_val_if_fail (key, CKR_ARGUMENTS_BAD);
1256 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1257 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1259 return CKR_MECHANISM_INVALID;
1263 mock_unsupported_C_SeedRandom (CK_SESSION_HANDLE session,
1267 return CKR_FUNCTION_NOT_SUPPORTED;
1271 mock_unsupported_C_GenerateRandom (CK_SESSION_HANDLE session,
1272 CK_BYTE_PTR random_data,
1273 CK_ULONG random_len)
1275 return CKR_FUNCTION_NOT_SUPPORTED;
1278 CK_FUNCTION_LIST mock_default_functions = {
1279 { 2, 11 }, /* version */
1283 mock_C_GetFunctionList,
1286 mock_C_GetTokenInfo,
1287 mock_C_GetMechanismList,
1288 mock_C_GetMechanismInfo,
1289 mock_unsupported_C_InitToken,
1290 mock_unsupported_C_InitPIN,
1291 mock_unsupported_C_SetPIN,
1293 mock_C_CloseSession,
1294 mock_C_CloseAllSessions,
1295 mock_C_GetSessionInfo,
1296 mock_unsupported_C_GetOperationState,
1297 mock_unsupported_C_SetOperationState,
1298 mock_unsupported_C_Login,
1299 mock_unsupported_C_Logout,
1300 mock_readonly_C_CreateObject,
1301 mock_unsupported_C_CopyObject,
1302 mock_readonly_C_DestroyObject,
1303 mock_unsupported_C_GetObjectSize,
1304 mock_C_GetAttributeValue,
1305 mock_readonly_C_SetAttributeValue,
1306 mock_C_FindObjectsInit,
1308 mock_C_FindObjectsFinal,
1309 mock_no_mechanisms_C_EncryptInit,
1310 mock_not_initialized_C_Encrypt,
1311 mock_unsupported_C_EncryptUpdate,
1312 mock_unsupported_C_EncryptFinal,
1313 mock_no_mechanisms_C_DecryptInit,
1314 mock_not_initialized_C_Decrypt,
1315 mock_unsupported_C_DecryptUpdate,
1316 mock_unsupported_C_DecryptFinal,
1317 mock_unsupported_C_DigestInit,
1318 mock_unsupported_C_Digest,
1319 mock_unsupported_C_DigestUpdate,
1320 mock_unsupported_C_DigestKey,
1321 mock_unsupported_C_DigestFinal,
1322 mock_no_mechanisms_C_SignInit,
1323 mock_not_initialized_C_Sign,
1324 mock_unsupported_C_SignUpdate,
1325 mock_unsupported_C_SignFinal,
1326 mock_unsupported_C_SignRecoverInit,
1327 mock_unsupported_C_SignRecover,
1328 mock_no_mechanisms_C_VerifyInit,
1329 mock_not_initialized_C_Verify,
1330 mock_unsupported_C_VerifyUpdate,
1331 mock_unsupported_C_VerifyFinal,
1332 mock_unsupported_C_VerifyRecoverInit,
1333 mock_unsupported_C_VerifyRecover,
1334 mock_unsupported_C_DigestEncryptUpdate,
1335 mock_unsupported_C_DecryptDigestUpdate,
1336 mock_unsupported_C_SignEncryptUpdate,
1337 mock_unsupported_C_DecryptVerifyUpdate,
1338 mock_unsupported_C_GenerateKey,
1339 mock_no_mechanisms_C_GenerateKeyPair,
1340 mock_no_mechanisms_C_WrapKey,
1341 mock_no_mechanisms_C_UnwrapKey,
1342 mock_no_mechanisms_C_DeriveKey,
1343 mock_unsupported_C_SeedRandom,
1344 mock_unsupported_C_GenerateRandom,
1345 mock_C_GetFunctionStatus,
1346 mock_C_CancelFunction,
1347 mock_unsupported_C_WaitForSlotEvent