1 /*
2 * Copyright (c) 2012 Stefan Walter
3 * Copyright (c) 2012-2013 Red Hat Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * * Redistributions of source code must retain the above
10 * copyright notice, this list of conditions and the
11 * following disclaimer.
12 * * Redistributions in binary form must reproduce the
13 * above copyright notice, this list of conditions and
14 * the following disclaimer in the documentation and/or
15 * other materials provided with the distribution.
16 * * The names of contributors to this software may not be
17 * used to endorse or promote products derived from this
18 * software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 * DAMAGE.
32 *
33 * Author: Stef Walter <stef@thewalter.net>
34 */
35
36 #include "test.h"
37
38 #include "library.h"
39 #include "mock.h"
40 #include "p11-kit.h"
41
42 #include <sys/types.h>
43 #include <string.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46
47 static void
test_get_info(void)48 test_get_info (void)
49 {
50 CK_FUNCTION_LIST_PTR module;
51 CK_INFO info;
52 CK_RV rv;
53
54 module = setup_mock_module (NULL);
55
56 rv = (module->C_GetInfo) (&info);
57 assert_num_eq (rv, CKR_OK);
58 assert_num_eq (MOCK_INFO.cryptokiVersion.major, info.cryptokiVersion.major);
59 assert_num_eq (MOCK_INFO.cryptokiVersion.minor, info.cryptokiVersion.minor);
60 assert (memcmp (MOCK_INFO.manufacturerID, info.manufacturerID, sizeof (info.manufacturerID)) == 0);
61 assert_num_eq (MOCK_INFO.flags, info.flags);
62 assert (memcmp (MOCK_INFO.libraryDescription, info.libraryDescription, sizeof (info.libraryDescription)) == 0);
63 assert_num_eq (MOCK_INFO.libraryVersion.major, info.libraryVersion.major);
64 assert_num_eq (MOCK_INFO.libraryVersion.minor, info.libraryVersion.minor);
65
66 teardown_mock_module (module);
67 }
68
69 static void
test_get_slot_list(void)70 test_get_slot_list (void)
71 {
72 CK_FUNCTION_LIST_PTR module;
73 CK_SLOT_ID slot_list[8];
74 CK_ULONG count = 0;
75 CK_RV rv;
76
77 module = setup_mock_module (NULL);
78
79 /* Normal module has 2 slots, one with token present */
80 rv = (module->C_GetSlotList) (CK_TRUE, NULL, &count);
81 assert (rv == CKR_OK);
82 assert_num_eq (MOCK_SLOTS_PRESENT, count);
83 rv = (module->C_GetSlotList) (CK_FALSE, NULL, &count);
84 assert (rv == CKR_OK);
85 assert_num_eq (MOCK_SLOTS_ALL, count);
86
87 count = 8;
88 rv = (module->C_GetSlotList) (CK_TRUE, slot_list, &count);
89 assert (rv == CKR_OK);
90 assert_num_eq (MOCK_SLOTS_PRESENT, count);
91 assert_num_eq (MOCK_SLOT_ONE_ID, slot_list[0]);
92
93 count = 8;
94 rv = (module->C_GetSlotList) (CK_FALSE, slot_list, &count);
95 assert (rv == CKR_OK);
96 assert_num_eq (MOCK_SLOTS_ALL, count);
97 assert_num_eq (MOCK_SLOT_ONE_ID, slot_list[0]);
98 assert_num_eq (MOCK_SLOT_TWO_ID, slot_list[1]);
99
100 teardown_mock_module (module);
101 }
102
103 static void
test_get_slot_info(void)104 test_get_slot_info (void)
105 {
106 CK_FUNCTION_LIST_PTR module;
107 CK_SLOT_INFO info;
108 char *string;
109 CK_RV rv;
110
111 module = setup_mock_module (NULL);
112
113 rv = (module->C_GetSlotInfo) (MOCK_SLOT_ONE_ID, &info);
114 assert (rv == CKR_OK);
115 string = p11_kit_space_strdup (info.slotDescription, sizeof (info.slotDescription));
116 assert_str_eq ("TEST SLOT", string);
117 free (string);
118 string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID));
119 assert_str_eq ("TEST MANUFACTURER", string);
120 free (string);
121 assert_num_eq (CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE, info.flags);
122 assert_num_eq (55, info.hardwareVersion.major);
123 assert_num_eq (155, info.hardwareVersion.minor);
124 assert_num_eq (65, info.firmwareVersion.major);
125 assert_num_eq (165, info.firmwareVersion.minor);
126
127 rv = (module->C_GetSlotInfo) (MOCK_SLOT_TWO_ID, &info);
128 assert (rv == CKR_OK);
129 assert_num_eq (CKF_REMOVABLE_DEVICE, info.flags);
130
131 rv = (module->C_GetSlotInfo) (0, &info);
132 assert (rv == CKR_SLOT_ID_INVALID);
133
134 teardown_mock_module (module);
135 }
136
137 static void
test_get_token_info(void)138 test_get_token_info (void)
139 {
140 CK_FUNCTION_LIST_PTR module;
141 CK_TOKEN_INFO info;
142 char *string;
143 CK_RV rv;
144
145 module = setup_mock_module (NULL);
146
147 rv = (module->C_GetTokenInfo) (MOCK_SLOT_ONE_ID, &info);
148 assert (rv == CKR_OK);
149
150 string = p11_kit_space_strdup (info.label, sizeof (info.label));
151 assert_str_eq ("TEST LABEL", string);
152 free (string);
153 string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID));
154 assert_str_eq ("TEST MANUFACTURER", string);
155 free (string);
156 string = p11_kit_space_strdup (info.model, sizeof (info.model));
157 assert_str_eq ("TEST MODEL", string);
158 free (string);
159 string = p11_kit_space_strdup (info.serialNumber, sizeof (info.serialNumber));
160 assert_str_eq ("TEST SERIAL", string);
161 free (string);
162 assert_num_eq (CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED | CKF_CLOCK_ON_TOKEN | CKF_TOKEN_INITIALIZED, info.flags);
163 assert_num_eq (1, info.ulMaxSessionCount);
164 assert_num_eq (2, info.ulSessionCount);
165 assert_num_eq (3, info.ulMaxRwSessionCount);
166 assert_num_eq (4, info.ulRwSessionCount);
167 assert_num_eq (5, info.ulMaxPinLen);
168 assert_num_eq (6, info.ulMinPinLen);
169 assert_num_eq (7, info.ulTotalPublicMemory);
170 assert_num_eq (8, info.ulFreePublicMemory);
171 assert_num_eq (9, info.ulTotalPrivateMemory);
172 assert_num_eq (10, info.ulFreePrivateMemory);
173 assert_num_eq (75, info.hardwareVersion.major);
174 assert_num_eq (175, info.hardwareVersion.minor);
175 assert_num_eq (85, info.firmwareVersion.major);
176 assert_num_eq (185, info.firmwareVersion.minor);
177 assert (memcmp (info.utcTime, "1999052509195900", sizeof (info.utcTime)) == 0);
178
179 rv = (module->C_GetTokenInfo) (MOCK_SLOT_TWO_ID, &info);
180 assert (rv == CKR_TOKEN_NOT_PRESENT);
181
182 rv = (module->C_GetTokenInfo) (0, &info);
183 assert (rv == CKR_SLOT_ID_INVALID);
184
185 teardown_mock_module (module);
186 }
187
188 static void
test_get_mechanism_list(void)189 test_get_mechanism_list (void)
190 {
191 CK_FUNCTION_LIST_PTR module;
192 CK_MECHANISM_TYPE mechs[8];
193 CK_ULONG count = 0;
194 CK_RV rv;
195
196 module = setup_mock_module (NULL);
197
198 rv = (module->C_GetMechanismList) (MOCK_SLOT_ONE_ID, NULL, &count);
199 assert (rv == CKR_OK);
200 assert_num_eq (2, count);
201 rv = (module->C_GetMechanismList) (MOCK_SLOT_TWO_ID, NULL, &count);
202 assert (rv == CKR_TOKEN_NOT_PRESENT);
203 rv = (module->C_GetMechanismList) (0, NULL, &count);
204 assert (rv == CKR_SLOT_ID_INVALID);
205
206 count = 8;
207 rv = (module->C_GetMechanismList) (MOCK_SLOT_ONE_ID, mechs, &count);
208 assert (rv == CKR_OK);
209 assert_num_eq (2, count);
210 assert_num_eq (mechs[0], CKM_MOCK_CAPITALIZE);
211 assert_num_eq (mechs[1], CKM_MOCK_PREFIX);
212
213 teardown_mock_module (module);
214 }
215
216 static void
test_get_mechanism_info(void)217 test_get_mechanism_info (void)
218 {
219 CK_FUNCTION_LIST_PTR module;
220 CK_MECHANISM_INFO info;
221 CK_RV rv;
222
223 module = setup_mock_module (NULL);
224
225 rv = (module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, CKM_MOCK_CAPITALIZE, &info);
226 assert_num_eq (rv, CKR_OK);
227 assert_num_eq (512, info.ulMinKeySize);
228 assert_num_eq (4096, info.ulMaxKeySize);
229 assert_num_eq (CKF_ENCRYPT | CKF_DECRYPT, info.flags);
230
231 rv = (module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, CKM_MOCK_PREFIX, &info);
232 assert (rv == CKR_OK);
233 assert_num_eq (2048, info.ulMinKeySize);
234 assert_num_eq (2048, info.ulMaxKeySize);
235 assert_num_eq (CKF_SIGN | CKF_VERIFY, info.flags);
236
237 rv = (module->C_GetMechanismInfo) (MOCK_SLOT_TWO_ID, CKM_MOCK_PREFIX, &info);
238 assert (rv == CKR_TOKEN_NOT_PRESENT);
239 rv = (module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, 0, &info);
240 assert (rv == CKR_MECHANISM_INVALID);
241 rv = (module->C_GetMechanismInfo) (0, CKM_MOCK_PREFIX, &info);
242 assert (rv == CKR_SLOT_ID_INVALID);
243
244 teardown_mock_module (module);
245 }
246
247 static void
test_init_token(void)248 test_init_token (void)
249 {
250 CK_FUNCTION_LIST_PTR module;
251 CK_RV rv;
252
253 module = setup_mock_module (NULL);
254
255 rv = (module->C_InitToken) (MOCK_SLOT_ONE_ID, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL");
256 assert (rv == CKR_OK);
257
258 rv = (module->C_InitToken) (MOCK_SLOT_ONE_ID, (CK_UTF8CHAR_PTR)"OTHER", 5, (CK_UTF8CHAR_PTR)"TEST LABEL");
259 assert (rv == CKR_PIN_INVALID);
260 rv = (module->C_InitToken) (MOCK_SLOT_TWO_ID, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL");
261 assert (rv == CKR_TOKEN_NOT_PRESENT);
262 rv = (module->C_InitToken) (0, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL");
263 assert (rv == CKR_SLOT_ID_INVALID);
264
265 teardown_mock_module (module);
266 }
267
268 static void
test_wait_for_slot_event(void)269 test_wait_for_slot_event (void)
270 {
271 CK_FUNCTION_LIST_PTR module;
272 CK_SLOT_ID slot;
273 CK_RV rv;
274
275 #ifdef MOCK_SKIP_WAIT_TEST
276 return;
277 #endif
278
279 module = setup_mock_module (NULL);
280
281 rv = (module->C_WaitForSlotEvent) (0, &slot, NULL);
282 assert (rv == CKR_OK);
283 assert_num_eq (slot, MOCK_SLOT_TWO_ID);
284
285 rv = (module->C_WaitForSlotEvent) (CKF_DONT_BLOCK, &slot, NULL);
286 assert (rv == CKR_NO_EVENT);
287
288 teardown_mock_module (module);
289 }
290
291 static void
test_open_close_session(void)292 test_open_close_session (void)
293 {
294 CK_FUNCTION_LIST_PTR module;
295 CK_SESSION_HANDLE session = 0;
296 CK_RV rv;
297
298 module = setup_mock_module (NULL);
299
300 rv = (module->C_OpenSession) (MOCK_SLOT_TWO_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
301 assert (rv == CKR_TOKEN_NOT_PRESENT);
302 rv = (module->C_OpenSession) (0, CKF_SERIAL_SESSION, NULL, NULL, &session);
303 assert (rv == CKR_SLOT_ID_INVALID);
304
305 rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
306 assert (rv == CKR_OK);
307 assert (session != 0);
308
309 rv = (module->C_CloseSession) (session);
310 assert (rv == CKR_OK);
311
312 rv = (module->C_CloseSession) (session);
313 assert (rv == CKR_SESSION_HANDLE_INVALID);
314
315 teardown_mock_module (module);
316 }
317
318 static void
test_close_all_sessions(void)319 test_close_all_sessions (void)
320 {
321 CK_FUNCTION_LIST_PTR module;
322 CK_SESSION_HANDLE session = 0;
323 CK_RV rv;
324
325 module = setup_mock_module (NULL);
326
327 rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
328 assert (rv == CKR_OK);
329 assert (session != 0);
330
331 rv = (module->C_CloseAllSessions) (MOCK_SLOT_ONE_ID);
332 assert (rv == CKR_OK);
333
334 rv = (module->C_CloseSession) (session);
335 assert (rv == CKR_SESSION_HANDLE_INVALID);
336
337 teardown_mock_module (module);
338 }
339
340 static void
test_get_function_status(void)341 test_get_function_status (void)
342 {
343 CK_FUNCTION_LIST_PTR module;
344 CK_SESSION_HANDLE session = 0;
345 CK_RV rv;
346
347 module = setup_mock_module (&session);
348
349 rv = (module->C_GetFunctionStatus) (session);
350 assert (rv == CKR_FUNCTION_NOT_PARALLEL);
351
352 teardown_mock_module (module);
353 }
354
355 static void
test_cancel_function(void)356 test_cancel_function (void)
357 {
358 CK_FUNCTION_LIST_PTR module;
359 CK_SESSION_HANDLE session = 0;
360 CK_RV rv;
361
362 module = setup_mock_module (&session);
363
364 rv = (module->C_CancelFunction) (session);
365 assert (rv == CKR_FUNCTION_NOT_PARALLEL);
366
367 teardown_mock_module (module);
368 }
369
370 static void
test_get_session_info(void)371 test_get_session_info (void)
372 {
373 CK_FUNCTION_LIST_PTR module;
374 CK_SESSION_HANDLE session = 0;
375 CK_SESSION_INFO info;
376 CK_RV rv;
377
378 module = setup_mock_module (NULL);
379
380 rv = (module->C_GetSessionInfo) (0, &info);
381 assert (rv == CKR_SESSION_HANDLE_INVALID);
382
383 rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session);
384 assert (rv == CKR_OK);
385 assert (session != 0);
386
387 rv = (module->C_GetSessionInfo) (session, &info);
388 assert (rv == CKR_OK);
389 assert_num_eq (MOCK_SLOT_ONE_ID, info.slotID);
390 assert_num_eq (CKS_RO_PUBLIC_SESSION, info.state);
391 assert_num_eq (CKF_SERIAL_SESSION, info.flags);
392 assert_num_eq (1414, info.ulDeviceError);
393
394 rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_RW_SESSION | CKF_SERIAL_SESSION, NULL, NULL, &session);
395 assert (rv == CKR_OK);
396 assert (session != 0);
397
398 rv = (module->C_GetSessionInfo) (session, &info);
399 assert (rv == CKR_OK);
400 assert_num_eq (MOCK_SLOT_ONE_ID, info.slotID);
401 assert_num_eq (CKS_RW_PUBLIC_SESSION, info.state);
402 assert_num_eq (CKF_SERIAL_SESSION | CKF_RW_SESSION, info.flags);
403 assert_num_eq (1414, info.ulDeviceError);
404
405 teardown_mock_module (module);
406 }
407
408 static void
test_init_pin(void)409 test_init_pin (void)
410 {
411 CK_FUNCTION_LIST_PTR module;
412 CK_SESSION_HANDLE session = 0;
413 CK_RV rv;
414
415 module = setup_mock_module (&session);
416
417 rv = (module->C_InitPIN) (0, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
418 assert (rv == CKR_SESSION_HANDLE_INVALID);
419
420 rv = (module->C_InitPIN) (session, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
421 assert (rv == CKR_OK);
422
423 rv = (module->C_InitPIN) (session, (CK_UTF8CHAR_PTR)"OTHER", 5);
424 assert (rv == CKR_PIN_INVALID);
425
426 teardown_mock_module (module);
427 }
428
429 static void
test_set_pin(void)430 test_set_pin (void)
431 {
432 CK_FUNCTION_LIST_PTR module;
433 CK_SESSION_HANDLE session = 0;
434 CK_RV rv;
435
436 module = setup_mock_module (&session);
437
438 rv = (module->C_SetPIN) (0, (CK_UTF8CHAR_PTR)"booo", 4, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
439 assert (rv == CKR_SESSION_HANDLE_INVALID);
440
441 rv = (module->C_SetPIN) (session, (CK_UTF8CHAR_PTR)"booo", 4, (CK_UTF8CHAR_PTR)"TEST PIN", 8);
442 assert (rv == CKR_OK);
443
444 rv = (module->C_SetPIN) (session, (CK_UTF8CHAR_PTR)"other", 5, (CK_UTF8CHAR_PTR)"OTHER", 5);
445 assert (rv == CKR_PIN_INCORRECT);
446
447 teardown_mock_module (module);
448 }
449
450 static void
test_operation_state(void)451 test_operation_state (void)
452 {
453 CK_FUNCTION_LIST_PTR module;
454 CK_BYTE state[128];
455 CK_ULONG state_len;
456 CK_SESSION_HANDLE session = 0;
457 CK_RV rv;
458
459 module = setup_mock_module (&session);
460
461 state_len = sizeof (state);
462 rv = (module->C_GetOperationState) (0, state, &state_len);
463 assert (rv == CKR_SESSION_HANDLE_INVALID);
464
465 state_len = sizeof (state);
466 rv = (module->C_GetOperationState) (session, state, &state_len);
467 assert (rv == CKR_OK);
468
469 rv = (module->C_SetOperationState) (session, state, state_len, 355, 455);
470 assert (rv == CKR_OK);
471
472 rv = (module->C_SetOperationState) (0, state, state_len, 355, 455);
473 assert (rv == CKR_SESSION_HANDLE_INVALID);
474
475 teardown_mock_module (module);
476 }
477
478 static void
test_login_logout(void)479 test_login_logout (void)
480 {
481 CK_FUNCTION_LIST_PTR module;
482 CK_SESSION_HANDLE session = 0;
483 CK_RV rv;
484
485 module = setup_mock_module (&session);
486
487 rv = (module->C_Login) (0, CKU_USER, (CK_UTF8CHAR_PTR)"booo", 4);
488 assert (rv == CKR_SESSION_HANDLE_INVALID);
489
490 rv = (module->C_Login) (session, CKU_USER, (CK_UTF8CHAR_PTR)"bo", 2);
491 assert (rv == CKR_PIN_INCORRECT);
492
493 rv = (module->C_Login) (session, CKU_USER, (CK_UTF8CHAR_PTR)"booo", 4);
494 assert (rv == CKR_OK);
495
496 rv = (module->C_Logout) (session);
497 assert (rv == CKR_OK);
498
499 rv = (module->C_Logout) (session);
500 assert (rv == CKR_USER_NOT_LOGGED_IN);
501
502 teardown_mock_module (module);
503 }
504
505 static void
test_get_attribute_value(void)506 test_get_attribute_value (void)
507 {
508 CK_FUNCTION_LIST_PTR module;
509 CK_SESSION_HANDLE session = 0;
510 CK_ATTRIBUTE attrs[8];
511 char label[32];
512 CK_OBJECT_CLASS klass;
513 CK_RV rv;
514
515 module = setup_mock_module (&session);
516
517 attrs[0].type = CKA_CLASS;
518 attrs[0].pValue = &klass;
519 attrs[0].ulValueLen = sizeof (klass);
520 attrs[1].type = CKA_LABEL;
521 attrs[1].pValue = label;
522 attrs[1].ulValueLen = 2; /* too small */
523 attrs[2].type = CKA_BITS_PER_PIXEL;
524 attrs[2].pValue = NULL;
525 attrs[2].ulValueLen = 0;
526
527 rv = (module->C_GetAttributeValue) (session, MOCK_PRIVATE_KEY_CAPITALIZE, attrs, 3);
528 assert (rv == CKR_USER_NOT_LOGGED_IN);
529
530 rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
531 assert (rv == CKR_BUFFER_TOO_SMALL);
532
533 /* Get right size */
534 attrs[1].pValue = NULL;
535 attrs[1].ulValueLen = 0;
536
537 rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
538 assert (rv == CKR_OK);
539
540 rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 3);
541 assert (rv == CKR_ATTRIBUTE_TYPE_INVALID);
542
543 assert_num_eq (CKO_PUBLIC_KEY, klass);
544 assert_num_eq (21, attrs[1].ulValueLen);
545 assert_ptr_eq (NULL, attrs[1].pValue);
546 attrs[1].pValue = label;
547 attrs[1].ulValueLen = sizeof (label);
548 assert ((CK_ULONG)-1 == attrs[2].ulValueLen);
549 assert_ptr_eq (NULL, attrs[2].pValue);
550
551 rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 3);
552 assert (rv == CKR_ATTRIBUTE_TYPE_INVALID);
553
554 assert_num_eq (CKO_PUBLIC_KEY, klass);
555 assert_num_eq (21, attrs[1].ulValueLen);
556 assert_ptr_eq (label, attrs[1].pValue);
557 assert (memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0);
558 assert ((CK_ULONG)-1 == attrs[2].ulValueLen);
559 assert_ptr_eq (NULL, attrs[2].pValue);
560
561 teardown_mock_module (module);
562 }
563
564 static void
test_set_attribute_value(void)565 test_set_attribute_value (void)
566 {
567 CK_FUNCTION_LIST_PTR module;
568 CK_SESSION_HANDLE session = 0;
569 CK_ATTRIBUTE attrs[8];
570 char label[32];
571 CK_ULONG bits;
572 CK_RV rv;
573
574 module = setup_mock_module (&session);
575
576 strcpy (label, "Blahooo");
577 bits = 1555;
578
579 attrs[0].type = CKA_LABEL;
580 attrs[0].pValue = label;
581 attrs[0].ulValueLen = strlen (label);
582 attrs[1].type = CKA_BITS_PER_PIXEL;
583 attrs[1].pValue = &bits;
584 attrs[1].ulValueLen = sizeof (bits);
585
586 rv = (module->C_SetAttributeValue) (session, MOCK_PRIVATE_KEY_CAPITALIZE, attrs, 2);
587 assert (rv == CKR_USER_NOT_LOGGED_IN);
588
589 rv = (module->C_SetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
590 assert (rv == CKR_OK);
591
592 memset (label, 0, sizeof (label));
593 bits = 0;
594
595 rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2);
596 assert (rv == CKR_OK);
597
598 assert_num_eq (bits, 1555);
599 assert_num_eq (7, attrs[0].ulValueLen);
600 assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
601
602 teardown_mock_module (module);
603 }
604
605 static void
test_create_object(void)606 test_create_object (void)
607 {
608 CK_FUNCTION_LIST_PTR module;
609 CK_SESSION_HANDLE session = 0;
610 CK_OBJECT_HANDLE object;
611 CK_ATTRIBUTE attrs[8];
612 char label[32];
613 CK_ULONG bits;
614 CK_RV rv;
615
616 module = setup_mock_module (&session);
617
618 strcpy (label, "Blahooo");
619 bits = 1555;
620
621 attrs[0].type = CKA_LABEL;
622 attrs[0].pValue = label;
623 attrs[0].ulValueLen = strlen (label);
624 attrs[1].type = CKA_BITS_PER_PIXEL;
625 attrs[1].pValue = &bits;
626 attrs[1].ulValueLen = sizeof (bits);
627
628 rv = (module->C_CreateObject) (0, attrs, 2, &object);
629 assert (rv == CKR_SESSION_HANDLE_INVALID);
630
631 rv = (module->C_CreateObject) (session, attrs, 2, &object);
632 assert (rv == CKR_OK);
633
634 attrs[0].ulValueLen = sizeof (label);
635 memset (label, 0, sizeof (label));
636 bits = 0;
637
638 rv = (module->C_GetAttributeValue) (session, object, attrs, 2);
639 assert (rv == CKR_OK);
640
641 assert_num_eq (bits, 1555);
642 assert_num_eq (7, attrs[0].ulValueLen);
643 assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
644
645 teardown_mock_module (module);
646 }
647
648 static void
test_copy_object(void)649 test_copy_object (void)
650 {
651 CK_FUNCTION_LIST_PTR module;
652 CK_SESSION_HANDLE session = 0;
653 CK_OBJECT_HANDLE object;
654 CK_ATTRIBUTE attrs[8];
655 char label[32];
656 CK_ULONG bits;
657 CK_RV rv;
658
659 module = setup_mock_module (&session);
660
661 bits = 1555;
662
663 attrs[0].type = CKA_BITS_PER_PIXEL;
664 attrs[0].pValue = &bits;
665 attrs[0].ulValueLen = sizeof (bits);
666
667 rv = (module->C_CopyObject) (session, 1333, attrs, 1, &object);
668 assert (rv == CKR_OBJECT_HANDLE_INVALID);
669
670 rv = (module->C_CopyObject) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1, &object);
671 assert (rv == CKR_OK);
672
673 attrs[1].type = CKA_LABEL;
674 attrs[1].pValue = label;
675 attrs[1].ulValueLen = sizeof (label);
676 bits = 0;
677
678 rv = (module->C_GetAttributeValue) (session, object, attrs, 2);
679 assert (rv == CKR_OK);
680
681 assert_num_eq (bits, 1555);
682 assert_num_eq (21, attrs[1].ulValueLen);
683 assert (memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0);
684
685 teardown_mock_module (module);
686 }
687
688 static void
test_destroy_object(void)689 test_destroy_object (void)
690 {
691 CK_FUNCTION_LIST_PTR module;
692 CK_SESSION_HANDLE session = 0;
693 CK_ATTRIBUTE attrs[8];
694 char label[32];
695 CK_RV rv;
696
697 module = setup_mock_module (&session);
698
699 attrs[0].type = CKA_LABEL;
700 attrs[0].pValue = label;
701 attrs[0].ulValueLen = sizeof (label);
702
703 rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1);
704 assert (rv == CKR_OK);
705
706 rv = (module->C_DestroyObject) (0, MOCK_PUBLIC_KEY_CAPITALIZE);
707 assert (rv == CKR_SESSION_HANDLE_INVALID);
708
709 rv = (module->C_DestroyObject) (session, MOCK_PUBLIC_KEY_CAPITALIZE);
710 assert (rv == CKR_OK);
711
712 rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1);
713 assert (rv == CKR_OBJECT_HANDLE_INVALID);
714
715 teardown_mock_module (module);
716 }
717
718 static void
test_get_object_size(void)719 test_get_object_size (void)
720 {
721 CK_FUNCTION_LIST_PTR module;
722 CK_SESSION_HANDLE session = 0;
723 CK_ULONG size;
724 CK_RV rv;
725
726 module = setup_mock_module (&session);
727
728 rv = (module->C_GetObjectSize) (session, 1333, &size);
729 assert (rv == CKR_OBJECT_HANDLE_INVALID);
730
731 rv = (module->C_GetObjectSize) (session, MOCK_PUBLIC_KEY_CAPITALIZE, &size);
732 assert (rv == CKR_OK);
733
734 /* The number here is the length of all attributes added up */
735 assert_num_eq (sizeof (CK_ULONG) == 8 ? 44 : 36, size);
736
737 teardown_mock_module (module);
738 }
739
740 static void
test_find_objects(void)741 test_find_objects (void)
742 {
743 CK_FUNCTION_LIST_PTR module;
744 CK_SESSION_HANDLE session = 0;
745 CK_OBJECT_CLASS klass = CKO_PUBLIC_KEY;
746 CK_ATTRIBUTE attr = { CKA_CLASS, &klass, sizeof (klass) };
747 CK_OBJECT_HANDLE objects[16];
748 CK_ULONG count = 0;
749 CK_ULONG i;
750 CK_RV rv;
751
752 module = setup_mock_module (&session);
753
754 rv = (module->C_FindObjectsInit) (0, &attr, 1);
755 assert (rv == CKR_SESSION_HANDLE_INVALID);
756
757 rv = (module->C_FindObjectsInit) (session, &attr, 1);
758 assert (rv == CKR_OK);
759
760 rv = (module->C_FindObjects) (0, objects, 16, &count);
761 assert (rv == CKR_SESSION_HANDLE_INVALID);
762
763 rv = (module->C_FindObjects) (session, objects, 16, &count);
764 assert (rv == CKR_OK);
765
766 assert (count < 16);
767
768 /* Make sure we get the capitalize public key */
769 for (i = 0; i < count; i++) {
770 if (objects[i] == MOCK_PUBLIC_KEY_CAPITALIZE)
771 break;
772 }
773 assert (i != count);
774
775 /* Make sure we get the prefix public key */
776 for (i = 0; i < count; i++) {
777 if (objects[i] == MOCK_PUBLIC_KEY_PREFIX)
778 break;
779 }
780 assert (i != count);
781
782 /* Make sure all public keys */
783 for (i = 0; i < count; i++) {
784 klass = (CK_ULONG)-1;
785 rv = (module->C_GetAttributeValue) (session, objects[i], &attr, 1);
786 assert (rv == CKR_OK);
787 assert_num_eq (CKO_PUBLIC_KEY, klass);
788 }
789
790 rv = (module->C_FindObjectsFinal) (session);
791 assert (rv == CKR_OK);
792
793 rv = (module->C_FindObjectsFinal) (session);
794 assert (rv == CKR_OPERATION_NOT_INITIALIZED);
795
796 teardown_mock_module (module);
797 }
798
799 static void
test_encrypt(void)800 test_encrypt (void)
801 {
802 CK_FUNCTION_LIST_PTR module;
803 CK_SESSION_HANDLE session = 0;
804 CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
805 CK_BYTE data[128];
806 CK_ULONG length;
807 CK_RV rv;
808
809 module = setup_mock_module (&session);
810
811 rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
812 assert (rv == CKR_KEY_HANDLE_INVALID);
813
814 rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
815 assert (rv == CKR_OK);
816
817 length = sizeof (data);
818 rv = (module->C_Encrypt) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
819 assert (rv == CKR_SESSION_HANDLE_INVALID);
820
821 length = sizeof (data);
822 rv = (module->C_Encrypt) (session, (CK_BYTE_PTR)"blah", 4, data, &length);
823 assert (rv == CKR_OK);
824
825 assert_num_eq (4, length);
826 assert (memcmp (data, "BLAH", 4) == 0);
827
828 rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
829 assert (rv == CKR_OK);
830
831 length = sizeof (data);
832 rv = (module->C_EncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
833 assert (rv == CKR_SESSION_HANDLE_INVALID);
834
835 length = sizeof (data);
836 rv = (module->C_EncryptUpdate) (session, (CK_BYTE_PTR)"sLurm", 5, data, &length);
837 assert (rv == CKR_OK);
838
839 assert_num_eq (5, length);
840 assert (memcmp (data, "SLURM", 5) == 0);
841
842 length = sizeof (data);
843 rv = (module->C_EncryptFinal) (0, data, &length);
844 assert (rv == CKR_SESSION_HANDLE_INVALID);
845
846 length = sizeof (data);
847 rv = (module->C_EncryptFinal) (session, data, &length);
848 assert (rv == CKR_OK);
849
850 teardown_mock_module (module);
851 }
852
853 static void
test_decrypt(void)854 test_decrypt (void)
855 {
856 CK_FUNCTION_LIST_PTR module;
857 CK_SESSION_HANDLE session = 0;
858 CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
859 CK_BYTE data[128];
860 CK_ULONG length;
861 CK_RV rv;
862
863 module = setup_mock_module (&session);
864
865 rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
866 assert (rv == CKR_OK);
867
868 rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
869 assert (rv == CKR_KEY_HANDLE_INVALID);
870
871 rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
872 assert (rv == CKR_OK);
873
874 length = sizeof (data);
875 rv = (module->C_Decrypt) (0, (CK_BYTE_PTR)"bLAH", 4, data, &length);
876 assert (rv == CKR_SESSION_HANDLE_INVALID);
877
878 length = sizeof (data);
879 rv = (module->C_Decrypt) (session, (CK_BYTE_PTR)"BLAh", 4, data, &length);
880 assert (rv == CKR_OK);
881
882 assert_num_eq (4, length);
883 assert (memcmp (data, "blah", 4) == 0);
884
885 rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
886 assert (rv == CKR_OK);
887
888 length = sizeof (data);
889 rv = (module->C_DecryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
890 assert (rv == CKR_SESSION_HANDLE_INVALID);
891
892 length = sizeof (data);
893 rv = (module->C_DecryptUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5, data, &length);
894 assert (rv == CKR_OK);
895
896 assert_num_eq (5, length);
897 assert (memcmp (data, "slurm", 5) == 0);
898
899 length = sizeof (data);
900 rv = (module->C_DecryptFinal) (0, data, &length);
901 assert (rv == CKR_SESSION_HANDLE_INVALID);
902
903 length = sizeof (data);
904 rv = (module->C_DecryptFinal) (session, data, &length);
905 assert (rv == CKR_OK);
906
907 teardown_mock_module (module);
908 }
909
910 static void
test_digest(void)911 test_digest (void)
912 {
913 CK_FUNCTION_LIST_PTR module;
914 CK_SESSION_HANDLE session = 0;
915 CK_MECHANISM mech = { CKM_MOCK_COUNT, NULL, 0 };
916 CK_BYTE digest[128];
917 CK_ULONG length;
918 CK_RV rv;
919
920 module = setup_mock_module (&session);
921
922 rv = (module->C_DigestInit) (0, &mech);
923 assert (rv == CKR_SESSION_HANDLE_INVALID);
924
925 rv = (module->C_DigestInit) (session, &mech);
926 assert (rv == CKR_OK);
927
928 length = sizeof (digest);
929 rv = (module->C_Digest) (0, (CK_BYTE_PTR)"bLAH", 4, digest, &length);
930 assert (rv == CKR_SESSION_HANDLE_INVALID);
931
932 length = sizeof (digest);
933 rv = (module->C_Digest) (session, (CK_BYTE_PTR)"BLAh", 4, digest, &length);
934 assert (rv == CKR_OK);
935
936 assert_num_eq (1, length);
937 assert (memcmp (digest, "4", 1) == 0);
938
939 rv = (module->C_DigestInit) (session, &mech);
940 assert (rv == CKR_OK);
941
942 rv = (module->C_DigestUpdate) (0, (CK_BYTE_PTR)"blah", 4);
943 assert (rv == CKR_SESSION_HANDLE_INVALID);
944
945 rv = (module->C_DigestUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5);
946 assert (rv == CKR_OK);
947
948 /* Adds the the value of object handle to hash: 6 */
949 assert_num_eq (6, MOCK_PUBLIC_KEY_PREFIX);
950 rv = (module->C_DigestKey) (session, MOCK_PUBLIC_KEY_PREFIX);
951 assert (rv == CKR_OK);
952
953 rv = (module->C_DigestUpdate) (session, (CK_BYTE_PTR)"Other", 5);
954 assert (rv == CKR_OK);
955
956 length = sizeof (digest);
957 rv = (module->C_DigestFinal) (0, digest, &length);
958 assert (rv == CKR_SESSION_HANDLE_INVALID);
959
960 length = sizeof (digest);
961 rv = (module->C_DigestFinal) (session, digest, &length);
962 assert (rv == CKR_OK);
963
964 assert_num_eq (2, length);
965 assert (memcmp (digest, "16", 2) == 0);
966
967 teardown_mock_module (module);
968 }
969
970 static void
test_sign(void)971 test_sign (void)
972 {
973 CK_FUNCTION_LIST_PTR module;
974 CK_SESSION_HANDLE session = 0;
975 CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
976 CK_BYTE signature[128];
977 CK_ULONG length;
978 CK_RV rv;
979
980 module = setup_mock_module (&session);
981
982 rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
983 assert (rv == CKR_OK);
984
985 rv = (module->C_SignInit) (0, &mech, MOCK_PRIVATE_KEY_PREFIX);
986 assert (rv == CKR_SESSION_HANDLE_INVALID);
987
988 rv = (module->C_SignInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
989 assert (rv == CKR_OK);
990
991 rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
992 assert (rv == CKR_OK);
993
994 length = sizeof (signature);
995 rv = (module->C_Sign) (0, (CK_BYTE_PTR)"bLAH", 4, signature, &length);
996 assert (rv == CKR_SESSION_HANDLE_INVALID);
997
998 length = sizeof (signature);
999 rv = (module->C_Sign) (session, (CK_BYTE_PTR)"BLAh", 4, signature, &length);
1000 assert (rv == CKR_OK);
1001
1002 assert_num_eq (13, length);
1003 assert (memcmp (signature, "prefix:value4", 13) == 0);
1004
1005 rv = (module->C_SignInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
1006 assert (rv == CKR_OK);
1007
1008 rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
1009 assert (rv == CKR_OK);
1010
1011 rv = (module->C_SignUpdate) (0, (CK_BYTE_PTR)"blah", 4);
1012 assert (rv == CKR_SESSION_HANDLE_INVALID);
1013
1014 rv = (module->C_SignUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5);
1015 assert (rv == CKR_OK);
1016
1017 rv = (module->C_SignUpdate) (session, (CK_BYTE_PTR)"Other", 5);
1018 assert (rv == CKR_OK);
1019
1020 length = sizeof (signature);
1021 rv = (module->C_SignFinal) (0, signature, &length);
1022 assert (rv == CKR_SESSION_HANDLE_INVALID);
1023
1024 length = sizeof (signature);
1025 rv = (module->C_SignFinal) (session, signature, &length);
1026 assert (rv == CKR_OK);
1027
1028 assert_num_eq (14, length);
1029 assert (memcmp (signature, "prefix:value10", 2) == 0);
1030
1031 teardown_mock_module (module);
1032 }
1033
1034 static void
test_sign_recover(void)1035 test_sign_recover (void)
1036 {
1037 CK_FUNCTION_LIST_PTR module;
1038 CK_SESSION_HANDLE session = 0;
1039 CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
1040 CK_BYTE signature[128];
1041 CK_ULONG length;
1042 CK_RV rv;
1043
1044 module = setup_mock_module (&session);
1045
1046 rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
1047 assert (rv == CKR_OK);
1048
1049 rv = (module->C_SignRecoverInit) (0, &mech, MOCK_PRIVATE_KEY_PREFIX);
1050 assert (rv == CKR_SESSION_HANDLE_INVALID);
1051
1052 rv = (module->C_SignRecoverInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX);
1053 assert (rv == CKR_OK);
1054
1055 rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
1056 assert (rv == CKR_OK);
1057
1058 length = sizeof (signature);
1059 rv = (module->C_SignRecover) (0, (CK_BYTE_PTR)"bLAH", 4, signature, &length);
1060 assert (rv == CKR_SESSION_HANDLE_INVALID);
1061
1062 length = sizeof (signature);
1063 rv = (module->C_SignRecover) (session, (CK_BYTE_PTR)"BLAh", 4, signature, &length);
1064 assert (rv == CKR_OK);
1065
1066 assert_num_eq (16, length);
1067 assert (memcmp (signature, "prefix:valueBLAh", 16) == 0);
1068
1069 teardown_mock_module (module);
1070 }
1071
1072 static void
test_verify(void)1073 test_verify (void)
1074 {
1075 CK_FUNCTION_LIST_PTR module;
1076 CK_SESSION_HANDLE session = 0;
1077 CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
1078 CK_BYTE signature[128];
1079 CK_ULONG length;
1080 CK_RV rv;
1081
1082 module = setup_mock_module (&session);
1083
1084 rv = (module->C_VerifyInit) (0, &mech, MOCK_PUBLIC_KEY_PREFIX);
1085 assert (rv == CKR_SESSION_HANDLE_INVALID);
1086
1087 rv = (module->C_VerifyInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
1088 assert (rv == CKR_OK);
1089
1090 length = 13;
1091 memcpy (signature, "prefix:value4", length);
1092 rv = (module->C_Verify) (0, (CK_BYTE_PTR)"bLAH", 4, signature, 5);
1093 assert (rv == CKR_SESSION_HANDLE_INVALID);
1094
1095 rv = (module->C_Verify) (session, (CK_BYTE_PTR)"BLAh", 4, signature, length);
1096 assert (rv == CKR_OK);
1097
1098 rv = (module->C_VerifyInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
1099 assert (rv == CKR_OK);
1100
1101 rv = (module->C_VerifyUpdate) (0, (CK_BYTE_PTR)"blah", 4);
1102 assert (rv == CKR_SESSION_HANDLE_INVALID);
1103
1104 rv = (module->C_VerifyUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5);
1105 assert (rv == CKR_OK);
1106
1107 rv = (module->C_VerifyUpdate) (session, (CK_BYTE_PTR)"Other", 5);
1108 assert (rv == CKR_OK);
1109
1110 length = 14;
1111 memcpy (signature, "prefix:value10", length);
1112
1113 rv = (module->C_VerifyFinal) (session, signature, 5);
1114 assert (rv == CKR_SIGNATURE_LEN_RANGE);
1115
1116 rv = (module->C_VerifyFinal) (session, signature, length);
1117 assert (rv == CKR_OK);
1118
1119 teardown_mock_module (module);
1120 }
1121
1122 static void
test_verify_recover(void)1123 test_verify_recover (void)
1124 {
1125 CK_FUNCTION_LIST_PTR module;
1126 CK_SESSION_HANDLE session = 0;
1127 CK_MECHANISM mech = { CKM_MOCK_PREFIX, "prefix:", 7 };
1128 CK_BYTE data[128];
1129 CK_ULONG length;
1130 CK_RV rv;
1131
1132 module = setup_mock_module (&session);
1133
1134 rv = (module->C_VerifyRecoverInit) (0, &mech, MOCK_PUBLIC_KEY_PREFIX);
1135 assert (rv == CKR_SESSION_HANDLE_INVALID);
1136
1137 rv = (module->C_VerifyRecoverInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX);
1138 assert (rv == CKR_OK);
1139
1140 length = sizeof (data);
1141 rv = (module->C_VerifyRecover) (0, (CK_BYTE_PTR)"prefix:valueBLah", 16, data, &length);
1142 assert (rv == CKR_SESSION_HANDLE_INVALID);
1143
1144 length = sizeof (data);
1145 rv = (module->C_VerifyRecover) (session, (CK_BYTE_PTR)"prefix:valueBLah", 16, data, &length);
1146 assert (rv == CKR_OK);
1147
1148 assert_num_eq (4, length);
1149 assert (memcmp (data, "BLah", 4) == 0);
1150
1151 teardown_mock_module (module);
1152 }
1153
1154 static void
test_digest_encrypt(void)1155 test_digest_encrypt (void)
1156 {
1157 CK_FUNCTION_LIST_PTR module;
1158 CK_SESSION_HANDLE session = 0;
1159 CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
1160 CK_MECHANISM dmech = { CKM_MOCK_COUNT, NULL, 0 };
1161 CK_BYTE data[128];
1162 CK_ULONG length;
1163 CK_RV rv;
1164
1165 module = setup_mock_module (&session);
1166
1167 rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
1168 assert (rv == CKR_OK);
1169
1170 rv = (module->C_DigestInit) (session, &dmech);
1171 assert (rv == CKR_OK);
1172
1173 length = sizeof (data);
1174 rv = (module->C_DigestEncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
1175 assert (rv == CKR_SESSION_HANDLE_INVALID);
1176
1177 length = sizeof (data);
1178 rv = (module->C_DigestEncryptUpdate) (session, (CK_BYTE_PTR)"blah", 4, data, &length);
1179 assert (rv == CKR_OK);
1180
1181 assert_num_eq (4, length);
1182 assert (memcmp (data, "BLAH", 4) == 0);
1183
1184 length = sizeof (data);
1185 rv = (module->C_EncryptFinal) (session, data, &length);
1186 assert (rv == CKR_OK);
1187
1188 length = sizeof (data);
1189 rv = (module->C_DigestFinal) (session, data, &length);
1190 assert (rv == CKR_OK);
1191
1192 assert_num_eq (1, length);
1193 assert (memcmp (data, "4", 1) == 0);
1194
1195 teardown_mock_module (module);
1196 }
1197
1198 static void
test_decrypt_digest(void)1199 test_decrypt_digest (void)
1200 {
1201 CK_FUNCTION_LIST_PTR module;
1202 CK_SESSION_HANDLE session = 0;
1203 CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
1204 CK_MECHANISM dmech = { CKM_MOCK_COUNT, NULL, 0 };
1205 CK_BYTE data[128];
1206 CK_ULONG length;
1207 CK_RV rv;
1208
1209 module = setup_mock_module (&session);
1210
1211 rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
1212 assert (rv == CKR_OK);
1213
1214 rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
1215 assert (rv == CKR_OK);
1216
1217 rv = (module->C_DigestInit) (session, &dmech);
1218 assert (rv == CKR_OK);
1219
1220 length = sizeof (data);
1221 rv = (module->C_DecryptDigestUpdate) (0, (CK_BYTE_PTR)"BLAH", 4, data, &length);
1222 assert (rv == CKR_SESSION_HANDLE_INVALID);
1223
1224 length = sizeof (data);
1225 rv = (module->C_DecryptDigestUpdate) (session, (CK_BYTE_PTR)"BLAH", 4, data, &length);
1226 assert (rv == CKR_OK);
1227
1228 assert_num_eq (4, length);
1229 assert (memcmp (data, "blah", 4) == 0);
1230
1231 length = sizeof (data);
1232 rv = (module->C_DecryptFinal) (session, data, &length);
1233 assert (rv == CKR_OK);
1234
1235 length = sizeof (data);
1236 rv = (module->C_DigestFinal) (session, data, &length);
1237 assert (rv == CKR_OK);
1238
1239 assert_num_eq (1, length);
1240 assert (memcmp (data, "4", 1) == 0);
1241
1242 teardown_mock_module (module);
1243 }
1244
1245 static void
test_sign_encrypt(void)1246 test_sign_encrypt (void)
1247 {
1248 CK_FUNCTION_LIST_PTR module;
1249 CK_SESSION_HANDLE session = 0;
1250 CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
1251 CK_MECHANISM smech = { CKM_MOCK_PREFIX, "p:", 2 };
1252 CK_BYTE data[128];
1253 CK_ULONG length;
1254 CK_RV rv;
1255
1256 module = setup_mock_module (&session);
1257
1258 rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
1259 assert (rv == CKR_OK);
1260
1261 rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE);
1262 assert (rv == CKR_OK);
1263
1264 rv = (module->C_SignInit) (session, &smech, MOCK_PRIVATE_KEY_PREFIX);
1265 assert (rv == CKR_OK);
1266
1267 rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4);
1268 assert (rv == CKR_OK);
1269
1270 length = sizeof (data);
1271 rv = (module->C_SignEncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length);
1272 assert (rv == CKR_SESSION_HANDLE_INVALID);
1273
1274 length = sizeof (data);
1275 rv = (module->C_SignEncryptUpdate) (session, (CK_BYTE_PTR)"blah", 4, data, &length);
1276 assert (rv == CKR_OK);
1277
1278 assert_num_eq (4, length);
1279 assert (memcmp (data, "BLAH", 4) == 0);
1280
1281 length = sizeof (data);
1282 rv = (module->C_EncryptFinal) (session, data, &length);
1283 assert (rv == CKR_OK);
1284
1285 length = sizeof (data);
1286 rv = (module->C_SignFinal) (session, data, &length);
1287 assert (rv == CKR_OK);
1288
1289 assert_num_eq (8, length);
1290 assert (memcmp (data, "p:value4", 1) == 0);
1291
1292 teardown_mock_module (module);
1293 }
1294
1295 static void
test_decrypt_verify(void)1296 test_decrypt_verify (void)
1297 {
1298 CK_FUNCTION_LIST_PTR module;
1299 CK_SESSION_HANDLE session = 0;
1300 CK_MECHANISM mech = { CKM_MOCK_CAPITALIZE, NULL, 0 };
1301 CK_MECHANISM vmech = { CKM_MOCK_PREFIX, "p:", 2 };
1302 CK_BYTE data[128];
1303 CK_ULONG length;
1304 CK_RV rv;
1305
1306 module = setup_mock_module (&session);
1307
1308 rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4);
1309 assert (rv == CKR_OK);
1310
1311 rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE);
1312 assert (rv == CKR_OK);
1313
1314 rv = (module->C_VerifyInit) (session, &vmech, MOCK_PUBLIC_KEY_PREFIX);
1315 assert (rv == CKR_OK);
1316
1317 length = sizeof (data);
1318 rv = (module->C_DecryptVerifyUpdate) (0, (CK_BYTE_PTR)"BLAH", 4, data, &length);
1319 assert (rv == CKR_SESSION_HANDLE_INVALID);
1320
1321 length = sizeof (data);
1322 rv = (module->C_DecryptVerifyUpdate) (session, (CK_BYTE_PTR)"BLAH", 4, data, &length);
1323 assert (rv == CKR_OK);
1324
1325 assert_num_eq (4, length);
1326 assert (memcmp (data, "blah", 4) == 0);
1327
1328 length = sizeof (data);
1329 rv = (module->C_DecryptFinal) (session, data, &length);
1330 assert (rv == CKR_OK);
1331
1332 rv = (module->C_VerifyFinal) (session, (CK_BYTE_PTR)"p:value4", 8);
1333 assert (rv == CKR_OK);
1334
1335 teardown_mock_module (module);
1336 }
1337
1338 static void
test_generate_key(void)1339 test_generate_key (void)
1340 {
1341 CK_FUNCTION_LIST_PTR module;
1342 CK_SESSION_HANDLE session = 0;
1343 CK_OBJECT_HANDLE object;
1344 CK_MECHANISM mech = { CKM_MOCK_GENERATE, NULL, 0 };
1345 CK_ATTRIBUTE attrs[8];
1346 char label[32];
1347 char value[64];
1348 CK_ULONG bits;
1349 CK_RV rv;
1350
1351 module = setup_mock_module (&session);
1352
1353 strcpy (label, "Blahooo");
1354 bits = 1555;
1355
1356 attrs[0].type = CKA_LABEL;
1357 attrs[0].pValue = label;
1358 attrs[0].ulValueLen = strlen (label);
1359 attrs[1].type = CKA_BITS_PER_PIXEL;
1360 attrs[1].pValue = &bits;
1361 attrs[1].ulValueLen = sizeof (bits);
1362
1363 rv = (module->C_GenerateKey) (session, &mech, attrs, 2, &object);
1364 assert (rv == CKR_MECHANISM_PARAM_INVALID);
1365
1366 mech.pParameter = "generate";
1367 mech.ulParameterLen = 9;
1368
1369 rv = (module->C_GenerateKey) (session, &mech, attrs, 2, &object);
1370 assert (rv == CKR_OK);
1371
1372 attrs[0].ulValueLen = sizeof (label);
1373 memset (label, 0, sizeof (label));
1374 bits = 0;
1375 attrs[2].type = CKA_VALUE;
1376 attrs[2].pValue = value;
1377 attrs[2].ulValueLen = sizeof (value);
1378
1379 rv = (module->C_GetAttributeValue) (session, object, attrs, 3);
1380 assert (rv == CKR_OK);
1381
1382 assert_num_eq (bits, 1555);
1383 assert_num_eq (7, attrs[0].ulValueLen);
1384 assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
1385 assert_num_eq (9, attrs[2].ulValueLen);
1386 assert (memcmp (value, "generated", attrs[2].ulValueLen) == 0);
1387
1388 teardown_mock_module (module);
1389 }
1390
1391 static void
test_generate_key_pair(void)1392 test_generate_key_pair (void)
1393 {
1394 CK_FUNCTION_LIST_PTR module;
1395 CK_SESSION_HANDLE session = 0;
1396 CK_OBJECT_HANDLE pub_object;
1397 CK_OBJECT_HANDLE priv_object;
1398 CK_MECHANISM mech = { CKM_MOCK_GENERATE, "generated", 9 };
1399 CK_ATTRIBUTE pub_attrs[8];
1400 CK_ATTRIBUTE priv_attrs[8];
1401 char pub_label[32];
1402 char pub_value[64];
1403 char priv_label[32];
1404 char priv_value[64];
1405 CK_ULONG pub_bits;
1406 CK_ULONG priv_bits;
1407 CK_RV rv;
1408
1409 module = setup_mock_module (&session);
1410
1411 strcpy (pub_label, "Blahooo");
1412 pub_bits = 1555;
1413 pub_attrs[0].type = CKA_LABEL;
1414 pub_attrs[0].pValue = pub_label;
1415 pub_attrs[0].ulValueLen = strlen (pub_label);
1416 pub_attrs[1].type = CKA_BITS_PER_PIXEL;
1417 pub_attrs[1].pValue = &pub_bits;
1418 pub_attrs[1].ulValueLen = sizeof (pub_bits);
1419
1420 strcpy (priv_label, "Private");
1421 priv_bits = 1666;
1422 priv_attrs[0].type = CKA_LABEL;
1423 priv_attrs[0].pValue = priv_label;
1424 priv_attrs[0].ulValueLen = strlen (priv_label);
1425 priv_attrs[1].type = CKA_BITS_PER_PIXEL;
1426 priv_attrs[1].pValue = &priv_bits;
1427 priv_attrs[1].ulValueLen = sizeof (priv_bits);
1428
1429 rv = (module->C_GenerateKeyPair) (0, &mech, pub_attrs, 2, priv_attrs, 2,
1430 &pub_object, &priv_object);
1431 assert (rv == CKR_SESSION_HANDLE_INVALID);
1432
1433 mech.pParameter = "generate";
1434 mech.ulParameterLen = 9;
1435
1436 rv = (module->C_GenerateKeyPair) (session, &mech, pub_attrs, 2, priv_attrs, 2,
1437 &pub_object, &priv_object);
1438 assert (rv == CKR_OK);
1439
1440 pub_bits = 0;
1441 pub_attrs[0].ulValueLen = sizeof (pub_label);
1442 memset (pub_label, 0, sizeof (pub_label));
1443 pub_attrs[2].type = CKA_VALUE;
1444 pub_attrs[2].pValue = pub_value;
1445 pub_attrs[2].ulValueLen = sizeof (pub_value);
1446
1447 rv = (module->C_GetAttributeValue) (session, pub_object, pub_attrs, 3);
1448 assert (rv == CKR_OK);
1449
1450 assert_num_eq (1555, pub_bits);
1451 assert_num_eq (7, pub_attrs[0].ulValueLen);
1452 assert (memcmp (pub_label, "Blahooo", pub_attrs[0].ulValueLen) == 0);
1453 assert_num_eq (9, pub_attrs[2].ulValueLen);
1454 assert (memcmp (pub_value, "generated", pub_attrs[2].ulValueLen) == 0);
1455
1456 priv_bits = 0;
1457 priv_attrs[0].ulValueLen = sizeof (priv_label);
1458 memset (priv_label, 0, sizeof (priv_label));
1459 priv_attrs[2].type = CKA_VALUE;
1460 priv_attrs[2].pValue = priv_value;
1461 priv_attrs[2].ulValueLen = sizeof (priv_value);
1462
1463 rv = (module->C_GetAttributeValue) (session, priv_object, priv_attrs, 3);
1464 assert (rv == CKR_OK);
1465
1466 assert_num_eq (1666, priv_bits);
1467 assert_num_eq (7, priv_attrs[0].ulValueLen);
1468 assert (memcmp (priv_label, "Private", priv_attrs[0].ulValueLen) == 0);
1469 assert_num_eq (9, priv_attrs[2].ulValueLen);
1470 assert (memcmp (priv_value, "generated", priv_attrs[2].ulValueLen) == 0);
1471
1472 teardown_mock_module (module);
1473 }
1474
1475 static void
test_wrap_key(void)1476 test_wrap_key (void)
1477 {
1478 CK_FUNCTION_LIST_PTR module;
1479 CK_SESSION_HANDLE session = 0;
1480 CK_MECHANISM mech = { CKM_MOCK_WRAP, NULL, 0 };
1481 CK_BYTE data[128];
1482 CK_ULONG length;
1483 CK_RV rv;
1484
1485 module = setup_mock_module (&session);
1486
1487 length = sizeof (data);
1488 rv = (module->C_WrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, MOCK_PUBLIC_KEY_PREFIX, data, &length);
1489 assert (rv == CKR_MECHANISM_PARAM_INVALID);
1490
1491 mech.pParameter = "wrap";
1492 mech.ulParameterLen = 4;
1493
1494 rv = (module->C_WrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, MOCK_PUBLIC_KEY_PREFIX, data, &length);
1495 assert (rv == CKR_OK);
1496
1497 assert_num_eq (5, length);
1498 assert (memcmp (data, "value", 5) == 0);
1499
1500 teardown_mock_module (module);
1501 }
1502
1503 static void
test_unwrap_key(void)1504 test_unwrap_key (void)
1505 {
1506 CK_FUNCTION_LIST_PTR module;
1507 CK_SESSION_HANDLE session = 0;
1508 CK_OBJECT_HANDLE object;
1509 CK_MECHANISM mech = { CKM_MOCK_WRAP, NULL, 0 };
1510 CK_ATTRIBUTE attrs[8];
1511 char label[32];
1512 char value[64];
1513 CK_ULONG bits;
1514 CK_RV rv;
1515
1516 module = setup_mock_module (&session);
1517
1518 strcpy (label, "Blahooo");
1519 bits = 1555;
1520
1521 attrs[0].type = CKA_LABEL;
1522 attrs[0].pValue = label;
1523 attrs[0].ulValueLen = strlen (label);
1524 attrs[1].type = CKA_BITS_PER_PIXEL;
1525 attrs[1].pValue = &bits;
1526 attrs[1].ulValueLen = sizeof (bits);
1527
1528 rv = (module->C_UnwrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
1529 (CK_BYTE_PTR)"wheee", 5, attrs, 2, &object);
1530 assert (rv == CKR_MECHANISM_PARAM_INVALID);
1531
1532 mech.pParameter = "wrap";
1533 mech.ulParameterLen = 4;
1534
1535 rv = (module->C_UnwrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
1536 (CK_BYTE_PTR)"wheee", 5, attrs, 2, &object);
1537 assert (rv == CKR_OK);
1538
1539 attrs[0].ulValueLen = sizeof (label);
1540 memset (label, 0, sizeof (label));
1541 bits = 0;
1542 attrs[2].type = CKA_VALUE;
1543 attrs[2].pValue = value;
1544 attrs[2].ulValueLen = sizeof (value);
1545
1546 rv = (module->C_GetAttributeValue) (session, object, attrs, 3);
1547 assert (rv == CKR_OK);
1548
1549 assert_num_eq (bits, 1555);
1550 assert_num_eq (7, attrs[0].ulValueLen);
1551 assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
1552 assert_num_eq (5, attrs[2].ulValueLen);
1553 assert (memcmp (value, "wheee", attrs[2].ulValueLen) == 0);
1554
1555 teardown_mock_module (module);
1556 }
1557
1558 static void
test_derive_key(void)1559 test_derive_key (void)
1560 {
1561 CK_FUNCTION_LIST_PTR module;
1562 CK_SESSION_HANDLE session = 0;
1563 CK_OBJECT_HANDLE object;
1564 CK_MECHANISM mech = { CKM_MOCK_DERIVE, NULL, 0 };
1565 CK_ATTRIBUTE attrs[8];
1566 char label[32];
1567 char value[64];
1568 CK_ULONG bits;
1569 CK_RV rv;
1570
1571 module = setup_mock_module (&session);
1572
1573 strcpy (label, "Blahooo");
1574 bits = 1555;
1575
1576 attrs[0].type = CKA_LABEL;
1577 attrs[0].pValue = label;
1578 attrs[0].ulValueLen = strlen (label);
1579 attrs[1].type = CKA_BITS_PER_PIXEL;
1580 attrs[1].pValue = &bits;
1581 attrs[1].ulValueLen = sizeof (bits);
1582
1583 rv = (module->C_DeriveKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
1584 attrs, 2, &object);
1585 assert (rv == CKR_MECHANISM_PARAM_INVALID);
1586
1587 mech.pParameter = "derive";
1588 mech.ulParameterLen = 6;
1589
1590 rv = (module->C_DeriveKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX,
1591 attrs, 2, &object);
1592 assert (rv == CKR_OK);
1593
1594 attrs[0].ulValueLen = sizeof (label);
1595 memset (label, 0, sizeof (label));
1596 bits = 0;
1597 attrs[2].type = CKA_VALUE;
1598 attrs[2].pValue = value;
1599 attrs[2].ulValueLen = sizeof (value);
1600
1601 rv = (module->C_GetAttributeValue) (session, object, attrs, 3);
1602 assert (rv == CKR_OK);
1603
1604 assert_num_eq (bits, 1555);
1605 assert_num_eq (7, attrs[0].ulValueLen);
1606 assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0);
1607 assert_num_eq (7, attrs[2].ulValueLen);
1608 assert (memcmp (value, "derived", attrs[2].ulValueLen) == 0);
1609
1610 teardown_mock_module (module);
1611 }
1612
1613 static void
test_random(void)1614 test_random (void)
1615 {
1616 CK_FUNCTION_LIST_PTR module;
1617 CK_SESSION_HANDLE session = 0;
1618 CK_BYTE data[10];
1619 CK_RV rv;
1620
1621 module = setup_mock_module (&session);
1622
1623 rv = (module->C_SeedRandom) (0, (CK_BYTE_PTR)"seed", 4);
1624 assert (rv == CKR_SESSION_HANDLE_INVALID);
1625
1626 rv = (module->C_SeedRandom) (session, (CK_BYTE_PTR)"seed", 4);
1627 assert (rv == CKR_OK);
1628
1629 rv = (module->C_GenerateRandom) (0, data, sizeof (data));
1630 assert (rv == CKR_SESSION_HANDLE_INVALID);
1631
1632 rv = (module->C_GenerateRandom) (session, data, sizeof (data));
1633 assert (rv == CKR_OK);
1634
1635 assert (memcmp (data, "seedseedse", sizeof (data)) == 0);
1636
1637 teardown_mock_module (module);
1638 }
1639
1640 static void
test_mock_add_tests(const char * prefix)1641 test_mock_add_tests (const char *prefix)
1642 {
1643 p11_fixture (NULL, NULL);
1644 p11_test (test_get_info, "%s/test_get_info", prefix);
1645 p11_test (test_get_slot_list, "%s/test_get_slot_list", prefix);
1646 p11_test (test_get_slot_info, "%s/test_get_slot_info", prefix);
1647 p11_test (test_get_token_info, "%s/test_get_token_info", prefix);
1648 p11_test (test_get_mechanism_list, "%s/test_get_mechanism_list", prefix);
1649 p11_test (test_get_mechanism_info, "%s/test_get_mechanism_info", prefix);
1650 p11_test (test_init_token, "%s/test_init_token", prefix);
1651 p11_test (test_wait_for_slot_event, "%s/test_wait_for_slot_event", prefix);
1652 p11_test (test_open_close_session, "%s/test_open_close_session", prefix);
1653 p11_test (test_close_all_sessions, "%s/test_close_all_sessions", prefix);
1654 p11_test (test_get_function_status, "%s/test_get_function_status", prefix);
1655 p11_test (test_cancel_function, "%s/test_cancel_function", prefix);
1656 p11_test (test_get_session_info, "%s/test_get_session_info", prefix);
1657 p11_test (test_init_pin, "%s/test_init_pin", prefix);
1658 p11_test (test_set_pin, "%s/test_set_pin", prefix);
1659 p11_test (test_operation_state, "%s/test_operation_state", prefix);
1660 p11_test (test_login_logout, "%s/test_login_logout", prefix);
1661 p11_test (test_get_attribute_value, "%s/test_get_attribute_value", prefix);
1662 p11_test (test_set_attribute_value, "%s/test_set_attribute_value", prefix);
1663 p11_test (test_create_object, "%s/test_create_object", prefix);
1664 p11_test (test_copy_object, "%s/test_copy_object", prefix);
1665 p11_test (test_destroy_object, "%s/test_destroy_object", prefix);
1666 p11_test (test_get_object_size, "%s/test_get_object_size", prefix);
1667 p11_test (test_find_objects, "%s/test_find_objects", prefix);
1668 p11_test (test_encrypt, "%s/test_encrypt", prefix);
1669 p11_test (test_decrypt, "%s/test_decrypt", prefix);
1670 p11_test (test_digest, "%s/test_digest", prefix);
1671 p11_test (test_sign, "%s/test_sign", prefix);
1672 p11_test (test_sign_recover, "%s/test_sign_recover", prefix);
1673 p11_test (test_verify, "%s/test_verify", prefix);
1674 p11_test (test_verify_recover, "%s/test_verify_recover", prefix);
1675 p11_test (test_digest_encrypt, "%s/test_digest_encrypt", prefix);
1676 p11_test (test_decrypt_digest, "%s/test_decrypt_digest", prefix);
1677 p11_test (test_sign_encrypt, "%s/test_sign_encrypt", prefix);
1678 p11_test (test_decrypt_verify, "%s/test_decrypt_verify", prefix);
1679 p11_test (test_generate_key, "%s/test_generate_key", prefix);
1680 p11_test (test_generate_key_pair, "%s/test_generate_key_pair", prefix);
1681 p11_test (test_wrap_key, "%s/test_wrap_key", prefix);
1682 p11_test (test_unwrap_key, "%s/test_unwrap_key", prefix);
1683 p11_test (test_derive_key, "%s/test_derive_key", prefix);
1684 p11_test (test_random, "%s/test_random", prefix);
1685 }
1686