gck/gck-mock.h

   1 /*
   2  * gnome-keyring
   3  *
   4  * Copyright (C) 2010 Stefan Walter
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU Lesser General Public License as
   8  * published by the Free Software Foundation; either version 2.1 of
   9  * the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #include <glib.h>
  23
  24 #include "gck.h"
  25
  26 #include <p11-kit/pkcs11.h>
  27 #include "pkcs11i.h"
  28
  29 #ifndef GCK_MOCK_H
  30 #define GCK_MOCK_H
  31
  32 CK_RV               gck_mock_C_Initialize                          (CK_VOID_PTR pInitArgs);
  33
  34 CK_RV               gck_mock_validate_and_C_Initialize             (CK_VOID_PTR pInitArgs);
  35
  36 CK_RV               gck_mock_C_Finalize                            (CK_VOID_PTR pReserved);
  37
  38 CK_RV               gck_mock_C_GetInfo                             (CK_INFO_PTR pInfo);
  39
  40 CK_RV               gck_mock_C_GetFunctionList                     (CK_FUNCTION_LIST_PTR_PTR list);
  41
  42 CK_RV               gck_mock_C_GetSlotList                         (CK_BBOOL tokenPresent,
  43                                                                     CK_SLOT_ID_PTR pSlotList,
  44                                                                     CK_ULONG_PTR pulCount);
  45
  46 CK_RV               gck_mock_C_GetSlotInfo                         (CK_SLOT_ID slotID,
  47                                                                     CK_SLOT_INFO_PTR pInfo);
  48
  49 CK_RV               gck_mock_C_GetTokenInfo                        (CK_SLOT_ID slotID,
  50                                                                     CK_TOKEN_INFO_PTR pInfo);
  51
  52 CK_RV               gck_mock_fail_C_GetTokenInfo                   (CK_SLOT_ID slotID,
  53                                                                     CK_TOKEN_INFO_PTR pInfo);
  54
  55 CK_RV               gck_mock_C_GetMechanismList                    (CK_SLOT_ID slotID,
  56                                                                     CK_MECHANISM_TYPE_PTR pMechanismList,
  57                                                                     CK_ULONG_PTR pulCount);
  58
  59 CK_RV               gck_mock_C_GetMechanismInfo                    (CK_SLOT_ID slotID,
  60                                                                     CK_MECHANISM_TYPE type,
  61                                                                     CK_MECHANISM_INFO_PTR pInfo);
  62
  63 CK_RV               gck_mock_specific_args_C_InitToken             (CK_SLOT_ID slotID,
  64                                                                     CK_UTF8CHAR_PTR pPin,
  65                                                                     CK_ULONG ulPinLen,
  66                                                                     CK_UTF8CHAR_PTR pLabel);
  67
  68 CK_RV               gck_mock_unsupported_C_WaitForSlotEvent        (CK_FLAGS flags,
  69                                                                     CK_SLOT_ID_PTR pSlot,
  70                                                                     CK_VOID_PTR pReserved);
  71
  72 CK_RV               gck_mock_C_OpenSession                         (CK_SLOT_ID slotID,
  73                                                                     CK_FLAGS flags,
  74                                                                     CK_VOID_PTR pApplication,
  75                                                                     CK_NOTIFY Notify,
  76                                                                     CK_SESSION_HANDLE_PTR phSession);
  77
  78 CK_RV               gck_mock_fail_C_OpenSession                    (CK_SLOT_ID slotID,
  79                                                                     CK_FLAGS flags,
  80                                                                     CK_VOID_PTR pApplication,
  81                                                                     CK_NOTIFY Notify,
  82                                                                     CK_SESSION_HANDLE_PTR phSession);
  83
  84 CK_RV               gck_mock_C_CloseSession                        (CK_SESSION_HANDLE hSession);
  85
  86 CK_RV               gck_mock_C_CloseAllSessions                    (CK_SLOT_ID slotID);
  87
  88 CK_RV               gck_mock_C_GetFunctionStatus                   (CK_SESSION_HANDLE hSession);
  89
  90 CK_RV               gck_mock_C_CancelFunction                      (CK_SESSION_HANDLE hSession);
  91
  92 CK_RV               gck_mock_C_GetSessionInfo                      (CK_SESSION_HANDLE hSession,
  93                                                                     CK_SESSION_INFO_PTR pInfo);
  94
  95 CK_RV               gck_mock_fail_C_GetSessionInfo                 (CK_SESSION_HANDLE hSession,
  96                                                                     CK_SESSION_INFO_PTR pInfo);
  97
  98 CK_RV               gck_mock_C_InitPIN                             (CK_SESSION_HANDLE hSession,
  99                                                                     CK_UTF8CHAR_PTR pPin,
 100                                                                     CK_ULONG ulPinLen);
 101
 102 CK_RV               gck_mock_C_SetPIN                              (CK_SESSION_HANDLE hSession,
 103                                                                     CK_UTF8CHAR_PTR pOldPin,
 104                                                                     CK_ULONG ulOldLen,
 105                                                                     CK_UTF8CHAR_PTR pNewPin,
 106                                                                     CK_ULONG ulNewLen);
 107
 108 CK_RV               gck_mock_unsupported_C_GetOperationState       (CK_SESSION_HANDLE hSession,
 109                                                                     CK_BYTE_PTR pOperationState,
 110                                                                     CK_ULONG_PTR pulOperationStateLen);
 111
 112 CK_RV               gck_mock_unsupported_C_SetOperationState       (CK_SESSION_HANDLE hSession,
 113                                                                     CK_BYTE_PTR pOperationState,
 114                                                                     CK_ULONG ulOperationStateLen,
 115                                                                     CK_OBJECT_HANDLE hEncryptionKey,
 116                                                                     CK_OBJECT_HANDLE hAuthenticationKey);
 117
 118 CK_RV               gck_mock_C_Login                               (CK_SESSION_HANDLE hSession,
 119                                                                     CK_USER_TYPE userType,
 120                                                                     CK_UTF8CHAR_PTR pPin,
 121                                                                     CK_ULONG pPinLen);
 122
 123 CK_RV               gck_mock_C_Logout                              (CK_SESSION_HANDLE hSession);
 124
 125 CK_RV               gck_mock_C_CreateObject                        (CK_SESSION_HANDLE hSession,
 126                                                                     CK_ATTRIBUTE_PTR pTemplate,
 127                                                                     CK_ULONG ulCount,
 128                                                                     CK_OBJECT_HANDLE_PTR phObject);
 129
 130 CK_RV               gck_mock_fail_C_CreateObject                   (CK_SESSION_HANDLE hSession,
 131                                                                     CK_ATTRIBUTE_PTR pTemplate,
 132                                                                     CK_ULONG ulCount,
 133                                                                     CK_OBJECT_HANDLE_PTR phObject);
 134
 135 CK_RV               gck_mock_unsupported_C_CopyObject              (CK_SESSION_HANDLE hSession,
 136                                                                     CK_OBJECT_HANDLE hObject,
 137                                                                     CK_ATTRIBUTE_PTR pTemplate,
 138                                                                     CK_ULONG ulCount,
 139                                                                     CK_OBJECT_HANDLE_PTR phNewObject);
 140
 141 CK_RV               gck_mock_C_DestroyObject                       (CK_SESSION_HANDLE hSession,
 142                                                                     CK_OBJECT_HANDLE hObject);
 143
 144 CK_RV               gck_mock_unsupported_C_GetObjectSize           (CK_SESSION_HANDLE hSession,
 145                                                                     CK_OBJECT_HANDLE hObject,
 146                                                                     CK_ULONG_PTR pulSize);
 147
 148 CK_RV               gck_mock_C_GetAttributeValue                   (CK_SESSION_HANDLE hSession,
 149                                                                     CK_OBJECT_HANDLE hObject,
 150                                                                     CK_ATTRIBUTE_PTR pTemplate,
 151                                                                     CK_ULONG ulCount);
 152
 153 CK_RV               gck_mock_fail_C_GetAttributeValue              (CK_SESSION_HANDLE hSession,
 154                                                                     CK_OBJECT_HANDLE hObject,
 155                                                                     CK_ATTRIBUTE_PTR pTemplate,
 156                                                                     CK_ULONG ulCount);
 157
 158 CK_RV               gck_mock_C_SetAttributeValue                   (CK_SESSION_HANDLE hSession,
 159                                                                     CK_OBJECT_HANDLE hObject,
 160                                                                     CK_ATTRIBUTE_PTR pTemplate,
 161                                                                     CK_ULONG ulCount);
 162
 163 CK_RV               gck_mock_C_FindObjectsInit                     (CK_SESSION_HANDLE hSession,
 164                                                                     CK_ATTRIBUTE_PTR pTemplate,
 165                                                                     CK_ULONG ulCount);
 166
 167 CK_RV               gck_mock_C_FindObjects                         (CK_SESSION_HANDLE hSession,
 168                                                                     CK_OBJECT_HANDLE_PTR phObject,
 169                                                                     CK_ULONG ulMaxObjectCount,
 170                                                                     CK_ULONG_PTR pulObjectCount);
 171
 172 CK_RV               gck_mock_fail_C_FindObjects                    (CK_SESSION_HANDLE hSession,
 173                                                                     CK_OBJECT_HANDLE_PTR phObject,
 174                                                                     CK_ULONG ulMaxObjectCount,
 175                                                                     CK_ULONG_PTR pulObjectCount);
 176
 177 CK_RV               gck_mock_C_FindObjectsFinal                    (CK_SESSION_HANDLE hSession);
 178
 179 CK_RV               gck_mock_C_EncryptInit                         (CK_SESSION_HANDLE hSession,
 180                                                                     CK_MECHANISM_PTR pMechanism,
 181                                                                     CK_OBJECT_HANDLE hKey);
 182
 183 CK_RV               gck_mock_C_Encrypt                             (CK_SESSION_HANDLE hSession,
 184                                                                     CK_BYTE_PTR pData,
 185                                                                     CK_ULONG ulDataLen,
 186                                                                     CK_BYTE_PTR pEncryptedData,
 187                                                                     CK_ULONG_PTR pulEncryptedDataLen);
 188
 189 CK_RV               gck_mock_unsupported_C_EncryptUpdate           (CK_SESSION_HANDLE hSession,
 190                                                                     CK_BYTE_PTR pPart,
 191                                                                     CK_ULONG ulPartLen,
 192                                                                     CK_BYTE_PTR pEncryptedPart,
 193                                                                     CK_ULONG_PTR pulEncryptedPartLen);
 194
 195 CK_RV               gck_mock_unsupported_C_EncryptFinal            (CK_SESSION_HANDLE hSession,
 196                                                                     CK_BYTE_PTR pLastEncryptedPart,
 197                                                                     CK_ULONG_PTR pulLastEncryptedPartLen);
 198
 199 CK_RV               gck_mock_C_DecryptInit                         (CK_SESSION_HANDLE hSession,
 200                                                                     CK_MECHANISM_PTR pMechanism,
 201                                                                     CK_OBJECT_HANDLE hKey);
 202
 203 CK_RV               gck_mock_C_Decrypt                             (CK_SESSION_HANDLE hSession,
 204                                                                     CK_BYTE_PTR pEncryptedData,
 205                                                                     CK_ULONG ulEncryptedDataLen,
 206                                                                     CK_BYTE_PTR pData,
 207                                                                     CK_ULONG_PTR pulDataLen);
 208
 209 CK_RV               gck_mock_unsupported_C_DecryptUpdate           (CK_SESSION_HANDLE hSession,
 210                                                                     CK_BYTE_PTR pEncryptedPart,
 211                                                                     CK_ULONG ulEncryptedPartLen,
 212                                                                     CK_BYTE_PTR pPart,
 213                                                                     CK_ULONG_PTR pulPartLen);
 214
 215 CK_RV               gck_mock_unsupported_C_DecryptFinal            (CK_SESSION_HANDLE hSession,
 216                                                                     CK_BYTE_PTR pLastPart,
 217                                                                     CK_ULONG_PTR pulLastPartLen);
 218
 219 CK_RV               gck_mock_unsupported_C_DigestInit              (CK_SESSION_HANDLE hSession,
 220                                                                     CK_MECHANISM_PTR pMechanism);
 221
 222 CK_RV               gck_mock_unsupported_C_Digest                  (CK_SESSION_HANDLE hSession,
 223                                                                     CK_BYTE_PTR pData,
 224                                                                     CK_ULONG ulDataLen,
 225                                                                     CK_BYTE_PTR pDigest,
 226                                                                     CK_ULONG_PTR pulDigestLen);
 227
 228 CK_RV               gck_mock_unsupported_C_DigestUpdate            (CK_SESSION_HANDLE hSession,
 229                                                                     CK_BYTE_PTR pPart,
 230                                                                     CK_ULONG ulPartLen);
 231
 232 CK_RV               gck_mock_unsupported_C_DigestKey               (CK_SESSION_HANDLE hSession,
 233                                                                     CK_OBJECT_HANDLE hKey);
 234
 235 CK_RV               gck_mock_unsupported_C_DigestFinal             (CK_SESSION_HANDLE hSession,
 236                                                                     CK_BYTE_PTR pDigest,
 237                                                                     CK_ULONG_PTR pulDigestLen);
 238
 239 CK_RV               gck_mock_C_SignInit                            (CK_SESSION_HANDLE hSession,
 240                                                                     CK_MECHANISM_PTR pMechanism,
 241                                                                     CK_OBJECT_HANDLE hKey);
 242
 243 CK_RV               gck_mock_C_Sign                                (CK_SESSION_HANDLE hSession,
 244                                                                     CK_BYTE_PTR pData,
 245                                                                     CK_ULONG ulDataLen,
 246                                                                     CK_BYTE_PTR pSignature,
 247                                                                     CK_ULONG_PTR pulSignatureLen);
 248
 249 CK_RV               gck_mock_unsupported_C_SignUpdate              (CK_SESSION_HANDLE hSession,
 250                                                                     CK_BYTE_PTR pPart,
 251                                                                     CK_ULONG ulPartLen);
 252
 253 CK_RV               gck_mock_unsupported_C_SignFinal               (CK_SESSION_HANDLE hSession,
 254                                                                     CK_BYTE_PTR pSignature,
 255                                                                     CK_ULONG_PTR pulSignatureLen);
 256
 257 CK_RV               gck_mock_unsupported_C_SignRecoverInit         (CK_SESSION_HANDLE hSession,
 258                                                                     CK_MECHANISM_PTR pMechanism,
 259                                                                     CK_OBJECT_HANDLE hKey);
 260
 261 CK_RV               gck_mock_unsupported_C_SignRecover             (CK_SESSION_HANDLE hSession,
 262                                                                     CK_BYTE_PTR pData,
 263                                                                     CK_ULONG ulDataLen,
 264                                                                     CK_BYTE_PTR pSignature,
 265                                                                     CK_ULONG_PTR pulSignatureLen);
 266
 267 CK_RV               gck_mock_C_VerifyInit                          (CK_SESSION_HANDLE hSession,
 268                                                                     CK_MECHANISM_PTR pMechanism,
 269                                                                     CK_OBJECT_HANDLE hKey);
 270
 271 CK_RV               gck_mock_C_Verify                              (CK_SESSION_HANDLE hSession,
 272                                                                     CK_BYTE_PTR pData,
 273                                                                     CK_ULONG ulDataLen,
 274                                                                     CK_BYTE_PTR pSignature,
 275                                                                     CK_ULONG ulSignatureLen);
 276
 277 CK_RV               gck_mock_unsupported_C_VerifyUpdate            (CK_SESSION_HANDLE hSession,
 278                                                                     CK_BYTE_PTR pPart,
 279                                                                     CK_ULONG ulPartLen);
 280
 281 CK_RV               gck_mock_unsupported_C_VerifyFinal             (CK_SESSION_HANDLE hSession,
 282                                                                     CK_BYTE_PTR pSignature,
 283                                                                     CK_ULONG pulSignatureLen);
 284
 285 CK_RV               gck_mock_unsupported_C_VerifyRecoverInit       (CK_SESSION_HANDLE hSession,
 286                                                                     CK_MECHANISM_PTR pMechanism,
 287                                                                     CK_OBJECT_HANDLE hKey);
 288
 289 CK_RV               gck_mock_unsupported_C_VerifyRecover           (CK_SESSION_HANDLE hSession,
 290                                                                     CK_BYTE_PTR pSignature,
 291                                                                     CK_ULONG pulSignatureLen,
 292                                                                     CK_BYTE_PTR pData,
 293                                                                     CK_ULONG_PTR pulDataLen);
 294
 295 CK_RV               gck_mock_unsupported_C_DigestEncryptUpdate     (CK_SESSION_HANDLE hSession,
 296                                                                     CK_BYTE_PTR pPart,
 297                                                                     CK_ULONG ulPartLen,
 298                                                                     CK_BYTE_PTR pEncryptedPart,
 299                                                                     CK_ULONG_PTR ulEncryptedPartLen);
 300
 301 CK_RV               gck_mock_unsupported_C_DecryptDigestUpdate     (CK_SESSION_HANDLE hSession,
 302                                                                     CK_BYTE_PTR pEncryptedPart,
 303                                                                     CK_ULONG ulEncryptedPartLen,
 304                                                                     CK_BYTE_PTR pPart,
 305                                                                     CK_ULONG_PTR pulPartLen);
 306
 307 CK_RV               gck_mock_unsupported_C_SignEncryptUpdate       (CK_SESSION_HANDLE hSession,
 308                                                                     CK_BYTE_PTR pPart,
 309                                                                     CK_ULONG ulPartLen,
 310                                                                     CK_BYTE_PTR pEncryptedPart,
 311                                                                     CK_ULONG_PTR ulEncryptedPartLen);
 312
 313 CK_RV               gck_mock_unsupported_C_DecryptVerifyUpdate     (CK_SESSION_HANDLE hSession,
 314                                                                     CK_BYTE_PTR pEncryptedPart,
 315                                                                     CK_ULONG ulEncryptedPartLen,
 316                                                                     CK_BYTE_PTR pPart,
 317                                                                     CK_ULONG_PTR pulPartLen);
 318
 319 CK_RV               gck_mock_unsupported_C_GenerateKey             (CK_SESSION_HANDLE hSession,
 320                                                                     CK_MECHANISM_PTR pMechanism,
 321                                                                     CK_ATTRIBUTE_PTR pTemplate,
 322                                                                     CK_ULONG ulCount,
 323                                                                     CK_OBJECT_HANDLE_PTR phKey);
 324
 325 CK_RV               gck_mock_unsupported_C_GenerateKeyPair         (CK_SESSION_HANDLE hSession,
 326                                                                     CK_MECHANISM_PTR pMechanism,
 327                                                                     CK_ATTRIBUTE_PTR pPublicKeyTemplate,
 328                                                                     CK_ULONG ulPublicKeyAttributeCount,
 329                                                                     CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
 330                                                                     CK_ULONG ulPrivateKeyAttributeCount,
 331                                                                     CK_OBJECT_HANDLE_PTR phPublicKey,
 332                                                                     CK_OBJECT_HANDLE_PTR phPrivateKey);
 333
 334 CK_RV               gck_mock_unsupported_C_WrapKey                 (CK_SESSION_HANDLE hSession,
 335                                                                     CK_MECHANISM_PTR pMechanism,
 336                                                                     CK_OBJECT_HANDLE hWrappingKey,
 337                                                                     CK_OBJECT_HANDLE hKey,
 338                                                                     CK_BYTE_PTR pWrappedKey,
 339                                                                     CK_ULONG_PTR pulWrappedKeyLen);
 340
 341 CK_RV               gck_mock_unsupported_C_UnwrapKey               (CK_SESSION_HANDLE hSession,
 342                                                                     CK_MECHANISM_PTR pMechanism,
 343                                                                     CK_OBJECT_HANDLE pUnwrappingKey,
 344                                                                     CK_BYTE_PTR pWrappedKey,
 345                                                                     CK_ULONG pulWrappedKeyLen,
 346                                                                     CK_ATTRIBUTE_PTR pTemplate,
 347                                                                     CK_ULONG ulCount,
 348                                                                     CK_OBJECT_HANDLE_PTR phKey);
 349
 350 CK_RV               gck_mock_unsupported_C_DeriveKey               (CK_SESSION_HANDLE hSession,
 351                                                                     CK_MECHANISM_PTR pMechanism,
 352                                                                     CK_OBJECT_HANDLE hBaseKey,
 353                                                                     CK_ATTRIBUTE_PTR pTemplate,
 354                                                                     CK_ULONG ulCount,
 355                                                                     CK_OBJECT_HANDLE_PTR phKey);
 356
 357 CK_RV               gck_mock_unsupported_C_SeedRandom              (CK_SESSION_HANDLE hSession,
 358                                                                     CK_BYTE_PTR pSeed,
 359                                                                     CK_ULONG ulSeedLen);
 360
 361 CK_RV               gck_mock_unsupported_C_GenerateRandom          (CK_SESSION_HANDLE hSession,
 362                                                                     CK_BYTE_PTR pRandomData,
 363                                                                     CK_ULONG ulRandomLen);
 364
 365 CK_OBJECT_HANDLE    gck_mock_module_find_object                    (CK_SESSION_HANDLE session,
 366                                                                     CK_ATTRIBUTE_PTR attrs,
 367                                                                     CK_ULONG n_attrs);
 368
 369 guint               gck_mock_module_count_objects                  (CK_SESSION_HANDLE session);
 370
 371 typedef gboolean    (*GckMockEnumerator)                           (CK_OBJECT_HANDLE handle,
 372                                                                     GckAttributes *attrs,
 373                                                                     gpointer user_data);
 374
 375 void                gck_mock_module_enumerate_objects              (CK_SESSION_HANDLE session,
 376                                                                     GckMockEnumerator func,
 377                                                                     gpointer user_data);
 378
 379 CK_OBJECT_HANDLE    gck_mock_module_add_object                     (GckAttributes *attrs);
 380
 381 void                gck_mock_module_set_object                     (CK_OBJECT_HANDLE object,
 382                                                                     CK_ATTRIBUTE_PTR attrs,
 383                                                                     CK_ULONG n_attrs);
 384
 385 void                gck_mock_module_set_pin                        (const gchar *password);
 386
 387 /*
 388  * Some dumb crypto mechanisms for simple testing.
 389  *
 390  * CKM_T_CAPITALIZE (encrypt/decrypt)
 391  *     capitalizes to encrypt
 392  *     lowercase to decrypt
 393  *
 394  * CKM_T_PREFIX (sign/verify)
 395  *     sign prefixes data with key label
 396  *     verify unprefixes data with key label.
 397  *
 398  * CKM_T_GENERATE (generate-pair)
 399  *     generates a pair of keys, mechanism param should be 'generate'
 400  *
 401  * CKM_T_WRAP (wrap key)
 402  *     wraps key by returning value, mechanism param should be 'wrap'
 403  *
 404  * CKM_T_DERIVE (derive-key)
 405  *     derives key by setting value to 'derived'.
 406  *     mechanism param should be 'derive'
 407  */
 408
 409 #define CKM_MOCK_CAPITALIZE    (CKM_VENDOR_DEFINED | 1)
 410 #define CKM_MOCK_PREFIX        (CKM_VENDOR_DEFINED | 2)
 411 #define CKM_MOCK_GENERATE      (CKM_VENDOR_DEFINED | 3)
 412 #define CKM_MOCK_WRAP          (CKM_VENDOR_DEFINED | 4)
 413 #define CKM_MOCK_DERIVE        (CKM_VENDOR_DEFINED | 5)
 414
 415 #define GCK_MOCK_SLOT_ONE_ID  52
 416 #define GCK_MOCK_SLOT_TWO_ID  134
 417
 418 #define GCK_MOCK_SLOT_ONE_URI "pkcs11:manufacturer=TEST%20MANUFACTURER;serial=TEST%20SERIAL"
 419
 420 #endif /* GCK_MOCK_H */