1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 // This is a testing PKCS #11 module that simulates a token being inserted and
7 // removed from a slot every 50ms. This is achieved mainly in
8 // Test_C_WaitForSlotEvent. If the application that loaded this module calls
9 // C_WaitForSlotEvent, this module waits for 50ms and returns, having changed
10 // its internal state to report that the token has either been inserted or
11 // removed, as appropriate.
12 // This module also provides an alternate token that is always present for tests
13 // that don't want the cyclic behavior described above.
14
15 #include <assert.h>
16 #include <string.h>
17
18 #ifdef _WIN32
19 # include <windows.h> // for Sleep
20 #else
21 # include <unistd.h> // for usleep
22 #endif
23
24 #include "pkcs11t.h"
25
26 #undef CK_DECLARE_FUNCTION
27
28 #ifdef _WIN32
29 #define CK_DECLARE_FUNCTION(rtype, func) extern rtype __declspec(dllexport) func
30 #else
31 #define CK_DECLARE_FUNCTION(rtype, func) extern rtype func
32 #endif
33
34 #include "pkcs11.h"
35
36 #if __cplusplus < 201103L
37 # include <prtypes.h>
38 # define static_assert(condition, message) PR_STATIC_ASSERT(condition)
39 #endif
40
Test_C_Initialize(CK_VOID_PTR)41 CK_RV Test_C_Initialize(CK_VOID_PTR) { return CKR_OK; }
42
Test_C_Finalize(CK_VOID_PTR)43 CK_RV Test_C_Finalize(CK_VOID_PTR) { return CKR_OK; }
44
45 static const CK_VERSION CryptokiVersion = {2, 2};
46 static const CK_VERSION TestLibraryVersion = {0, 0};
47 static const char TestLibraryDescription[] = "Test PKCS11 Library";
48 static const char TestManufacturerID[] = "Test PKCS11 Manufacturer ID";
49
50 /* The dest buffer is one in the CK_INFO or CK_TOKEN_INFO structs.
51 * Those buffers are padded with spaces. DestSize corresponds to the declared
52 * size for those buffers (e.g. 32 for `char foo[32]`).
53 * The src buffer is a string literal. SrcSize includes the string
54 * termination character (e.g. 4 for `const char foo[] = "foo"` */
55 template <size_t DestSize, size_t SrcSize>
CopyString(unsigned char (& dest)[DestSize],const char (& src)[SrcSize])56 void CopyString(unsigned char (&dest)[DestSize], const char (&src)[SrcSize]) {
57 static_assert(DestSize >= SrcSize - 1, "DestSize >= SrcSize - 1");
58 memcpy(dest, src, SrcSize - 1);
59 memset(dest + SrcSize - 1, ' ', DestSize - SrcSize + 1);
60 }
61
Test_C_GetInfo(CK_INFO_PTR pInfo)62 CK_RV Test_C_GetInfo(CK_INFO_PTR pInfo) {
63 if (!pInfo) {
64 return CKR_ARGUMENTS_BAD;
65 }
66
67 pInfo->cryptokiVersion = CryptokiVersion;
68 CopyString(pInfo->manufacturerID, TestManufacturerID);
69 pInfo->flags = 0; // must be 0
70 CopyString(pInfo->libraryDescription, TestLibraryDescription);
71 pInfo->libraryVersion = TestLibraryVersion;
72 return CKR_OK;
73 }
74
Test_C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR)75 CK_RV Test_C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR) { return CKR_OK; }
76
77 static int tokenPresent = 0;
78
79 // The token in slot 4 has 2 objects. Both of them are profile object
80 // and identified by object ID 1 or 2.
81 static bool readingProfile = false;
82 static const CK_PROFILE_ID profiles[] = {CKP_PUBLIC_CERTIFICATES_TOKEN,
83 CKP_BASELINE_PROVIDER};
84 static int profileIndex = 0;
85
Test_C_GetSlotList(CK_BBOOL limitToTokensPresent,CK_SLOT_ID_PTR pSlotList,CK_ULONG_PTR pulCount)86 CK_RV Test_C_GetSlotList(CK_BBOOL limitToTokensPresent,
87 CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount) {
88 if (!pulCount) {
89 return CKR_ARGUMENTS_BAD;
90 }
91
92 CK_SLOT_ID slots[4];
93 CK_ULONG slotCount = 0;
94
95 // We always return slot 2 and 4.
96 slots[slotCount++] = 2;
97 slots[slotCount++] = 4;
98
99 // Slot 1 is a removable slot where a token is present if
100 // tokenPresent = CK_TRUE.
101 if (tokenPresent || !limitToTokensPresent) {
102 slots[slotCount++] = 1;
103 }
104
105 // Slot 3 is a removable slot which never has a token.
106 if (!limitToTokensPresent) {
107 slots[slotCount++] = 3;
108 }
109
110 if (pSlotList) {
111 if (*pulCount < slotCount) {
112 return CKR_BUFFER_TOO_SMALL;
113 }
114 memcpy(pSlotList, slots, sizeof(CK_SLOT_ID) * slotCount);
115 }
116
117 *pulCount = slotCount;
118 return CKR_OK;
119 }
120
121 static const char TestSlotDescription[] = "Test PKCS11 Slot";
122 static const char TestSlot2Description[] = "Test PKCS11 Slot 二";
123 static const char TestSlot3Description[] = "Empty PKCS11 Slot";
124 static const char TestSlot4Description[] = "Test PKCS11 Public Certs Slot";
125
Test_C_GetSlotInfo(CK_SLOT_ID slotID,CK_SLOT_INFO_PTR pInfo)126 CK_RV Test_C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) {
127 if (!pInfo) {
128 return CKR_ARGUMENTS_BAD;
129 }
130
131 switch (slotID) {
132 case 1:
133 CopyString(pInfo->slotDescription, TestSlotDescription);
134 pInfo->flags =
135 (tokenPresent ? CKF_TOKEN_PRESENT : 0) | CKF_REMOVABLE_DEVICE;
136 break;
137 case 2:
138 CopyString(pInfo->slotDescription, TestSlot2Description);
139 pInfo->flags = CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE;
140 break;
141 case 3:
142 CopyString(pInfo->slotDescription, TestSlot3Description);
143 pInfo->flags = CKF_REMOVABLE_DEVICE;
144 break;
145 case 4:
146 CopyString(pInfo->slotDescription, TestSlot4Description);
147 pInfo->flags = CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE;
148 break;
149 default:
150 return CKR_ARGUMENTS_BAD;
151 }
152
153 CopyString(pInfo->manufacturerID, TestManufacturerID);
154 pInfo->hardwareVersion = TestLibraryVersion;
155 pInfo->firmwareVersion = TestLibraryVersion;
156 return CKR_OK;
157 }
158
159 // Deliberately include énye to ensure we're handling encoding correctly.
160 // The PKCS #11 base specification v2.20 specifies that strings be encoded
161 // as UTF-8.
162 static const char TestTokenLabel[] = "Test PKCS11 Tokeñ Label";
163 static const char TestToken2Label[] = "Test PKCS11 Tokeñ 2 Label";
164 static const char TestToken4Label[] = "Test PKCS11 Public Certs Token";
165 static const char TestTokenModel[] = "Test Model";
166
Test_C_GetTokenInfo(CK_SLOT_ID slotID,CK_TOKEN_INFO_PTR pInfo)167 CK_RV Test_C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) {
168 if (!pInfo) {
169 return CKR_ARGUMENTS_BAD;
170 }
171
172 switch (slotID) {
173 case 1:
174 CopyString(pInfo->label, TestTokenLabel);
175 break;
176 case 2:
177 CopyString(pInfo->label, TestToken2Label);
178 break;
179 case 4:
180 CopyString(pInfo->label, TestToken4Label);
181 break;
182 default:
183 return CKR_ARGUMENTS_BAD;
184 }
185
186 CopyString(pInfo->manufacturerID, TestManufacturerID);
187 CopyString(pInfo->model, TestTokenModel);
188 memset(pInfo->serialNumber, 0, sizeof(pInfo->serialNumber));
189 pInfo->flags = CKF_TOKEN_INITIALIZED;
190 pInfo->ulMaxSessionCount = 1;
191 pInfo->ulSessionCount = 0;
192 pInfo->ulMaxRwSessionCount = 1;
193 pInfo->ulRwSessionCount = 0;
194 pInfo->ulMaxPinLen = 4;
195 pInfo->ulMinPinLen = 4;
196 pInfo->ulTotalPublicMemory = 1024;
197 pInfo->ulFreePublicMemory = 1024;
198 pInfo->ulTotalPrivateMemory = 1024;
199 pInfo->ulFreePrivateMemory = 1024;
200 pInfo->hardwareVersion = TestLibraryVersion;
201 pInfo->firmwareVersion = TestLibraryVersion;
202 memset(pInfo->utcTime, 0, sizeof(pInfo->utcTime));
203 return CKR_OK;
204 }
205
Test_C_GetMechanismList(CK_SLOT_ID,CK_MECHANISM_TYPE_PTR,CK_ULONG_PTR pulCount)206 CK_RV Test_C_GetMechanismList(CK_SLOT_ID, CK_MECHANISM_TYPE_PTR,
207 CK_ULONG_PTR pulCount) {
208 if (!pulCount) {
209 return CKR_ARGUMENTS_BAD;
210 }
211
212 *pulCount = 0;
213 return CKR_OK;
214 }
215
Test_C_GetMechanismInfo(CK_SLOT_ID,CK_MECHANISM_TYPE,CK_MECHANISM_INFO_PTR)216 CK_RV Test_C_GetMechanismInfo(CK_SLOT_ID, CK_MECHANISM_TYPE,
217 CK_MECHANISM_INFO_PTR) {
218 return CKR_OK;
219 }
220
Test_C_InitToken(CK_SLOT_ID,CK_UTF8CHAR_PTR,CK_ULONG,CK_UTF8CHAR_PTR)221 CK_RV Test_C_InitToken(CK_SLOT_ID, CK_UTF8CHAR_PTR, CK_ULONG, CK_UTF8CHAR_PTR) {
222 return CKR_OK;
223 }
224
Test_C_InitPIN(CK_SESSION_HANDLE,CK_UTF8CHAR_PTR,CK_ULONG)225 CK_RV Test_C_InitPIN(CK_SESSION_HANDLE, CK_UTF8CHAR_PTR, CK_ULONG) {
226 return CKR_FUNCTION_NOT_SUPPORTED;
227 }
228
Test_C_SetPIN(CK_SESSION_HANDLE,CK_UTF8CHAR_PTR,CK_ULONG,CK_UTF8CHAR_PTR,CK_ULONG)229 CK_RV Test_C_SetPIN(CK_SESSION_HANDLE, CK_UTF8CHAR_PTR, CK_ULONG,
230 CK_UTF8CHAR_PTR, CK_ULONG) {
231 return CKR_FUNCTION_NOT_SUPPORTED;
232 }
233
Test_C_OpenSession(CK_SLOT_ID slotID,CK_FLAGS,CK_VOID_PTR,CK_NOTIFY,CK_SESSION_HANDLE_PTR phSession)234 CK_RV Test_C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS, CK_VOID_PTR, CK_NOTIFY,
235 CK_SESSION_HANDLE_PTR phSession) {
236 switch (slotID) {
237 case 1:
238 *phSession = 1;
239 break;
240 case 2:
241 *phSession = 2;
242 break;
243 case 4:
244 *phSession = 4;
245 break;
246 default:
247 return CKR_ARGUMENTS_BAD;
248 }
249
250 return CKR_OK;
251 }
252
Test_C_CloseSession(CK_SESSION_HANDLE)253 CK_RV Test_C_CloseSession(CK_SESSION_HANDLE) { return CKR_OK; }
254
Test_C_CloseAllSessions(CK_SLOT_ID)255 CK_RV Test_C_CloseAllSessions(CK_SLOT_ID) { return CKR_OK; }
256
Test_C_GetSessionInfo(CK_SESSION_HANDLE hSession,CK_SESSION_INFO_PTR pInfo)257 CK_RV Test_C_GetSessionInfo(CK_SESSION_HANDLE hSession,
258 CK_SESSION_INFO_PTR pInfo) {
259 if (!pInfo) {
260 return CKR_ARGUMENTS_BAD;
261 }
262
263 switch (hSession) {
264 case 1:
265 pInfo->slotID = 1;
266 break;
267 case 2:
268 pInfo->slotID = 2;
269 break;
270 case 4:
271 pInfo->slotID = 4;
272 break;
273 default:
274 return CKR_ARGUMENTS_BAD;
275 }
276
277 pInfo->state = CKS_RO_PUBLIC_SESSION;
278 pInfo->flags = CKF_SERIAL_SESSION;
279 return CKR_OK;
280 }
281
Test_C_GetOperationState(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG_PTR)282 CK_RV Test_C_GetOperationState(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG_PTR) {
283 return CKR_FUNCTION_NOT_SUPPORTED;
284 }
285
Test_C_SetOperationState(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_OBJECT_HANDLE,CK_OBJECT_HANDLE)286 CK_RV Test_C_SetOperationState(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
287 CK_OBJECT_HANDLE, CK_OBJECT_HANDLE) {
288 return CKR_FUNCTION_NOT_SUPPORTED;
289 }
290
Test_C_Login(CK_SESSION_HANDLE,CK_USER_TYPE,CK_UTF8CHAR_PTR,CK_ULONG)291 CK_RV Test_C_Login(CK_SESSION_HANDLE, CK_USER_TYPE, CK_UTF8CHAR_PTR, CK_ULONG) {
292 return CKR_FUNCTION_NOT_SUPPORTED;
293 }
294
Test_C_Logout(CK_SESSION_HANDLE)295 CK_RV Test_C_Logout(CK_SESSION_HANDLE) { return CKR_FUNCTION_NOT_SUPPORTED; }
296
Test_C_CreateObject(CK_SESSION_HANDLE,CK_ATTRIBUTE_PTR,CK_ULONG,CK_OBJECT_HANDLE_PTR)297 CK_RV Test_C_CreateObject(CK_SESSION_HANDLE, CK_ATTRIBUTE_PTR, CK_ULONG,
298 CK_OBJECT_HANDLE_PTR) {
299 return CKR_FUNCTION_NOT_SUPPORTED;
300 }
301
Test_C_CopyObject(CK_SESSION_HANDLE,CK_OBJECT_HANDLE,CK_ATTRIBUTE_PTR,CK_ULONG,CK_OBJECT_HANDLE_PTR)302 CK_RV Test_C_CopyObject(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ATTRIBUTE_PTR,
303 CK_ULONG, CK_OBJECT_HANDLE_PTR) {
304 return CKR_FUNCTION_NOT_SUPPORTED;
305 }
306
Test_C_DestroyObject(CK_SESSION_HANDLE,CK_OBJECT_HANDLE)307 CK_RV Test_C_DestroyObject(CK_SESSION_HANDLE, CK_OBJECT_HANDLE) {
308 return CKR_FUNCTION_NOT_SUPPORTED;
309 }
310
Test_C_GetObjectSize(CK_SESSION_HANDLE,CK_OBJECT_HANDLE,CK_ULONG_PTR)311 CK_RV Test_C_GetObjectSize(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ULONG_PTR) {
312 return CKR_FUNCTION_NOT_SUPPORTED;
313 }
314
Test_C_GetAttributeValue(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE hObject,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)315 CK_RV Test_C_GetAttributeValue(CK_SESSION_HANDLE hSession,
316 CK_OBJECT_HANDLE hObject,
317 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) {
318 if (hSession == 4) {
319 assert(hObject >= 1 &&
320 hObject - 1 < sizeof(profiles) / sizeof(profiles[0]));
321 for (CK_ULONG count = 0; count < ulCount; count++) {
322 if (pTemplate[count].type == CKA_PROFILE_ID) {
323 if (pTemplate[count].pValue) {
324 assert(pTemplate[count].ulValueLen == sizeof(CK_ULONG));
325 CK_ULONG value = profiles[hObject - 1];
326 memcpy(pTemplate[count].pValue, &value, sizeof(value));
327 } else {
328 pTemplate[count].ulValueLen = sizeof(CK_ULONG);
329 }
330 } else {
331 pTemplate[count].ulValueLen = (CK_ULONG)-1;
332 }
333 }
334 return CKR_OK;
335 }
336 return CKR_FUNCTION_NOT_SUPPORTED;
337 }
338
Test_C_SetAttributeValue(CK_SESSION_HANDLE,CK_OBJECT_HANDLE,CK_ATTRIBUTE_PTR,CK_ULONG)339 CK_RV Test_C_SetAttributeValue(CK_SESSION_HANDLE, CK_OBJECT_HANDLE,
340 CK_ATTRIBUTE_PTR, CK_ULONG) {
341 return CKR_FUNCTION_NOT_SUPPORTED;
342 }
343
Test_C_FindObjectsInit(CK_SESSION_HANDLE hSession,CK_ATTRIBUTE_PTR pTemplate,CK_ULONG ulCount)344 CK_RV Test_C_FindObjectsInit(CK_SESSION_HANDLE hSession,
345 CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) {
346 // Slot 4
347 if (hSession == 4) {
348 for (CK_ULONG count = 0; count < ulCount; count++) {
349 CK_ATTRIBUTE attribute = pTemplate[count];
350 if (attribute.type == CKA_CLASS) {
351 assert(attribute.ulValueLen == sizeof(CK_ULONG));
352
353 CK_ULONG value;
354 memcpy(&value, attribute.pValue, attribute.ulValueLen);
355 if (value == CKO_PROFILE) {
356 readingProfile = true;
357 profileIndex = 0;
358 break;
359 }
360 }
361 }
362 }
363 return CKR_OK;
364 }
365
Test_C_FindObjects(CK_SESSION_HANDLE hSession,CK_OBJECT_HANDLE_PTR phObject,CK_ULONG ulMaxObjectCount,CK_ULONG_PTR pulObjectCount)366 CK_RV Test_C_FindObjects(CK_SESSION_HANDLE hSession,
367 CK_OBJECT_HANDLE_PTR phObject,
368 CK_ULONG ulMaxObjectCount,
369 CK_ULONG_PTR pulObjectCount) {
370 if (readingProfile) {
371 assert(hSession == 4);
372 CK_ULONG count = ulMaxObjectCount;
373 size_t remaining = sizeof(profiles) / sizeof(profiles[0]) - profileIndex;
374 if (count > remaining) {
375 count = remaining;
376 }
377 for (CK_ULONG i = 0; i < count; i++) {
378 phObject[i] = i + 1;
379 }
380 profileIndex += count;
381 *pulObjectCount = count;
382 } else {
383 *pulObjectCount = 0;
384 }
385 return CKR_OK;
386 }
387
Test_C_FindObjectsFinal(CK_SESSION_HANDLE hSession)388 CK_RV Test_C_FindObjectsFinal(CK_SESSION_HANDLE hSession) {
389 readingProfile = false;
390 return CKR_OK;
391 }
392
Test_C_EncryptInit(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE)393 CK_RV Test_C_EncryptInit(CK_SESSION_HANDLE, CK_MECHANISM_PTR,
394 CK_OBJECT_HANDLE) {
395 return CKR_FUNCTION_NOT_SUPPORTED;
396 }
397
Test_C_Encrypt(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)398 CK_RV Test_C_Encrypt(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG, CK_BYTE_PTR,
399 CK_ULONG_PTR) {
400 return CKR_FUNCTION_NOT_SUPPORTED;
401 }
402
Test_C_EncryptUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)403 CK_RV Test_C_EncryptUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
404 CK_BYTE_PTR, CK_ULONG_PTR) {
405 return CKR_FUNCTION_NOT_SUPPORTED;
406 }
407
Test_C_EncryptFinal(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG_PTR)408 CK_RV Test_C_EncryptFinal(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG_PTR) {
409 return CKR_FUNCTION_NOT_SUPPORTED;
410 }
411
Test_C_DecryptInit(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE)412 CK_RV Test_C_DecryptInit(CK_SESSION_HANDLE, CK_MECHANISM_PTR,
413 CK_OBJECT_HANDLE) {
414 return CKR_FUNCTION_NOT_SUPPORTED;
415 }
416
Test_C_Decrypt(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)417 CK_RV Test_C_Decrypt(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG, CK_BYTE_PTR,
418 CK_ULONG_PTR) {
419 return CKR_FUNCTION_NOT_SUPPORTED;
420 }
421
Test_C_DecryptUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)422 CK_RV Test_C_DecryptUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
423 CK_BYTE_PTR, CK_ULONG_PTR) {
424 return CKR_FUNCTION_NOT_SUPPORTED;
425 }
426
Test_C_DecryptFinal(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG_PTR)427 CK_RV Test_C_DecryptFinal(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG_PTR) {
428 return CKR_FUNCTION_NOT_SUPPORTED;
429 }
430
Test_C_DigestInit(CK_SESSION_HANDLE,CK_MECHANISM_PTR)431 CK_RV Test_C_DigestInit(CK_SESSION_HANDLE, CK_MECHANISM_PTR) {
432 return CKR_FUNCTION_NOT_SUPPORTED;
433 }
434
Test_C_Digest(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)435 CK_RV Test_C_Digest(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG, CK_BYTE_PTR,
436 CK_ULONG_PTR) {
437 return CKR_FUNCTION_NOT_SUPPORTED;
438 }
439
Test_C_DigestUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG)440 CK_RV Test_C_DigestUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG) {
441 return CKR_FUNCTION_NOT_SUPPORTED;
442 }
443
Test_C_DigestKey(CK_SESSION_HANDLE,CK_OBJECT_HANDLE)444 CK_RV Test_C_DigestKey(CK_SESSION_HANDLE, CK_OBJECT_HANDLE) {
445 return CKR_FUNCTION_NOT_SUPPORTED;
446 }
447
Test_C_DigestFinal(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG_PTR)448 CK_RV Test_C_DigestFinal(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG_PTR) {
449 return CKR_FUNCTION_NOT_SUPPORTED;
450 }
451
Test_C_SignInit(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE)452 CK_RV Test_C_SignInit(CK_SESSION_HANDLE, CK_MECHANISM_PTR, CK_OBJECT_HANDLE) {
453 return CKR_FUNCTION_NOT_SUPPORTED;
454 }
455
Test_C_Sign(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)456 CK_RV Test_C_Sign(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG, CK_BYTE_PTR,
457 CK_ULONG_PTR) {
458 return CKR_FUNCTION_NOT_SUPPORTED;
459 }
460
Test_C_SignUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG)461 CK_RV Test_C_SignUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG) {
462 return CKR_FUNCTION_NOT_SUPPORTED;
463 }
464
Test_C_SignFinal(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG_PTR)465 CK_RV Test_C_SignFinal(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG_PTR) {
466 return CKR_FUNCTION_NOT_SUPPORTED;
467 }
468
Test_C_SignRecoverInit(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE)469 CK_RV Test_C_SignRecoverInit(CK_SESSION_HANDLE, CK_MECHANISM_PTR,
470 CK_OBJECT_HANDLE) {
471 return CKR_FUNCTION_NOT_SUPPORTED;
472 }
473
Test_C_SignRecover(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)474 CK_RV Test_C_SignRecover(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG, CK_BYTE_PTR,
475 CK_ULONG_PTR) {
476 return CKR_FUNCTION_NOT_SUPPORTED;
477 }
478
Test_C_VerifyInit(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE)479 CK_RV Test_C_VerifyInit(CK_SESSION_HANDLE, CK_MECHANISM_PTR, CK_OBJECT_HANDLE) {
480 return CKR_FUNCTION_NOT_SUPPORTED;
481 }
482
Test_C_Verify(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG)483 CK_RV Test_C_Verify(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG, CK_BYTE_PTR,
484 CK_ULONG) {
485 return CKR_FUNCTION_NOT_SUPPORTED;
486 }
487
Test_C_VerifyUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG)488 CK_RV Test_C_VerifyUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG) {
489 return CKR_FUNCTION_NOT_SUPPORTED;
490 }
491
Test_C_VerifyFinal(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG)492 CK_RV Test_C_VerifyFinal(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG) {
493 return CKR_FUNCTION_NOT_SUPPORTED;
494 }
495
Test_C_VerifyRecoverInit(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE)496 CK_RV Test_C_VerifyRecoverInit(CK_SESSION_HANDLE, CK_MECHANISM_PTR,
497 CK_OBJECT_HANDLE) {
498 return CKR_FUNCTION_NOT_SUPPORTED;
499 }
500
Test_C_VerifyRecover(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)501 CK_RV Test_C_VerifyRecover(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
502 CK_BYTE_PTR, CK_ULONG_PTR) {
503 return CKR_FUNCTION_NOT_SUPPORTED;
504 }
505
Test_C_DigestEncryptUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)506 CK_RV Test_C_DigestEncryptUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
507 CK_BYTE_PTR, CK_ULONG_PTR) {
508 return CKR_FUNCTION_NOT_SUPPORTED;
509 }
510
Test_C_DecryptDigestUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)511 CK_RV Test_C_DecryptDigestUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
512 CK_BYTE_PTR, CK_ULONG_PTR) {
513 return CKR_FUNCTION_NOT_SUPPORTED;
514 }
515
Test_C_SignEncryptUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)516 CK_RV Test_C_SignEncryptUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
517 CK_BYTE_PTR, CK_ULONG_PTR) {
518 return CKR_FUNCTION_NOT_SUPPORTED;
519 }
520
Test_C_DecryptVerifyUpdate(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_BYTE_PTR,CK_ULONG_PTR)521 CK_RV Test_C_DecryptVerifyUpdate(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG,
522 CK_BYTE_PTR, CK_ULONG_PTR) {
523 return CKR_FUNCTION_NOT_SUPPORTED;
524 }
525
Test_C_GenerateKey(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_ATTRIBUTE_PTR,CK_ULONG,CK_OBJECT_HANDLE_PTR)526 CK_RV Test_C_GenerateKey(CK_SESSION_HANDLE, CK_MECHANISM_PTR, CK_ATTRIBUTE_PTR,
527 CK_ULONG, CK_OBJECT_HANDLE_PTR) {
528 return CKR_FUNCTION_NOT_SUPPORTED;
529 }
530
Test_C_GenerateKeyPair(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_ATTRIBUTE_PTR,CK_ULONG,CK_ATTRIBUTE_PTR,CK_ULONG,CK_OBJECT_HANDLE_PTR,CK_OBJECT_HANDLE_PTR)531 CK_RV Test_C_GenerateKeyPair(CK_SESSION_HANDLE, CK_MECHANISM_PTR,
532 CK_ATTRIBUTE_PTR, CK_ULONG, CK_ATTRIBUTE_PTR,
533 CK_ULONG, CK_OBJECT_HANDLE_PTR,
534 CK_OBJECT_HANDLE_PTR) {
535 return CKR_FUNCTION_NOT_SUPPORTED;
536 }
537
Test_C_WrapKey(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE,CK_OBJECT_HANDLE,CK_BYTE_PTR,CK_ULONG_PTR)538 CK_RV Test_C_WrapKey(CK_SESSION_HANDLE, CK_MECHANISM_PTR, CK_OBJECT_HANDLE,
539 CK_OBJECT_HANDLE, CK_BYTE_PTR, CK_ULONG_PTR) {
540 return CKR_FUNCTION_NOT_SUPPORTED;
541 }
542
Test_C_UnwrapKey(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE,CK_BYTE_PTR,CK_ULONG,CK_ATTRIBUTE_PTR,CK_ULONG,CK_OBJECT_HANDLE_PTR)543 CK_RV Test_C_UnwrapKey(CK_SESSION_HANDLE, CK_MECHANISM_PTR, CK_OBJECT_HANDLE,
544 CK_BYTE_PTR, CK_ULONG, CK_ATTRIBUTE_PTR, CK_ULONG,
545 CK_OBJECT_HANDLE_PTR) {
546 return CKR_FUNCTION_NOT_SUPPORTED;
547 }
548
Test_C_DeriveKey(CK_SESSION_HANDLE,CK_MECHANISM_PTR,CK_OBJECT_HANDLE,CK_ATTRIBUTE_PTR,CK_ULONG,CK_OBJECT_HANDLE_PTR)549 CK_RV Test_C_DeriveKey(CK_SESSION_HANDLE, CK_MECHANISM_PTR, CK_OBJECT_HANDLE,
550 CK_ATTRIBUTE_PTR, CK_ULONG, CK_OBJECT_HANDLE_PTR) {
551 return CKR_FUNCTION_NOT_SUPPORTED;
552 }
553
Test_C_SeedRandom(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG)554 CK_RV Test_C_SeedRandom(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG) {
555 return CKR_FUNCTION_NOT_SUPPORTED;
556 }
557
Test_C_GenerateRandom(CK_SESSION_HANDLE,CK_BYTE_PTR,CK_ULONG)558 CK_RV Test_C_GenerateRandom(CK_SESSION_HANDLE, CK_BYTE_PTR, CK_ULONG) {
559 return CKR_FUNCTION_NOT_SUPPORTED;
560 }
561
Test_C_GetFunctionStatus(CK_SESSION_HANDLE)562 CK_RV Test_C_GetFunctionStatus(CK_SESSION_HANDLE) {
563 return CKR_FUNCTION_NOT_SUPPORTED;
564 }
565
Test_C_CancelFunction(CK_SESSION_HANDLE)566 CK_RV Test_C_CancelFunction(CK_SESSION_HANDLE) {
567 return CKR_FUNCTION_NOT_SUPPORTED;
568 }
569
Test_C_WaitForSlotEvent(CK_FLAGS,CK_SLOT_ID_PTR pSlot,CK_VOID_PTR)570 CK_RV Test_C_WaitForSlotEvent(CK_FLAGS, CK_SLOT_ID_PTR pSlot, CK_VOID_PTR) {
571 #ifdef _WIN32
572 Sleep(50); // Sleep takes the duration argument as milliseconds
573 #else
574 usleep(50000); // usleep takes the duration argument as microseconds
575 #endif
576 *pSlot = 1;
577 tokenPresent = !tokenPresent;
578 return CKR_OK;
579 }
580
581 static CK_FUNCTION_LIST FunctionList = {{2, 2},
582 Test_C_Initialize,
583 Test_C_Finalize,
584 Test_C_GetInfo,
585 Test_C_GetFunctionList,
586 Test_C_GetSlotList,
587 Test_C_GetSlotInfo,
588 Test_C_GetTokenInfo,
589 Test_C_GetMechanismList,
590 Test_C_GetMechanismInfo,
591 Test_C_InitToken,
592 Test_C_InitPIN,
593 Test_C_SetPIN,
594 Test_C_OpenSession,
595 Test_C_CloseSession,
596 Test_C_CloseAllSessions,
597 Test_C_GetSessionInfo,
598 Test_C_GetOperationState,
599 Test_C_SetOperationState,
600 Test_C_Login,
601 Test_C_Logout,
602 Test_C_CreateObject,
603 Test_C_CopyObject,
604 Test_C_DestroyObject,
605 Test_C_GetObjectSize,
606 Test_C_GetAttributeValue,
607 Test_C_SetAttributeValue,
608 Test_C_FindObjectsInit,
609 Test_C_FindObjects,
610 Test_C_FindObjectsFinal,
611 Test_C_EncryptInit,
612 Test_C_Encrypt,
613 Test_C_EncryptUpdate,
614 Test_C_EncryptFinal,
615 Test_C_DecryptInit,
616 Test_C_Decrypt,
617 Test_C_DecryptUpdate,
618 Test_C_DecryptFinal,
619 Test_C_DigestInit,
620 Test_C_Digest,
621 Test_C_DigestUpdate,
622 Test_C_DigestKey,
623 Test_C_DigestFinal,
624 Test_C_SignInit,
625 Test_C_Sign,
626 Test_C_SignUpdate,
627 Test_C_SignFinal,
628 Test_C_SignRecoverInit,
629 Test_C_SignRecover,
630 Test_C_VerifyInit,
631 Test_C_Verify,
632 Test_C_VerifyUpdate,
633 Test_C_VerifyFinal,
634 Test_C_VerifyRecoverInit,
635 Test_C_VerifyRecover,
636 Test_C_DigestEncryptUpdate,
637 Test_C_DecryptDigestUpdate,
638 Test_C_SignEncryptUpdate,
639 Test_C_DecryptVerifyUpdate,
640 Test_C_GenerateKey,
641 Test_C_GenerateKeyPair,
642 Test_C_WrapKey,
643 Test_C_UnwrapKey,
644 Test_C_DeriveKey,
645 Test_C_SeedRandom,
646 Test_C_GenerateRandom,
647 Test_C_GetFunctionStatus,
648 Test_C_CancelFunction,
649 Test_C_WaitForSlotEvent};
650
651 #ifdef _WIN32
652 __declspec(dllexport)
653 #endif
654
C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)655 CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList) {
656 *ppFunctionList = &FunctionList;
657 return CKR_OK;
658 }
659