1 /*
2 * Copyright (C) 2015 Mathias Brossard <mathias@brossard.org>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
17 * USA
18 */
19
20 #include "config.h"
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25
26 #ifdef _WIN32
27 #include <windows.h>
28 #include <winreg.h>
29 #include <limits.h>
30 #else
31 #ifdef HAVE_SYS_TIME_H
32 #include <sys/time.h>
33 #endif
34 #include <time.h>
35 #endif
36
37 #define CRYPTOKI_EXPORTS
38 #include "pkcs11-display.h"
39 #include "common/libpkcs11.h"
40
41 #define __PASTE(x,y) x##y
42
43 /* Declare all spy_* Cryptoki function */
44
45 /* Spy Module Function List */
46 static CK_FUNCTION_LIST_PTR pkcs11_spy = NULL;
47 static CK_FUNCTION_LIST_3_0_PTR pkcs11_spy_3_0 = NULL;
48 /* Real Module Function List */
49 static CK_FUNCTION_LIST_3_0_PTR po = NULL;
50 /* Dynamic Module Handle */
51 static void *modhandle = NULL;
52 /* Spy module output */
53 static FILE *spy_output = NULL;
54
55 static void *
allocate_function_list(int v3)56 allocate_function_list(int v3)
57 {
58 CK_FUNCTION_LIST_PTR list = NULL;
59 CK_FUNCTION_LIST_3_0_PTR list_3_0 = NULL;
60
61 if (v3) {
62 list = malloc(sizeof(CK_FUNCTION_LIST_3_0));
63 } else {
64 list = malloc(sizeof(CK_FUNCTION_LIST));
65 }
66 if (list == NULL) {
67 return NULL;
68 }
69 /* with our own pkcs11.h we need to maintain this ourself */
70 list->version.major = 2;
71 list->version.minor = 11;
72 list->C_Initialize = C_Initialize;
73 list->C_Finalize = C_Finalize;
74 list->C_GetInfo = C_GetInfo;
75 list->C_GetFunctionList = C_GetFunctionList;
76 list->C_GetSlotList = C_GetSlotList;
77 list->C_GetSlotInfo = C_GetSlotInfo;
78 list->C_GetTokenInfo = C_GetTokenInfo;
79 list->C_GetMechanismList = C_GetMechanismList;
80 list->C_GetMechanismInfo = C_GetMechanismInfo;
81 list->C_InitToken = C_InitToken;
82 list->C_InitPIN = C_InitPIN;
83 list->C_SetPIN = C_SetPIN;
84 list->C_OpenSession = C_OpenSession;
85 list->C_CloseSession = C_CloseSession;
86 list->C_CloseAllSessions = C_CloseAllSessions;
87 list->C_GetSessionInfo = C_GetSessionInfo;
88 list->C_GetOperationState = C_GetOperationState;
89 list->C_SetOperationState = C_SetOperationState;
90 list->C_Login = C_Login;
91 list->C_Logout = C_Logout;
92 list->C_CreateObject = C_CreateObject;
93 list->C_CopyObject = C_CopyObject;
94 list->C_DestroyObject = C_DestroyObject;
95 list->C_GetObjectSize = C_GetObjectSize;
96 list->C_GetAttributeValue = C_GetAttributeValue;
97 list->C_SetAttributeValue = C_SetAttributeValue;
98 list->C_FindObjectsInit = C_FindObjectsInit;
99 list->C_FindObjects = C_FindObjects;
100 list->C_FindObjectsFinal = C_FindObjectsFinal;
101 list->C_EncryptInit = C_EncryptInit;
102 list->C_Encrypt = C_Encrypt;
103 list->C_EncryptUpdate = C_EncryptUpdate;
104 list->C_EncryptFinal = C_EncryptFinal;
105 list->C_DecryptInit = C_DecryptInit;
106 list->C_Decrypt = C_Decrypt;
107 list->C_DecryptUpdate = C_DecryptUpdate;
108 list->C_DecryptFinal = C_DecryptFinal;
109 list->C_DigestInit = C_DigestInit;
110 list->C_Digest = C_Digest;
111 list->C_DigestUpdate = C_DigestUpdate;
112 list->C_DigestKey = C_DigestKey;
113 list->C_DigestFinal = C_DigestFinal;
114 list->C_SignInit = C_SignInit;
115 list->C_Sign = C_Sign;
116 list->C_SignUpdate = C_SignUpdate;
117 list->C_SignFinal = C_SignFinal;
118 list->C_SignRecoverInit = C_SignRecoverInit;
119 list->C_SignRecover = C_SignRecover;
120 list->C_VerifyInit = C_VerifyInit;
121 list->C_Verify = C_Verify;
122 list->C_VerifyUpdate = C_VerifyUpdate;
123 list->C_VerifyFinal = C_VerifyFinal;
124 list->C_VerifyRecoverInit = C_VerifyRecoverInit;
125 list->C_VerifyRecover = C_VerifyRecover;
126 list->C_DigestEncryptUpdate = C_DigestEncryptUpdate;
127 list->C_DecryptDigestUpdate = C_DecryptDigestUpdate;
128 list->C_SignEncryptUpdate = C_SignEncryptUpdate;
129 list->C_DecryptVerifyUpdate = C_DecryptVerifyUpdate;
130 list->C_GenerateKey = C_GenerateKey;
131 list->C_GenerateKeyPair = C_GenerateKeyPair;
132 list->C_WrapKey = C_WrapKey;
133 list->C_UnwrapKey = C_UnwrapKey;
134 list->C_DeriveKey = C_DeriveKey;
135 list->C_SeedRandom = C_SeedRandom;
136 list->C_GenerateRandom = C_GenerateRandom;
137 list->C_GetFunctionStatus = C_GetFunctionStatus;
138 list->C_CancelFunction = C_CancelFunction;
139 list->C_WaitForSlotEvent = C_WaitForSlotEvent;
140 if (!v3) {
141 return list;
142 }
143
144 /* Add also PKCS #11 3.0 functions if requested and fixup version */
145 list_3_0 = (CK_FUNCTION_LIST_3_0_PTR) list;
146 list_3_0->version.major = 3;
147 list_3_0->version.minor = 0;
148 list_3_0->C_GetInterfaceList = C_GetInterfaceList;
149 list_3_0->C_GetInterface = C_GetInterface;
150 list_3_0->C_LoginUser = C_LoginUser;
151 list_3_0->C_SessionCancel = C_SessionCancel;
152 list_3_0->C_MessageEncryptInit = C_MessageEncryptInit;
153 list_3_0->C_EncryptMessage = C_EncryptMessage;
154 list_3_0->C_EncryptMessageBegin = C_EncryptMessageBegin;
155 list_3_0->C_EncryptMessageNext = C_EncryptMessageNext;
156 list_3_0->C_MessageEncryptFinal = C_MessageEncryptFinal;
157 list_3_0->C_MessageDecryptInit = C_MessageDecryptInit;
158 list_3_0->C_DecryptMessage = C_DecryptMessage;
159 list_3_0->C_DecryptMessageBegin = C_DecryptMessageBegin;
160 list_3_0->C_DecryptMessageNext = C_DecryptMessageNext;
161 list_3_0->C_MessageDecryptFinal = C_MessageDecryptFinal;
162 list_3_0->C_MessageSignInit = C_MessageSignInit;
163 list_3_0->C_SignMessage = C_SignMessage;
164 list_3_0->C_SignMessageBegin = C_SignMessageBegin;
165 list_3_0->C_SignMessageNext = C_SignMessageNext;
166 list_3_0->C_MessageSignFinal = C_MessageSignFinal;
167 list_3_0->C_MessageVerifyInit = C_MessageVerifyInit;
168 list_3_0->C_VerifyMessage = C_VerifyMessage;
169 list_3_0->C_VerifyMessageBegin = C_VerifyMessageBegin;
170 list_3_0->C_VerifyMessageNext = C_VerifyMessageNext;
171 list_3_0->C_MessageVerifyFinal = C_MessageVerifyFinal;
172
173 return list_3_0;
174 }
175
176 /* The compatibility interfaces that can be returned from Interface functions
177 * if the V3 API is used, but the proxied module does not support V3 API */
178 #define NUM_INTERFACES 1
179 CK_INTERFACE compat_interfaces[NUM_INTERFACES] = {
180 {"PKCS 11", NULL, 0}
181 };
182
183 /* Inits the spy. If successful, po != NULL */
184 static CK_RV
init_spy(void)185 init_spy(void)
186 {
187 CK_FUNCTION_LIST_PTR po_v2 = NULL;
188 const char *output, *module;
189 CK_RV rv = CKR_OK;
190 #ifdef _WIN32
191 char temp_path[PATH_MAX], expanded_path[PATH_MAX];
192 DWORD temp_len, expanded_len;
193 long rc;
194 HKEY hKey;
195 #endif
196
197 /* Allocates and initializes the pkcs11_spy structure */
198 pkcs11_spy = allocate_function_list(0);
199 if (pkcs11_spy == NULL) {
200 return CKR_HOST_MEMORY;
201 }
202 pkcs11_spy_3_0 = allocate_function_list(1);
203 if (pkcs11_spy_3_0 == NULL) {
204 free(pkcs11_spy);
205 return CKR_HOST_MEMORY;
206 }
207
208 compat_interfaces[0].pFunctionList = pkcs11_spy;
209
210 /*
211 * Don't use getenv() as the last parameter for scconf_get_str(),
212 * as we want to be able to override configuration file via
213 * environment variables
214 */
215 output = getenv("PKCS11SPY_OUTPUT");
216 if (output)
217 spy_output = fopen(output, "a");
218
219
220
221
222 #ifdef _WIN32
223 if (!spy_output) {
224 /* try for the machine version first, as we may be running
225 * without a user during login
226 */
227 rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE, "Software\\OpenSC Project\\PKCS11-Spy", 0, KEY_QUERY_VALUE, &hKey );
228 if (rc != ERROR_SUCCESS )
229 rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\OpenSC Project\\PKCS11-Spy", 0, KEY_QUERY_VALUE, &hKey );
230
231 if( rc == ERROR_SUCCESS ) {
232 temp_len = PATH_MAX;
233 rc = RegQueryValueEx( hKey, "Output", NULL, NULL, (LPBYTE) temp_path, &temp_len);
234 if (rc == ERROR_SUCCESS) {
235 expanded_len = PATH_MAX;
236 expanded_len = ExpandEnvironmentStrings(temp_path, expanded_path, expanded_len);
237 if (expanded_len > 0) {
238 memcpy(temp_path, expanded_path, PATH_MAX);
239 temp_len = expanded_len;
240 }
241 }
242
243 if( (rc == ERROR_SUCCESS) && (temp_len < PATH_MAX) )
244 output = temp_path;
245 RegCloseKey( hKey );
246 }
247
248 spy_output = fopen(output, "a");
249 }
250 #endif
251 if (!spy_output)
252 spy_output = stderr;
253
254 fprintf(spy_output, "\n\n*************** OpenSC PKCS#11 spy *****************\n");
255
256 module = getenv("PKCS11SPY");
257 #ifdef _WIN32
258 if (!module) {
259 /* try for the machine version first, as we may be running
260 * without a user during login
261 */
262 rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE, "Software\\OpenSC Project\\PKCS11-Spy",
263 0, KEY_QUERY_VALUE, &hKey );
264 if (rc != ERROR_SUCCESS)
265 rc = RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\OpenSC Project\\PKCS11-Spy",
266 0, KEY_QUERY_VALUE, &hKey );
267
268 if (rc == ERROR_SUCCESS) {
269 temp_len = PATH_MAX;
270 rc = RegQueryValueEx( hKey, "Module", NULL, NULL, (LPBYTE) temp_path, &temp_len);
271 if (rc == ERROR_SUCCESS) {
272 expanded_len = PATH_MAX;
273 expanded_len = ExpandEnvironmentStrings(temp_path, expanded_path, expanded_len);
274 if (expanded_len > 0) {
275 memcpy(temp_path, expanded_path, PATH_MAX);
276 temp_len = expanded_len;
277 }
278 }
279
280 if( (rc == ERROR_SUCCESS) && (temp_len < PATH_MAX) )
281 module = temp_path;
282 RegCloseKey( hKey );
283 }
284 }
285 #endif
286 if (module == NULL) {
287 fprintf(spy_output, "Error: no module specified. Please set PKCS11SPY environment.\n");
288 free(pkcs11_spy);
289 return CKR_DEVICE_ERROR;
290 }
291 modhandle = C_LoadModule(module, &po_v2);
292 po = (CK_FUNCTION_LIST_3_0_PTR) po_v2;
293 if (modhandle && po) {
294 fprintf(spy_output, "Loaded: \"%s\"\n", module);
295 }
296 else {
297 po = NULL;
298 free(pkcs11_spy);
299 rv = CKR_GENERAL_ERROR;
300 }
301
302 return rv;
303 }
304
305
306 static void
enter(const char * function)307 enter(const char *function)
308 {
309 static int count = 0;
310 #ifdef _WIN32
311 SYSTEMTIME st;
312 #else
313 struct tm *tm;
314 struct timeval tv;
315 char time_string[40];
316 #endif
317
318 fprintf(spy_output, "\n%d: %s\n", count++, function);
319 #ifdef _WIN32
320 GetLocalTime(&st);
321 fprintf(spy_output, "%i-%02i-%02i %02i:%02i:%02i.%03i\n", st.wYear, st.wMonth, st.wDay,
322 st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
323 #else
324 gettimeofday (&tv, NULL);
325 tm = localtime (&tv.tv_sec);
326 strftime (time_string, sizeof(time_string), "%F %H:%M:%S", tm);
327 fprintf(spy_output, "%s.%03ld\n", time_string, (long)tv.tv_usec / 1000);
328 #endif
329
330 }
331
332 static CK_RV
retne(CK_RV rv)333 retne(CK_RV rv)
334 {
335 fprintf(spy_output, "Returned: %ld %s\n", (unsigned long) rv, lookup_enum ( RV_T, rv ));
336 fflush(spy_output);
337 return rv;
338 }
339
340
341 static void
spy_dump_string_in(const char * name,CK_VOID_PTR data,CK_ULONG size)342 spy_dump_string_in(const char *name, CK_VOID_PTR data, CK_ULONG size)
343 {
344 fprintf(spy_output, "[in] %s ", name);
345 print_generic(spy_output, 0, data, size, NULL);
346 }
347
348 static void
spy_dump_string_out(const char * name,CK_VOID_PTR data,CK_ULONG size)349 spy_dump_string_out(const char *name, CK_VOID_PTR data, CK_ULONG size)
350 {
351 fprintf(spy_output, "[out] %s ", name);
352 print_generic(spy_output, 0, data, size, NULL);
353 }
354
355 static void
spy_dump_ulong_in(const char * name,CK_ULONG value)356 spy_dump_ulong_in(const char *name, CK_ULONG value)
357 {
358 fprintf(spy_output, "[in] %s = 0x%lx\n", name, value);
359 }
360
361 static void
spy_dump_ulong_out(const char * name,CK_ULONG value)362 spy_dump_ulong_out(const char *name, CK_ULONG value)
363 {
364 fprintf(spy_output, "[out] %s = 0x%lx\n", name, value);
365 }
366
367 static void
spy_dump_desc_out(const char * name)368 spy_dump_desc_out(const char *name)
369 {
370 fprintf(spy_output, "[out] %s: \n", name);
371 }
372
373 static void
spy_dump_array_out(const char * name,CK_ULONG size)374 spy_dump_array_out(const char *name, CK_ULONG size)
375 {
376 fprintf(spy_output, "[out] %s[%ld]: \n", name, size);
377 }
378
379 static void
spy_attribute_req_in(const char * name,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)380 spy_attribute_req_in(const char *name, CK_ATTRIBUTE_PTR pTemplate,
381 CK_ULONG ulCount)
382 {
383 fprintf(spy_output, "[in] %s[%ld]: \n", name, ulCount);
384 print_attribute_list_req(spy_output, pTemplate, ulCount);
385 }
386
387 static void
spy_attribute_list_in(const char * name,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)388 spy_attribute_list_in(const char *name, CK_ATTRIBUTE_PTR pTemplate,
389 CK_ULONG ulCount)
390 {
391 fprintf(spy_output, "[in] %s[%ld]: \n", name, ulCount);
392 print_attribute_list(spy_output, pTemplate, ulCount);
393 }
394
395 static void
spy_attribute_list_out(const char * name,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)396 spy_attribute_list_out(const char *name, CK_ATTRIBUTE_PTR pTemplate,
397 CK_ULONG ulCount)
398 {
399 fprintf(spy_output, "[out] %s[%ld]: \n", name, ulCount);
400 print_attribute_list(spy_output, pTemplate, ulCount);
401 }
402
403 static void
spy_dump_mechanism_in(const char * name,CK_MECHANISM_PTR pMechanism)404 spy_dump_mechanism_in(const char *name, CK_MECHANISM_PTR pMechanism)
405 {
406 char param_name[64];
407
408 if (!pMechanism) {
409 fprintf(spy_output, "[in] %s = NULL\n", name);
410 return;
411 }
412
413 fprintf(spy_output, "[in] %s->type = %s\n", name, lookup_enum(MEC_T, pMechanism->mechanism));
414 switch (pMechanism->mechanism) {
415 case CKM_AES_GCM:
416 if (pMechanism->pParameter != NULL) {
417 CK_GCM_PARAMS *param =
418 (CK_GCM_PARAMS *) pMechanism->pParameter;
419 snprintf(param_name, sizeof(param_name), "%s->pParameter->pIv[ulIvLen]", name);
420 spy_dump_string_in(param_name,
421 param->pIv, param->ulIvLen);
422 snprintf(param_name, sizeof(param_name), "%s->pParameter->ulIvBits", name);
423 spy_dump_ulong_in(param_name, param->ulIvBits);
424 snprintf(param_name, sizeof(param_name), "%s->pParameter->pAAD[ulAADLen]", name);
425 spy_dump_string_in(param_name,
426 param->pAAD, param->ulAADLen);
427 fprintf(spy_output, "[in] %s->pParameter->ulTagBits = %lu\n", name, param->ulTagBits);
428 } else {
429 fprintf(spy_output, "[in] %s->pParameter = NULL\n", name);
430 break;
431 }
432 break;
433 case CKM_ECDH1_DERIVE:
434 case CKM_ECDH1_COFACTOR_DERIVE:
435 if (pMechanism->pParameter != NULL) {
436 CK_ECDH1_DERIVE_PARAMS *param =
437 (CK_ECDH1_DERIVE_PARAMS *) pMechanism->pParameter;
438 fprintf(spy_output, "[in] %s->pParameter->kdf = %s\n", name,
439 lookup_enum(CKD_T, param->kdf));
440 fprintf(spy_output, "[in] %s->pParameter->pSharedData[ulSharedDataLen] = ", name);
441 print_generic(spy_output, 0, param->pSharedData,
442 param->ulSharedDataLen, NULL);
443 fprintf(spy_output, "[in] %s->pParameter->pPublicData[ulPublicDataLen] = ", name);
444 print_generic(spy_output, 0, param->pPublicData,
445 param->ulPublicDataLen, NULL);
446 } else {
447 fprintf(spy_output, "[in] %s->pParameter = NULL\n", name);
448 break;
449 }
450 break;
451 case CKM_ECMQV_DERIVE:
452 if (pMechanism->pParameter != NULL) {
453 CK_ECMQV_DERIVE_PARAMS *param =
454 (CK_ECMQV_DERIVE_PARAMS *) pMechanism->pParameter;
455 fprintf(spy_output, "[in] %s->pParameter->kdf = %s\n", name,
456 lookup_enum(CKD_T, param->kdf));
457 fprintf(spy_output, "%s->pParameter->pSharedData[ulSharedDataLen] = ", name);
458 print_generic(spy_output, 0, param->pSharedData,
459 param->ulSharedDataLen, NULL);
460 fprintf(spy_output, "%s->pParameter->pPublicData[ulPublicDataLen] = ", name);
461 print_generic(spy_output, 0, param->pPublicData,
462 param->ulPublicDataLen, NULL);
463 fprintf(spy_output, "%s->pParameter->ulPrivateDataLen = %lu", name,
464 param->ulPrivateDataLen);
465 fprintf(spy_output, "%s->pParameter->hPrivateData = %lu", name, param->hPrivateData);
466 fprintf(spy_output, "%s->pParameter->pPublicData2[ulPublicDataLen2] = ", name);
467 print_generic(spy_output, 0, param->pPublicData2,
468 param->ulPublicDataLen2, NULL);
469 fprintf(spy_output, "%s->pParameter->publicKey = %lu", name, param->publicKey);
470 } else {
471 fprintf(spy_output, "[in] %s->pParameter = NULL\n", name);
472 break;
473 }
474 break;
475 case CKM_RSA_PKCS_OAEP:
476 if (pMechanism->pParameter != NULL) {
477 CK_RSA_PKCS_OAEP_PARAMS *param =
478 (CK_RSA_PKCS_OAEP_PARAMS *) pMechanism->pParameter;
479 fprintf(spy_output, "[in] %s->pParameter->hashAlg = %s\n", name,
480 lookup_enum(MEC_T, param->hashAlg));
481 fprintf(spy_output, "[in] %s->pParameter->mgf = %s\n", name,
482 lookup_enum(MGF_T, param->mgf));
483 fprintf(spy_output, "[in] %s->pParameter->source = %lu\n", name, param->source);
484 snprintf(param_name, sizeof(param_name), "%s->pParameter->pSourceData[ulSourceDalaLen]", name);
485 spy_dump_string_in(param_name,
486 param->pSourceData, param->ulSourceDataLen);
487 } else {
488 fprintf(spy_output, "[in] %s->pParameter = NULL\n", name);
489 break;
490 }
491 break;
492 case CKM_RSA_PKCS_PSS:
493 case CKM_SHA1_RSA_PKCS_PSS:
494 case CKM_SHA256_RSA_PKCS_PSS:
495 case CKM_SHA384_RSA_PKCS_PSS:
496 case CKM_SHA512_RSA_PKCS_PSS:
497 if (pMechanism->pParameter != NULL) {
498 CK_RSA_PKCS_PSS_PARAMS *param =
499 (CK_RSA_PKCS_PSS_PARAMS *) pMechanism->pParameter;
500 fprintf(spy_output, "[in] %s->pParameter->hashAlg = %s\n", name,
501 lookup_enum(MEC_T, param->hashAlg));
502 fprintf(spy_output, "[in] %s->pParameter->mgf = %s\n", name,
503 lookup_enum(MGF_T, param->mgf));
504 fprintf(spy_output, "[in] %s->pParameter->sLen = %lu\n", name,
505 param->sLen);
506 } else {
507 fprintf(spy_output, "[in] %s->pParameter = NULL\n", name);
508 break;
509 }
510 break;
511 default:
512 snprintf(param_name, sizeof(param_name), "%s->pParameter[ulParameterLen]", name);
513 spy_dump_string_in(param_name, pMechanism->pParameter, pMechanism->ulParameterLen);
514 break;
515 }
516 }
517
518 static void
print_ptr_in(const char * name,CK_VOID_PTR ptr)519 print_ptr_in(const char *name, CK_VOID_PTR ptr)
520 {
521 fprintf(spy_output, "[in] %s = %p\n", name, ptr);
522 }
523
C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)524 CK_RV C_GetFunctionList
525 (CK_FUNCTION_LIST_PTR_PTR ppFunctionList)
526 {
527 if (po == NULL) {
528 CK_RV rv = init_spy();
529 if (rv != CKR_OK)
530 return rv;
531 }
532
533 enter("C_GetFunctionList");
534 if (ppFunctionList == NULL)
535 return retne(CKR_ARGUMENTS_BAD);
536 *ppFunctionList = pkcs11_spy;
537 return retne(CKR_OK);
538 }
539
540 CK_RV
C_Initialize(CK_VOID_PTR pInitArgs)541 C_Initialize(CK_VOID_PTR pInitArgs)
542 {
543 CK_RV rv;
544
545 if (po == NULL) {
546 rv = init_spy();
547 if (rv != CKR_OK)
548 return rv;
549 }
550
551 enter("C_Initialize");
552 print_ptr_in("pInitArgs", pInitArgs);
553
554 if (pInitArgs) {
555 CK_C_INITIALIZE_ARGS *ptr = pInitArgs;
556 fprintf(spy_output, " flags: %ld\n", ptr->flags);
557 if (ptr->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS)
558 fprintf(spy_output, " CKF_LIBRARY_CANT_CREATE_OS_THREADS\n");
559 if (ptr->flags & CKF_OS_LOCKING_OK)
560 fprintf(spy_output, " CKF_OS_LOCKING_OK\n");
561 }
562
563 rv = po->C_Initialize(pInitArgs);
564 return retne(rv);
565 }
566
567 CK_RV
C_Finalize(CK_VOID_PTR pReserved)568 C_Finalize(CK_VOID_PTR pReserved)
569 {
570 CK_RV rv;
571
572 enter("C_Finalize");
573 rv = po->C_Finalize(pReserved);
574 return retne(rv);
575 }
576
577 CK_RV
C_GetInfo(CK_INFO_PTR pInfo)578 C_GetInfo(CK_INFO_PTR pInfo)
579 {
580 CK_RV rv;
581
582 enter("C_GetInfo");
583 rv = po->C_GetInfo(pInfo);
584 if(rv == CKR_OK) {
585 spy_dump_desc_out("pInfo");
586 print_ck_info(spy_output, pInfo);
587 }
588 return retne(rv);
589 }
590
591 CK_RV
C_GetSlotList(CK_BBOOL tokenPresent,CK_SLOT_ID_PTR pSlotList,CK_ULONG_PTR pulCount)592 C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList,
593 CK_ULONG_PTR pulCount)
594 {
595 CK_RV rv;
596
597 enter("C_GetSlotList");
598 spy_dump_ulong_in("tokenPresent", tokenPresent);
599 rv = po->C_GetSlotList(tokenPresent, pSlotList, pulCount);
600 if(rv == CKR_OK) {
601 spy_dump_desc_out("pSlotList");
602 print_slot_list(spy_output, pSlotList, *pulCount);
603 spy_dump_ulong_out("*pulCount", *pulCount);
604 }
605 return retne(rv);
606 }
607
608 CK_RV
C_GetSlotInfo(CK_SLOT_ID slotID,CK_SLOT_INFO_PTR pInfo)609 C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
610 {
611 CK_RV rv;
612
613 enter("C_GetSlotInfo");
614 spy_dump_ulong_in("slotID", slotID);
615 rv = po->C_GetSlotInfo(slotID, pInfo);
616 if(rv == CKR_OK) {
617 spy_dump_desc_out("pInfo");
618 print_slot_info(spy_output, pInfo);
619 }
620 return retne(rv);
621 }
622
623 CK_RV
C_GetTokenInfo(CK_SLOT_ID slotID,CK_TOKEN_INFO_PTR pInfo)624 C_GetTokenInfo(CK_SLOT_ID slotID,
625 CK_TOKEN_INFO_PTR pInfo)
626 {
627 CK_RV rv;
628
629 enter("C_GetTokenInfo");
630 spy_dump_ulong_in("slotID", slotID);
631 rv = po->C_GetTokenInfo(slotID, pInfo);
632 if(rv == CKR_OK) {
633 spy_dump_desc_out("pInfo");
634 print_token_info(spy_output, pInfo);
635 }
636 return retne(rv);
637 }
638
639 CK_RV
C_GetMechanismList(CK_SLOT_ID slotID,CK_MECHANISM_TYPE_PTR pMechanismList,CK_ULONG_PTR pulCount)640 C_GetMechanismList(CK_SLOT_ID slotID, CK_MECHANISM_TYPE_PTR pMechanismList,
641 CK_ULONG_PTR pulCount)
642 {
643 CK_RV rv;
644
645 enter("C_GetMechanismList");
646 spy_dump_ulong_in("slotID", slotID);
647 rv = po->C_GetMechanismList(slotID, pMechanismList, pulCount);
648 if(rv == CKR_OK) {
649 spy_dump_array_out("pMechanismList", *pulCount);
650 print_mech_list(spy_output, pMechanismList, *pulCount);
651 }
652 return retne(rv);
653 }
654
655 CK_RV
C_GetMechanismInfo(CK_SLOT_ID slotID,CK_MECHANISM_TYPE type,CK_MECHANISM_INFO_PTR pInfo)656 C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
657 CK_MECHANISM_INFO_PTR pInfo)
658 {
659 CK_RV rv;
660 const char *name = lookup_enum(MEC_T, type);
661
662 enter("C_GetMechanismInfo");
663 spy_dump_ulong_in("slotID", slotID);
664 if (name)
665 fprintf(spy_output, "[in] type = %30s\n", name);
666 else
667 fprintf(spy_output, "[in] type = Unknown Mechanism (%08lx)\n", type);
668
669 rv = po->C_GetMechanismInfo(slotID, type, pInfo);
670 if(rv == CKR_OK) {
671 spy_dump_desc_out("pInfo");
672 print_mech_info(spy_output, type, pInfo);
673 }
674 return retne(rv);
675 }
676
677 CK_RV
C_InitToken(CK_SLOT_ID slotID,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen,CK_UTF8CHAR_PTR pLabel)678 C_InitToken (CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen,
679 CK_UTF8CHAR_PTR pLabel)
680 {
681 CK_RV rv;
682
683 enter("C_InitToken");
684 spy_dump_ulong_in("slotID", slotID);
685 spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen);
686 spy_dump_string_in("pLabel[32]", pLabel, 32);
687 rv = po->C_InitToken (slotID, pPin, ulPinLen, pLabel);
688 return retne(rv);
689 }
690
691 CK_RV
C_InitPIN(CK_SESSION_HANDLE hSession,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen)692 C_InitPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
693 {
694 CK_RV rv;
695
696 enter("C_InitPIN");
697 spy_dump_ulong_in("hSession", hSession);
698 spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen);
699 rv = po->C_InitPIN(hSession, pPin, ulPinLen);
700 return retne(rv);
701 }
702
703 CK_RV
C_SetPIN(CK_SESSION_HANDLE hSession,CK_UTF8CHAR_PTR pOldPin,CK_ULONG ulOldLen,CK_UTF8CHAR_PTR pNewPin,CK_ULONG ulNewLen)704 C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, CK_ULONG ulOldLen,
705 CK_UTF8CHAR_PTR pNewPin, CK_ULONG ulNewLen)
706 {
707 CK_RV rv;
708
709 enter("C_SetPIN");
710 spy_dump_ulong_in("hSession", hSession);
711 spy_dump_string_in("pOldPin[ulOldLen]", pOldPin, ulOldLen);
712 spy_dump_string_in("pNewPin[ulNewLen]", pNewPin, ulNewLen);
713 rv = po->C_SetPIN(hSession, pOldPin, ulOldLen, pNewPin, ulNewLen);
714 return retne(rv);
715 }
716
717 CK_RV
C_OpenSession(CK_SLOT_ID slotID,CK_FLAGS flags,CK_VOID_PTR pApplication,CK_NOTIFY Notify,CK_SESSION_HANDLE_PTR phSession)718 C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication,
719 CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession)
720 {
721 CK_RV rv;
722
723 enter("C_OpenSession");
724 spy_dump_ulong_in("slotID", slotID);
725 spy_dump_ulong_in("flags", flags);
726 fprintf(spy_output, "[in] pApplication = %p\n", pApplication);
727 fprintf(spy_output, "[in] Notify = %p\n", (void *)Notify);
728 rv = po->C_OpenSession(slotID, flags, pApplication, Notify, phSession);
729 if (phSession)
730 spy_dump_ulong_out("*phSession", *phSession);
731 else
732 fprintf(spy_output, "[out] phSession = %p\n", phSession);
733 return retne(rv);
734 }
735
736 CK_RV
C_CloseSession(CK_SESSION_HANDLE hSession)737 C_CloseSession(CK_SESSION_HANDLE hSession)
738 {
739 CK_RV rv;
740
741 enter("C_CloseSession");
742 spy_dump_ulong_in("hSession", hSession);
743 rv = po->C_CloseSession(hSession);
744 return retne(rv);
745 }
746
747 CK_RV
C_CloseAllSessions(CK_SLOT_ID slotID)748 C_CloseAllSessions(CK_SLOT_ID slotID)
749 {
750 CK_RV rv;
751 enter("C_CloseAllSessions");
752 spy_dump_ulong_in("slotID", slotID);
753 rv = po->C_CloseAllSessions(slotID);
754 return retne(rv);
755 }
756
757 CK_RV
C_GetSessionInfo(CK_SESSION_HANDLE hSession,CK_SESSION_INFO_PTR pInfo)758 C_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo)
759 {
760 CK_RV rv;
761
762 enter("C_GetSessionInfo");
763 spy_dump_ulong_in("hSession", hSession);
764 rv = po->C_GetSessionInfo(hSession, pInfo);
765 if(rv == CKR_OK) {
766 spy_dump_desc_out("pInfo");
767 print_session_info(spy_output, pInfo);
768 }
769 return retne(rv);
770 }
771
772 CK_RV
C_GetOperationState(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG_PTR pulOperationStateLen)773 C_GetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState,
774 CK_ULONG_PTR pulOperationStateLen)
775 {
776 CK_RV rv;
777
778 enter("C_GetOperationState");
779 spy_dump_ulong_in("hSession", hSession);
780 rv = po->C_GetOperationState(hSession, pOperationState, pulOperationStateLen);
781 if (rv == CKR_OK)
782 spy_dump_string_out("pOperationState[*pulOperationStateLen]", pOperationState, *pulOperationStateLen);
783 return retne(rv);
784 }
785
786 CK_RV
C_SetOperationState(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG ulOperationStateLen,CK_OBJECT_HANDLE hEncryptionKey,CK_OBJECT_HANDLE hAuthenticationKey)787 C_SetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState, CK_ULONG ulOperationStateLen,
788 CK_OBJECT_HANDLE hEncryptionKey, CK_OBJECT_HANDLE hAuthenticationKey)
789 {
790 CK_RV rv;
791
792 enter("SetOperationState");
793 spy_dump_ulong_in("hSession", hSession);
794 spy_dump_string_in("pOperationState[ulOperationStateLen]", pOperationState, ulOperationStateLen);
795 spy_dump_ulong_in("hEncryptionKey", hEncryptionKey);
796 spy_dump_ulong_in("hAuthenticationKey", hAuthenticationKey);
797 rv = po->C_SetOperationState(hSession, pOperationState, ulOperationStateLen,
798 hEncryptionKey, hAuthenticationKey);
799 return retne(rv);
800 }
801
802 CK_RV
C_Login(CK_SESSION_HANDLE hSession,CK_USER_TYPE userType,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen)803 C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
804 CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
805 {
806 CK_RV rv;
807
808 enter("C_Login");
809 spy_dump_ulong_in("hSession", hSession);
810 fprintf(spy_output, "[in] userType = %s\n",
811 lookup_enum(USR_T, userType));
812 spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen);
813 rv = po->C_Login(hSession, userType, pPin, ulPinLen);
814 return retne(rv);
815 }
816
817 CK_RV
C_Logout(CK_SESSION_HANDLE hSession)818 C_Logout(CK_SESSION_HANDLE hSession)
819 {
820 CK_RV rv;
821 enter("C_Logout");
822 spy_dump_ulong_in("hSession", hSession);
823 rv = po->C_Logout(hSession);
824 return retne(rv);
825 }
826
827 CK_RV
C_CreateObject(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phObject)828 C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
829 CK_OBJECT_HANDLE_PTR phObject)
830 {
831 CK_RV rv;
832
833 enter("C_CreateObject");
834 spy_dump_ulong_in("hSession", hSession);
835 spy_attribute_list_in("pTemplate", pTemplate, ulCount);
836 rv = po->C_CreateObject(hSession, pTemplate, ulCount, phObject);
837 if (rv == CKR_OK)
838 spy_dump_ulong_out("*phObject", *phObject);
839 return retne(rv);
840 }
841
842 CK_RV
C_CopyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phNewObject)843 C_CopyObject(CK_SESSION_HANDLE hSession,
844 CK_OBJECT_HANDLE hObject,
845 CK_ATTRIBUTE_PTR pTemplate,
846 CK_ULONG ulCount,
847 CK_OBJECT_HANDLE_PTR phNewObject)
848 {
849 CK_RV rv;
850
851 enter("C_CopyObject");
852 spy_dump_ulong_in("hSession", hSession);
853 spy_dump_ulong_in("hObject", hObject);
854 spy_attribute_list_in("pTemplate", pTemplate, ulCount);
855 rv = po->C_CopyObject(hSession, hObject, pTemplate, ulCount, phNewObject);
856 if (rv == CKR_OK)
857 spy_dump_ulong_out("*phNewObject", *phNewObject);
858
859 return retne(rv);
860 }
861
862 CK_RV
C_DestroyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject)863 C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject)
864 {
865 CK_RV rv;
866
867 enter("C_DestroyObject");
868 spy_dump_ulong_in("hSession", hSession);
869 spy_dump_ulong_in("hObject", hObject);
870 rv = po->C_DestroyObject(hSession, hObject);
871 return retne(rv);
872 }
873
874 CK_RV
C_GetObjectSize(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ULONG_PTR pulSize)875 C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize)
876 {
877 CK_RV rv;
878
879 enter("C_GetObjectSize");
880 spy_dump_ulong_in("hSession", hSession);
881 spy_dump_ulong_in("hObject", hObject);
882 rv = po->C_GetObjectSize(hSession, hObject, pulSize);
883 if (rv == CKR_OK)
884 spy_dump_ulong_out("*pulSize", *pulSize);
885
886 return retne(rv);
887 }
888
889 CK_RV
C_GetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)890 C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
891 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
892 {
893 CK_RV rv;
894
895 enter("C_GetAttributeValue");
896 spy_dump_ulong_in("hSession", hSession);
897 spy_dump_ulong_in("hObject", hObject);
898 spy_attribute_req_in("pTemplate", pTemplate, ulCount);
899 /* PKCS#11 says:
900 * ``Note that the error codes CKR_ATTRIBUTE_SENSITIVE,
901 * CKR_ATTRIBUTE_TYPE_INVALID, and CKR_BUFFER_TOO_SMALL do not denote
902 * true errors for C_GetAttributeValue.''
903 * That's why we ignore these error codes, because we want to display
904 * all other attributes anyway (they may have been returned correctly)
905 */
906 rv = po->C_GetAttributeValue(hSession, hObject, pTemplate, ulCount);
907 if (rv == CKR_OK || rv == CKR_ATTRIBUTE_SENSITIVE ||
908 rv == CKR_ATTRIBUTE_TYPE_INVALID || rv == CKR_BUFFER_TOO_SMALL)
909 spy_attribute_list_out("pTemplate", pTemplate, ulCount);
910 return retne(rv);
911 }
912
913 CK_RV
C_SetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)914 C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
915 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
916 {
917 CK_RV rv;
918
919 enter("C_SetAttributeValue");
920 spy_dump_ulong_in("hSession", hSession);
921 spy_dump_ulong_in("hObject", hObject);
922 spy_attribute_list_in("pTemplate", pTemplate, ulCount);
923 rv = po->C_SetAttributeValue(hSession, hObject, pTemplate, ulCount);
924 return retne(rv);
925 }
926
927 CK_RV
C_FindObjectsInit(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)928 C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
929 {
930 CK_RV rv;
931
932 enter("C_FindObjectsInit");
933 spy_dump_ulong_in("hSession", hSession);
934 spy_attribute_list_in("pTemplate", pTemplate, ulCount);
935 rv = po->C_FindObjectsInit(hSession, pTemplate, ulCount);
936 return retne(rv);
937 }
938
939 CK_RV
C_FindObjects(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE_PTR phObject,CK_ULONG ulMaxObjectCount,CK_ULONG_PTR pulObjectCount)940 C_FindObjects(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phObject, CK_ULONG ulMaxObjectCount,
941 CK_ULONG_PTR pulObjectCount)
942 {
943 CK_RV rv;
944
945 enter("C_FindObjects");
946 spy_dump_ulong_in("hSession", hSession);
947 spy_dump_ulong_in("ulMaxObjectCount", ulMaxObjectCount);
948 rv = po->C_FindObjects(hSession, phObject, ulMaxObjectCount, pulObjectCount);
949 if (rv == CKR_OK) {
950 CK_ULONG i;
951 spy_dump_ulong_out("ulObjectCount", *pulObjectCount);
952 for (i = 0; i < *pulObjectCount; i++)
953 fprintf(spy_output, "Object 0x%lx matches\n", phObject[i]);
954 }
955 return retne(rv);
956 }
957
958 CK_RV
C_FindObjectsFinal(CK_SESSION_HANDLE hSession)959 C_FindObjectsFinal(CK_SESSION_HANDLE hSession)
960 {
961 CK_RV rv;
962
963 enter("C_FindObjectsFinal");
964 spy_dump_ulong_in("hSession", hSession);
965 rv = po->C_FindObjectsFinal(hSession);
966 return retne(rv);
967 }
968
969 CK_RV
C_EncryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)970 C_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
971 {
972 CK_RV rv;
973
974 enter("C_EncryptInit");
975 spy_dump_ulong_in("hSession", hSession);
976 spy_dump_mechanism_in("pMechanism", pMechanism);
977 spy_dump_ulong_in("hKey", hKey);
978 rv = po->C_EncryptInit(hSession, pMechanism, hKey);
979 return retne(rv);
980 }
981
982 CK_RV
C_Encrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pEncryptedData,CK_ULONG_PTR pulEncryptedDataLen)983 C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
984 CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen)
985 {
986 CK_RV rv;
987
988 enter("C_Encrypt");
989 spy_dump_ulong_in("hSession", hSession);
990 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
991 rv = po->C_Encrypt(hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen);
992 if (rv == CKR_OK)
993 spy_dump_string_out("pEncryptedData[*pulEncryptedDataLen]", pEncryptedData, *pulEncryptedDataLen);
994 return retne(rv);
995 }
996
997 CK_RV
C_EncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)998 C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen,
999 CK_BYTE_PTR pEncryptedPart, CK_ULONG_PTR pulEncryptedPartLen)
1000 {
1001 CK_RV rv;
1002
1003 enter("C_EncryptUpdate");
1004 spy_dump_ulong_in("hSession", hSession);
1005 spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
1006 rv = po->C_EncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
1007 if (rv == CKR_OK)
1008 spy_dump_string_out("pEncryptedPart[*pulEncryptedPartLen]", pEncryptedPart, *pulEncryptedPartLen);
1009 return retne(rv);
1010 }
1011
1012 CK_RV
C_EncryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastEncryptedPart,CK_ULONG_PTR pulLastEncryptedPartLen)1013 C_EncryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastEncryptedPart, CK_ULONG_PTR pulLastEncryptedPartLen)
1014 {
1015 CK_RV rv;
1016
1017 enter("C_EncryptFinal");
1018 spy_dump_ulong_in("hSession", hSession);
1019 rv = po->C_EncryptFinal(hSession, pLastEncryptedPart, pulLastEncryptedPartLen);
1020 if (rv == CKR_OK)
1021 spy_dump_string_out("pLastEncryptedPart[*pulLastEncryptedPartLen]", pLastEncryptedPart,
1022 *pulLastEncryptedPartLen);
1023
1024 return retne(rv);
1025 }
1026
1027 CK_RV
C_DecryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1028 C_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1029 {
1030 CK_RV rv;
1031
1032 enter("C_DecryptInit");
1033 spy_dump_ulong_in("hSession", hSession);
1034 spy_dump_mechanism_in("pMechanism", pMechanism);
1035 spy_dump_ulong_in("hKey", hKey);
1036 rv = po->C_DecryptInit(hSession, pMechanism, hKey);
1037 return retne(rv);
1038 }
1039
1040 CK_RV
C_Decrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedData,CK_ULONG ulEncryptedDataLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)1041 C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen,
1042 CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
1043 {
1044 CK_RV rv;
1045
1046 enter("C_Decrypt");
1047 spy_dump_ulong_in("hSession", hSession);
1048 spy_dump_string_in("pEncryptedData[ulEncryptedDataLen]", pEncryptedData, ulEncryptedDataLen);
1049 rv = po->C_Decrypt(hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen);
1050 if (rv == CKR_OK)
1051 spy_dump_string_out("pData[*pulDataLen]", pData, *pulDataLen);
1052
1053 return retne(rv);
1054 }
1055
1056 CK_RV
C_DecryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1057 C_DecryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart, CK_ULONG ulEncryptedPartLen,
1058 CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
1059 {
1060 CK_RV rv;
1061
1062 enter("C_DecryptUpdate");
1063 spy_dump_ulong_in("hSession", hSession);
1064 spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]", pEncryptedPart, ulEncryptedPartLen);
1065 rv = po->C_DecryptUpdate(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
1066 if (rv == CKR_OK)
1067 spy_dump_string_out("pPart[*pulPartLen]", pPart, *pulPartLen);
1068
1069 return retne(rv);
1070 }
1071
1072 CK_RV
C_DecryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastPart,CK_ULONG_PTR pulLastPartLen)1073 C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart, CK_ULONG_PTR pulLastPartLen)
1074 {
1075 CK_RV rv;
1076
1077 enter("C_DecryptFinal");
1078 spy_dump_ulong_in("hSession", hSession);
1079 rv = po->C_DecryptFinal(hSession, pLastPart, pulLastPartLen);
1080 if (rv == CKR_OK)
1081 spy_dump_string_out("pLastPart[*pulLastPartLen]", pLastPart, *pulLastPartLen);
1082
1083 return retne(rv);
1084 }
1085
1086 CK_RV
C_DigestInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism)1087 C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism)
1088 {
1089 CK_RV rv;
1090
1091 enter("C_DigestInit");
1092 spy_dump_ulong_in("hSession", hSession);
1093 spy_dump_mechanism_in("pMechanism", pMechanism);
1094 rv = po->C_DigestInit(hSession, pMechanism);
1095 return retne(rv);
1096 }
1097
1098 CK_RV
C_Digest(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pDigest,CK_ULONG_PTR pulDigestLen)1099 C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
1100 CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen)
1101 {
1102 CK_RV rv;
1103
1104 enter("C_Digest");
1105 spy_dump_ulong_in("hSession", hSession);
1106 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1107 rv = po->C_Digest(hSession, pData, ulDataLen, pDigest, pulDigestLen);
1108 if (rv == CKR_OK)
1109 spy_dump_string_out("pDigest[*pulDigestLen]", pDigest, *pulDigestLen);
1110
1111 return retne(rv);
1112 }
1113
1114 CK_RV
C_DigestUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)1115 C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen)
1116 {
1117 CK_RV rv;
1118
1119 enter("C_DigestUpdate");
1120 spy_dump_ulong_in("hSession", hSession);
1121 spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
1122 rv = po->C_DigestUpdate(hSession, pPart, ulPartLen);
1123 return retne(rv);
1124 }
1125
1126 CK_RV
C_DigestKey(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hKey)1127 C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey)
1128 {
1129 CK_RV rv;
1130
1131 enter("C_DigestKey");
1132 spy_dump_ulong_in("hSession", hSession);
1133 spy_dump_ulong_in("hKey", hKey);
1134 rv = po->C_DigestKey(hSession, hKey);
1135 return retne(rv);
1136 }
1137
1138 CK_RV
C_DigestFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pDigest,CK_ULONG_PTR pulDigestLen)1139 C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen)
1140 {
1141 CK_RV rv;
1142
1143 enter("C_DigestFinal");
1144 spy_dump_ulong_in("hSession", hSession);
1145 rv = po->C_DigestFinal(hSession, pDigest, pulDigestLen);
1146 if (rv == CKR_OK)
1147 spy_dump_string_out("pDigest[*pulDigestLen]", pDigest, *pulDigestLen);
1148
1149 return retne(rv);
1150 }
1151
1152 CK_RV
C_SignInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1153 C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1154 {
1155 CK_RV rv;
1156
1157 enter("C_SignInit");
1158 spy_dump_ulong_in("hSession", hSession);
1159 spy_dump_mechanism_in("pMechanism", pMechanism);
1160 spy_dump_ulong_in("hKey", hKey);
1161 rv = po->C_SignInit(hSession, pMechanism, hKey);
1162 return retne(rv);
1163 }
1164
1165 CK_RV
C_Sign(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1166 C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
1167 CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
1168 {
1169 CK_RV rv;
1170
1171 enter("C_Sign");
1172 spy_dump_ulong_in("hSession", hSession);
1173 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1174 rv = po->C_Sign(hSession, pData, ulDataLen, pSignature, pulSignatureLen);
1175 if (rv == CKR_OK)
1176 spy_dump_string_out("pSignature[*pulSignatureLen]", pSignature, *pulSignatureLen);
1177
1178 return retne(rv);
1179 }
1180
1181 CK_RV
C_SignUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)1182 C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen)
1183 {
1184 CK_RV rv;
1185
1186 enter("C_SignUpdate");
1187 spy_dump_ulong_in("hSession", hSession);
1188 spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
1189 rv = po->C_SignUpdate(hSession, pPart, ulPartLen);
1190 return retne(rv);
1191 }
1192
1193 CK_RV
C_SignFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1194 C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
1195 {
1196 CK_RV rv;
1197
1198 enter("C_SignFinal");
1199 spy_dump_ulong_in("hSession", hSession);
1200 rv = po->C_SignFinal(hSession, pSignature, pulSignatureLen);
1201 if (rv == CKR_OK)
1202 spy_dump_string_out("pSignature[*pulSignatureLen]", pSignature, *pulSignatureLen);
1203
1204 return retne(rv);
1205 }
1206
1207 CK_RV
C_SignRecoverInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1208 C_SignRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1209 {
1210 CK_RV rv;
1211
1212 enter("C_SignRecoverInit");
1213 spy_dump_ulong_in("hSession", hSession);
1214 spy_dump_mechanism_in("pMechanism", pMechanism);
1215 spy_dump_ulong_in("hKey", hKey);
1216 rv = po->C_SignRecoverInit(hSession, pMechanism, hKey);
1217 return retne(rv);
1218 }
1219
1220 CK_RV
C_SignRecover(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1221 C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
1222 CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
1223 {
1224 CK_RV rv;
1225
1226 enter("C_SignRecover");
1227 spy_dump_ulong_in("hSession", hSession);
1228 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1229 rv = po->C_SignRecover(hSession, pData, ulDataLen, pSignature, pulSignatureLen);
1230 if (rv == CKR_OK)
1231 spy_dump_string_out("pSignature[*pulSignatureLen]", pSignature, *pulSignatureLen);
1232 return retne(rv);
1233 }
1234
1235 CK_RV
C_VerifyInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1236 C_VerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1237 {
1238 CK_RV rv;
1239
1240 enter("C_VerifyInit");
1241 spy_dump_ulong_in("hSession", hSession);
1242 spy_dump_mechanism_in("pMechanism", pMechanism);
1243 spy_dump_ulong_in("hKey", hKey);
1244 rv = po->C_VerifyInit(hSession, pMechanism, hKey);
1245 return retne(rv);
1246 }
1247
1248 CK_RV
C_Verify(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1249 C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
1250 CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
1251 {
1252 CK_RV rv;
1253
1254 enter("C_Verify");
1255 spy_dump_ulong_in("hSession", hSession);
1256 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1257 spy_dump_string_in("pSignature[ulSignatureLen]", pSignature, ulSignatureLen);
1258 rv = po->C_Verify(hSession, pData, ulDataLen, pSignature, ulSignatureLen);
1259 return retne(rv);
1260 }
1261
1262 CK_RV
C_VerifyUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)1263 C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen)
1264 {
1265 CK_RV rv;
1266
1267 enter("C_VerifyUpdate");
1268 spy_dump_ulong_in("hSession", hSession);
1269 spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
1270 rv = po->C_VerifyUpdate(hSession, pPart, ulPartLen);
1271 return retne(rv);
1272 }
1273
1274 CK_RV
C_VerifyFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1275 C_VerifyFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
1276 {
1277 CK_RV rv;
1278
1279 enter("C_VerifyFinal");
1280 spy_dump_ulong_in("hSession", hSession);
1281 spy_dump_string_in("pSignature[ulSignatureLen]", pSignature, ulSignatureLen);
1282 rv = po->C_VerifyFinal(hSession, pSignature, ulSignatureLen);
1283 return retne(rv);
1284 }
1285
1286
1287 CK_RV
C_VerifyRecoverInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1288 C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1289 CK_OBJECT_HANDLE hKey)
1290 {
1291 CK_RV rv;
1292
1293 enter("C_VerifyRecoverInit");
1294 spy_dump_ulong_in("hSession", hSession);
1295 spy_dump_mechanism_in("pMechanism", pMechanism);
1296 spy_dump_ulong_in("hKey", hKey);
1297 rv = po->C_VerifyRecoverInit(hSession, pMechanism, hKey);
1298 return retne(rv);
1299 }
1300
1301 CK_RV
C_VerifyRecover(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)1302 C_VerifyRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen,
1303 CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
1304 {
1305 CK_RV rv;
1306
1307 enter("C_VerifyRecover");
1308 spy_dump_ulong_in("hSession", hSession);
1309 spy_dump_string_in("pSignature[ulSignatureLen]", pSignature, ulSignatureLen);
1310 rv = po->C_VerifyRecover(hSession, pSignature, ulSignatureLen, pData, pulDataLen);
1311 if (rv == CKR_OK)
1312 spy_dump_string_out("pData[*pulDataLen]", pData, *pulDataLen);
1313 return retne(rv);
1314 }
1315
1316 CK_RV
C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1317 C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen,
1318 CK_BYTE_PTR pEncryptedPart, CK_ULONG_PTR pulEncryptedPartLen)
1319 {
1320 CK_RV rv;
1321
1322 enter("C_DigestEncryptUpdate");
1323 spy_dump_ulong_in("hSession", hSession);
1324 spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
1325 rv = po->C_DigestEncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
1326 if (rv == CKR_OK)
1327 spy_dump_string_out("pEncryptedPart[*pulEncryptedPartLen]", pEncryptedPart, *pulEncryptedPartLen);
1328
1329 return retne(rv);
1330 }
1331
1332 CK_RV
C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1333 C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,
1334 CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
1335 {
1336 CK_RV rv;
1337
1338 enter("C_DecryptDigestUpdate");
1339 spy_dump_ulong_in("hSession", hSession);
1340 spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]", pEncryptedPart, ulEncryptedPartLen);
1341 rv = po->C_DecryptDigestUpdate(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
1342 if (rv == CKR_OK)
1343 spy_dump_string_out("pPart[*pulPartLen]", pPart, *pulPartLen);
1344 return retne(rv);
1345 }
1346
1347 CK_RV
C_SignEncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1348 C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen,
1349 CK_BYTE_PTR pEncryptedPart, CK_ULONG_PTR pulEncryptedPartLen)
1350 {
1351 CK_RV rv;
1352
1353 enter("C_SignEncryptUpdate");
1354 spy_dump_ulong_in("hSession", hSession);
1355 spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
1356 rv = po->C_SignEncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen);
1357 if (rv == CKR_OK)
1358 spy_dump_string_out("pEncryptedPart[*pulEncryptedPartLen]", pEncryptedPart, *pulEncryptedPartLen);
1359
1360 return retne(rv);
1361 }
1362
1363 CK_RV
C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1364 C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart, CK_ULONG ulEncryptedPartLen,
1365 CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen)
1366 {
1367 CK_RV rv;
1368
1369 enter("C_DecryptVerifyUpdate");
1370 spy_dump_ulong_in("hSession", hSession);
1371 spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]", pEncryptedPart, ulEncryptedPartLen);
1372 rv = po->C_DecryptVerifyUpdate(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen);
1373 if (rv == CKR_OK)
1374 spy_dump_string_out("pPart[*pulPartLen]", pPart, *pulPartLen);
1375
1376 return retne(rv);
1377 }
1378
1379 CK_RV
C_GenerateKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phKey)1380 C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1381 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount,
1382 CK_OBJECT_HANDLE_PTR phKey)
1383 {
1384 CK_RV rv;
1385
1386 enter("C_GenerateKey");
1387 spy_dump_ulong_in("hSession", hSession);
1388 spy_dump_mechanism_in("pMechanism", pMechanism);
1389 spy_attribute_list_in("pTemplate", pTemplate, ulCount);
1390 rv = po->C_GenerateKey(hSession, pMechanism, pTemplate, ulCount, phKey);
1391 if (rv == CKR_OK)
1392 spy_dump_ulong_out("hKey", *phKey);
1393
1394 return retne(rv);
1395 }
1396
1397 CK_RV
C_GenerateKeyPair(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_ATTRIBUTE_PTR pPublicKeyTemplate,CK_ULONG ulPublicKeyAttributeCount,CK_ATTRIBUTE_PTR pPrivateKeyTemplate,CK_ULONG ulPrivateKeyAttributeCount,CK_OBJECT_HANDLE_PTR phPublicKey,CK_OBJECT_HANDLE_PTR phPrivateKey)1398 C_GenerateKeyPair(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1399 CK_ATTRIBUTE_PTR pPublicKeyTemplate, CK_ULONG ulPublicKeyAttributeCount,
1400 CK_ATTRIBUTE_PTR pPrivateKeyTemplate, CK_ULONG ulPrivateKeyAttributeCount,
1401 CK_OBJECT_HANDLE_PTR phPublicKey, CK_OBJECT_HANDLE_PTR phPrivateKey)
1402 {
1403 CK_RV rv;
1404
1405 enter("C_GenerateKeyPair");
1406 spy_dump_ulong_in("hSession", hSession);
1407 spy_dump_mechanism_in("pMechanism", pMechanism);
1408 spy_attribute_list_in("pPublicKeyTemplate", pPublicKeyTemplate, ulPublicKeyAttributeCount);
1409 spy_attribute_list_in("pPrivateKeyTemplate", pPrivateKeyTemplate, ulPrivateKeyAttributeCount);
1410 rv = po->C_GenerateKeyPair(hSession, pMechanism,
1411 pPublicKeyTemplate, ulPublicKeyAttributeCount,
1412 pPrivateKeyTemplate, ulPrivateKeyAttributeCount,
1413 phPublicKey, phPrivateKey);
1414 if (rv == CKR_OK) {
1415 spy_dump_ulong_out("hPublicKey", *phPublicKey);
1416 spy_dump_ulong_out("hPrivateKey", *phPrivateKey);
1417 }
1418 return retne(rv);
1419 }
1420
1421 CK_RV
C_WrapKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hWrappingKey,CK_OBJECT_HANDLE hKey,CK_BYTE_PTR pWrappedKey,CK_ULONG_PTR pulWrappedKeyLen)1422 C_WrapKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1423 CK_OBJECT_HANDLE hWrappingKey, CK_OBJECT_HANDLE hKey,
1424 CK_BYTE_PTR pWrappedKey, CK_ULONG_PTR pulWrappedKeyLen)
1425 {
1426 CK_RV rv;
1427
1428 enter("C_WrapKey");
1429 spy_dump_ulong_in("hSession", hSession);
1430 spy_dump_mechanism_in("pMechanism", pMechanism);
1431 spy_dump_ulong_in("hWrappingKey", hWrappingKey);
1432 spy_dump_ulong_in("hKey", hKey);
1433 rv = po->C_WrapKey(hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen);
1434 if (rv == CKR_OK)
1435 spy_dump_string_out("pWrappedKey[*pulWrappedKeyLen]", pWrappedKey, *pulWrappedKeyLen);
1436
1437 return retne(rv);
1438 }
1439
1440 CK_RV
C_UnwrapKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hUnwrappingKey,CK_BYTE_PTR pWrappedKey,CK_ULONG ulWrappedKeyLen,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulAttributeCount,CK_OBJECT_HANDLE_PTR phKey)1441 C_UnwrapKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
1442 CK_OBJECT_HANDLE hUnwrappingKey, CK_BYTE_PTR pWrappedKey, CK_ULONG ulWrappedKeyLen,
1443 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulAttributeCount,
1444 CK_OBJECT_HANDLE_PTR phKey)
1445 {
1446 CK_RV rv;
1447
1448 enter("C_UnwrapKey");
1449 spy_dump_ulong_in("hSession", hSession);
1450 spy_dump_mechanism_in("pMechanism", pMechanism);
1451 spy_dump_ulong_in("hUnwrappingKey", hUnwrappingKey);
1452 spy_dump_string_in("pWrappedKey[ulWrappedKeyLen]", pWrappedKey, ulWrappedKeyLen);
1453 spy_attribute_list_in("pTemplate", pTemplate, ulAttributeCount);
1454 rv = po->C_UnwrapKey(hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate,
1455 ulAttributeCount, phKey);
1456 if (rv == CKR_OK)
1457 spy_dump_ulong_out("hKey", *phKey);
1458 return retne(rv);
1459 }
1460
1461 CK_RV
C_DeriveKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hBaseKey,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulAttributeCount,CK_OBJECT_HANDLE_PTR phKey)1462 C_DeriveKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hBaseKey,
1463 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulAttributeCount, CK_OBJECT_HANDLE_PTR phKey)
1464 {
1465 CK_RV rv;
1466
1467 enter("C_DeriveKey");
1468 spy_dump_ulong_in("hSession", hSession);
1469 spy_dump_mechanism_in("pMechanism", pMechanism);
1470 spy_dump_ulong_in("hBaseKey", hBaseKey);
1471 spy_attribute_list_in("pTemplate", pTemplate, ulAttributeCount);
1472 rv = po->C_DeriveKey(hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey);
1473 if (rv == CKR_OK)
1474 spy_dump_ulong_out("hKey", *phKey);
1475
1476 return retne(rv);
1477 }
1478
1479 CK_RV
C_SeedRandom(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSeed,CK_ULONG ulSeedLen)1480 C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, CK_ULONG ulSeedLen)
1481 {
1482 CK_RV rv;
1483
1484 enter("C_SeedRandom");
1485 spy_dump_ulong_in("hSession", hSession);
1486 spy_dump_string_in("pSeed[ulSeedLen]", pSeed, ulSeedLen);
1487 rv = po->C_SeedRandom(hSession, pSeed, ulSeedLen);
1488 return retne(rv);
1489 }
1490
1491 CK_RV
C_GenerateRandom(CK_SESSION_HANDLE hSession,CK_BYTE_PTR RandomData,CK_ULONG ulRandomLen)1492 C_GenerateRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR RandomData, CK_ULONG ulRandomLen)
1493 {
1494 CK_RV rv;
1495
1496 enter("C_GenerateRandom");
1497 spy_dump_ulong_in("hSession", hSession);
1498 rv = po->C_GenerateRandom(hSession, RandomData, ulRandomLen);
1499 if (rv == CKR_OK)
1500 spy_dump_string_out("RandomData[ulRandomLen]", RandomData, ulRandomLen);
1501 return retne(rv);
1502 }
1503
1504 CK_RV
C_GetFunctionStatus(CK_SESSION_HANDLE hSession)1505 C_GetFunctionStatus(CK_SESSION_HANDLE hSession)
1506 {
1507 CK_RV rv;
1508
1509 enter("C_GetFunctionStatus");
1510 spy_dump_ulong_in("hSession", hSession);
1511 rv = po->C_GetFunctionStatus(hSession);
1512 return retne(rv);
1513 }
1514
1515 CK_RV
C_CancelFunction(CK_SESSION_HANDLE hSession)1516 C_CancelFunction(CK_SESSION_HANDLE hSession)
1517 {
1518 CK_RV rv;
1519
1520 enter("C_CancelFunction");
1521 spy_dump_ulong_in("hSession", hSession);
1522 rv = po->C_CancelFunction(hSession);
1523 return retne(rv);
1524 }
1525
1526 CK_RV
C_WaitForSlotEvent(CK_FLAGS flags,CK_SLOT_ID_PTR pSlot,CK_VOID_PTR pRserved)1527 C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot, CK_VOID_PTR pRserved)
1528 {
1529 CK_RV rv;
1530
1531 enter("C_WaitForSlotEvent");
1532 spy_dump_ulong_in("flags", flags);
1533 if (pSlot != NULL) {
1534 spy_dump_ulong_in("pSlot", *pSlot);
1535 }
1536 rv = po->C_WaitForSlotEvent(flags, pSlot, pRserved);
1537 return retne(rv);
1538 }
1539
1540 /* PKCS #11 3.0 functions */
1541 static void
spy_interface_function_list(CK_INTERFACE_PTR pInterface)1542 spy_interface_function_list(CK_INTERFACE_PTR pInterface)
1543 {
1544 CK_VERSION *version;
1545
1546 /* Do not touch unknown interfaces. We can not do anything with these */
1547 if (strcmp(pInterface->pInterfaceName, "PKCS 11") != 0) {
1548 return;
1549 }
1550
1551 version = (CK_VERSION *)pInterface->pFunctionList;
1552 if (version->major == 2) {
1553 pInterface->pFunctionList = pkcs11_spy;
1554 } else if (version->major == 3 && version->minor == 0) {
1555 pInterface->pFunctionList = pkcs11_spy_3_0;
1556 }
1557 }
1558
1559 CK_RV
C_GetInterfaceList(CK_INTERFACE_PTR pInterfacesList,CK_ULONG_PTR pulCount)1560 C_GetInterfaceList(CK_INTERFACE_PTR pInterfacesList, CK_ULONG_PTR pulCount)
1561 {
1562 CK_RV rv;
1563
1564 if (po == NULL) {
1565 CK_RV rv = init_spy();
1566 if (rv != CKR_OK)
1567 return rv;
1568 }
1569
1570 enter("C_GetInterfaceList");
1571 if (po->version.major < 3) {
1572 fprintf(spy_output, "[compat]\n");
1573
1574 memcpy(pInterfacesList, compat_interfaces, NUM_INTERFACES * sizeof(CK_INTERFACE));
1575 *pulCount = NUM_INTERFACES;
1576
1577 spy_dump_desc_out("pInterfacesList");
1578 print_interfaces_list(spy_output, pInterfacesList, *pulCount);
1579 spy_dump_ulong_out("*pulCount", *pulCount);
1580 return retne(CKR_OK);
1581 }
1582 rv = po->C_GetInterfaceList(pInterfacesList, pulCount);
1583 if (rv == CKR_OK) {
1584 spy_dump_desc_out("pInterfacesList");
1585 print_interfaces_list(spy_output, pInterfacesList, *pulCount);
1586 spy_dump_ulong_out("*pulCount", *pulCount);
1587
1588 /* Now, replace function lists of known interfaces (PKCS 11, v 2.x and 3.0) */
1589 if (pInterfacesList != NULL) {
1590 unsigned long i;
1591 for (i = 0; i < *pulCount; i++) {
1592 spy_interface_function_list(&pInterfacesList[i]);
1593 }
1594 }
1595 }
1596 return retne(rv);
1597 }
1598
1599 CK_RV
C_GetInterface(CK_UTF8CHAR_PTR pInterfaceName,CK_VERSION_PTR pVersion,CK_INTERFACE_PTR_PTR ppInterface,CK_FLAGS flags)1600 C_GetInterface(CK_UTF8CHAR_PTR pInterfaceName, CK_VERSION_PTR pVersion,
1601 CK_INTERFACE_PTR_PTR ppInterface, CK_FLAGS flags)
1602 {
1603 CK_RV rv;
1604
1605 if (po == NULL) {
1606 CK_RV rv = init_spy();
1607 if (rv != CKR_OK)
1608 return rv;
1609 }
1610
1611 enter("C_GetInterface");
1612 if (po->version.major < 3) {
1613 fprintf(spy_output, "[compat]\n");
1614 }
1615 spy_dump_string_in("pInterfaceName", pInterfaceName, strlen((char *)pInterfaceName));
1616 if (pVersion != NULL) {
1617 fprintf(spy_output, "[in] pVersion = %d.%d\n", pVersion->major, pVersion->minor);
1618 } else {
1619 fprintf(spy_output, "[in] pVersion = NULL\n");
1620 }
1621 fprintf(spy_output, "[in] flags = %s\n",
1622 (flags & CKF_INTERFACE_FORK_SAFE ? "CKF_INTERFACE_FORK_SAFE" : ""));
1623 if (po->version.major >= 3) {
1624 rv = po->C_GetInterface(pInterfaceName, pVersion, ppInterface, flags);
1625 if (ppInterface != NULL) {
1626 spy_interface_function_list(*ppInterface);
1627 }
1628 } else {
1629 if ((pInterfaceName == NULL_PTR || strcmp((char *)pInterfaceName, "PKCS 11") == 0) &&
1630 (pVersion == NULL_PTR || (pVersion->major == 2 && pVersion->minor == 11)) &&
1631 flags == 0) {
1632 *ppInterface = &compat_interfaces[0];
1633 return retne(CKR_OK);
1634 }
1635 /* We can not serve this particular interface */
1636 return retne(CKR_ARGUMENTS_BAD);
1637 }
1638
1639 return retne(rv);
1640 }
1641
1642 CK_RV
C_LoginUser(CK_SESSION_HANDLE hSession,CK_USER_TYPE userType,CK_CHAR_PTR pPin,CK_ULONG ulPinLen,CK_UTF8CHAR_PTR pUsername,CK_ULONG ulUsernameLen)1643 C_LoginUser(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
1644 CK_CHAR_PTR pPin, CK_ULONG ulPinLen, CK_UTF8CHAR_PTR pUsername, CK_ULONG ulUsernameLen)
1645 {
1646 CK_RV rv;
1647
1648 enter("C_LoginUser");
1649 spy_dump_ulong_in("hSession", hSession);
1650 fprintf(spy_output, "[in] userType = %s\n",
1651 lookup_enum(USR_T, userType));
1652 spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen);
1653 spy_dump_string_in("pUsername[ulUsernameLen]", pUsername, ulUsernameLen);
1654 rv = po->C_LoginUser(hSession, userType, pPin, ulPinLen, pUsername, ulUsernameLen);
1655
1656 return retne(rv);
1657 }
1658
C_SessionCancel(CK_SESSION_HANDLE hSession,CK_FLAGS flags)1659 CK_RV C_SessionCancel(CK_SESSION_HANDLE hSession, CK_FLAGS flags)
1660 {
1661 CK_RV rv;
1662
1663 enter("C_SessionCancel");
1664 spy_dump_ulong_in("hSession", hSession);
1665 fprintf(spy_output, "[in] flags = %s%s%s%s%s%s%s%s%s%s%s%s\n",
1666 (flags & CKF_ENCRYPT) ? "Encrypt " : "",
1667 (flags & CKF_DECRYPT) ? "Decrypt " : "",
1668 (flags & CKF_DIGEST) ? "Digest " : "",
1669 (flags & CKF_SIGN) ? "Sign " : "",
1670 (flags & CKF_SIGN_RECOVER) ? "SigRecov " : "",
1671 (flags & CKF_VERIFY) ? "Verify " : "",
1672 (flags & CKF_VERIFY_RECOVER) ? "VerRecov " : "",
1673 (flags & CKF_GENERATE) ? "Generate " : "",
1674 (flags & CKF_GENERATE_KEY_PAIR) ? "KeyPair " : "",
1675 (flags & CKF_WRAP) ? "Wrap " : "",
1676 (flags & CKF_UNWRAP) ? "Unwrap " : "",
1677 (flags & CKF_DERIVE) ? "Derive " : "");
1678 rv = po->C_SessionCancel(hSession, flags);
1679
1680 return retne(rv);
1681 }
1682
1683 CK_RV
C_MessageEncryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1684 C_MessageEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1685 {
1686 CK_RV rv;
1687
1688 enter("C_MessageEncryptInit");
1689 spy_dump_ulong_in("hSession", hSession);
1690 spy_dump_mechanism_in("pMechanism", pMechanism);
1691 spy_dump_ulong_in("hKey", hKey);
1692 rv = po->C_MessageEncryptInit(hSession, pMechanism, hKey);
1693 return retne(rv);
1694 }
1695
1696 CK_RV
C_EncryptMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen,CK_BYTE_PTR pPlaintext,CK_ULONG ulPlaintextLen,CK_BYTE_PTR pCiphertext,CK_ULONG_PTR pulCiphertextLen)1697 C_EncryptMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1698 CK_BYTE_PTR pAssociatedData, CK_ULONG ulAssociatedDataLen,
1699 CK_BYTE_PTR pPlaintext, CK_ULONG ulPlaintextLen,
1700 CK_BYTE_PTR pCiphertext, CK_ULONG_PTR pulCiphertextLen)
1701 {
1702 CK_RV rv;
1703
1704 enter("C_EncryptMessage");
1705 spy_dump_ulong_in("hSession", hSession);
1706 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1707 spy_dump_string_in("pAssociatedData[ulAssociatedDataLen]", pAssociatedData, ulAssociatedDataLen);
1708 spy_dump_string_in("pPlaintext[ulPlaintextLen]", pPlaintext, ulPlaintextLen);
1709 rv = po->C_EncryptMessage(hSession, pParameter, ulParameterLen,
1710 pAssociatedData, ulAssociatedDataLen, pPlaintext, ulPlaintextLen,
1711 pCiphertext, pulCiphertextLen);
1712 if (rv == CKR_OK) {
1713 spy_dump_string_out("pCiphertext[*pulCiphertextLen]", pCiphertext, *pulCiphertextLen);
1714 }
1715 return retne(rv);
1716 }
1717
1718 CK_RV
C_EncryptMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen)1719 C_EncryptMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1720 CK_BYTE_PTR pAssociatedData, CK_ULONG ulAssociatedDataLen)
1721 {
1722 CK_RV rv;
1723
1724 enter("C_EncryptMessageBegin");
1725 spy_dump_ulong_in("hSession", hSession);
1726 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1727 spy_dump_string_in("pAssociatedData[ulAssociatedDataLen]", pAssociatedData, ulAssociatedDataLen);
1728 rv = po->C_EncryptMessageBegin(hSession, pParameter, ulParameterLen,
1729 pAssociatedData, ulAssociatedDataLen);
1730 return retne(rv);
1731 }
1732
1733 CK_RV
C_EncryptMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pPlaintextPart,CK_ULONG ulPlaintextPartLen,CK_BYTE_PTR pCiphertextPart,CK_ULONG_PTR pulCiphertextPartLen,CK_FLAGS flags)1734 C_EncryptMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1735 CK_BYTE_PTR pPlaintextPart, CK_ULONG ulPlaintextPartLen,
1736 CK_BYTE_PTR pCiphertextPart, CK_ULONG_PTR pulCiphertextPartLen, CK_FLAGS flags)
1737 {
1738 CK_RV rv;
1739
1740 enter("C_EncryptMessageNext");
1741 spy_dump_ulong_in("hSession", hSession);
1742 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1743 spy_dump_string_in("pPlaintextPart[ulPlaintextPartLen]", pPlaintextPart, ulPlaintextPartLen);
1744 rv = po->C_EncryptMessageNext(hSession, pParameter, ulParameterLen,
1745 pPlaintextPart, ulPlaintextPartLen, pCiphertextPart, pulCiphertextPartLen, flags);
1746 if (rv == CKR_OK) {
1747 spy_dump_string_out("pCiphertextPart[*pulCiphertextPartLen]",
1748 pCiphertextPart, *pulCiphertextPartLen);
1749 }
1750 fprintf(spy_output, "[in] flags = %s\n",
1751 (flags & CKF_END_OF_MESSAGE ? "CKF_END_OF_MESSAGE" : ""));
1752 return retne(rv);
1753 }
1754
1755 CK_RV
C_MessageEncryptFinal(CK_SESSION_HANDLE hSession)1756 C_MessageEncryptFinal(CK_SESSION_HANDLE hSession)
1757 {
1758 CK_RV rv;
1759
1760 enter("C_MessageEncryptFinal");
1761 spy_dump_ulong_in("hSession", hSession);
1762 rv = po->C_MessageEncryptFinal(hSession);
1763 return retne(rv);
1764 }
1765
1766 CK_RV
C_MessageDecryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1767 C_MessageDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1768 {
1769 CK_RV rv;
1770
1771 enter("C_MessageDecryptInit");
1772 spy_dump_ulong_in("hSession", hSession);
1773 spy_dump_mechanism_in("pMechanism", pMechanism);
1774 spy_dump_ulong_in("hKey", hKey);
1775 rv = po->C_MessageDecryptInit(hSession, pMechanism, hKey);
1776 return retne(rv);
1777 }
1778
1779 CK_RV
C_DecryptMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen,CK_BYTE_PTR pCiphertext,CK_ULONG ulCiphertextLen,CK_BYTE_PTR pPlaintext,CK_ULONG_PTR pulPlaintextLen)1780 C_DecryptMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1781 CK_BYTE_PTR pAssociatedData, CK_ULONG ulAssociatedDataLen,
1782 CK_BYTE_PTR pCiphertext, CK_ULONG ulCiphertextLen,
1783 CK_BYTE_PTR pPlaintext, CK_ULONG_PTR pulPlaintextLen)
1784 {
1785 CK_RV rv;
1786
1787 enter("C_DecryptMessage");
1788 spy_dump_ulong_in("hSession", hSession);
1789 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1790 spy_dump_string_in("pAssociatedData[ulAssociatedDataLen]", pAssociatedData, ulAssociatedDataLen);
1791 spy_dump_string_in("pCiphertext[ulCiphertextLen]", pCiphertext, ulCiphertextLen);
1792 rv = po->C_DecryptMessage(hSession, pParameter, ulParameterLen,
1793 pAssociatedData, ulAssociatedDataLen, pCiphertext, ulCiphertextLen,
1794 pPlaintext, pulPlaintextLen);
1795 if (rv == CKR_OK) {
1796 spy_dump_string_out("pPlaintext[*pulPlaintextLen]", pPlaintext, *pulPlaintextLen);
1797 }
1798 return retne(rv);
1799 }
1800
1801 CK_RV
C_DecryptMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pAssociatedData,CK_ULONG ulAssociatedDataLen)1802 C_DecryptMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1803 CK_BYTE_PTR pAssociatedData, CK_ULONG ulAssociatedDataLen)
1804 {
1805 CK_RV rv;
1806
1807 enter("C_DecryptMessageBegin");
1808 spy_dump_ulong_in("hSession", hSession);
1809 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1810 spy_dump_string_in("pAssociatedData[ulAssociatedDataLen]", pAssociatedData, ulAssociatedDataLen);
1811 rv = po->C_DecryptMessageBegin(hSession, pParameter, ulParameterLen,
1812 pAssociatedData, ulAssociatedDataLen);
1813 return retne(rv);
1814 }
1815
1816 CK_RV
C_DecryptMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pCiphertextPart,CK_ULONG ulCiphertextPartLen,CK_BYTE_PTR pPlaintextPart,CK_ULONG_PTR pulPlaintextPartLen,CK_FLAGS flags)1817 C_DecryptMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1818 CK_BYTE_PTR pCiphertextPart, CK_ULONG ulCiphertextPartLen,
1819 CK_BYTE_PTR pPlaintextPart, CK_ULONG_PTR pulPlaintextPartLen, CK_FLAGS flags)
1820 {
1821 CK_RV rv;
1822
1823 enter("C_DecryptMessageNext");
1824 spy_dump_ulong_in("hSession", hSession);
1825 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1826 spy_dump_string_in("pCiphertextPart[ulCiphertextPartLen]", pCiphertextPart, ulCiphertextPartLen);
1827 rv = po->C_DecryptMessageNext(hSession, pParameter, ulParameterLen,
1828 pCiphertextPart, ulCiphertextPartLen, pPlaintextPart, pulPlaintextPartLen, flags);
1829 if (rv == CKR_OK) {
1830 spy_dump_string_out("pPlaintextPart[*pulPlaintextPartLen]",
1831 pPlaintextPart, *pulPlaintextPartLen);
1832 }
1833 fprintf(spy_output, "[in] flags = %s\n",
1834 (flags & CKF_END_OF_MESSAGE ? "CKF_END_OF_MESSAGE" : ""));
1835 return retne(rv);
1836 }
1837
1838 CK_RV
C_MessageDecryptFinal(CK_SESSION_HANDLE hSession)1839 C_MessageDecryptFinal(CK_SESSION_HANDLE hSession)
1840 {
1841 CK_RV rv;
1842
1843 enter("C_MessageDecryptFinal");
1844 spy_dump_ulong_in("hSession", hSession);
1845 rv = po->C_MessageDecryptFinal(hSession);
1846 return retne(rv);
1847 }
1848
1849 CK_RV
C_MessageSignInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1850 C_MessageSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1851 {
1852 CK_RV rv;
1853
1854 enter("C_MessageSignInit");
1855 spy_dump_ulong_in("hSession", hSession);
1856 spy_dump_mechanism_in("pMechanism", pMechanism);
1857 spy_dump_ulong_in("hKey", hKey);
1858 rv = po->C_MessageSignInit(hSession, pMechanism, hKey);
1859 return retne(rv);
1860 }
1861
1862 CK_RV
C_SignMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1863 C_SignMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1864 CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
1865 {
1866 CK_RV rv;
1867
1868 enter("C_SignMessage");
1869 spy_dump_ulong_in("hSession", hSession);
1870 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1871 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1872 rv = po->C_SignMessage(hSession, pParameter, ulParameterLen,
1873 pData, ulDataLen, pSignature, pulSignatureLen);
1874 if (rv == CKR_OK) {
1875 spy_dump_string_out("pSignature[*pulSignatureLen]", pSignature, *pulSignatureLen);
1876 }
1877 return retne(rv);
1878 }
1879
1880 CK_RV
C_SignMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen)1881 C_SignMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen)
1882 {
1883 CK_RV rv;
1884
1885 enter("C_SignMessageBegin");
1886 spy_dump_ulong_in("hSession", hSession);
1887 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1888 rv = po->C_SignMessageBegin(hSession, pParameter, ulParameterLen);
1889 return retne(rv);
1890 }
1891
1892 CK_RV
C_SignMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1893 C_SignMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1894 CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
1895 {
1896 CK_RV rv;
1897
1898 enter("C_SignMessageNext");
1899 spy_dump_ulong_in("hSession", hSession);
1900 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1901 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1902 rv = po->C_SignMessageNext(hSession, pParameter, ulParameterLen,
1903 pData, ulDataLen, pSignature, pulSignatureLen);
1904 if (rv == CKR_OK) {
1905 spy_dump_string_out("pSignature[*pulSignatureLen]", pSignature, *pulSignatureLen);
1906 }
1907 return retne(rv);
1908 }
1909
1910 CK_RV
C_MessageSignFinal(CK_SESSION_HANDLE hSession)1911 C_MessageSignFinal(CK_SESSION_HANDLE hSession)
1912 {
1913 CK_RV rv;
1914
1915 enter("C_MessageSignFinal");
1916 spy_dump_ulong_in("hSession", hSession);
1917 rv = po->C_MessageSignFinal(hSession);
1918 return retne(rv);
1919 }
1920
1921 CK_RV
C_MessageVerifyInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1922 C_MessageVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey)
1923 {
1924 CK_RV rv;
1925
1926 enter("C_MessageVerifyInit");
1927 spy_dump_ulong_in("hSession", hSession);
1928 spy_dump_mechanism_in("pMechanism", pMechanism);
1929 spy_dump_ulong_in("hKey", hKey);
1930 rv = po->C_MessageVerifyInit(hSession, pMechanism, hKey);
1931 return retne(rv);
1932 }
1933
1934 CK_RV
C_VerifyMessage(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1935 C_VerifyMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1936 CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
1937 {
1938 CK_RV rv;
1939
1940 enter("C_VerifyMessage");
1941 spy_dump_ulong_in("hSession", hSession);
1942 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1943 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1944 spy_dump_string_in("pSignature[ulSignatureLen]", pSignature, ulSignatureLen);
1945 rv = po->C_VerifyMessage(hSession, pParameter, ulParameterLen,
1946 pData, ulDataLen, pSignature, ulSignatureLen);
1947 return retne(rv);
1948 }
1949
1950 CK_RV
C_VerifyMessageBegin(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen)1951 C_VerifyMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen)
1952 {
1953 CK_RV rv;
1954
1955 enter("C_VerifyMessageBegin");
1956 spy_dump_ulong_in("hSession", hSession);
1957 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1958 rv = po->C_VerifyMessageBegin(hSession, pParameter, ulParameterLen);
1959 return retne(rv);
1960 }
1961
C_VerifyMessageNext(CK_SESSION_HANDLE hSession,CK_VOID_PTR pParameter,CK_ULONG ulParameterLen,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1962 CK_RV C_VerifyMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, CK_ULONG ulParameterLen,
1963 CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
1964 {
1965 CK_RV rv;
1966
1967 enter("C_VerifyMessageNext");
1968 spy_dump_ulong_in("hSession", hSession);
1969 spy_dump_string_in("pParameter[ulParameterLen]", pParameter, ulParameterLen);
1970 spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
1971 spy_dump_string_in("pSignature[ulSignatureLen]", pSignature, ulSignatureLen);
1972 rv = po->C_VerifyMessageNext(hSession, pParameter, ulParameterLen,
1973 pData, ulDataLen, pSignature, ulSignatureLen);
1974 return retne(rv);
1975 }
1976
C_MessageVerifyFinal(CK_SESSION_HANDLE hSession)1977 CK_RV C_MessageVerifyFinal(CK_SESSION_HANDLE hSession)
1978 {
1979 CK_RV rv;
1980
1981 enter("C_MessageVerifyFinal");
1982 spy_dump_ulong_in("hSession", hSession);
1983 rv = po->C_MessageVerifyFinal(hSession);
1984 return retne(rv);
1985 }
1986