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"
27 * This is *NOT* how you'd want to implement a PKCS#11 module. This
28 * fake module simply provides enough for gnutls-pkcs11 backend to test against.
29 * It doesn't pass any tests, or behave as expected from a PKCS#11 module.
32 static gboolean initialized = FALSE;
38 static CK_OBJECT_HANDLE unique_identifier = 100;
39 static GHashTable *the_sessions = NULL;
40 static GHashTable *the_certificates = NULL;
41 static GHashTable *the_assertions = NULL;
45 CK_ULONG assertion_type;
51 free_assertion (gpointer data)
53 Assertion *assertion = data;
54 g_clear_object (&assertion->cert);
55 g_free (assertion->purpose);
56 g_free (assertion->peer);
61 CK_SESSION_HANDLE handle;
66 /* For find operations */
71 free_session (gpointer data)
73 Session *sess = (Session*)data;
74 g_list_free (sess->matches);
79 mock_module_add_certificate (GcrCertificate *cert)
81 CK_OBJECT_HANDLE handle;
83 g_return_val_if_fail (GCR_IS_CERTIFICATE (cert), 0);
85 handle = unique_identifier++;
86 g_hash_table_insert (the_certificates, GUINT_TO_POINTER (handle), g_object_ref (cert));
91 mock_module_add_assertion (GcrCertificate *cert,
92 CK_X_ASSERTION_TYPE assertion_type,
97 CK_OBJECT_HANDLE handle;
99 g_return_val_if_fail (GCR_IS_CERTIFICATE (cert), 0);
101 assertion = g_new0 (Assertion, 1);
102 assertion->cert = g_object_ref (cert);
103 assertion->assertion_type = assertion_type;
104 assertion->purpose = g_strdup (purpose);
105 assertion->peer = g_strdup (peer);
107 handle = unique_identifier++;
108 g_hash_table_insert (the_assertions, GUINT_TO_POINTER (handle), assertion);
113 mock_C_Initialize (CK_VOID_PTR init_args)
115 CK_C_INITIALIZE_ARGS_PTR args;
117 g_return_val_if_fail (initialized == FALSE, CKR_CRYPTOKI_ALREADY_INITIALIZED);
119 args = (CK_C_INITIALIZE_ARGS_PTR)init_args;
122 g_return_val_if_fail(
123 (args->CreateMutex == NULL && args->DestroyMutex == NULL &&
124 args->LockMutex == NULL && args->UnlockMutex == NULL) ||
125 (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
126 args->LockMutex != NULL && args->UnlockMutex != NULL),
129 /* Flags should allow OS locking and os threads */
130 g_return_val_if_fail ((args->flags & CKF_OS_LOCKING_OK), CKR_CANT_LOCK);
131 g_return_val_if_fail ((args->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS) == 0, CKR_NEED_TO_CREATE_THREADS);
134 the_sessions = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, free_session);
135 the_certificates = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)g_object_unref);
136 the_assertions = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, free_assertion);
143 mock_C_Finalize (CK_VOID_PTR reserved)
145 g_return_val_if_fail (reserved == NULL, CKR_ARGUMENTS_BAD);
146 g_return_val_if_fail (initialized == TRUE, CKR_CRYPTOKI_NOT_INITIALIZED);
150 g_hash_table_destroy (the_certificates);
151 the_certificates = NULL;
153 g_hash_table_destroy (the_assertions);
154 the_assertions = NULL;
156 g_hash_table_destroy (the_sessions);
162 static const CK_INFO TEST_INFO = {
163 { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
164 "TEST MANUFACTURER ",
171 mock_C_GetInfo (CK_INFO_PTR info)
173 g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
174 memcpy (info, &TEST_INFO, sizeof (*info));
179 mock_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
181 g_return_val_if_fail (list, CKR_ARGUMENTS_BAD);
182 *list = &mock_default_functions;
187 mock_C_GetSlotList (CK_BBOOL token_present,
188 CK_SLOT_ID_PTR slot_list,
193 g_return_val_if_fail (count, CKR_ARGUMENTS_BAD);
195 /* Application only wants to know the number of slots. */
196 if (slot_list == NULL)
203 g_return_val_if_reached (CKR_BUFFER_TOO_SMALL);
206 slot_list[0] = MOCK_SLOT_ONE_ID;
210 /* Update mock-pkcs11.h URIs when updating this */
212 static const CK_SLOT_INFO MOCK_INFO_ONE = {
214 "MOCK MANUFACTURER ",
215 CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE,
221 mock_C_GetSlotInfo (CK_SLOT_ID slot_id,
222 CK_SLOT_INFO_PTR info)
224 g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
226 if (slot_id == MOCK_SLOT_ONE_ID)
228 memcpy (info, &MOCK_INFO_ONE, sizeof (*info));
233 g_return_val_if_reached (CKR_SLOT_ID_INVALID);
237 /* Update mock-pkcs11.h URIs when updating this */
239 static const CK_TOKEN_INFO MOCK_TOKEN_ONE = {
241 "MOCK MANUFACTURER ",
244 CKF_TOKEN_INITIALIZED | CKF_WRITE_PROTECTED,
257 { '1', '9', '9', '9', '0', '5', '2', '5', '0', '9', '1', '9', '5', '9', '0', '0' }
261 mock_C_GetTokenInfo (CK_SLOT_ID slot_id,
262 CK_TOKEN_INFO_PTR info)
264 g_return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
266 if (slot_id == MOCK_SLOT_ONE_ID)
268 memcpy (info, &MOCK_TOKEN_ONE, sizeof (*info));
273 g_return_val_if_reached (CKR_SLOT_ID_INVALID);
278 mock_C_GetMechanismList (CK_SLOT_ID slot_id,
279 CK_MECHANISM_TYPE_PTR mechanism_list,
282 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
283 g_return_val_if_fail (count, CKR_ARGUMENTS_BAD);
285 /* Application only wants to know the number of slots. */
286 if (mechanism_list == NULL)
296 mock_C_GetMechanismInfo (CK_SLOT_ID slot_id,
297 CK_MECHANISM_TYPE type,
298 CK_MECHANISM_INFO_PTR info)
300 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
301 g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
303 g_return_val_if_reached (CKR_MECHANISM_INVALID);
307 mock_unsupported_C_InitToken (CK_SLOT_ID slot_id,
310 CK_UTF8CHAR_PTR label)
312 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
313 return CKR_FUNCTION_NOT_SUPPORTED;
317 mock_unsupported_C_WaitForSlotEvent (CK_FLAGS flags,
318 CK_SLOT_ID_PTR slot_id,
319 CK_VOID_PTR reserved)
321 return CKR_FUNCTION_NOT_SUPPORTED;
325 mock_C_OpenSession (CK_SLOT_ID slot_id,
327 CK_VOID_PTR application,
329 CK_SESSION_HANDLE_PTR session)
333 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
334 g_return_val_if_fail (session != NULL, CKR_ARGUMENTS_BAD);
335 g_return_val_if_fail ((flags & CKF_SERIAL_SESSION) == CKF_SERIAL_SESSION, CKR_SESSION_PARALLEL_NOT_SUPPORTED);
337 if (flags & CKF_RW_SESSION)
338 return CKR_TOKEN_WRITE_PROTECTED;
340 sess = g_new0 (Session, 1);
341 sess->handle = ++unique_identifier;
342 sess->info.flags = flags;
343 sess->info.slotID = slot_id;
344 sess->info.state = CKS_RO_PUBLIC_SESSION;
345 sess->info.ulDeviceError = 0;
346 *session = sess->handle;
348 g_hash_table_replace (the_sessions, GUINT_TO_POINTER (sess->handle), sess);
353 mock_C_CloseSession (CK_SESSION_HANDLE session)
357 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
358 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
360 g_hash_table_remove (the_sessions, GUINT_TO_POINTER (sess));
365 mock_C_CloseAllSessions (CK_SLOT_ID slot_id)
367 g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
369 g_hash_table_remove_all (the_sessions);
374 mock_C_GetFunctionStatus (CK_SESSION_HANDLE session)
376 return CKR_FUNCTION_NOT_PARALLEL;
380 mock_C_CancelFunction (CK_SESSION_HANDLE session)
382 return CKR_FUNCTION_NOT_PARALLEL;
386 mock_C_GetSessionInfo (CK_SESSION_HANDLE session,
387 CK_SESSION_INFO_PTR info)
391 g_return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
393 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
394 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
396 memcpy (info, &sess->info, sizeof (*info));
401 mock_unsupported_C_InitPIN (CK_SESSION_HANDLE session,
405 return CKR_FUNCTION_NOT_SUPPORTED;
409 mock_unsupported_C_SetPIN (CK_SESSION_HANDLE session,
410 CK_UTF8CHAR_PTR old_pin,
412 CK_UTF8CHAR_PTR new_pin,
415 return CKR_FUNCTION_NOT_SUPPORTED;
419 mock_unsupported_C_GetOperationState (CK_SESSION_HANDLE session,
420 CK_BYTE_PTR operation_state,
421 CK_ULONG_PTR operation_state_len)
423 return CKR_FUNCTION_NOT_SUPPORTED;
427 mock_unsupported_C_SetOperationState (CK_SESSION_HANDLE session,
428 CK_BYTE_PTR operation_state,
429 CK_ULONG operation_state_len,
430 CK_OBJECT_HANDLE encryption_key,
431 CK_OBJECT_HANDLE authentication_key)
433 return CKR_FUNCTION_NOT_SUPPORTED;
437 mock_unsupported_C_Login (CK_SESSION_HANDLE session,
438 CK_USER_TYPE user_type,
442 return CKR_FUNCTION_NOT_SUPPORTED;
446 mock_unsupported_C_Logout (CK_SESSION_HANDLE session)
448 return CKR_FUNCTION_NOT_SUPPORTED;
452 mock_readonly_C_CreateObject (CK_SESSION_HANDLE session,
453 CK_ATTRIBUTE_PTR template,
455 CK_OBJECT_HANDLE_PTR object)
459 g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
461 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
462 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
464 return CKR_TOKEN_WRITE_PROTECTED;
468 mock_unsupported_C_CopyObject (CK_SESSION_HANDLE session,
469 CK_OBJECT_HANDLE object,
470 CK_ATTRIBUTE_PTR template,
472 CK_OBJECT_HANDLE_PTR new_object)
474 return CKR_FUNCTION_NOT_SUPPORTED;
478 mock_readonly_C_DestroyObject (CK_SESSION_HANDLE session,
479 CK_OBJECT_HANDLE object)
483 g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
485 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
486 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
488 return CKR_TOKEN_WRITE_PROTECTED;
492 mock_unsupported_C_GetObjectSize (CK_SESSION_HANDLE session,
493 CK_OBJECT_HANDLE object,
494 CK_ULONG_PTR pulSize)
496 return CKR_FUNCTION_NOT_SUPPORTED;
500 fill_data_attribute (CK_ATTRIBUTE *attr,
505 attr->ulValueLen = length;
507 } else if (attr->ulValueLen < length) {
508 attr->ulValueLen = length;
509 return CKR_BUFFER_TOO_SMALL;
511 memcpy (attr->pValue, data, length);
512 attr->ulValueLen = length;
518 fill_check_value_attribute (CK_ATTRIBUTE *attr,
519 GcrCertificate *cert)
525 data = gcr_certificate_get_fingerprint (cert, G_CHECKSUM_SHA1, &length);
526 rv = fill_data_attribute (attr, data, 3);
533 fill_subject_attribute (CK_ATTRIBUTE *attr,
534 GcrCertificate *cert)
540 data = gcr_certificate_get_subject_raw (cert, &length);
541 rv = fill_data_attribute (attr, data, length);
548 fill_issuer_attribute (CK_ATTRIBUTE *attr,
549 GcrCertificate *cert)
555 data = gcr_certificate_get_issuer_raw (cert, &length);
556 rv = fill_data_attribute (attr, data, length);
563 fill_serial_attribute (CK_ATTRIBUTE *attr,
564 GcrCertificate *cert)
570 data = gcr_certificate_get_serial_number (cert, &length);
571 rv = fill_data_attribute (attr, data, length);
578 fill_string_attribute (CK_ATTRIBUTE *attr,
581 return fill_data_attribute (attr, data, strlen (data));
585 fill_id_attribute (CK_ATTRIBUTE *attr,
586 GcrCertificate *cert)
591 data = g_strdup_printf ("%p", cert);
592 rv = fill_string_attribute (attr, data);
599 fill_value_attribute (CK_ATTRIBUTE *attr,
600 GcrCertificate *cert)
605 data = gcr_certificate_get_der_data (cert, &length);
606 return fill_data_attribute (attr, data, length);
610 fill_ulong_attribute (CK_ATTRIBUTE *attr,
613 return fill_data_attribute (attr, &value, sizeof (value));
617 fill_bool_attribute (CK_ATTRIBUTE *attr,
620 return fill_data_attribute (attr, &value, sizeof (value));
624 fill_certificate_attribute (CK_ATTRIBUTE *attr,
625 GcrCertificate *cert)
630 return fill_ulong_attribute (attr, CKO_CERTIFICATE);
632 return fill_bool_attribute (attr, CK_TRUE);
636 return fill_bool_attribute (attr, CK_FALSE);
638 return fill_string_attribute (attr, "Certificate");
639 case CKA_CERTIFICATE_TYPE:
640 return fill_ulong_attribute (attr, CKC_X_509);
641 case CKA_CERTIFICATE_CATEGORY:
642 return fill_ulong_attribute (attr, 2);
643 case CKA_CHECK_VALUE:
644 return fill_check_value_attribute (attr, cert);
647 return fill_data_attribute (attr, "", 0);
649 return fill_subject_attribute (attr, cert);
651 return fill_id_attribute (attr, cert);
653 return fill_issuer_attribute (attr, cert);
654 case CKA_SERIAL_NUMBER:
655 return fill_serial_attribute (attr, cert);
657 return fill_value_attribute (attr, cert);
659 case CKA_HASH_OF_SUBJECT_PUBLIC_KEY:
660 case CKA_HASH_OF_ISSUER_PUBLIC_KEY:
661 case CKA_JAVA_MIDP_SECURITY_DOMAIN:
663 return CKR_ATTRIBUTE_TYPE_INVALID;
668 fill_assertion_attribute (CK_ATTRIBUTE *attr,
669 Assertion *assertion)
676 return fill_ulong_attribute (attr, CKO_X_TRUST_ASSERTION);
678 return fill_bool_attribute (attr, CK_TRUE);
682 return fill_bool_attribute (attr, CK_FALSE);
684 return fill_string_attribute (attr, "Assertion");
685 case CKA_X_ASSERTION_TYPE:
686 return fill_ulong_attribute (attr, assertion->assertion_type);
688 return fill_string_attribute (attr, assertion->purpose);
690 if (!assertion->peer)
691 return CKR_ATTRIBUTE_TYPE_INVALID;
692 return fill_string_attribute (attr, assertion->peer);
693 case CKA_SERIAL_NUMBER:
695 return fill_certificate_attribute (attr, assertion->cert);
696 case CKA_X_CERTIFICATE_VALUE:
697 attr->type = CKA_VALUE;
698 rv = fill_certificate_attribute (attr, assertion->cert);
699 attr->type = CKA_X_CERTIFICATE_VALUE;
703 return CKR_ATTRIBUTE_TYPE_INVALID;
708 mock_C_GetAttributeValue (CK_SESSION_HANDLE session,
709 CK_OBJECT_HANDLE object,
710 CK_ATTRIBUTE_PTR template,
713 CK_RV rv, ret = CKR_OK;
714 GcrCertificate *cert;
715 Assertion *assertion;
719 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
720 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
722 cert = g_hash_table_lookup (the_certificates, GUINT_TO_POINTER (object));
723 assertion = g_hash_table_lookup (the_assertions, GUINT_TO_POINTER (object));
726 for (i = 0; i < count; i++) {
727 rv = fill_certificate_attribute (template + i, cert);
729 template[i].ulValueLen = (CK_ULONG)-1;
733 } else if (assertion != NULL) {
734 for (i = 0; i < count; i++) {
735 rv = fill_assertion_attribute (template + i, assertion);
737 template[i].ulValueLen = (CK_ULONG)-1;
742 ret = CKR_OBJECT_HANDLE_INVALID;
749 mock_readonly_C_SetAttributeValue (CK_SESSION_HANDLE session,
750 CK_OBJECT_HANDLE object,
751 CK_ATTRIBUTE_PTR template,
756 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
757 g_return_val_if_fail (sess, CKR_SESSION_HANDLE_INVALID);
759 return CKR_TOKEN_WRITE_PROTECTED;
763 match_object_attributes (CK_SESSION_HANDLE session,
765 CK_ATTRIBUTE_PTR template,
768 CK_ATTRIBUTE_PTR values;
769 gboolean mismatch = FALSE;
773 values = g_new0 (CK_ATTRIBUTE, count);
774 for (i = 0; i < count; i++) {
775 values[i].type = template[i].type;
776 if (template[i].ulValueLen != 0 &&
777 template[i].ulValueLen != (CK_ULONG)-1)
778 values[i].pValue = g_malloc (template[i].ulValueLen);
779 values[i].ulValueLen = template[i].ulValueLen;
782 rv = mock_C_GetAttributeValue (session, object, values, count);
785 for (i = 0; i < count; i++) {
786 if (gcr_comparable_memcmp (values[i].pValue, values[i].ulValueLen,
787 template[i].pValue, template[i].ulValueLen) != 0) {
794 for (i = 0; i < count; i++)
795 g_free (values[i].pValue);
805 mock_C_FindObjectsInit (CK_SESSION_HANDLE session,
806 CK_ATTRIBUTE_PTR template,
809 GList *objects = NULL, *l;
812 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
813 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
815 /* Starting an operation, cancels any previous one */
816 if (sess->operation != 0)
819 sess->operation = OP_FIND;
820 g_list_free (sess->matches);
821 sess->matches = NULL;
823 objects = g_list_concat (objects, g_hash_table_get_keys (the_certificates));
824 objects = g_list_concat (objects, g_hash_table_get_keys (the_assertions));
826 for (l = objects; l != NULL; l = g_list_next (l)) {
827 if (match_object_attributes (session, GPOINTER_TO_UINT (l->data), template, count))
828 sess->matches = g_list_prepend (sess->matches, l->data);
831 g_list_free (objects);
836 mock_C_FindObjects (CK_SESSION_HANDLE session,
837 CK_OBJECT_HANDLE_PTR object,
838 CK_ULONG max_object_count,
839 CK_ULONG_PTR object_count)
843 g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
844 g_return_val_if_fail (object_count, CKR_ARGUMENTS_BAD);
845 g_return_val_if_fail (max_object_count != 0, CKR_ARGUMENTS_BAD);
847 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
848 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
849 g_return_val_if_fail (sess->operation == OP_FIND, CKR_OPERATION_NOT_INITIALIZED);
852 while (max_object_count > 0 && sess->matches)
854 *object = GPOINTER_TO_UINT (sess->matches->data);
858 sess->matches = g_list_remove (sess->matches, sess->matches->data);
865 mock_C_FindObjectsFinal (CK_SESSION_HANDLE session)
869 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
870 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
871 g_return_val_if_fail (sess->operation == OP_FIND, CKR_OPERATION_NOT_INITIALIZED);
874 g_list_free (sess->matches);
875 sess->matches = NULL;
881 mock_no_mechanisms_C_EncryptInit (CK_SESSION_HANDLE session,
882 CK_MECHANISM_PTR mechanism,
883 CK_OBJECT_HANDLE key)
887 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
888 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
890 return CKR_MECHANISM_INVALID;
894 mock_not_initialized_C_Encrypt (CK_SESSION_HANDLE session,
897 CK_BYTE_PTR encrypted_data,
898 CK_ULONG_PTR encrypted_data_len)
900 return CKR_OPERATION_NOT_INITIALIZED;
904 mock_unsupported_C_EncryptUpdate (CK_SESSION_HANDLE session,
907 CK_BYTE_PTR encrypted_part,
908 CK_ULONG_PTR encrypted_part_len)
910 return CKR_FUNCTION_NOT_SUPPORTED;
914 mock_unsupported_C_EncryptFinal (CK_SESSION_HANDLE session,
915 CK_BYTE_PTR last_encrypted_part,
916 CK_ULONG_PTR last_encrypted_part_len)
918 return CKR_FUNCTION_NOT_SUPPORTED;
922 mock_no_mechanisms_C_DecryptInit (CK_SESSION_HANDLE session,
923 CK_MECHANISM_PTR mechanism,
924 CK_OBJECT_HANDLE key)
928 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
929 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
931 return CKR_MECHANISM_INVALID;
935 mock_not_initialized_C_Decrypt (CK_SESSION_HANDLE session,
936 CK_BYTE_PTR encrypted_data,
937 CK_ULONG encrypted_data_len,
939 CK_ULONG_PTR data_len)
941 return CKR_OPERATION_NOT_INITIALIZED;
945 mock_unsupported_C_DecryptUpdate (CK_SESSION_HANDLE session,
946 CK_BYTE_PTR encrypted_part,
947 CK_ULONG encrypted_key_len,
949 CK_ULONG_PTR part_len)
951 return CKR_FUNCTION_NOT_SUPPORTED;
955 mock_unsupported_C_DecryptFinal (CK_SESSION_HANDLE session,
956 CK_BYTE_PTR last_part,
957 CK_ULONG_PTR last_part_len)
959 return CKR_FUNCTION_NOT_SUPPORTED;
963 mock_unsupported_C_DigestInit (CK_SESSION_HANDLE session,
964 CK_MECHANISM_PTR mechanism)
966 return CKR_FUNCTION_NOT_SUPPORTED;
970 mock_unsupported_C_Digest (CK_SESSION_HANDLE session,
974 CK_ULONG_PTR digest_len)
976 return CKR_FUNCTION_NOT_SUPPORTED;
980 mock_unsupported_C_DigestUpdate (CK_SESSION_HANDLE session,
984 return CKR_FUNCTION_NOT_SUPPORTED;
988 mock_unsupported_C_DigestKey (CK_SESSION_HANDLE session,
989 CK_OBJECT_HANDLE key)
991 return CKR_FUNCTION_NOT_SUPPORTED;
995 mock_unsupported_C_DigestFinal (CK_SESSION_HANDLE session,
997 CK_ULONG_PTR digest_len)
999 return CKR_FUNCTION_NOT_SUPPORTED;
1003 mock_no_mechanisms_C_SignInit (CK_SESSION_HANDLE session,
1004 CK_MECHANISM_PTR mechanism,
1005 CK_OBJECT_HANDLE key)
1009 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1010 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1012 return CKR_MECHANISM_INVALID;
1016 mock_not_initialized_C_Sign (CK_SESSION_HANDLE session,
1019 CK_BYTE_PTR signature,
1020 CK_ULONG_PTR signature_len)
1022 return CKR_OPERATION_NOT_INITIALIZED;
1026 mock_unsupported_C_SignUpdate (CK_SESSION_HANDLE session,
1030 return CKR_FUNCTION_NOT_SUPPORTED;
1034 mock_unsupported_C_SignFinal (CK_SESSION_HANDLE session,
1035 CK_BYTE_PTR signature,
1036 CK_ULONG_PTR signature_len)
1038 return CKR_FUNCTION_NOT_SUPPORTED;
1042 mock_unsupported_C_SignRecoverInit (CK_SESSION_HANDLE session,
1043 CK_MECHANISM_PTR mechanism,
1044 CK_OBJECT_HANDLE key)
1046 return CKR_FUNCTION_NOT_SUPPORTED;
1050 mock_unsupported_C_SignRecover (CK_SESSION_HANDLE session,
1053 CK_BYTE_PTR signature,
1054 CK_ULONG_PTR signature_len)
1056 return CKR_FUNCTION_NOT_SUPPORTED;
1060 mock_no_mechanisms_C_VerifyInit (CK_SESSION_HANDLE session,
1061 CK_MECHANISM_PTR mechanism,
1062 CK_OBJECT_HANDLE key)
1066 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1067 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1069 return CKR_MECHANISM_INVALID;
1073 mock_not_initialized_C_Verify (CK_SESSION_HANDLE session,
1076 CK_BYTE_PTR signature,
1077 CK_ULONG signature_len)
1079 return CKR_OPERATION_NOT_INITIALIZED;
1083 mock_unsupported_C_VerifyUpdate (CK_SESSION_HANDLE session,
1087 return CKR_FUNCTION_NOT_SUPPORTED;
1091 mock_unsupported_C_VerifyFinal (CK_SESSION_HANDLE session,
1092 CK_BYTE_PTR signature,
1093 CK_ULONG signature_len)
1095 return CKR_FUNCTION_NOT_SUPPORTED;
1099 mock_unsupported_C_VerifyRecoverInit (CK_SESSION_HANDLE session,
1100 CK_MECHANISM_PTR mechanism,
1101 CK_OBJECT_HANDLE key)
1103 return CKR_FUNCTION_NOT_SUPPORTED;
1107 mock_unsupported_C_VerifyRecover (CK_SESSION_HANDLE session,
1108 CK_BYTE_PTR signature,
1109 CK_ULONG signature_len,
1111 CK_ULONG_PTR data_len)
1113 return CKR_FUNCTION_NOT_SUPPORTED;
1117 mock_unsupported_C_DigestEncryptUpdate (CK_SESSION_HANDLE session,
1120 CK_BYTE_PTR encrypted_part,
1121 CK_ULONG_PTR encrypted_key_len)
1123 return CKR_FUNCTION_NOT_SUPPORTED;
1127 mock_unsupported_C_DecryptDigestUpdate (CK_SESSION_HANDLE session,
1128 CK_BYTE_PTR encrypted_part,
1129 CK_ULONG encrypted_key_len,
1131 CK_ULONG_PTR part_len)
1133 return CKR_FUNCTION_NOT_SUPPORTED;
1137 mock_unsupported_C_SignEncryptUpdate (CK_SESSION_HANDLE session,
1140 CK_BYTE_PTR encrypted_part,
1141 CK_ULONG_PTR encrypted_key_len)
1143 return CKR_FUNCTION_NOT_SUPPORTED;
1147 mock_unsupported_C_DecryptVerifyUpdate (CK_SESSION_HANDLE session,
1148 CK_BYTE_PTR encrypted_part,
1149 CK_ULONG encrypted_key_len,
1151 CK_ULONG_PTR part_len)
1153 return CKR_FUNCTION_NOT_SUPPORTED;
1157 mock_unsupported_C_GenerateKey (CK_SESSION_HANDLE session,
1158 CK_MECHANISM_PTR mechanism,
1159 CK_ATTRIBUTE_PTR template,
1161 CK_OBJECT_HANDLE_PTR key)
1163 return CKR_FUNCTION_NOT_SUPPORTED;
1167 mock_no_mechanisms_C_GenerateKeyPair (CK_SESSION_HANDLE session,
1168 CK_MECHANISM_PTR mechanism,
1169 CK_ATTRIBUTE_PTR public_key_template,
1170 CK_ULONG public_key_attribute_count,
1171 CK_ATTRIBUTE_PTR private_key_template,
1172 CK_ULONG private_key_attribute_count,
1173 CK_OBJECT_HANDLE_PTR public_key,
1174 CK_OBJECT_HANDLE_PTR private_key)
1178 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1179 g_return_val_if_fail (public_key_template, CKR_TEMPLATE_INCOMPLETE);
1180 g_return_val_if_fail (public_key_attribute_count, CKR_TEMPLATE_INCOMPLETE);
1181 g_return_val_if_fail (private_key_template, CKR_TEMPLATE_INCOMPLETE);
1182 g_return_val_if_fail (private_key_attribute_count, CKR_TEMPLATE_INCOMPLETE);
1183 g_return_val_if_fail (public_key, CKR_ARGUMENTS_BAD);
1184 g_return_val_if_fail (private_key, CKR_ARGUMENTS_BAD);
1186 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1187 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1189 return CKR_MECHANISM_INVALID;
1193 mock_no_mechanisms_C_WrapKey (CK_SESSION_HANDLE session,
1194 CK_MECHANISM_PTR mechanism,
1195 CK_OBJECT_HANDLE wrapping_key,
1196 CK_OBJECT_HANDLE key,
1197 CK_BYTE_PTR wrapped_key,
1198 CK_ULONG_PTR wrapped_key_len)
1202 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1203 g_return_val_if_fail (wrapping_key, CKR_OBJECT_HANDLE_INVALID);
1204 g_return_val_if_fail (key, CKR_OBJECT_HANDLE_INVALID);
1205 g_return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
1207 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1208 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1210 return CKR_MECHANISM_INVALID;
1214 mock_no_mechanisms_C_UnwrapKey (CK_SESSION_HANDLE session,
1215 CK_MECHANISM_PTR mechanism,
1216 CK_OBJECT_HANDLE unwrapping_key,
1217 CK_BYTE_PTR wrapped_key,
1218 CK_ULONG wrapped_key_len,
1219 CK_ATTRIBUTE_PTR template,
1221 CK_OBJECT_HANDLE_PTR key)
1225 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1226 g_return_val_if_fail (unwrapping_key, CKR_WRAPPING_KEY_HANDLE_INVALID);
1227 g_return_val_if_fail (wrapped_key, CKR_WRAPPED_KEY_INVALID);
1228 g_return_val_if_fail (wrapped_key_len, CKR_WRAPPED_KEY_LEN_RANGE);
1229 g_return_val_if_fail (key, CKR_ARGUMENTS_BAD);
1230 g_return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
1231 g_return_val_if_fail (count, CKR_TEMPLATE_INCONSISTENT);
1233 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1234 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1236 return CKR_MECHANISM_INVALID;
1240 mock_no_mechanisms_C_DeriveKey (CK_SESSION_HANDLE session,
1241 CK_MECHANISM_PTR mechanism,
1242 CK_OBJECT_HANDLE base_key,
1243 CK_ATTRIBUTE_PTR template,
1245 CK_OBJECT_HANDLE_PTR key)
1249 g_return_val_if_fail (mechanism, CKR_MECHANISM_INVALID);
1250 g_return_val_if_fail (count, CKR_TEMPLATE_INCOMPLETE);
1251 g_return_val_if_fail (template, CKR_TEMPLATE_INCOMPLETE);
1252 g_return_val_if_fail (key, CKR_ARGUMENTS_BAD);
1254 sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1255 g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1257 return CKR_MECHANISM_INVALID;
1261 mock_unsupported_C_SeedRandom (CK_SESSION_HANDLE session,
1265 return CKR_FUNCTION_NOT_SUPPORTED;
1269 mock_unsupported_C_GenerateRandom (CK_SESSION_HANDLE session,
1270 CK_BYTE_PTR random_data,
1271 CK_ULONG random_len)
1273 return CKR_FUNCTION_NOT_SUPPORTED;
1276 CK_FUNCTION_LIST mock_default_functions = {
1277 { 2, 11 }, /* version */
1281 mock_C_GetFunctionList,
1284 mock_C_GetTokenInfo,
1285 mock_C_GetMechanismList,
1286 mock_C_GetMechanismInfo,
1287 mock_unsupported_C_InitToken,
1288 mock_unsupported_C_InitPIN,
1289 mock_unsupported_C_SetPIN,
1291 mock_C_CloseSession,
1292 mock_C_CloseAllSessions,
1293 mock_C_GetSessionInfo,
1294 mock_unsupported_C_GetOperationState,
1295 mock_unsupported_C_SetOperationState,
1296 mock_unsupported_C_Login,
1297 mock_unsupported_C_Logout,
1298 mock_readonly_C_CreateObject,
1299 mock_unsupported_C_CopyObject,
1300 mock_readonly_C_DestroyObject,
1301 mock_unsupported_C_GetObjectSize,
1302 mock_C_GetAttributeValue,
1303 mock_readonly_C_SetAttributeValue,
1304 mock_C_FindObjectsInit,
1306 mock_C_FindObjectsFinal,
1307 mock_no_mechanisms_C_EncryptInit,
1308 mock_not_initialized_C_Encrypt,
1309 mock_unsupported_C_EncryptUpdate,
1310 mock_unsupported_C_EncryptFinal,
1311 mock_no_mechanisms_C_DecryptInit,
1312 mock_not_initialized_C_Decrypt,
1313 mock_unsupported_C_DecryptUpdate,
1314 mock_unsupported_C_DecryptFinal,
1315 mock_unsupported_C_DigestInit,
1316 mock_unsupported_C_Digest,
1317 mock_unsupported_C_DigestUpdate,
1318 mock_unsupported_C_DigestKey,
1319 mock_unsupported_C_DigestFinal,
1320 mock_no_mechanisms_C_SignInit,
1321 mock_not_initialized_C_Sign,
1322 mock_unsupported_C_SignUpdate,
1323 mock_unsupported_C_SignFinal,
1324 mock_unsupported_C_SignRecoverInit,
1325 mock_unsupported_C_SignRecover,
1326 mock_no_mechanisms_C_VerifyInit,
1327 mock_not_initialized_C_Verify,
1328 mock_unsupported_C_VerifyUpdate,
1329 mock_unsupported_C_VerifyFinal,
1330 mock_unsupported_C_VerifyRecoverInit,
1331 mock_unsupported_C_VerifyRecover,
1332 mock_unsupported_C_DigestEncryptUpdate,
1333 mock_unsupported_C_DecryptDigestUpdate,
1334 mock_unsupported_C_SignEncryptUpdate,
1335 mock_unsupported_C_DecryptVerifyUpdate,
1336 mock_unsupported_C_GenerateKey,
1337 mock_no_mechanisms_C_GenerateKeyPair,
1338 mock_no_mechanisms_C_WrapKey,
1339 mock_no_mechanisms_C_UnwrapKey,
1340 mock_no_mechanisms_C_DeriveKey,
1341 mock_unsupported_C_SeedRandom,
1342 mock_unsupported_C_GenerateRandom,
1343 mock_C_GetFunctionStatus,
1344 mock_C_CancelFunction,
1345 mock_unsupported_C_WaitForSlotEvent