1 // SPDX-License-Identifier: BSD-2-Clause
2 /*
3 * Copyright (c) 2017-2020, Linaro Limited
4 */
5
6 #include <pkcs11.h>
7 #include <stdbool.h>
8 #include <stddef.h>
9
10 #include "ck_helpers.h"
11 #include "invoke_ta.h"
12 #include "pkcs11_processing.h"
13 #include "pkcs11_token.h"
14
15 static const CK_FUNCTION_LIST libckteec_function_list = {
16 .version = {
17 .major = CK_PKCS11_VERSION_MAJOR,
18 .minor = CK_PKCS11_VERSION_MINOR,
19 },
20 .C_Initialize = C_Initialize,
21 .C_Finalize = C_Finalize,
22 .C_GetInfo = C_GetInfo,
23 .C_GetFunctionList = C_GetFunctionList,
24 .C_GetSlotList = C_GetSlotList,
25 .C_GetSlotInfo = C_GetSlotInfo,
26 .C_GetTokenInfo = C_GetTokenInfo,
27 .C_GetMechanismList = C_GetMechanismList,
28 .C_GetMechanismInfo = C_GetMechanismInfo,
29 .C_InitToken = C_InitToken,
30 .C_InitPIN = C_InitPIN,
31 .C_SetPIN = C_SetPIN,
32 .C_OpenSession = C_OpenSession,
33 .C_CloseSession = C_CloseSession,
34 .C_CloseAllSessions = C_CloseAllSessions,
35 .C_GetSessionInfo = C_GetSessionInfo,
36 .C_GetOperationState = C_GetOperationState,
37 .C_SetOperationState = C_SetOperationState,
38 .C_Login = C_Login,
39 .C_Logout = C_Logout,
40 .C_CreateObject = C_CreateObject,
41 .C_CopyObject = C_CopyObject,
42 .C_DestroyObject = C_DestroyObject,
43 .C_GetObjectSize = C_GetObjectSize,
44 .C_GetAttributeValue = C_GetAttributeValue,
45 .C_SetAttributeValue = C_SetAttributeValue,
46 .C_FindObjectsInit = C_FindObjectsInit,
47 .C_FindObjects = C_FindObjects,
48 .C_FindObjectsFinal = C_FindObjectsFinal,
49 .C_EncryptInit = C_EncryptInit,
50 .C_Encrypt = C_Encrypt,
51 .C_EncryptUpdate = C_EncryptUpdate,
52 .C_EncryptFinal = C_EncryptFinal,
53 .C_DecryptInit = C_DecryptInit,
54 .C_Decrypt = C_Decrypt,
55 .C_DecryptUpdate = C_DecryptUpdate,
56 .C_DecryptFinal = C_DecryptFinal,
57 .C_DigestInit = C_DigestInit,
58 .C_Digest = C_Digest,
59 .C_DigestUpdate = C_DigestUpdate,
60 .C_DigestKey = C_DigestKey,
61 .C_DigestFinal = C_DigestFinal,
62 .C_SignInit = C_SignInit,
63 .C_Sign = C_Sign,
64 .C_SignUpdate = C_SignUpdate,
65 .C_SignFinal = C_SignFinal,
66 .C_SignRecoverInit = C_SignRecoverInit,
67 .C_SignRecover = C_SignRecover,
68 .C_VerifyInit = C_VerifyInit,
69 .C_Verify = C_Verify,
70 .C_VerifyUpdate = C_VerifyUpdate,
71 .C_VerifyFinal = C_VerifyFinal,
72 .C_VerifyRecoverInit = C_VerifyRecoverInit,
73 .C_VerifyRecover = C_VerifyRecover,
74 .C_DigestEncryptUpdate = C_DigestEncryptUpdate,
75 .C_DecryptDigestUpdate = C_DecryptDigestUpdate,
76 .C_SignEncryptUpdate = C_SignEncryptUpdate,
77 .C_DecryptVerifyUpdate = C_DecryptVerifyUpdate,
78 .C_GenerateKey = C_GenerateKey,
79 .C_GenerateKeyPair = C_GenerateKeyPair,
80 .C_WrapKey = C_WrapKey,
81 .C_UnwrapKey = C_UnwrapKey,
82 .C_DeriveKey = C_DeriveKey,
83 .C_SeedRandom = C_SeedRandom,
84 .C_GenerateRandom = C_GenerateRandom,
85 .C_GetFunctionStatus = C_GetFunctionStatus,
86 .C_CancelFunction = C_CancelFunction,
87 .C_WaitForSlotEvent = C_WaitForSlotEvent,
88 };
89
lib_initiated(void)90 static bool lib_initiated(void)
91 {
92 return ckteec_invoke_initiated();
93 }
94
C_Initialize(CK_VOID_PTR pInitArgs)95 CK_RV C_Initialize(CK_VOID_PTR pInitArgs)
96 {
97 CK_C_INITIALIZE_ARGS_PTR args = NULL;
98 CK_RV rv = 0;
99
100 if (pInitArgs) {
101 args = (CK_C_INITIALIZE_ARGS_PTR)pInitArgs;
102
103 /* Reserved must be set to NULL in this version of PKCS#11 */
104 if (args->reserved)
105 return CKR_ARGUMENTS_BAD;
106 }
107
108 rv = ckteec_invoke_init();
109
110 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CANT_LOCK,
111 CKR_CRYPTOKI_ALREADY_INITIALIZED, CKR_FUNCTION_FAILED,
112 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
113 CKR_NEED_TO_CREATE_THREADS, CKR_OK,
114 CKR_MUTEX_BAD);
115
116 return rv;
117 }
118
C_Finalize(CK_VOID_PTR pReserved)119 CK_RV C_Finalize(CK_VOID_PTR pReserved)
120 {
121 CK_RV rv = 0;
122
123 /* Reserved must be set to NULL in this version of PKCS#11 */
124 if (pReserved)
125 return CKR_ARGUMENTS_BAD;
126
127 rv = ckteec_invoke_terminate();
128
129 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
130 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
131 CKR_OK);
132
133 return rv;
134 }
135
C_GetInfo(CK_INFO_PTR pInfo)136 CK_RV C_GetInfo(CK_INFO_PTR pInfo)
137 {
138 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
139
140 if (lib_initiated())
141 rv = ck_get_info(pInfo);
142
143 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
144 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
145 CKR_OK);
146
147 return rv;
148 }
149
C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)150 CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)
151 {
152 if (!ppFunctionList)
153 return CKR_ARGUMENTS_BAD;
154
155 /* Discard the const attribute when exporting the list address */
156 *ppFunctionList = (void *)&libckteec_function_list;
157
158 return CKR_OK;
159 }
160
C_GetSlotList(CK_BBOOL tokenPresent,CK_SLOT_ID_PTR pSlotList,CK_ULONG_PTR pulCount)161 CK_RV C_GetSlotList(CK_BBOOL tokenPresent,
162 CK_SLOT_ID_PTR pSlotList,
163 CK_ULONG_PTR pulCount)
164 {
165 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
166
167 if (lib_initiated())
168 rv = ck_slot_get_list(tokenPresent, pSlotList, pulCount);
169
170 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
171 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_FUNCTION_FAILED,
172 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK);
173
174 return rv;
175 }
176
C_GetSlotInfo(CK_SLOT_ID slotID,CK_SLOT_INFO_PTR pInfo)177 CK_RV C_GetSlotInfo(CK_SLOT_ID slotID,
178 CK_SLOT_INFO_PTR pInfo)
179 {
180 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
181
182 if (lib_initiated())
183 rv = ck_slot_get_info(slotID, pInfo);
184
185 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
186 CKR_DEVICE_ERROR, CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR,
187 CKR_HOST_MEMORY, CKR_OK, CKR_SLOT_ID_INVALID);
188
189 return rv;
190 }
191
C_InitToken(CK_SLOT_ID slotID,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen,CK_UTF8CHAR_PTR pLabel)192 CK_RV C_InitToken(CK_SLOT_ID slotID,
193 CK_UTF8CHAR_PTR pPin,
194 CK_ULONG ulPinLen,
195 CK_UTF8CHAR_PTR pLabel)
196 {
197 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
198
199 if (lib_initiated())
200 rv = ck_init_token(slotID, pPin, ulPinLen, pLabel);
201
202 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
203 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
204 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
205 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
206 CKR_PIN_INCORRECT, CKR_PIN_LOCKED, CKR_SESSION_EXISTS,
207 CKR_SLOT_ID_INVALID, CKR_TOKEN_NOT_PRESENT,
208 CKR_TOKEN_NOT_RECOGNIZED, CKR_TOKEN_WRITE_PROTECTED);
209
210 return rv;
211 }
212
C_GetTokenInfo(CK_SLOT_ID slotID,CK_TOKEN_INFO_PTR pInfo)213 CK_RV C_GetTokenInfo(CK_SLOT_ID slotID,
214 CK_TOKEN_INFO_PTR pInfo)
215 {
216 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
217
218 if (lib_initiated())
219 rv = ck_token_get_info(slotID, pInfo);
220
221 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
222 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
223 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
224 CKR_SLOT_ID_INVALID, CKR_TOKEN_NOT_PRESENT,
225 CKR_TOKEN_NOT_RECOGNIZED, CKR_ARGUMENTS_BAD);
226
227 return rv;
228 }
229
C_GetMechanismList(CK_SLOT_ID slotID,CK_MECHANISM_TYPE_PTR pMechanismList,CK_ULONG_PTR pulCount)230 CK_RV C_GetMechanismList(CK_SLOT_ID slotID,
231 CK_MECHANISM_TYPE_PTR pMechanismList,
232 CK_ULONG_PTR pulCount)
233 {
234 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
235
236 if (lib_initiated())
237 rv = ck_token_mechanism_ids(slotID, pMechanismList, pulCount);
238
239 ASSERT_CK_RV(rv, CKR_BUFFER_TOO_SMALL, CKR_CRYPTOKI_NOT_INITIALIZED,
240 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
241 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
242 CKR_OK, CKR_SLOT_ID_INVALID, CKR_TOKEN_NOT_PRESENT,
243 CKR_TOKEN_NOT_RECOGNIZED, CKR_ARGUMENTS_BAD);
244
245 return rv;
246 }
247
C_GetMechanismInfo(CK_SLOT_ID slotID,CK_MECHANISM_TYPE type,CK_MECHANISM_INFO_PTR pInfo)248 CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID,
249 CK_MECHANISM_TYPE type,
250 CK_MECHANISM_INFO_PTR pInfo)
251 {
252 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
253
254 if (lib_initiated())
255 rv = ck_token_mechanism_info(slotID, type, pInfo);
256
257 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
258 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
259 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_MECHANISM_INVALID,
260 CKR_OK, CKR_SLOT_ID_INVALID, CKR_TOKEN_NOT_PRESENT,
261 CKR_TOKEN_NOT_RECOGNIZED, CKR_ARGUMENTS_BAD);
262
263 return rv;
264 }
265
C_OpenSession(CK_SLOT_ID slotID,CK_FLAGS flags,CK_VOID_PTR pApplication,CK_NOTIFY Notify,CK_SESSION_HANDLE_PTR phSession)266 CK_RV C_OpenSession(CK_SLOT_ID slotID,
267 CK_FLAGS flags,
268 CK_VOID_PTR pApplication,
269 CK_NOTIFY Notify,
270 CK_SESSION_HANDLE_PTR phSession)
271 {
272 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
273
274 if (lib_initiated())
275 rv = ck_open_session(slotID, flags, pApplication, Notify,
276 phSession);
277
278 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
279 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
280 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
281 CKR_SESSION_COUNT, CKR_SESSION_PARALLEL_NOT_SUPPORTED,
282 CKR_SESSION_READ_WRITE_SO_EXISTS, CKR_SLOT_ID_INVALID,
283 CKR_TOKEN_NOT_PRESENT, CKR_TOKEN_NOT_RECOGNIZED,
284 CKR_TOKEN_WRITE_PROTECTED, CKR_ARGUMENTS_BAD);
285
286 return rv;
287 }
288
C_CloseSession(CK_SESSION_HANDLE hSession)289 CK_RV C_CloseSession(CK_SESSION_HANDLE hSession)
290 {
291 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
292
293 if (lib_initiated())
294 rv = ck_close_session(hSession);
295
296 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
297 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
298 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
299 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID);
300
301 return rv;
302 }
303
C_CloseAllSessions(CK_SLOT_ID slotID)304 CK_RV C_CloseAllSessions(CK_SLOT_ID slotID)
305 {
306 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
307
308 if (lib_initiated())
309 rv = ck_close_all_sessions(slotID);
310
311 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
312 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
313 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
314 CKR_SLOT_ID_INVALID, CKR_TOKEN_NOT_PRESENT);
315
316 return rv;
317 }
318
C_GetSessionInfo(CK_SESSION_HANDLE hSession,CK_SESSION_INFO_PTR pInfo)319 CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession,
320 CK_SESSION_INFO_PTR pInfo)
321 {
322 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
323
324 if (lib_initiated())
325 rv = ck_get_session_info(hSession, pInfo);
326
327 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
328 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
329 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
330 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
331 CKR_ARGUMENTS_BAD);
332
333 return rv;
334 }
335
C_InitPIN(CK_SESSION_HANDLE hSession,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen)336 CK_RV C_InitPIN(CK_SESSION_HANDLE hSession,
337 CK_UTF8CHAR_PTR pPin,
338 CK_ULONG ulPinLen)
339 {
340 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
341
342 if (lib_initiated())
343 rv = ck_init_pin(hSession, pPin, ulPinLen);
344
345 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
346 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
347 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
348 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
349 CKR_PIN_INVALID, CKR_PIN_LEN_RANGE, CKR_SESSION_CLOSED,
350 CKR_SESSION_READ_ONLY, CKR_SESSION_HANDLE_INVALID,
351 CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN,
352 CKR_ARGUMENTS_BAD);
353
354 return rv;
355 }
356
C_SetPIN(CK_SESSION_HANDLE hSession,CK_UTF8CHAR_PTR pOldPin,CK_ULONG ulOldLen,CK_UTF8CHAR_PTR pNewPin,CK_ULONG ulNewLen)357 CK_RV C_SetPIN(CK_SESSION_HANDLE hSession,
358 CK_UTF8CHAR_PTR pOldPin,
359 CK_ULONG ulOldLen,
360 CK_UTF8CHAR_PTR pNewPin,
361 CK_ULONG ulNewLen)
362 {
363 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
364
365 if (lib_initiated())
366 rv = ck_set_pin(hSession, pOldPin, ulOldLen, pNewPin, ulNewLen);
367
368 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
369 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
370 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
371 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
372 CKR_OK, CKR_PIN_INCORRECT, CKR_PIN_INVALID,
373 CKR_PIN_LEN_RANGE, CKR_PIN_LOCKED, CKR_SESSION_CLOSED,
374 CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY,
375 CKR_TOKEN_WRITE_PROTECTED, CKR_ARGUMENTS_BAD);
376
377 return rv;
378 }
379
C_Login(CK_SESSION_HANDLE hSession,CK_USER_TYPE userType,CK_UTF8CHAR_PTR pPin,CK_ULONG ulPinLen)380 CK_RV C_Login(CK_SESSION_HANDLE hSession,
381 CK_USER_TYPE userType,
382 CK_UTF8CHAR_PTR pPin,
383 CK_ULONG ulPinLen)
384
385 {
386 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
387
388 if (lib_initiated())
389 rv = ck_login(hSession, userType, pPin, ulPinLen);
390
391 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
392 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
393 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
394 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
395 CKR_OPERATION_NOT_INITIALIZED, CKR_PIN_INCORRECT,
396 CKR_PIN_LOCKED, CKR_SESSION_CLOSED,
397 CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY_EXISTS,
398 CKR_USER_ALREADY_LOGGED_IN,
399 CKR_USER_ANOTHER_ALREADY_LOGGED_IN,
400 CKR_USER_PIN_NOT_INITIALIZED, CKR_USER_TOO_MANY_TYPES,
401 CKR_USER_TYPE_INVALID);
402
403 return rv;
404 }
405
C_Logout(CK_SESSION_HANDLE hSession)406 CK_RV C_Logout(CK_SESSION_HANDLE hSession)
407 {
408 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
409
410 if (lib_initiated())
411 rv = ck_logout(hSession);
412
413 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
414 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
415 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
416 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
417 CKR_USER_NOT_LOGGED_IN);
418
419 return rv;
420 }
421
C_GetOperationState(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG_PTR pulOperationStateLen)422 CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession,
423 CK_BYTE_PTR pOperationState,
424 CK_ULONG_PTR pulOperationStateLen)
425 {
426 (void)hSession;
427 (void)pOperationState;
428 (void)pulOperationStateLen;
429
430 if (!lib_initiated())
431 return CKR_CRYPTOKI_NOT_INITIALIZED;
432
433 return CKR_FUNCTION_NOT_SUPPORTED;
434 }
435
C_SetOperationState(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pOperationState,CK_ULONG ulOperationStateLen,CK_OBJECT_HANDLE hEncryptionKey,CK_OBJECT_HANDLE hAuthenticationKey)436 CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession,
437 CK_BYTE_PTR pOperationState,
438 CK_ULONG ulOperationStateLen,
439 CK_OBJECT_HANDLE hEncryptionKey,
440 CK_OBJECT_HANDLE hAuthenticationKey)
441 {
442 (void)hSession;
443 (void)pOperationState;
444 (void)ulOperationStateLen;
445 (void)hEncryptionKey;
446 (void)hAuthenticationKey;
447
448 if (!lib_initiated())
449 return CKR_CRYPTOKI_NOT_INITIALIZED;
450
451 return CKR_FUNCTION_NOT_SUPPORTED;
452 }
453
C_CreateObject(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phObject)454 CK_RV C_CreateObject(CK_SESSION_HANDLE hSession,
455 CK_ATTRIBUTE_PTR pTemplate,
456 CK_ULONG ulCount,
457 CK_OBJECT_HANDLE_PTR phObject)
458 {
459 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
460
461 if (lib_initiated())
462 rv = ck_create_object(hSession, pTemplate, ulCount, phObject);
463
464 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY,
465 CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID,
466 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_CURVE_NOT_SUPPORTED,
467 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
468 CKR_DOMAIN_PARAMS_INVALID, CKR_FUNCTION_FAILED,
469 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
470 CKR_OK, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED,
471 CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY,
472 CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT,
473 CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN);
474
475 return rv;
476 }
477
C_CopyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phNewObject)478 CK_RV C_CopyObject(CK_SESSION_HANDLE hSession,
479 CK_OBJECT_HANDLE hObject,
480 CK_ATTRIBUTE_PTR pTemplate,
481 CK_ULONG ulCount,
482 CK_OBJECT_HANDLE_PTR phNewObject)
483 {
484 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
485
486 if (lib_initiated())
487 rv = ck_copy_object(hSession, hObject, pTemplate, ulCount,
488 phNewObject);
489
490 ASSERT_CK_RV(rv, CKR_ACTION_PROHIBITED, CKR_ARGUMENTS_BAD,
491 CKR_ATTRIBUTE_READ_ONLY, CKR_ATTRIBUTE_TYPE_INVALID,
492 CKR_ATTRIBUTE_VALUE_INVALID, CKR_CRYPTOKI_NOT_INITIALIZED,
493 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
494 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
495 CKR_OBJECT_HANDLE_INVALID, CKR_OK, CKR_PIN_EXPIRED,
496 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
497 CKR_SESSION_READ_ONLY, CKR_TEMPLATE_INCONSISTENT,
498 CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN);
499
500 return rv;
501 }
502
C_DestroyObject(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject)503 CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession,
504 CK_OBJECT_HANDLE hObject)
505 {
506 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
507
508 if (lib_initiated())
509 rv = ck_destroy_object(hSession, hObject);
510
511 ASSERT_CK_RV(rv, CKR_ACTION_PROHIBITED, CKR_CRYPTOKI_NOT_INITIALIZED,
512 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
513 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
514 CKR_OBJECT_HANDLE_INVALID, CKR_OK, CKR_PIN_EXPIRED,
515 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
516 CKR_SESSION_READ_ONLY, CKR_TOKEN_WRITE_PROTECTED);
517
518 return rv;
519 }
520
C_GetObjectSize(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ULONG_PTR pulSize)521 CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession,
522 CK_OBJECT_HANDLE hObject,
523 CK_ULONG_PTR pulSize)
524 {
525 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
526
527 if (lib_initiated())
528 rv = ck_get_object_size(hSession, hObject, pulSize);
529
530 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
531 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
532 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
533 CKR_INFORMATION_SENSITIVE, CKR_OBJECT_HANDLE_INVALID,
534 CKR_OK, CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID);
535
536 return rv;
537 }
538
C_GetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)539 CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession,
540 CK_OBJECT_HANDLE hObject,
541 CK_ATTRIBUTE_PTR pTemplate,
542 CK_ULONG ulCount)
543 {
544 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
545
546 if (lib_initiated())
547 rv = ck_get_attribute_value(hSession, hObject, pTemplate, ulCount);
548
549 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_SENSITIVE,
550 CKR_ATTRIBUTE_TYPE_INVALID, CKR_BUFFER_TOO_SMALL,
551 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
552 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
553 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
554 CKR_OBJECT_HANDLE_INVALID, CKR_OK, CKR_SESSION_CLOSED,
555 CKR_SESSION_HANDLE_INVALID);
556
557 return rv;
558 }
559
C_SetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)560 CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession,
561 CK_OBJECT_HANDLE hObject,
562 CK_ATTRIBUTE_PTR pTemplate,
563 CK_ULONG ulCount)
564 {
565 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
566
567 if (lib_initiated())
568 rv = ck_set_attribute_value(hSession, hObject, pTemplate, ulCount);
569
570 ASSERT_CK_RV(rv, CKR_ACTION_PROHIBITED, CKR_ARGUMENTS_BAD,
571 CKR_ATTRIBUTE_READ_ONLY, CKR_ATTRIBUTE_TYPE_INVALID,
572 CKR_ATTRIBUTE_VALUE_INVALID, CKR_CRYPTOKI_NOT_INITIALIZED,
573 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
574 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
575 CKR_OBJECT_HANDLE_INVALID, CKR_OK, CKR_SESSION_CLOSED,
576 CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY,
577 CKR_TEMPLATE_INCONSISTENT, CKR_TOKEN_WRITE_PROTECTED,
578 CKR_USER_NOT_LOGGED_IN);
579
580 return rv;
581 }
582
C_FindObjectsInit(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)583 CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession,
584 CK_ATTRIBUTE_PTR pTemplate,
585 CK_ULONG ulCount)
586 {
587 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
588
589 if (lib_initiated())
590 rv = ck_find_objects_init(hSession, pTemplate, ulCount);
591
592 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_TYPE_INVALID,
593 CKR_ATTRIBUTE_VALUE_INVALID, CKR_CRYPTOKI_NOT_INITIALIZED,
594 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
595 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
596 CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED,
597 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID);
598
599 return rv;
600 }
601
C_FindObjects(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE_PTR phObject,CK_ULONG ulMaxObjectCount,CK_ULONG_PTR pulObjectCount)602 CK_RV C_FindObjects(CK_SESSION_HANDLE hSession,
603 CK_OBJECT_HANDLE_PTR phObject,
604 CK_ULONG ulMaxObjectCount,
605 CK_ULONG_PTR pulObjectCount)
606
607 {
608 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
609
610 if (lib_initiated())
611 rv = ck_find_objects(hSession, phObject,
612 ulMaxObjectCount, pulObjectCount);
613
614 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
615 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
616 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
617 CKR_OK, CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
618 CKR_SESSION_HANDLE_INVALID);
619
620 return rv;
621 }
622
C_FindObjectsFinal(CK_SESSION_HANDLE hSession)623 CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession)
624 {
625 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
626
627 if (lib_initiated())
628 rv = ck_find_objects_final(hSession);
629
630 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
631 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED, CKR_FUNCTION_FAILED,
632 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
633 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
634 CKR_SESSION_HANDLE_INVALID);
635
636 return rv;
637 }
638
C_EncryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)639 CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession,
640 CK_MECHANISM_PTR pMechanism,
641 CK_OBJECT_HANDLE hKey)
642 {
643 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
644
645 if (lib_initiated())
646 rv = ck_encdecrypt_init(hSession, pMechanism, hKey, CK_FALSE);
647
648 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
649 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
650 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
651 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
652 CKR_KEY_FUNCTION_NOT_PERMITTED, CKR_KEY_HANDLE_INVALID,
653 CKR_KEY_SIZE_RANGE, CKR_KEY_TYPE_INCONSISTENT,
654 CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID,
655 CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED,
656 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
657 CKR_USER_NOT_LOGGED_IN);
658
659 return rv;
660 }
661
C_Encrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pEncryptedData,CK_ULONG_PTR pulEncryptedDataLen)662 CK_RV C_Encrypt(CK_SESSION_HANDLE hSession,
663 CK_BYTE_PTR pData,
664 CK_ULONG ulDataLen,
665 CK_BYTE_PTR pEncryptedData,
666 CK_ULONG_PTR pulEncryptedDataLen)
667 {
668 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
669
670 if (lib_initiated())
671 rv = ck_encdecrypt_oneshot(hSession, pData, ulDataLen,
672 pEncryptedData, pulEncryptedDataLen,
673 CK_FALSE);
674
675 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
676 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DATA_LEN_RANGE,
677 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
678 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
679 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
680 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
681 CKR_SESSION_HANDLE_INVALID);
682
683 return rv;
684 }
685
C_EncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedData,CK_ULONG_PTR pulEncryptedDataLen)686 CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession,
687 CK_BYTE_PTR pPart,
688 CK_ULONG ulPartLen,
689 CK_BYTE_PTR pEncryptedData,
690 CK_ULONG_PTR pulEncryptedDataLen)
691 {
692 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
693
694 if (lib_initiated())
695 rv = ck_encdecrypt_update(hSession, pPart, ulPartLen,
696 pEncryptedData,
697 pulEncryptedDataLen, CK_FALSE);
698
699 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
700 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DATA_LEN_RANGE,
701 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
702 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
703 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
704 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
705 CKR_SESSION_HANDLE_INVALID);
706
707 return rv;
708 }
709
C_EncryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastEncryptedPart,CK_ULONG_PTR pulLastEncryptedPartLen)710 CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession,
711 CK_BYTE_PTR pLastEncryptedPart,
712 CK_ULONG_PTR pulLastEncryptedPartLen)
713 {
714 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
715
716 if (lib_initiated())
717 rv = ck_encdecrypt_final(hSession, pLastEncryptedPart,
718 pulLastEncryptedPartLen, CK_FALSE);
719
720 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
721 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DATA_LEN_RANGE,
722 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
723 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
724 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
725 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
726 CKR_SESSION_HANDLE_INVALID);
727
728 return rv;
729 }
730
C_DecryptInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)731 CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession,
732 CK_MECHANISM_PTR pMechanism,
733 CK_OBJECT_HANDLE hKey)
734 {
735 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
736
737 if (lib_initiated())
738 rv = ck_encdecrypt_init(hSession, pMechanism, hKey, CK_TRUE);
739
740 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
741 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
742 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
743 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
744 CKR_KEY_FUNCTION_NOT_PERMITTED, CKR_KEY_HANDLE_INVALID,
745 CKR_KEY_SIZE_RANGE, CKR_KEY_TYPE_INCONSISTENT,
746 CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID,
747 CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED,
748 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
749 CKR_USER_NOT_LOGGED_IN);
750
751 return rv;
752 }
753
C_Decrypt(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedData,CK_ULONG ulEncryptedDataLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)754 CK_RV C_Decrypt(CK_SESSION_HANDLE hSession,
755 CK_BYTE_PTR pEncryptedData,
756 CK_ULONG ulEncryptedDataLen,
757 CK_BYTE_PTR pData,
758 CK_ULONG_PTR pulDataLen)
759 {
760 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
761
762 if (lib_initiated())
763 rv = ck_encdecrypt_oneshot(hSession, pEncryptedData,
764 ulEncryptedDataLen,
765 pData, pulDataLen, CK_TRUE);
766
767 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
768 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
769 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
770 CKR_ENCRYPTED_DATA_INVALID, CKR_ENCRYPTED_DATA_LEN_RANGE,
771 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
772 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
773 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
774 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN);
775
776 return rv;
777 }
778
C_DecryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)779 CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession,
780 CK_BYTE_PTR pEncryptedPart,
781 CK_ULONG ulEncryptedPartLen,
782 CK_BYTE_PTR pPart,
783 CK_ULONG_PTR pulPartLen)
784 {
785 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
786
787 if (lib_initiated())
788 rv = ck_encdecrypt_update(hSession, pEncryptedPart,
789 ulEncryptedPartLen,
790 pPart, pulPartLen, CK_TRUE);
791
792 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
793 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
794 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
795 CKR_ENCRYPTED_DATA_INVALID, CKR_ENCRYPTED_DATA_LEN_RANGE,
796 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
797 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
798 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
799 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN);
800
801 return rv;
802 }
803
C_DecryptFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pLastPart,CK_ULONG_PTR pulLastPartLen)804 CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession,
805 CK_BYTE_PTR pLastPart,
806 CK_ULONG_PTR pulLastPartLen)
807 {
808 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
809
810 if (lib_initiated())
811 rv = ck_encdecrypt_final(hSession, pLastPart, pulLastPartLen,
812 CK_TRUE);
813
814 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
815 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
816 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
817 CKR_ENCRYPTED_DATA_INVALID, CKR_ENCRYPTED_DATA_LEN_RANGE,
818 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
819 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
820 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
821 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN);
822
823 return rv;
824 }
825
C_DigestInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism)826 CK_RV C_DigestInit(CK_SESSION_HANDLE hSession,
827 CK_MECHANISM_PTR pMechanism)
828 {
829 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
830
831 if (lib_initiated())
832 rv = ck_digest_init(hSession, pMechanism);
833
834 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
835 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
836 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
837 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_MECHANISM_INVALID,
838 CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE,
839 CKR_PIN_EXPIRED, CKR_SESSION_CLOSED,
840 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN);
841
842 return rv;
843 }
844
C_Digest(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pDigest,CK_ULONG_PTR pulDigestLen)845 CK_RV C_Digest(CK_SESSION_HANDLE hSession,
846 CK_BYTE_PTR pData,
847 CK_ULONG ulDataLen,
848 CK_BYTE_PTR pDigest,
849 CK_ULONG_PTR pulDigestLen)
850 {
851 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
852
853 if (lib_initiated())
854 rv = ck_digest_oneshot(hSession, pData, ulDataLen, pDigest,
855 pulDigestLen);
856
857 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
858 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
859 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
860 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
861 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
862 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
863 CKR_SESSION_HANDLE_INVALID);
864
865 return rv;
866 }
867
C_DigestUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)868 CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession,
869 CK_BYTE_PTR pPart,
870 CK_ULONG ulPartLen)
871 {
872 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
873
874 if (lib_initiated())
875 rv = ck_digest_update(hSession, pPart, ulPartLen);
876
877 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
878 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
879 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
880 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
881 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
882 CKR_SESSION_HANDLE_INVALID);
883
884 return rv;
885 }
886
C_DigestKey(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hKey)887 CK_RV C_DigestKey(CK_SESSION_HANDLE hSession,
888 CK_OBJECT_HANDLE hKey)
889 {
890 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
891
892 if (lib_initiated())
893 rv = ck_digest_key(hSession, hKey);
894
895 ASSERT_CK_RV(rv, CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
896 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
897 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
898 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
899 CKR_KEY_HANDLE_INVALID, CKR_KEY_INDIGESTIBLE,
900 CKR_KEY_SIZE_RANGE, CKR_OK,
901 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
902 CKR_SESSION_HANDLE_INVALID);
903
904 return rv;
905 }
906
C_DigestFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pDigest,CK_ULONG_PTR pulDigestLen)907 CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession,
908 CK_BYTE_PTR pDigest,
909 CK_ULONG_PTR pulDigestLen)
910 {
911 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
912
913 if (lib_initiated())
914 rv = ck_digest_final(hSession, pDigest, pulDigestLen);
915
916 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
917 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
918 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
919 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
920 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
921 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
922 CKR_SESSION_HANDLE_INVALID);
923
924 return rv;
925 }
926
C_SignInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)927 CK_RV C_SignInit(CK_SESSION_HANDLE hSession,
928 CK_MECHANISM_PTR pMechanism,
929 CK_OBJECT_HANDLE hKey)
930 {
931 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
932
933 if (lib_initiated())
934 rv = ck_signverify_init(hSession, pMechanism, hKey, CK_TRUE);
935
936 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
937 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
938 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
939 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
940 CKR_KEY_FUNCTION_NOT_PERMITTED, CKR_KEY_HANDLE_INVALID,
941 CKR_KEY_SIZE_RANGE, CKR_KEY_TYPE_INCONSISTENT,
942 CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID,
943 CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED,
944 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
945 CKR_USER_NOT_LOGGED_IN);
946
947 return rv;
948 }
949
C_Sign(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)950 CK_RV C_Sign(CK_SESSION_HANDLE hSession,
951 CK_BYTE_PTR pData,
952 CK_ULONG ulDataLen,
953 CK_BYTE_PTR pSignature,
954 CK_ULONG_PTR pulSignatureLen)
955 {
956 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
957
958 if (lib_initiated())
959 rv = ck_signverify_oneshot(hSession, pData, ulDataLen,
960 pSignature, pulSignatureLen,
961 CK_TRUE);
962
963 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
964 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DATA_INVALID,
965 CKR_DATA_LEN_RANGE, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY,
966 CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED,
967 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
968 CKR_OK, CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
969 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN,
970 CKR_FUNCTION_REJECTED);
971
972 return rv;
973 }
974
C_SignUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)975 CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession,
976 CK_BYTE_PTR pPart,
977 CK_ULONG ulPartLen)
978 {
979 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
980
981 if (lib_initiated())
982 rv = ck_signverify_update(hSession, pPart, ulPartLen, CK_TRUE);
983
984 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
985 CKR_DATA_LEN_RANGE, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY,
986 CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED,
987 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
988 CKR_OK, CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
989 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN);
990
991 return rv;
992 }
993
C_SignFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)994 CK_RV C_SignFinal(CK_SESSION_HANDLE hSession,
995 CK_BYTE_PTR pSignature,
996 CK_ULONG_PTR pulSignatureLen)
997 {
998 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
999
1000 if (lib_initiated())
1001 rv = ck_signverify_final(hSession, pSignature, pulSignatureLen,
1002 CK_TRUE);
1003
1004 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
1005 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DATA_LEN_RANGE,
1006 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1007 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
1008 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
1009 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
1010 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN,
1011 CKR_FUNCTION_REJECTED);
1012
1013 return rv;
1014 }
1015
C_SignRecoverInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1016 CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession,
1017 CK_MECHANISM_PTR pMechanism,
1018 CK_OBJECT_HANDLE hKey)
1019 {
1020 (void)hSession;
1021 (void)pMechanism;
1022 (void)hKey;
1023
1024 if (!lib_initiated())
1025 return CKR_CRYPTOKI_NOT_INITIALIZED;
1026
1027 return CKR_FUNCTION_NOT_SUPPORTED;
1028 }
1029
C_SignRecover(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG_PTR pulSignatureLen)1030 CK_RV C_SignRecover(CK_SESSION_HANDLE hSession,
1031 CK_BYTE_PTR pData,
1032 CK_ULONG ulDataLen,
1033 CK_BYTE_PTR pSignature,
1034 CK_ULONG_PTR pulSignatureLen)
1035 {
1036 (void)hSession;
1037 (void)pData;
1038 (void)ulDataLen;
1039 (void)pSignature;
1040 (void)pulSignatureLen;
1041
1042 if (!lib_initiated())
1043 return CKR_CRYPTOKI_NOT_INITIALIZED;
1044
1045 return CKR_FUNCTION_NOT_SUPPORTED;
1046 }
1047
C_VerifyInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1048 CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession,
1049 CK_MECHANISM_PTR pMechanism,
1050 CK_OBJECT_HANDLE hKey)
1051 {
1052 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1053
1054 if (lib_initiated())
1055 rv = ck_signverify_init(hSession, pMechanism, hKey, CK_FALSE);
1056
1057 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
1058 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1059 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
1060 CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
1061 CKR_KEY_FUNCTION_NOT_PERMITTED, CKR_KEY_HANDLE_INVALID,
1062 CKR_KEY_SIZE_RANGE, CKR_KEY_TYPE_INCONSISTENT,
1063 CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID,
1064 CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED,
1065 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
1066 CKR_USER_NOT_LOGGED_IN);
1067
1068 return rv;
1069 }
1070
C_Verify(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pData,CK_ULONG ulDataLen,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1071 CK_RV C_Verify(CK_SESSION_HANDLE hSession,
1072 CK_BYTE_PTR pData,
1073 CK_ULONG ulDataLen,
1074 CK_BYTE_PTR pSignature,
1075 CK_ULONG ulSignatureLen)
1076 {
1077 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1078 CK_ULONG out_size = ulSignatureLen;
1079
1080 if (lib_initiated())
1081 rv = ck_signverify_oneshot(hSession, pData, ulDataLen,
1082 pSignature, &out_size,
1083 CK_FALSE);
1084
1085 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
1086 CKR_DATA_INVALID, CKR_DATA_LEN_RANGE, CKR_DEVICE_ERROR,
1087 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1088 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
1089 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
1090 CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
1091 CKR_SESSION_HANDLE_INVALID, CKR_SIGNATURE_INVALID,
1092 CKR_SIGNATURE_LEN_RANGE);
1093
1094 return rv;
1095 }
1096
C_VerifyUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen)1097 CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession,
1098 CK_BYTE_PTR pPart,
1099 CK_ULONG ulPartLen)
1100 {
1101 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1102
1103 if (lib_initiated())
1104 rv = ck_signverify_update(hSession, pPart, ulPartLen, CK_FALSE);
1105
1106 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
1107 CKR_DATA_LEN_RANGE, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY,
1108 CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED,
1109 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
1110 CKR_OK, CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
1111 CKR_SESSION_HANDLE_INVALID);
1112
1113 return rv;
1114 }
1115
C_VerifyFinal(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen)1116 CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession,
1117 CK_BYTE_PTR pSignature,
1118 CK_ULONG ulSignatureLen)
1119 {
1120 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1121
1122 if (lib_initiated())
1123 rv = ck_signverify_final(hSession, pSignature, &ulSignatureLen,
1124 CK_FALSE);
1125
1126 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
1127 CKR_DATA_LEN_RANGE, CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY,
1128 CKR_DEVICE_REMOVED, CKR_FUNCTION_CANCELED,
1129 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
1130 CKR_OK, CKR_OPERATION_NOT_INITIALIZED, CKR_SESSION_CLOSED,
1131 CKR_SESSION_HANDLE_INVALID, CKR_SIGNATURE_INVALID,
1132 CKR_SIGNATURE_LEN_RANGE);
1133
1134 return rv;
1135 }
1136
C_VerifyRecoverInit(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hKey)1137 CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession,
1138 CK_MECHANISM_PTR pMechanism,
1139 CK_OBJECT_HANDLE hKey)
1140 {
1141 (void)hSession;
1142 (void)pMechanism;
1143 (void)hKey;
1144
1145 if (!lib_initiated())
1146 return CKR_CRYPTOKI_NOT_INITIALIZED;
1147
1148 return CKR_FUNCTION_NOT_SUPPORTED;
1149 }
1150
C_VerifyRecover(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSignature,CK_ULONG ulSignatureLen,CK_BYTE_PTR pData,CK_ULONG_PTR pulDataLen)1151 CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession,
1152 CK_BYTE_PTR pSignature,
1153 CK_ULONG ulSignatureLen,
1154 CK_BYTE_PTR pData,
1155 CK_ULONG_PTR pulDataLen)
1156 {
1157 (void)hSession;
1158 (void)pSignature;
1159 (void)ulSignatureLen;
1160 (void)pData;
1161 (void)pulDataLen;
1162
1163 if (!lib_initiated())
1164 return CKR_CRYPTOKI_NOT_INITIALIZED;
1165
1166 return CKR_FUNCTION_NOT_SUPPORTED;
1167 }
1168
C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1169 CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession,
1170 CK_BYTE_PTR pPart,
1171 CK_ULONG ulPartLen,
1172 CK_BYTE_PTR pEncryptedPart,
1173 CK_ULONG_PTR pulEncryptedPartLen)
1174 {
1175 (void)hSession;
1176 (void)pPart;
1177 (void)ulPartLen;
1178 (void)pEncryptedPart;
1179 (void)pulEncryptedPartLen;
1180
1181 if (!lib_initiated())
1182 return CKR_CRYPTOKI_NOT_INITIALIZED;
1183
1184 return CKR_FUNCTION_NOT_SUPPORTED;
1185 }
1186
C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1187 CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession,
1188 CK_BYTE_PTR pEncryptedPart,
1189 CK_ULONG ulEncryptedPartLen,
1190 CK_BYTE_PTR pPart,
1191 CK_ULONG_PTR pulPartLen)
1192 {
1193 (void)hSession;
1194 (void)pEncryptedPart;
1195 (void)ulEncryptedPartLen;
1196 (void)pPart;
1197 (void)pulPartLen;
1198
1199 if (!lib_initiated())
1200 return CKR_CRYPTOKI_NOT_INITIALIZED;
1201
1202 return CKR_FUNCTION_NOT_SUPPORTED;
1203 }
1204
C_SignEncryptUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pPart,CK_ULONG ulPartLen,CK_BYTE_PTR pEncryptedPart,CK_ULONG_PTR pulEncryptedPartLen)1205 CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession,
1206 CK_BYTE_PTR pPart,
1207 CK_ULONG ulPartLen,
1208 CK_BYTE_PTR pEncryptedPart,
1209 CK_ULONG_PTR pulEncryptedPartLen)
1210 {
1211 (void)hSession;
1212 (void)pPart;
1213 (void)ulPartLen;
1214 (void)pEncryptedPart;
1215 (void)pulEncryptedPartLen;
1216
1217 if (!lib_initiated())
1218 return CKR_CRYPTOKI_NOT_INITIALIZED;
1219
1220 return CKR_FUNCTION_NOT_SUPPORTED;
1221 }
1222
C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pEncryptedPart,CK_ULONG ulEncryptedPartLen,CK_BYTE_PTR pPart,CK_ULONG_PTR pulPartLen)1223 CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession,
1224 CK_BYTE_PTR pEncryptedPart,
1225 CK_ULONG ulEncryptedPartLen,
1226 CK_BYTE_PTR pPart,
1227 CK_ULONG_PTR pulPartLen)
1228 {
1229 (void)hSession;
1230 (void)pEncryptedPart;
1231 (void)ulEncryptedPartLen;
1232 (void)pPart;
1233 (void)pulPartLen;
1234
1235 if (!lib_initiated())
1236 return CKR_CRYPTOKI_NOT_INITIALIZED;
1237
1238 return CKR_FUNCTION_NOT_SUPPORTED;
1239 }
1240
C_GenerateKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phKey)1241 CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession,
1242 CK_MECHANISM_PTR pMechanism,
1243 CK_ATTRIBUTE_PTR pTemplate,
1244 CK_ULONG ulCount,
1245 CK_OBJECT_HANDLE_PTR phKey)
1246 {
1247 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1248
1249 if (lib_initiated())
1250 rv = ck_generate_key(hSession, pMechanism, pTemplate, ulCount,
1251 phKey);
1252
1253 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY,
1254 CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID,
1255 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_CURVE_NOT_SUPPORTED,
1256 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1257 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
1258 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_MECHANISM_INVALID,
1259 CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE,
1260 CKR_PIN_EXPIRED, CKR_SESSION_CLOSED,
1261 CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY,
1262 CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT,
1263 CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN);
1264
1265 return rv;
1266 }
1267
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)1268 CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE hSession,
1269 CK_MECHANISM_PTR pMechanism,
1270 CK_ATTRIBUTE_PTR pPublicKeyTemplate,
1271 CK_ULONG ulPublicKeyAttributeCount,
1272 CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
1273 CK_ULONG ulPrivateKeyAttributeCount,
1274 CK_OBJECT_HANDLE_PTR phPublicKey,
1275 CK_OBJECT_HANDLE_PTR phPrivateKey)
1276 {
1277 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1278
1279 if (lib_initiated())
1280 rv = ck_generate_key_pair(hSession, pMechanism,
1281 pPublicKeyTemplate,
1282 ulPublicKeyAttributeCount,
1283 pPrivateKeyTemplate,
1284 ulPrivateKeyAttributeCount,
1285 phPublicKey, phPrivateKey);
1286
1287 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY,
1288 CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID,
1289 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_CURVE_NOT_SUPPORTED,
1290 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1291 CKR_DOMAIN_PARAMS_INVALID, CKR_FUNCTION_CANCELED,
1292 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
1293 CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID,
1294 CKR_OK, CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED,
1295 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
1296 CKR_SESSION_READ_ONLY, CKR_TEMPLATE_INCOMPLETE,
1297 CKR_TEMPLATE_INCONSISTENT, CKR_TOKEN_WRITE_PROTECTED,
1298 CKR_USER_NOT_LOGGED_IN);
1299
1300 return rv;
1301 }
1302
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)1303 CK_RV C_WrapKey(CK_SESSION_HANDLE hSession,
1304 CK_MECHANISM_PTR pMechanism,
1305 CK_OBJECT_HANDLE hWrappingKey,
1306 CK_OBJECT_HANDLE hKey,
1307 CK_BYTE_PTR pWrappedKey,
1308 CK_ULONG_PTR pulWrappedKeyLen)
1309 {
1310 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1311
1312 if (lib_initiated())
1313 rv = ck_wrap_key(hSession, pMechanism, hWrappingKey, hKey,
1314 pWrappedKey, pulWrappedKeyLen);
1315
1316 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_BUFFER_TOO_SMALL,
1317 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_DEVICE_ERROR,
1318 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1319 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
1320 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_KEY_HANDLE_INVALID,
1321 CKR_KEY_NOT_WRAPPABLE, CKR_KEY_SIZE_RANGE,
1322 CKR_KEY_UNEXTRACTABLE, CKR_MECHANISM_INVALID,
1323 CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE,
1324 CKR_PIN_EXPIRED, CKR_SESSION_CLOSED,
1325 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN,
1326 CKR_WRAPPING_KEY_HANDLE_INVALID,
1327 CKR_WRAPPING_KEY_SIZE_RANGE,
1328 CKR_WRAPPING_KEY_TYPE_INCONSISTENT);
1329
1330 return rv;
1331 }
1332
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 ulCount,CK_OBJECT_HANDLE_PTR phKey)1333 CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession,
1334 CK_MECHANISM_PTR pMechanism,
1335 CK_OBJECT_HANDLE hUnwrappingKey,
1336 CK_BYTE_PTR pWrappedKey,
1337 CK_ULONG ulWrappedKeyLen,
1338 CK_ATTRIBUTE_PTR pTemplate,
1339 CK_ULONG ulCount,
1340 CK_OBJECT_HANDLE_PTR phKey)
1341 {
1342 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1343
1344 if (lib_initiated())
1345 rv = ck_unwrap_key(hSession, pMechanism, hUnwrappingKey,
1346 pWrappedKey, ulWrappedKeyLen, pTemplate,
1347 ulCount, phKey);
1348
1349 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY,
1350 CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID,
1351 CKR_BUFFER_TOO_SMALL, CKR_CRYPTOKI_NOT_INITIALIZED,
1352 CKR_CURVE_NOT_SUPPORTED, CKR_DEVICE_ERROR,
1353 CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1354 CKR_DOMAIN_PARAMS_INVALID, CKR_FUNCTION_CANCELED,
1355 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
1356 CKR_MECHANISM_INVALID, CKR_MECHANISM_PARAM_INVALID, CKR_OK,
1357 CKR_OPERATION_ACTIVE, CKR_PIN_EXPIRED, CKR_SESSION_CLOSED,
1358 CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY,
1359 CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT,
1360 CKR_TOKEN_WRITE_PROTECTED,
1361 CKR_UNWRAPPING_KEY_HANDLE_INVALID,
1362 CKR_UNWRAPPING_KEY_SIZE_RANGE,
1363 CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT,
1364 CKR_USER_NOT_LOGGED_IN, CKR_WRAPPED_KEY_INVALID,
1365 CKR_WRAPPED_KEY_LEN_RANGE);
1366
1367 return rv;
1368 }
1369
C_DeriveKey(CK_SESSION_HANDLE hSession,CK_MECHANISM_PTR pMechanism,CK_OBJECT_HANDLE hBaseKey,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount,CK_OBJECT_HANDLE_PTR phKey)1370 CK_RV C_DeriveKey(CK_SESSION_HANDLE hSession,
1371 CK_MECHANISM_PTR pMechanism,
1372 CK_OBJECT_HANDLE hBaseKey,
1373 CK_ATTRIBUTE_PTR pTemplate,
1374 CK_ULONG ulCount,
1375 CK_OBJECT_HANDLE_PTR phKey)
1376 {
1377 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1378
1379 if (lib_initiated())
1380 rv = ck_derive_key(hSession, pMechanism, hBaseKey, pTemplate,
1381 ulCount, phKey);
1382
1383 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_ATTRIBUTE_READ_ONLY,
1384 CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_VALUE_INVALID,
1385 CKR_CRYPTOKI_NOT_INITIALIZED, CKR_CURVE_NOT_SUPPORTED,
1386 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1387 CKR_DOMAIN_PARAMS_INVALID, CKR_FUNCTION_CANCELED,
1388 CKR_FUNCTION_FAILED, CKR_GENERAL_ERROR, CKR_HOST_MEMORY,
1389 CKR_KEY_HANDLE_INVALID, CKR_KEY_SIZE_RANGE,
1390 CKR_KEY_TYPE_INCONSISTENT, CKR_MECHANISM_INVALID,
1391 CKR_MECHANISM_PARAM_INVALID, CKR_OK, CKR_OPERATION_ACTIVE,
1392 CKR_PIN_EXPIRED, CKR_SESSION_CLOSED,
1393 CKR_SESSION_HANDLE_INVALID, CKR_SESSION_READ_ONLY,
1394 CKR_TEMPLATE_INCOMPLETE, CKR_TEMPLATE_INCONSISTENT,
1395 CKR_TOKEN_WRITE_PROTECTED, CKR_USER_NOT_LOGGED_IN,
1396 CKR_DATA_LEN_RANGE);
1397
1398 return rv;
1399 }
1400
C_SeedRandom(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pSeed,CK_ULONG ulSeedLen)1401 CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession,
1402 CK_BYTE_PTR pSeed,
1403 CK_ULONG ulSeedLen)
1404 {
1405 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1406
1407 if (lib_initiated())
1408 rv = ck_seed_random(hSession, pSeed, ulSeedLen);
1409
1410 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
1411 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1412 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
1413 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
1414 CKR_OPERATION_ACTIVE, CKR_RANDOM_SEED_NOT_SUPPORTED,
1415 CKR_RANDOM_NO_RNG, CKR_SESSION_CLOSED,
1416 CKR_SESSION_HANDLE_INVALID, CKR_USER_NOT_LOGGED_IN);
1417
1418 return rv;
1419 }
1420
C_GenerateRandom(CK_SESSION_HANDLE hSession,CK_BYTE_PTR pRandomData,CK_ULONG ulRandomLen)1421 CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession,
1422 CK_BYTE_PTR pRandomData,
1423 CK_ULONG ulRandomLen)
1424 {
1425 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1426
1427 if (lib_initiated())
1428 rv = ck_generate_random(hSession, pRandomData, ulRandomLen);
1429
1430 ASSERT_CK_RV(rv, CKR_ARGUMENTS_BAD, CKR_CRYPTOKI_NOT_INITIALIZED,
1431 CKR_DEVICE_ERROR, CKR_DEVICE_MEMORY, CKR_DEVICE_REMOVED,
1432 CKR_FUNCTION_CANCELED, CKR_FUNCTION_FAILED,
1433 CKR_GENERAL_ERROR, CKR_HOST_MEMORY, CKR_OK,
1434 CKR_OPERATION_ACTIVE, CKR_RANDOM_NO_RNG,
1435 CKR_SESSION_CLOSED, CKR_SESSION_HANDLE_INVALID,
1436 CKR_USER_NOT_LOGGED_IN);
1437
1438 return rv;
1439 }
1440
C_GetFunctionStatus(CK_SESSION_HANDLE hSession)1441 CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession)
1442 {
1443 (void)hSession;
1444
1445 if (!lib_initiated())
1446 return CKR_CRYPTOKI_NOT_INITIALIZED;
1447
1448 return CKR_FUNCTION_NOT_PARALLEL;
1449 }
1450
C_CancelFunction(CK_SESSION_HANDLE hSession)1451 CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession)
1452 {
1453 (void)hSession;
1454
1455 if (!lib_initiated())
1456 return CKR_CRYPTOKI_NOT_INITIALIZED;
1457
1458 return CKR_FUNCTION_NOT_PARALLEL;
1459 }
1460
C_WaitForSlotEvent(CK_FLAGS flags,CK_SLOT_ID_PTR slotID,CK_VOID_PTR pReserved)1461 CK_RV C_WaitForSlotEvent(CK_FLAGS flags,
1462 CK_SLOT_ID_PTR slotID,
1463 CK_VOID_PTR pReserved)
1464 {
1465 (void)flags;
1466 (void)slotID;
1467 (void)pReserved;
1468
1469 if (!lib_initiated())
1470 return CKR_CRYPTOKI_NOT_INITIALIZED;
1471
1472 return CKR_FUNCTION_NOT_SUPPORTED;
1473 }
1474