tests/mock-pkcs11.c

   1 /*
   2  * Copyright (C) 2010 Stefan Walter
   3  * Copyright (C) 2011 Collabora Ltd.
   4  *
   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.
   9  *
  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.
  14  *
  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
  18  * 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "mock-pkcs11.h"
  23
  24 #include <string.h>
  25
  26 /*
  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.
  30  */
  31
  32 static gboolean initialized = FALSE;
  33
  34 typedef enum {
  35   OP_FIND = 1,
  36 } Operation;
  37
  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;
  42
  43 typedef struct {
  44   GcrCertificate *cert;
  45   CK_ULONG assertion_type;
  46   gchar *purpose;
  47   gchar *peer;
  48 } Assertion;
  49
  50 static void
  51 free_assertion (gpointer data)
  52 {
  53   Assertion *assertion = data;
  54   g_clear_object (&assertion->cert);
  55   g_free (assertion->purpose);
  56   g_free (assertion->peer);
  57   g_free (assertion);
  58 }
  59
  60 typedef struct {
  61   CK_SESSION_HANDLE handle;
  62   CK_SESSION_INFO info;
  63
  64   Operation operation;
  65
  66   /* For find operations */
  67   GList *matches;
  68 } Session;
  69
  70 static void
  71 free_session (gpointer data)
  72 {
  73   Session *sess = (Session *) data;
  74   g_list_free (sess->matches);
  75   g_free (sess);
  76 }
  77
  78 CK_OBJECT_HANDLE
  79 mock_module_add_certificate (GcrCertificate *cert)
  80 {
  81   CK_OBJECT_HANDLE handle;
  82
  83   g_return_val_if_fail (GCR_IS_CERTIFICATE (cert), 0);
  84
  85   handle = unique_identifier++;
  86   g_hash_table_insert (the_certificates, GUINT_TO_POINTER (handle), g_object_ref (cert));
  87   return handle;
  88 }
  89
  90 CK_OBJECT_HANDLE
  91 mock_module_add_assertion (GcrCertificate *cert,
  92                            CK_X_ASSERTION_TYPE assertion_type,
  93                            const gchar *purpose,
  94                            const gchar *peer)
  95 {
  96   Assertion *assertion;
  97   CK_OBJECT_HANDLE handle;
  98
  99   g_return_val_if_fail (GCR_IS_CERTIFICATE (cert), 0);
 100
 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);
 106
 107   handle = unique_identifier++;
 108   g_hash_table_insert (the_assertions, GUINT_TO_POINTER (handle), assertion);
 109   return handle;
 110 }
 111
 112 CK_RV
 113 mock_C_Initialize (CK_VOID_PTR init_args)
 114 {
 115   CK_C_INITIALIZE_ARGS_PTR args;
 116
 117   g_return_val_if_fail (initialized == FALSE, CKR_CRYPTOKI_ALREADY_INITIALIZED);
 118
 119   args = (CK_C_INITIALIZE_ARGS_PTR)init_args;
 120   if (args)
 121     {
 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),
 127           CKR_ARGUMENTS_BAD);
 128
 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);
 132     }
 133
 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);
 137
 138   initialized = TRUE;
 139   return CKR_OK;
 140 }
 141
 142 CK_RV
 143 mock_C_Finalize (CK_VOID_PTR reserved)
 144 {
 145   g_return_val_if_fail (reserved == NULL, CKR_ARGUMENTS_BAD);
 146   g_return_val_if_fail (initialized == TRUE, CKR_CRYPTOKI_NOT_INITIALIZED);
 147
 148   initialized = FALSE;
 149
 150   g_hash_table_destroy (the_certificates);
 151   the_certificates = NULL;
 152
 153   g_hash_table_destroy (the_assertions);
 154   the_assertions = NULL;
 155
 156   g_hash_table_destroy (the_sessions);
 157   the_sessions = NULL;
 158
 159   return CKR_OK;
 160 }
 161
 162 static const CK_INFO TEST_INFO = {
 163   { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
 164   "TEST MANUFACTURER              ",
 165   0,
 166   "TEST LIBRARY                   ",
 167   { 45, 145 }
 168 };
 169
 170 CK_RV
 171 mock_C_GetInfo (CK_INFO_PTR info)
 172 {
 173   g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
 174   memcpy (info, &TEST_INFO, sizeof (*info));
 175   return CKR_OK;
 176 }
 177
 178 CK_RV
 179 mock_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
 180 {
 181   g_return_val_if_fail (list, CKR_ARGUMENTS_BAD);
 182   *list = &mock_default_functions;
 183   return CKR_OK;
 184 }
 185
 186 CK_RV
 187 mock_C_GetSlotList (CK_BBOOL token_present,
 188                     CK_SLOT_ID_PTR slot_list,
 189                     CK_ULONG_PTR count)
 190 {
 191   CK_ULONG num = 1;
 192
 193   g_return_val_if_fail (count, CKR_ARGUMENTS_BAD);
 194
 195   /* Application only wants to know the number of slots. */
 196   if (slot_list == NULL)
 197     {
 198       *count = num;
 199       return CKR_OK;
 200     }
 201
 202   if (*count < num)
 203     g_return_val_if_reached (CKR_BUFFER_TOO_SMALL);
 204
 205   *count = num;
 206   slot_list[0] = MOCK_SLOT_ONE_ID;
 207   return CKR_OK;
 208 }
 209
 210 /* Update mock-pkcs11.h URIs when updating this */
 211
 212 static const CK_SLOT_INFO MOCK_INFO_ONE = {
 213   "MOCK SLOT                                                       ",
 214   "MOCK MANUFACTURER              ",
 215   CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE,
 216   { 55, 155 },
 217   { 65, 165 },
 218 };
 219
 220 CK_RV
 221 mock_C_GetSlotInfo (CK_SLOT_ID slot_id,
 222                     CK_SLOT_INFO_PTR info)
 223 {
 224   g_return_val_if_fail (info, CKR_ARGUMENTS_BAD);
 225
 226   if (slot_id == MOCK_SLOT_ONE_ID)
 227     {
 228       memcpy (info, &MOCK_INFO_ONE, sizeof (*info));
 229       return CKR_OK;
 230     }
 231   else
 232     {
 233       g_return_val_if_reached (CKR_SLOT_ID_INVALID);
 234     }
 235 }
 236
 237 /* Update mock-pkcs11.h URIs when updating this */
 238
 239 static const CK_TOKEN_INFO MOCK_TOKEN_ONE = {
 240   "MOCK LABEL                      ",
 241   "MOCK MANUFACTURER               ",
 242   "MOCK MODEL      ",
 243   "MOCK SERIAL     ",
 244   CKF_TOKEN_INITIALIZED | CKF_WRITE_PROTECTED,
 245   1,
 246   2,
 247   3,
 248   4,
 249   5,
 250   6,
 251   7,
 252   8,
 253   9,
 254   10,
 255   { 75, 175 },
 256   { 85, 185 },
 257   { '1', '9', '9', '9', '0', '5', '2', '5', '0', '9', '1', '9', '5', '9', '0', '0' }
 258 };
 259
 260 CK_RV
 261 mock_C_GetTokenInfo (CK_SLOT_ID slot_id,
 262                      CK_TOKEN_INFO_PTR info)
 263 {
 264   g_return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
 265
 266   if (slot_id == MOCK_SLOT_ONE_ID)
 267     {
 268       memcpy (info, &MOCK_TOKEN_ONE, sizeof (*info));
 269       return CKR_OK;
 270     }
 271   else
 272     {
 273       g_return_val_if_reached (CKR_SLOT_ID_INVALID);
 274     }
 275 }
 276
 277 CK_RV
 278 mock_C_GetMechanismList (CK_SLOT_ID slot_id,
 279                          CK_MECHANISM_TYPE_PTR mechanism_list,
 280                          CK_ULONG_PTR count)
 281 {
 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);
 284
 285   /* Application only wants to know the number of slots. */
 286   if (mechanism_list == NULL)
 287     {
 288       *count = 0;
 289       return CKR_OK;
 290     }
 291
 292   return CKR_OK;
 293 }
 294
 295 CK_RV
 296 mock_C_GetMechanismInfo (CK_SLOT_ID slot_id,
 297                          CK_MECHANISM_TYPE type,
 298                          CK_MECHANISM_INFO_PTR info)
 299 {
 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);
 302
 303   g_return_val_if_reached (CKR_MECHANISM_INVALID);
 304 }
 305
 306 CK_RV
 307 mock_unsupported_C_InitToken (CK_SLOT_ID slot_id,
 308                               CK_UTF8CHAR_PTR pin,
 309                               CK_ULONG pin_len,
 310                               CK_UTF8CHAR_PTR label)
 311 {
 312   g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
 313   return CKR_FUNCTION_NOT_SUPPORTED;
 314 }
 315
 316 CK_RV
 317 mock_unsupported_C_WaitForSlotEvent (CK_FLAGS flags,
 318                                      CK_SLOT_ID_PTR slot_id,
 319                                      CK_VOID_PTR reserved)
 320 {
 321   return CKR_FUNCTION_NOT_SUPPORTED;
 322 }
 323
 324 CK_RV
 325 mock_C_OpenSession (CK_SLOT_ID slot_id,
 326                     CK_FLAGS flags,
 327                     CK_VOID_PTR application,
 328                     CK_NOTIFY notify,
 329                     CK_SESSION_HANDLE_PTR session)
 330 {
 331   Session *sess;
 332
 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);
 336
 337   if (flags & CKF_RW_SESSION)
 338     return CKR_TOKEN_WRITE_PROTECTED;
 339
 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;
 347
 348   g_hash_table_replace (the_sessions, GUINT_TO_POINTER (sess->handle), sess);
 349   return CKR_OK;
 350 }
 351
 352 CK_RV
 353 mock_C_CloseSession (CK_SESSION_HANDLE session)
 354 {
 355   Session *sess;
 356
 357   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 358   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 359
 360   g_hash_table_remove (the_sessions, GUINT_TO_POINTER (sess));
 361   return CKR_OK;
 362 }
 363
 364 CK_RV
 365 mock_C_CloseAllSessions (CK_SLOT_ID slot_id)
 366 {
 367   g_return_val_if_fail (slot_id == MOCK_SLOT_ONE_ID, CKR_SLOT_ID_INVALID);
 368
 369   g_hash_table_remove_all (the_sessions);
 370   return CKR_OK;
 371 }
 372
 373 CK_RV
 374 mock_C_GetFunctionStatus (CK_SESSION_HANDLE session)
 375 {
 376   return CKR_FUNCTION_NOT_PARALLEL;
 377 }
 378
 379 CK_RV
 380 mock_C_CancelFunction (CK_SESSION_HANDLE session)
 381 {
 382   return CKR_FUNCTION_NOT_PARALLEL;
 383 }
 384
 385 CK_RV
 386 mock_C_GetSessionInfo (CK_SESSION_HANDLE session,
 387                        CK_SESSION_INFO_PTR info)
 388 {
 389   Session *sess;
 390
 391   g_return_val_if_fail (info != NULL, CKR_ARGUMENTS_BAD);
 392
 393   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 394   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 395
 396   memcpy (info, &sess->info, sizeof (*info));
 397   return CKR_OK;
 398 }
 399
 400 CK_RV
 401 mock_unsupported_C_InitPIN (CK_SESSION_HANDLE session,
 402                             CK_UTF8CHAR_PTR pin,
 403                             CK_ULONG pin_len)
 404 {
 405   return CKR_FUNCTION_NOT_SUPPORTED;
 406 }
 407
 408 CK_RV
 409 mock_unsupported_C_SetPIN (CK_SESSION_HANDLE session,
 410                            CK_UTF8CHAR_PTR old_pin,
 411                            CK_ULONG old_len,
 412                            CK_UTF8CHAR_PTR new_pin,
 413                            CK_ULONG new_len)
 414 {
 415   return CKR_FUNCTION_NOT_SUPPORTED;
 416 }
 417
 418 CK_RV
 419 mock_unsupported_C_GetOperationState (CK_SESSION_HANDLE session,
 420                                       CK_BYTE_PTR operation_state,
 421                                       CK_ULONG_PTR operation_state_len)
 422 {
 423   return CKR_FUNCTION_NOT_SUPPORTED;
 424 }
 425
 426 CK_RV
 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)
 432 {
 433   return CKR_FUNCTION_NOT_SUPPORTED;
 434 }
 435
 436 CK_RV
 437 mock_unsupported_C_Login (CK_SESSION_HANDLE session,
 438                           CK_USER_TYPE user_type,
 439                           CK_UTF8CHAR_PTR pin,
 440                           CK_ULONG pin_len)
 441 {
 442   return CKR_FUNCTION_NOT_SUPPORTED;
 443 }
 444
 445 CK_RV
 446 mock_unsupported_C_Logout (CK_SESSION_HANDLE session)
 447 {
 448   return CKR_FUNCTION_NOT_SUPPORTED;
 449 }
 450
 451 CK_RV
 452 mock_readonly_C_CreateObject (CK_SESSION_HANDLE session,
 453                               CK_ATTRIBUTE_PTR template,
 454                               CK_ULONG count,
 455                               CK_OBJECT_HANDLE_PTR object)
 456 {
 457   Session *sess;
 458
 459   g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
 460
 461   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 462   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 463
 464   return CKR_TOKEN_WRITE_PROTECTED;
 465 }
 466
 467 CK_RV
 468 mock_unsupported_C_CopyObject (CK_SESSION_HANDLE session,
 469                                CK_OBJECT_HANDLE object,
 470                                CK_ATTRIBUTE_PTR template,
 471                                CK_ULONG count,
 472                                CK_OBJECT_HANDLE_PTR new_object)
 473 {
 474   return CKR_FUNCTION_NOT_SUPPORTED;
 475 }
 476
 477 CK_RV
 478 mock_readonly_C_DestroyObject (CK_SESSION_HANDLE session,
 479                                CK_OBJECT_HANDLE object)
 480 {
 481   Session *sess;
 482
 483   g_return_val_if_fail (object, CKR_ARGUMENTS_BAD);
 484
 485   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 486   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 487
 488   return CKR_TOKEN_WRITE_PROTECTED;
 489 }
 490
 491 CK_RV
 492 mock_unsupported_C_GetObjectSize (CK_SESSION_HANDLE session,
 493                                   CK_OBJECT_HANDLE object,
 494                                   CK_ULONG_PTR pulSize)
 495 {
 496   return CKR_FUNCTION_NOT_SUPPORTED;
 497 }
 498
 499 static CK_RV
 500 fill_data_attribute (CK_ATTRIBUTE *attr,
 501                      gconstpointer data,
 502                      gsize length)
 503 {
 504   if (!attr->pValue) {
 505       attr->ulValueLen = length;
 506       return CKR_OK;
 507   } else if (attr->ulValueLen < length) {
 508       attr->ulValueLen = length;
 509       return CKR_BUFFER_TOO_SMALL;
 510   } else {
 511       memcpy (attr->pValue, data, length);
 512       attr->ulValueLen = length;
 513       return CKR_OK;
 514   }
 515 }
 516
 517 static CK_RV
 518 fill_check_value_attribute (CK_ATTRIBUTE *attr,
 519                             GcrCertificate *cert)
 520 {
 521   guchar *data;
 522   gsize length;
 523   CK_RV rv;
 524
 525   data = gcr_certificate_get_fingerprint (cert, G_CHECKSUM_SHA1, &length);
 526   rv = fill_data_attribute (attr, data, 3);
 527   g_free (data);
 528
 529   return rv;
 530 }
 531
 532 static CK_RV
 533 fill_subject_attribute (CK_ATTRIBUTE *attr,
 534                         GcrCertificate *cert)
 535 {
 536   guchar *data;
 537   gsize length;
 538   CK_RV rv;
 539
 540   data = gcr_certificate_get_subject_raw (cert, &length);
 541   rv = fill_data_attribute (attr, data, length);
 542   g_free (data);
 543
 544   return rv;
 545 }
 546
 547 static CK_RV
 548 fill_issuer_attribute (CK_ATTRIBUTE *attr,
 549                        GcrCertificate *cert)
 550 {
 551   guchar *data;
 552   gsize length;
 553   CK_RV rv;
 554
 555   data = gcr_certificate_get_issuer_raw (cert, &length);
 556   rv = fill_data_attribute (attr, data, length);
 557   g_free (data);
 558
 559   return rv;
 560 }
 561
 562 static CK_RV
 563 fill_serial_attribute (CK_ATTRIBUTE *attr,
 564                        GcrCertificate *cert)
 565 {
 566   guchar *data;
 567   gsize length;
 568   CK_RV rv;
 569
 570   data = gcr_certificate_get_serial_number (cert, &length);
 571   rv = fill_data_attribute (attr, data, length);
 572   g_free (data);
 573
 574   return rv;
 575 }
 576
 577 static CK_RV
 578 fill_string_attribute (CK_ATTRIBUTE *attr,
 579                        const gchar *data)
 580 {
 581   return fill_data_attribute (attr, data, strlen (data));
 582 }
 583
 584 static CK_RV
 585 fill_id_attribute (CK_ATTRIBUTE *attr,
 586                    GcrCertificate *cert)
 587 {
 588   gchar *data;
 589   CK_RV rv;
 590
 591   data = g_strdup_printf ("%p", cert);
 592   rv = fill_string_attribute (attr, data);
 593   g_free (data);
 594
 595   return rv;
 596 }
 597
 598 static CK_RV
 599 fill_value_attribute (CK_ATTRIBUTE *attr,
 600                       GcrCertificate *cert)
 601 {
 602   const guchar *data;
 603   gsize length;
 604
 605   data = gcr_certificate_get_der_data (cert, &length);
 606   return fill_data_attribute (attr, data, length);
 607 }
 608
 609 static CK_RV
 610 fill_ulong_attribute (CK_ATTRIBUTE *attr,
 611                       CK_ULONG value)
 612 {
 613   return fill_data_attribute (attr, &value, sizeof (value));
 614 }
 615
 616 static CK_RV
 617 fill_bool_attribute (CK_ATTRIBUTE *attr,
 618                      CK_BBOOL value)
 619 {
 620   return fill_data_attribute (attr, &value, sizeof (value));
 621 }
 622
 623 static CK_RV
 624 fill_certificate_attribute (CK_ATTRIBUTE *attr,
 625                             GcrCertificate *cert)
 626 {
 627   switch (attr->type)
 628   {
 629   case CKA_CLASS:
 630     return fill_ulong_attribute (attr, CKO_CERTIFICATE);
 631   case CKA_TOKEN:
 632     return fill_bool_attribute (attr, CK_TRUE);
 633   case CKA_PRIVATE:
 634   case CKA_MODIFIABLE:
 635   case CKA_TRUSTED:
 636     return fill_bool_attribute (attr, CK_FALSE);
 637   case CKA_LABEL:
 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);
 645   case CKA_START_DATE:
 646   case CKA_END_DATE:
 647     return fill_data_attribute (attr, "", 0);
 648   case CKA_SUBJECT:
 649     return fill_subject_attribute (attr, cert);
 650   case CKA_ID:
 651     return fill_id_attribute (attr, cert);
 652   case CKA_ISSUER:
 653     return fill_issuer_attribute (attr, cert);
 654   case CKA_SERIAL_NUMBER:
 655     return fill_serial_attribute (attr, cert);
 656   case CKA_VALUE:
 657     return fill_value_attribute (attr, cert);
 658   case CKA_URL:
 659   case CKA_HASH_OF_SUBJECT_PUBLIC_KEY:
 660   case CKA_HASH_OF_ISSUER_PUBLIC_KEY:
 661   case CKA_JAVA_MIDP_SECURITY_DOMAIN:
 662   default:
 663     return CKR_ATTRIBUTE_TYPE_INVALID;
 664   }
 665 }
 666
 667 static CK_RV
 668 fill_assertion_attribute (CK_ATTRIBUTE *attr,
 669                           Assertion *assertion)
 670 {
 671   CK_RV rv;
 672
 673   switch (attr->type)
 674   {
 675   case CKA_CLASS:
 676     return fill_ulong_attribute (attr, CKO_X_TRUST_ASSERTION);
 677   case CKA_TOKEN:
 678     return fill_bool_attribute (attr, CK_TRUE);
 679   case CKA_PRIVATE:
 680   case CKA_MODIFIABLE:
 681   case CKA_TRUSTED:
 682     return fill_bool_attribute (attr, CK_FALSE);
 683   case CKA_LABEL:
 684     return fill_string_attribute (attr, "Assertion");
 685   case CKA_X_ASSERTION_TYPE:
 686     return fill_ulong_attribute (attr, assertion->assertion_type);
 687   case CKA_X_PURPOSE:
 688     return fill_string_attribute (attr, assertion->purpose);
 689   case CKA_X_PEER:
 690     if (!assertion->peer)
 691       return CKR_ATTRIBUTE_TYPE_INVALID;
 692     return fill_string_attribute (attr, assertion->peer);
 693   case CKA_SERIAL_NUMBER:
 694   case CKA_ISSUER:
 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;
 700     return rv;
 701
 702   default:
 703     return CKR_ATTRIBUTE_TYPE_INVALID;
 704   }
 705 }
 706
 707 CK_RV
 708 mock_C_GetAttributeValue (CK_SESSION_HANDLE session,
 709                           CK_OBJECT_HANDLE object,
 710                           CK_ATTRIBUTE_PTR template,
 711                           CK_ULONG count)
 712 {
 713   CK_RV rv, ret = CKR_OK;
 714   GcrCertificate *cert;
 715   Assertion *assertion;
 716   Session *sess;
 717   CK_ULONG i;
 718
 719   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 720   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 721
 722   cert = g_hash_table_lookup (the_certificates, GUINT_TO_POINTER (object));
 723   assertion = g_hash_table_lookup (the_assertions, GUINT_TO_POINTER (object));
 724
 725   if (cert != NULL) {
 726       for (i = 0; i < count; i++) {
 727           rv = fill_certificate_attribute (template + i, cert);
 728           if (rv != CKR_OK)
 729             template[i].ulValueLen = (CK_ULONG)-1;
 730           if (ret != CKR_OK)
 731             ret = rv;
 732       }
 733   } else if (assertion != NULL) {
 734       for (i = 0; i < count; i++) {
 735           rv = fill_assertion_attribute (template + i, assertion);
 736           if (rv != CKR_OK)
 737             template[i].ulValueLen = (CK_ULONG)-1;
 738           if (ret != CKR_OK)
 739             ret = rv;
 740       }
 741   } else {
 742       ret = CKR_OBJECT_HANDLE_INVALID;
 743   }
 744
 745   return ret;
 746 }
 747
 748 CK_RV
 749 mock_readonly_C_SetAttributeValue (CK_SESSION_HANDLE session,
 750                                    CK_OBJECT_HANDLE object,
 751                                    CK_ATTRIBUTE_PTR template,
 752                                    CK_ULONG count)
 753 {
 754   Session *sess;
 755
 756   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 757   g_return_val_if_fail (sess, CKR_SESSION_HANDLE_INVALID);
 758
 759   return CKR_TOKEN_WRITE_PROTECTED;
 760 }
 761
 762 static gboolean
 763 match_object_attributes (CK_SESSION_HANDLE session,
 764                          CK_ULONG object,
 765                          CK_ATTRIBUTE_PTR template,
 766                          CK_ULONG count)
 767 {
 768   CK_ATTRIBUTE_PTR values;
 769   gboolean mismatch = FALSE;
 770   CK_RV rv;
 771   CK_ULONG i;
 772
 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;
 780   }
 781
 782   rv = mock_C_GetAttributeValue (session, object, values, count);
 783
 784   if (rv == CKR_OK) {
 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) {
 788             mismatch = TRUE;
 789             break;
 790           }
 791       }
 792   }
 793
 794   for (i = 0; i < count; i++)
 795       g_free (values[i].pValue);
 796   g_free (values);
 797
 798   if (rv != CKR_OK)
 799     return FALSE;
 800
 801   return !mismatch;
 802 }
 803
 804 CK_RV
 805 mock_C_FindObjectsInit (CK_SESSION_HANDLE session,
 806                         CK_ATTRIBUTE_PTR template,
 807                         CK_ULONG count)
 808 {
 809   GList *objects = NULL, *l;
 810   Session *sess;
 811
 812   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 813   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 814
 815   /* Starting an operation, cancels any previous one */
 816   if (sess->operation != 0)
 817     sess->operation = 0;
 818
 819   sess->operation = OP_FIND;
 820   g_list_free (sess->matches);
 821   sess->matches = NULL;
 822
 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));
 825
 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);
 829   }
 830
 831   g_list_free (objects);
 832   return CKR_OK;
 833 }
 834
 835 CK_RV
 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)
 840 {
 841   Session *sess;
 842
 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);
 846
 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);
 850
 851   *object_count = 0;
 852   while (max_object_count > 0 && sess->matches)
 853     {
 854       *object = GPOINTER_TO_UINT (sess->matches->data);
 855       ++object;
 856       --max_object_count;
 857       ++(*object_count);
 858       sess->matches = g_list_remove (sess->matches, sess->matches->data);
 859     }
 860
 861   return CKR_OK;
 862 }
 863
 864 CK_RV
 865 mock_C_FindObjectsFinal (CK_SESSION_HANDLE session)
 866 {
 867   Session *sess;
 868
 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);
 872
 873   sess->operation = 0;
 874   g_list_free (sess->matches);
 875   sess->matches = NULL;
 876
 877   return CKR_OK;
 878 }
 879
 880 CK_RV
 881 mock_no_mechanisms_C_EncryptInit (CK_SESSION_HANDLE session,
 882                                   CK_MECHANISM_PTR mechanism,
 883                                   CK_OBJECT_HANDLE key)
 884 {
 885   Session *sess;
 886
 887   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 888   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 889
 890   return CKR_MECHANISM_INVALID;
 891 }
 892
 893 CK_RV
 894 mock_not_initialized_C_Encrypt (CK_SESSION_HANDLE session,
 895                                 CK_BYTE_PTR data,
 896                                 CK_ULONG data_len,
 897                                 CK_BYTE_PTR encrypted_data,
 898                                 CK_ULONG_PTR encrypted_data_len)
 899 {
 900   return CKR_OPERATION_NOT_INITIALIZED;
 901 }
 902
 903 CK_RV
 904 mock_unsupported_C_EncryptUpdate (CK_SESSION_HANDLE session,
 905                                   CK_BYTE_PTR part,
 906                                   CK_ULONG part_len,
 907                                   CK_BYTE_PTR encrypted_part,
 908                                   CK_ULONG_PTR encrypted_part_len)
 909 {
 910   return CKR_FUNCTION_NOT_SUPPORTED;
 911 }
 912
 913 CK_RV
 914 mock_unsupported_C_EncryptFinal (CK_SESSION_HANDLE session,
 915                                  CK_BYTE_PTR last_encrypted_part,
 916                                  CK_ULONG_PTR last_encrypted_part_len)
 917 {
 918   return CKR_FUNCTION_NOT_SUPPORTED;
 919 }
 920
 921 CK_RV
 922 mock_no_mechanisms_C_DecryptInit (CK_SESSION_HANDLE session,
 923                                   CK_MECHANISM_PTR mechanism,
 924                                   CK_OBJECT_HANDLE key)
 925 {
 926   Session *sess;
 927
 928   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
 929   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
 930
 931   return CKR_MECHANISM_INVALID;
 932 }
 933
 934 CK_RV
 935 mock_not_initialized_C_Decrypt (CK_SESSION_HANDLE session,
 936                                 CK_BYTE_PTR encrypted_data,
 937                                 CK_ULONG encrypted_data_len,
 938                                 CK_BYTE_PTR data,
 939                                 CK_ULONG_PTR data_len)
 940 {
 941   return CKR_OPERATION_NOT_INITIALIZED;
 942 }
 943
 944 CK_RV
 945 mock_unsupported_C_DecryptUpdate (CK_SESSION_HANDLE session,
 946                                   CK_BYTE_PTR encrypted_part,
 947                                   CK_ULONG encrypted_key_len,
 948                                   CK_BYTE_PTR part,
 949                                   CK_ULONG_PTR part_len)
 950 {
 951   return CKR_FUNCTION_NOT_SUPPORTED;
 952 }
 953
 954 CK_RV
 955 mock_unsupported_C_DecryptFinal (CK_SESSION_HANDLE session,
 956                                  CK_BYTE_PTR last_part,
 957                                  CK_ULONG_PTR last_part_len)
 958 {
 959   return CKR_FUNCTION_NOT_SUPPORTED;
 960 }
 961
 962 CK_RV
 963 mock_unsupported_C_DigestInit (CK_SESSION_HANDLE session,
 964                                CK_MECHANISM_PTR mechanism)
 965 {
 966   return CKR_FUNCTION_NOT_SUPPORTED;
 967 }
 968
 969 CK_RV
 970 mock_unsupported_C_Digest (CK_SESSION_HANDLE session,
 971                            CK_BYTE_PTR data,
 972                            CK_ULONG data_len,
 973                            CK_BYTE_PTR digest,
 974                            CK_ULONG_PTR digest_len)
 975 {
 976   return CKR_FUNCTION_NOT_SUPPORTED;
 977 }
 978
 979 CK_RV
 980 mock_unsupported_C_DigestUpdate (CK_SESSION_HANDLE session,
 981                                  CK_BYTE_PTR part,
 982                                  CK_ULONG part_len)
 983 {
 984   return CKR_FUNCTION_NOT_SUPPORTED;
 985 }
 986
 987 CK_RV
 988 mock_unsupported_C_DigestKey (CK_SESSION_HANDLE session,
 989                               CK_OBJECT_HANDLE key)
 990 {
 991   return CKR_FUNCTION_NOT_SUPPORTED;
 992 }
 993
 994 CK_RV
 995 mock_unsupported_C_DigestFinal (CK_SESSION_HANDLE session,
 996                                 CK_BYTE_PTR digest,
 997                                 CK_ULONG_PTR digest_len)
 998 {
 999   return CKR_FUNCTION_NOT_SUPPORTED;
1000 }
1001
1002 CK_RV
1003 mock_no_mechanisms_C_SignInit (CK_SESSION_HANDLE session,
1004                                CK_MECHANISM_PTR mechanism,
1005                                CK_OBJECT_HANDLE key)
1006 {
1007   Session *sess;
1008
1009   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1010   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1011
1012   return CKR_MECHANISM_INVALID;
1013 }
1014
1015 CK_RV
1016 mock_not_initialized_C_Sign (CK_SESSION_HANDLE session,
1017                              CK_BYTE_PTR data,
1018                              CK_ULONG data_len,
1019                              CK_BYTE_PTR signature,
1020                              CK_ULONG_PTR signature_len)
1021 {
1022   return CKR_OPERATION_NOT_INITIALIZED;
1023 }
1024
1025 CK_RV
1026 mock_unsupported_C_SignUpdate (CK_SESSION_HANDLE session,
1027                                CK_BYTE_PTR part,
1028                                CK_ULONG part_len)
1029 {
1030   return CKR_FUNCTION_NOT_SUPPORTED;
1031 }
1032
1033 CK_RV
1034 mock_unsupported_C_SignFinal (CK_SESSION_HANDLE session,
1035                               CK_BYTE_PTR signature,
1036                               CK_ULONG_PTR signature_len)
1037 {
1038   return CKR_FUNCTION_NOT_SUPPORTED;
1039 }
1040
1041 CK_RV
1042 mock_unsupported_C_SignRecoverInit (CK_SESSION_HANDLE session,
1043                                     CK_MECHANISM_PTR mechanism,
1044                                     CK_OBJECT_HANDLE key)
1045 {
1046   return CKR_FUNCTION_NOT_SUPPORTED;
1047 }
1048
1049 CK_RV
1050 mock_unsupported_C_SignRecover (CK_SESSION_HANDLE session,
1051                                 CK_BYTE_PTR data,
1052                                 CK_ULONG data_len,
1053                                 CK_BYTE_PTR signature,
1054                                 CK_ULONG_PTR signature_len)
1055 {
1056   return CKR_FUNCTION_NOT_SUPPORTED;
1057 }
1058
1059 CK_RV
1060 mock_no_mechanisms_C_VerifyInit (CK_SESSION_HANDLE session,
1061                                  CK_MECHANISM_PTR mechanism,
1062                                  CK_OBJECT_HANDLE key)
1063 {
1064   Session *sess;
1065
1066   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1067   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1068
1069   return CKR_MECHANISM_INVALID;
1070 }
1071
1072 CK_RV
1073 mock_not_initialized_C_Verify (CK_SESSION_HANDLE session,
1074                                CK_BYTE_PTR data,
1075                                CK_ULONG data_len,
1076                                CK_BYTE_PTR signature,
1077                                CK_ULONG signature_len)
1078 {
1079   return CKR_OPERATION_NOT_INITIALIZED;
1080 }
1081
1082 CK_RV
1083 mock_unsupported_C_VerifyUpdate (CK_SESSION_HANDLE session,
1084                                  CK_BYTE_PTR part,
1085                                  CK_ULONG part_len)
1086 {
1087   return CKR_FUNCTION_NOT_SUPPORTED;
1088 }
1089
1090 CK_RV
1091 mock_unsupported_C_VerifyFinal (CK_SESSION_HANDLE session,
1092                                 CK_BYTE_PTR signature,
1093                                 CK_ULONG signature_len)
1094 {
1095   return CKR_FUNCTION_NOT_SUPPORTED;
1096 }
1097
1098 CK_RV
1099 mock_unsupported_C_VerifyRecoverInit (CK_SESSION_HANDLE session,
1100                                       CK_MECHANISM_PTR mechanism,
1101                                       CK_OBJECT_HANDLE key)
1102 {
1103   return CKR_FUNCTION_NOT_SUPPORTED;
1104 }
1105
1106 CK_RV
1107 mock_unsupported_C_VerifyRecover (CK_SESSION_HANDLE session,
1108                                   CK_BYTE_PTR signature,
1109                                   CK_ULONG signature_len,
1110                                   CK_BYTE_PTR data,
1111                                   CK_ULONG_PTR data_len)
1112 {
1113   return CKR_FUNCTION_NOT_SUPPORTED;
1114 }
1115
1116 CK_RV
1117 mock_unsupported_C_DigestEncryptUpdate (CK_SESSION_HANDLE session,
1118                                         CK_BYTE_PTR part,
1119                                         CK_ULONG part_len,
1120                                         CK_BYTE_PTR encrypted_part,
1121                                         CK_ULONG_PTR encrypted_key_len)
1122 {
1123   return CKR_FUNCTION_NOT_SUPPORTED;
1124 }
1125
1126 CK_RV
1127 mock_unsupported_C_DecryptDigestUpdate (CK_SESSION_HANDLE session,
1128                                         CK_BYTE_PTR encrypted_part,
1129                                         CK_ULONG encrypted_key_len,
1130                                         CK_BYTE_PTR part,
1131                                         CK_ULONG_PTR part_len)
1132 {
1133   return CKR_FUNCTION_NOT_SUPPORTED;
1134 }
1135
1136 CK_RV
1137 mock_unsupported_C_SignEncryptUpdate (CK_SESSION_HANDLE session,
1138                                       CK_BYTE_PTR part,
1139                                       CK_ULONG part_len,
1140                                       CK_BYTE_PTR encrypted_part,
1141                                       CK_ULONG_PTR encrypted_key_len)
1142 {
1143   return CKR_FUNCTION_NOT_SUPPORTED;
1144 }
1145
1146 CK_RV
1147 mock_unsupported_C_DecryptVerifyUpdate (CK_SESSION_HANDLE session,
1148                                         CK_BYTE_PTR encrypted_part,
1149                                         CK_ULONG encrypted_key_len,
1150                                         CK_BYTE_PTR part,
1151                                         CK_ULONG_PTR part_len)
1152 {
1153   return CKR_FUNCTION_NOT_SUPPORTED;
1154 }
1155
1156 CK_RV
1157 mock_unsupported_C_GenerateKey (CK_SESSION_HANDLE session,
1158                                 CK_MECHANISM_PTR mechanism,
1159                                 CK_ATTRIBUTE_PTR template,
1160                                 CK_ULONG count,
1161                                 CK_OBJECT_HANDLE_PTR key)
1162 {
1163   return CKR_FUNCTION_NOT_SUPPORTED;
1164 }
1165
1166 CK_RV
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)
1175 {
1176   Session *sess;
1177
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);
1185
1186   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1187   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1188
1189   return CKR_MECHANISM_INVALID;
1190 }
1191
1192 CK_RV
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)
1199 {
1200   Session *sess;
1201
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);
1206
1207   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1208   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1209
1210   return CKR_MECHANISM_INVALID;
1211 }
1212
1213 CK_RV
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,
1220                                 CK_ULONG count,
1221                                 CK_OBJECT_HANDLE_PTR key)
1222 {
1223   Session *sess;
1224
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);
1232
1233   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1234   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1235
1236   return CKR_MECHANISM_INVALID;
1237 }
1238
1239 CK_RV
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,
1244                                 CK_ULONG count,
1245                                 CK_OBJECT_HANDLE_PTR key)
1246 {
1247   Session *sess;
1248
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);
1253
1254   sess = g_hash_table_lookup (the_sessions, GUINT_TO_POINTER (session));
1255   g_return_val_if_fail (sess != NULL, CKR_SESSION_HANDLE_INVALID);
1256
1257   return CKR_MECHANISM_INVALID;
1258 }
1259
1260 CK_RV
1261 mock_unsupported_C_SeedRandom (CK_SESSION_HANDLE session,
1262                                CK_BYTE_PTR pSeed,
1263                                CK_ULONG seed_len)
1264 {
1265   return CKR_FUNCTION_NOT_SUPPORTED;
1266 }
1267
1268 CK_RV
1269 mock_unsupported_C_GenerateRandom (CK_SESSION_HANDLE session,
1270                                    CK_BYTE_PTR random_data,
1271                                    CK_ULONG random_len)
1272 {
1273   return CKR_FUNCTION_NOT_SUPPORTED;
1274 }
1275
1276 CK_FUNCTION_LIST mock_default_functions = {
1277   { 2, 11 },    /* version */
1278   mock_C_Initialize,
1279   mock_C_Finalize,
1280   mock_C_GetInfo,
1281   mock_C_GetFunctionList,
1282   mock_C_GetSlotList,
1283   mock_C_GetSlotInfo,
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,
1290   mock_C_OpenSession,
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,
1305   mock_C_FindObjects,
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
1346 };