Debian Codegraph @

pkcs11/gkm/gkm-module-ep.h

raw
1 /*
2 * gnome-keyring
3 *
4 * Copyright (C) 2008 Stefan Walter
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as
8 * published by the Free Software Foundation; either version 2.1 of
9 * the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this program; if not, see
18 * <http://www.gnu.org/licenses/>.
19 */
20
21 #include "gkm-crypto.h"
22 #include "gkm-module.h"
23 #include "gkm-session.h"
24
25 #include "pkcs11/pkcs11.h"
26
27 #include <unistd.h>
28
29 /* Forward declaration, this must be defined manually or using GKM_DEFINE_MODULE */
30 static GkmModule* gkm_module_instantiate (CK_C_INITIALIZE_ARGS_PTR args, GMutex *mutex);
31
32 static GkmModule *pkcs11_module = NULL;
33 static pid_t pkcs11_module_pid = 0;
34 static GMutex pkcs11_module_mutex = { 0, };
35
36 static CK_FUNCTION_LIST gkm_module_function_list;
37
38 static CK_RV
39 gkm_C_Initialize (CK_VOID_PTR init_args)
40 {
41 CK_C_INITIALIZE_ARGS_PTR args = (CK_C_INITIALIZE_ARGS_PTR)init_args;
42 CK_RV rv = CKR_OK;
43 pid_t pid = getpid ();
44 gboolean supplied_ok;
45
46 if (args) {
47
48 /* ALL supplied function pointers need to have the value either NULL or non-NULL. */
49 supplied_ok = (args->CreateMutex == NULL && args->DestroyMutex == NULL &&
50 args->LockMutex == NULL && args->UnlockMutex == NULL) ||
51 (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
52 args->LockMutex != NULL && args->UnlockMutex != NULL);
53
54 if (!supplied_ok) {
55 g_message ("invalid set of mutex calls supplied");
56 return CKR_ARGUMENTS_BAD;
57 }
58
59 if (!(args->flags & CKF_OS_LOCKING_OK)) {
60 g_message ("must be able to use our own locking and multi-thread primitives");
61 return CKR_CANT_LOCK;
62 }
63 }
64
65 gkm_crypto_initialize ();
66
67 g_mutex_lock (&pkcs11_module_mutex);
68
69 if (pkcs11_module != NULL) {
70 if (pkcs11_module_pid == pid)
71 rv = CKR_CRYPTOKI_ALREADY_INITIALIZED;
72 else
73 pkcs11_module_pid = pid;
74 } else {
75 pkcs11_module = gkm_module_instantiate (args, &pkcs11_module_mutex);
76 if (!pkcs11_module) {
77 g_warning ("module could not be instantiated");
78 rv = CKR_GENERAL_ERROR;
79 } else {
80 pkcs11_module_pid = pid;
81 }
82 }
83
84 g_mutex_unlock (&pkcs11_module_mutex);
85
86 return rv;
87 }
88
89 static CK_RV
90 gkm_C_Finalize (CK_VOID_PTR reserved)
91 {
92 CK_RV rv = CKR_OK;
93
94 if (reserved)
95 return CKR_ARGUMENTS_BAD;
96
97 g_mutex_lock (&pkcs11_module_mutex);
98
99 if (pkcs11_module == NULL) {
100 rv = CKR_CRYPTOKI_NOT_INITIALIZED;
101 } else {
102 g_object_run_dispose (G_OBJECT (pkcs11_module));
103 g_object_unref (pkcs11_module);
104 pkcs11_module = NULL;
105 pkcs11_module_pid = 0;
106 }
107
108 g_mutex_unlock (&pkcs11_module_mutex);
109
110 return rv;
111 }
112
113 static CK_RV
114 gkm_C_GetInfo (CK_INFO_PTR info)
115 {
116 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
117
118 g_mutex_lock (&pkcs11_module_mutex);
119
120 if (pkcs11_module != NULL)
121 rv = gkm_module_C_GetInfo (pkcs11_module, info);
122
123 g_mutex_unlock (&pkcs11_module_mutex);
124
125 return rv;
126 }
127
128 static CK_RV
129 gkm_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
130 {
131 if (!list)
132 return CKR_ARGUMENTS_BAD;
133 *list = &gkm_module_function_list;
134 return CKR_OK;
135 }
136
137 static CK_RV
138 gkm_C_GetSlotList (CK_BBOOL token_present, CK_SLOT_ID_PTR slot_list, CK_ULONG_PTR count)
139 {
140 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
141
142 g_mutex_lock (&pkcs11_module_mutex);
143
144 if (pkcs11_module != NULL)
145 rv = gkm_module_C_GetSlotList (pkcs11_module, token_present, slot_list, count);
146
147 g_mutex_unlock (&pkcs11_module_mutex);
148
149 return rv;
150 }
151
152 static CK_RV
153 gkm_C_GetSlotInfo (CK_SLOT_ID id, CK_SLOT_INFO_PTR info)
154 {
155 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
156
157 g_mutex_lock (&pkcs11_module_mutex);
158
159 if (pkcs11_module != NULL)
160 rv = gkm_module_C_GetSlotInfo (pkcs11_module, id, info);
161
162 g_mutex_unlock (&pkcs11_module_mutex);
163
164 return rv;
165 }
166
167 static CK_RV
168 gkm_C_GetTokenInfo (CK_SLOT_ID id, CK_TOKEN_INFO_PTR info)
169 {
170 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
171
172 g_mutex_lock (&pkcs11_module_mutex);
173
174 if (pkcs11_module != NULL)
175 rv = gkm_module_C_GetTokenInfo (pkcs11_module, id, info);
176
177 g_mutex_unlock (&pkcs11_module_mutex);
178
179 return rv;
180 }
181
182 static CK_RV
183 gkm_C_GetMechanismList (CK_SLOT_ID id, CK_MECHANISM_TYPE_PTR mechanism_list, CK_ULONG_PTR count)
184 {
185 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
186
187 g_mutex_lock (&pkcs11_module_mutex);
188
189 if (pkcs11_module != NULL)
190 rv = gkm_module_C_GetMechanismList (pkcs11_module, id, mechanism_list, count);
191
192 g_mutex_unlock (&pkcs11_module_mutex);
193
194 return rv;
195 }
196
197 static CK_RV
198 gkm_C_GetMechanismInfo (CK_SLOT_ID id, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR info)
199 {
200 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
201
202 g_mutex_lock (&pkcs11_module_mutex);
203
204 if (pkcs11_module != NULL)
205 rv = gkm_module_C_GetMechanismInfo (pkcs11_module, id, type, info);
206
207 g_mutex_unlock (&pkcs11_module_mutex);
208
209 return rv;
210 }
211
212 static CK_RV
213 gkm_C_InitToken (CK_SLOT_ID id, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len, CK_UTF8CHAR_PTR label)
214 {
215 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
216
217 g_mutex_lock (&pkcs11_module_mutex);
218
219 if (pkcs11_module != NULL)
220 rv = gkm_module_C_InitToken (pkcs11_module, id, pin, pin_len, label);
221
222 g_mutex_unlock (&pkcs11_module_mutex);
223
224 return rv;
225 }
226
227 static CK_RV
228 gkm_C_WaitForSlotEvent (CK_FLAGS flags, CK_SLOT_ID_PTR slot, CK_VOID_PTR reserved)
229 {
230 /*
231 * PKCS#11 GRAY AREA: What happens when we know we'll *never*
232 * have any slot events, and someone calls us without CKR_DONT_BLOCK?
233 * In case there's a thread dedicated to calling this function in a
234 * loop, we wait 5 seconds when called without CKR_DONT_BLOCK.
235 */
236
237 if (!(flags & CKF_DONT_BLOCK))
238 sleep (5);
239
240 return CKR_NO_EVENT;
241 }
242
243 static CK_RV
244 gkm_C_OpenSession (CK_SLOT_ID id, CK_FLAGS flags, CK_VOID_PTR user_data, CK_NOTIFY callback, CK_SESSION_HANDLE_PTR handle)
245 {
246 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
247
248 g_mutex_lock (&pkcs11_module_mutex);
249
250 if (pkcs11_module != NULL)
251 rv = gkm_module_C_OpenSession (pkcs11_module, id, flags, user_data, callback, handle);
252
253 g_mutex_unlock (&pkcs11_module_mutex);
254
255 return rv;
256 }
257
258 static CK_RV
259 gkm_C_CloseSession (CK_SESSION_HANDLE handle)
260 {
261 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
262
263 g_mutex_lock (&pkcs11_module_mutex);
264
265 if (pkcs11_module != NULL)
266 rv = gkm_module_C_CloseSession (pkcs11_module, handle);
267
268 g_mutex_unlock (&pkcs11_module_mutex);
269
270 return rv;
271 }
272
273 static CK_RV
274 gkm_C_CloseAllSessions (CK_SLOT_ID id)
275 {
276 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
277
278 g_mutex_lock (&pkcs11_module_mutex);
279
280 if (pkcs11_module != NULL)
281 rv = gkm_module_C_CloseAllSessions (pkcs11_module, id);
282
283 g_mutex_unlock (&pkcs11_module_mutex);
284
285 return rv;
286 }
287
288 static CK_RV
289 gkm_C_GetFunctionStatus (CK_SESSION_HANDLE handle)
290 {
291 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
292 GkmSession *session;
293
294 g_mutex_lock (&pkcs11_module_mutex);
295
296 if (pkcs11_module != NULL) {
297 session = gkm_module_lookup_session (pkcs11_module, handle);
298 if (session != NULL)
299 rv = gkm_session_C_GetFunctionStatus (session);
300 else
301 rv = CKR_SESSION_HANDLE_INVALID;
302 }
303
304 g_mutex_unlock (&pkcs11_module_mutex);
305
306 return rv;
307 }
308
309 static CK_RV
310 gkm_C_CancelFunction (CK_SESSION_HANDLE handle)
311 {
312 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
313 GkmSession *session;
314
315 g_mutex_lock (&pkcs11_module_mutex);
316
317 if (pkcs11_module != NULL) {
318 session = gkm_module_lookup_session (pkcs11_module, handle);
319 if (session != NULL)
320 rv = gkm_session_C_CancelFunction (session);
321 else
322 rv = CKR_SESSION_HANDLE_INVALID;
323 }
324
325 g_mutex_unlock (&pkcs11_module_mutex);
326
327 return rv;
328 }
329
330 static CK_RV
331 gkm_C_GetSessionInfo (CK_SESSION_HANDLE handle, CK_SESSION_INFO_PTR info)
332 {
333 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
334 GkmSession *session;
335
336 g_mutex_lock (&pkcs11_module_mutex);
337
338 if (pkcs11_module != NULL) {
339 session = gkm_module_lookup_session (pkcs11_module, handle);
340 if (session != NULL)
341 rv = gkm_session_C_GetSessionInfo (session,
342 info);
343 else
344 rv = CKR_SESSION_HANDLE_INVALID;
345 }
346
347 g_mutex_unlock (&pkcs11_module_mutex);
348
349 return rv;
350 }
351
352 static CK_RV
353 gkm_C_InitPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
354 {
355 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
356
357 g_mutex_lock (&pkcs11_module_mutex);
358
359 if (pkcs11_module != NULL)
360 rv = gkm_module_C_InitPIN (pkcs11_module, handle, pin, pin_len);
361
362 g_mutex_unlock (&pkcs11_module_mutex);
363
364 return rv;
365 }
366
367 static CK_RV
368 gkm_C_SetPIN (CK_SESSION_HANDLE handle, CK_UTF8CHAR_PTR old_pin, CK_ULONG old_pin_len, CK_UTF8CHAR_PTR new_pin, CK_ULONG new_pin_len)
369 {
370 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
371
372 g_mutex_lock (&pkcs11_module_mutex);
373
374 if (pkcs11_module != NULL)
375 rv = gkm_module_C_SetPIN (pkcs11_module, handle, old_pin, old_pin_len, new_pin, new_pin_len);
376
377 g_mutex_unlock (&pkcs11_module_mutex);
378
379 return rv;
380 }
381
382 static CK_RV
383 gkm_C_GetOperationState (CK_SESSION_HANDLE handle, CK_BYTE_PTR operation_state, CK_ULONG_PTR operation_state_len)
384 {
385 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
386 GkmSession *session;
387
388 g_mutex_lock (&pkcs11_module_mutex);
389
390 if (pkcs11_module != NULL) {
391 session = gkm_module_lookup_session (pkcs11_module, handle);
392 if (session != NULL)
393 rv = gkm_session_C_GetOperationState (session,
394 operation_state, operation_state_len);
395 else
396 rv = CKR_SESSION_HANDLE_INVALID;
397 }
398
399 g_mutex_unlock (&pkcs11_module_mutex);
400
401 return rv;
402 }
403
404 static CK_RV
405 gkm_C_SetOperationState (CK_SESSION_HANDLE handle, CK_BYTE_PTR operation_state,
406 CK_ULONG operation_state_len, CK_OBJECT_HANDLE encryption_key,
407 CK_OBJECT_HANDLE authentication_key)
408 {
409 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
410 GkmSession *session;
411
412 g_mutex_lock (&pkcs11_module_mutex);
413
414 if (pkcs11_module != NULL) {
415 session = gkm_module_lookup_session (pkcs11_module, handle);
416 if (session != NULL)
417 rv = gkm_session_C_SetOperationState (session,
418 operation_state, operation_state_len, encryption_key, authentication_key);
419 else
420 rv = CKR_SESSION_HANDLE_INVALID;
421 }
422
423 g_mutex_unlock (&pkcs11_module_mutex);
424
425 return rv;
426 }
427
428 static CK_RV
429 gkm_C_Login (CK_SESSION_HANDLE handle, CK_USER_TYPE user_type,
430 CK_UTF8CHAR_PTR pin, CK_ULONG pin_len)
431 {
432 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
433
434 g_mutex_lock (&pkcs11_module_mutex);
435
436 if (pkcs11_module != NULL)
437 rv = gkm_module_C_Login (pkcs11_module, handle, user_type, pin, pin_len);
438
439 g_mutex_unlock (&pkcs11_module_mutex);
440
441 return rv;
442 }
443
444 static CK_RV
445 gkm_C_Logout (CK_SESSION_HANDLE handle)
446 {
447 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
448
449 g_mutex_lock (&pkcs11_module_mutex);
450
451 if (pkcs11_module != NULL)
452 rv = gkm_module_C_Logout (pkcs11_module, handle);
453
454 g_mutex_unlock (&pkcs11_module_mutex);
455
456 return rv;
457 }
458
459 static CK_RV
460 gkm_C_CreateObject (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template,
461 CK_ULONG count, CK_OBJECT_HANDLE_PTR new_object)
462 {
463 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
464 GkmSession *session;
465
466 g_mutex_lock (&pkcs11_module_mutex);
467
468 if (pkcs11_module != NULL) {
469 session = gkm_module_lookup_session (pkcs11_module, handle);
470 if (session != NULL)
471 rv = gkm_session_C_CreateObject (session,
472 template, count, new_object);
473 else
474 rv = CKR_SESSION_HANDLE_INVALID;
475 }
476
477 g_mutex_unlock (&pkcs11_module_mutex);
478
479 return rv;
480 }
481
482 static CK_RV
483 gkm_C_CopyObject (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
484 CK_ATTRIBUTE_PTR template, CK_ULONG count,
485 CK_OBJECT_HANDLE_PTR new_object)
486 {
487 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
488 GkmSession *session;
489
490 g_mutex_lock (&pkcs11_module_mutex);
491
492 if (pkcs11_module != NULL) {
493 session = gkm_module_lookup_session (pkcs11_module, handle);
494 if (session != NULL)
495 rv = gkm_session_C_CopyObject (session,
496 object, template, count, new_object);
497 else
498 rv = CKR_SESSION_HANDLE_INVALID;
499 }
500
501 g_mutex_unlock (&pkcs11_module_mutex);
502
503 return rv;
504 }
505
506
507 static CK_RV
508 gkm_C_DestroyObject (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object)
509 {
510 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
511 GkmSession *session;
512
513 g_mutex_lock (&pkcs11_module_mutex);
514
515 if (pkcs11_module != NULL) {
516 session = gkm_module_lookup_session (pkcs11_module, handle);
517 if (session != NULL)
518 rv = gkm_session_C_DestroyObject (session, object);
519 else
520 rv = CKR_SESSION_HANDLE_INVALID;
521 }
522
523 g_mutex_unlock (&pkcs11_module_mutex);
524
525 return rv;
526 }
527
528 static CK_RV
529 gkm_C_GetObjectSize (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
530 CK_ULONG_PTR size)
531 {
532 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
533 GkmSession *session;
534
535 g_mutex_lock (&pkcs11_module_mutex);
536
537 if (pkcs11_module != NULL) {
538 session = gkm_module_lookup_session (pkcs11_module, handle);
539 if (session != NULL)
540 rv = gkm_session_C_GetObjectSize (session, object, size);
541 else
542 rv = CKR_SESSION_HANDLE_INVALID;
543 }
544
545 g_mutex_unlock (&pkcs11_module_mutex);
546
547 return rv;
548 }
549
550 static CK_RV
551 gkm_C_GetAttributeValue (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
552 CK_ATTRIBUTE_PTR template, CK_ULONG count)
553 {
554 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
555 GkmSession *session;
556
557 g_mutex_lock (&pkcs11_module_mutex);
558
559 if (pkcs11_module != NULL) {
560 session = gkm_module_lookup_session (pkcs11_module, handle);
561 if (session != NULL)
562 rv = gkm_session_C_GetAttributeValue (session, object, template, count);
563 else
564 rv = CKR_SESSION_HANDLE_INVALID;
565 }
566
567 g_mutex_unlock (&pkcs11_module_mutex);
568
569 return rv;
570 }
571
572 static CK_RV
573 gkm_C_SetAttributeValue (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE object,
574 CK_ATTRIBUTE_PTR template, CK_ULONG count)
575 {
576 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
577 GkmSession *session;
578
579 g_mutex_lock (&pkcs11_module_mutex);
580
581 if (pkcs11_module != NULL) {
582 session = gkm_module_lookup_session (pkcs11_module, handle);
583 if (session != NULL)
584 rv = gkm_session_C_SetAttributeValue (session, object, template, count);
585 else
586 rv = CKR_SESSION_HANDLE_INVALID;
587 }
588
589 g_mutex_unlock (&pkcs11_module_mutex);
590
591 return rv;
592 }
593
594 static CK_RV
595 gkm_C_FindObjectsInit (CK_SESSION_HANDLE handle, CK_ATTRIBUTE_PTR template,
596 CK_ULONG count)
597 {
598 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
599 GkmSession *session;
600
601 g_mutex_lock (&pkcs11_module_mutex);
602
603 if (pkcs11_module != NULL) {
604 session = gkm_module_lookup_session (pkcs11_module, handle);
605 if (session != NULL)
606 rv = gkm_session_C_FindObjectsInit (session, template, count);
607 else
608 rv = CKR_SESSION_HANDLE_INVALID;
609 }
610
611 g_mutex_unlock (&pkcs11_module_mutex);
612
613 return rv;
614 }
615
616 static CK_RV
617 gkm_C_FindObjects (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE_PTR objects,
618 CK_ULONG max_count, CK_ULONG_PTR count)
619 {
620 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
621 GkmSession *session;
622
623 g_mutex_lock (&pkcs11_module_mutex);
624
625 if (pkcs11_module != NULL) {
626 session = gkm_module_lookup_session (pkcs11_module, handle);
627 if (session != NULL)
628 rv = gkm_session_C_FindObjects (session, objects, max_count, count);
629 else
630 rv = CKR_SESSION_HANDLE_INVALID;
631 }
632
633 g_mutex_unlock (&pkcs11_module_mutex);
634
635 return rv;
636 }
637
638 static CK_RV
639 gkm_C_FindObjectsFinal (CK_SESSION_HANDLE handle)
640 {
641 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
642 GkmSession *session;
643
644 g_mutex_lock (&pkcs11_module_mutex);
645
646 if (pkcs11_module != NULL) {
647 session = gkm_module_lookup_session (pkcs11_module, handle);
648 if (session != NULL)
649 rv = gkm_session_C_FindObjectsFinal (session);
650 else
651 rv = CKR_SESSION_HANDLE_INVALID;
652 }
653
654 g_mutex_unlock (&pkcs11_module_mutex);
655
656 return rv;
657 }
658
659 static CK_RV
660 gkm_C_EncryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
661 CK_OBJECT_HANDLE key)
662 {
663 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
664 GkmSession *session;
665
666 g_mutex_lock (&pkcs11_module_mutex);
667
668 if (pkcs11_module != NULL) {
669 session = gkm_module_lookup_session (pkcs11_module, handle);
670 if (session != NULL)
671 rv = gkm_session_C_EncryptInit (session, mechanism, key);
672 else
673 rv = CKR_SESSION_HANDLE_INVALID;
674 }
675
676 g_mutex_unlock (&pkcs11_module_mutex);
677
678 return rv;
679 }
680
681 static CK_RV
682 gkm_C_Encrypt (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
683 CK_BYTE_PTR encrypted_data, CK_ULONG_PTR encrypted_data_len)
684 {
685 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
686 GkmSession *session;
687
688 g_mutex_lock (&pkcs11_module_mutex);
689
690 if (pkcs11_module != NULL) {
691 session = gkm_module_lookup_session (pkcs11_module, handle);
692 if (session != NULL)
693 rv = gkm_session_C_Encrypt (session, data, data_len, encrypted_data, encrypted_data_len);
694 else
695 rv = CKR_SESSION_HANDLE_INVALID;
696 }
697
698 g_mutex_unlock (&pkcs11_module_mutex);
699
700 return rv;
701 }
702
703 static CK_RV
704 gkm_C_EncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part,
705 CK_ULONG part_len, CK_BYTE_PTR encrypted_part,
706 CK_ULONG_PTR encrypted_part_len)
707 {
708 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
709 GkmSession *session;
710
711 g_mutex_lock (&pkcs11_module_mutex);
712
713 if (pkcs11_module != NULL) {
714 session = gkm_module_lookup_session (pkcs11_module, handle);
715 if (session != NULL)
716 rv = gkm_session_C_EncryptUpdate (session, part, part_len, encrypted_part, encrypted_part_len);
717 else
718 rv = CKR_SESSION_HANDLE_INVALID;
719 }
720
721 g_mutex_unlock (&pkcs11_module_mutex);
722
723 return rv;
724 }
725
726 static CK_RV
727 gkm_C_EncryptFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR last_part,
728 CK_ULONG_PTR last_part_len)
729 {
730 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
731 GkmSession *session;
732
733 g_mutex_lock (&pkcs11_module_mutex);
734
735 if (pkcs11_module != NULL) {
736 session = gkm_module_lookup_session (pkcs11_module, handle);
737 if (session != NULL)
738 rv = gkm_session_C_EncryptFinal (session, last_part, last_part_len);
739 else
740 rv = CKR_SESSION_HANDLE_INVALID;
741 }
742
743 g_mutex_unlock (&pkcs11_module_mutex);
744
745 return rv;
746 }
747
748 static CK_RV
749 gkm_C_DecryptInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
750 CK_OBJECT_HANDLE key)
751 {
752 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
753 GkmSession *session;
754
755 g_mutex_lock (&pkcs11_module_mutex);
756
757 if (pkcs11_module != NULL) {
758 session = gkm_module_lookup_session (pkcs11_module, handle);
759 if (session != NULL)
760 rv = gkm_session_C_DecryptInit (session, mechanism, key);
761 else
762 rv = CKR_SESSION_HANDLE_INVALID;
763 }
764
765 g_mutex_unlock (&pkcs11_module_mutex);
766
767 return rv;
768 }
769
770 static CK_RV
771 gkm_C_Decrypt (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_data,
772 CK_ULONG enc_data_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len)
773 {
774 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
775 GkmSession *session;
776
777 g_mutex_lock (&pkcs11_module_mutex);
778
779 if (pkcs11_module != NULL) {
780 session = gkm_module_lookup_session (pkcs11_module, handle);
781 if (session != NULL)
782 rv = gkm_session_C_Decrypt (session, enc_data, enc_data_len, data, data_len);
783 else
784 rv = CKR_SESSION_HANDLE_INVALID;
785 }
786
787 g_mutex_unlock (&pkcs11_module_mutex);
788
789 return rv;
790 }
791
792 static CK_RV
793 gkm_C_DecryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part,
794 CK_ULONG enc_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len)
795 {
796 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
797 GkmSession *session;
798
799 g_mutex_lock (&pkcs11_module_mutex);
800
801 if (pkcs11_module != NULL) {
802 session = gkm_module_lookup_session (pkcs11_module, handle);
803 if (session != NULL)
804 rv = gkm_session_C_DecryptUpdate (session, enc_part, enc_part_len, part, part_len);
805 else
806 rv = CKR_SESSION_HANDLE_INVALID;
807 }
808
809 g_mutex_unlock (&pkcs11_module_mutex);
810
811 return rv;
812 }
813
814 static CK_RV
815 gkm_C_DecryptFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR last_part,
816 CK_ULONG_PTR last_part_len)
817 {
818 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
819 GkmSession *session;
820
821 g_mutex_lock (&pkcs11_module_mutex);
822
823 if (pkcs11_module != NULL) {
824 session = gkm_module_lookup_session (pkcs11_module, handle);
825 if (session != NULL)
826 rv = gkm_session_C_DecryptFinal (session, last_part, last_part_len);
827 else
828 rv = CKR_SESSION_HANDLE_INVALID;
829 }
830
831 g_mutex_unlock (&pkcs11_module_mutex);
832
833 return rv;
834 }
835
836 static CK_RV
837 gkm_C_DigestInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism)
838 {
839 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
840 GkmSession *session;
841
842 g_mutex_lock (&pkcs11_module_mutex);
843
844 if (pkcs11_module != NULL) {
845 session = gkm_module_lookup_session (pkcs11_module, handle);
846 if (session != NULL)
847 rv = gkm_session_C_DigestInit (session, mechanism);
848 else
849 rv = CKR_SESSION_HANDLE_INVALID;
850 }
851
852 g_mutex_unlock (&pkcs11_module_mutex);
853
854 return rv;
855 }
856
857 static CK_RV
858 gkm_C_Digest (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
859 CK_BYTE_PTR digest, CK_ULONG_PTR digest_len)
860 {
861 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
862 GkmSession *session;
863
864 g_mutex_lock (&pkcs11_module_mutex);
865
866 if (pkcs11_module != NULL) {
867 session = gkm_module_lookup_session (pkcs11_module, handle);
868 if (session != NULL)
869 rv = gkm_session_C_Digest (session, data, data_len, digest, digest_len);
870 else
871 rv = CKR_SESSION_HANDLE_INVALID;
872 }
873
874 g_mutex_unlock (&pkcs11_module_mutex);
875
876 return rv;
877 }
878
879 static CK_RV
880 gkm_C_DigestUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len)
881 {
882 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
883 GkmSession *session;
884
885 g_mutex_lock (&pkcs11_module_mutex);
886
887 if (pkcs11_module != NULL) {
888 session = gkm_module_lookup_session (pkcs11_module, handle);
889 if (session != NULL)
890 rv = gkm_session_C_DigestUpdate (session, part, part_len);
891 else
892 rv = CKR_SESSION_HANDLE_INVALID;
893 }
894
895 g_mutex_unlock (&pkcs11_module_mutex);
896
897 return rv;
898 }
899
900 static CK_RV
901 gkm_C_DigestKey (CK_SESSION_HANDLE handle, CK_OBJECT_HANDLE key)
902 {
903 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
904 GkmSession *session;
905
906 g_mutex_lock (&pkcs11_module_mutex);
907
908 if (pkcs11_module != NULL) {
909 session = gkm_module_lookup_session (pkcs11_module, handle);
910 if (session != NULL)
911 rv = gkm_session_C_DigestKey (session, key);
912 else
913 rv = CKR_SESSION_HANDLE_INVALID;
914 }
915
916 g_mutex_unlock (&pkcs11_module_mutex);
917
918 return rv;
919 }
920
921 static CK_RV
922 gkm_C_DigestFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR digest,
923 CK_ULONG_PTR digest_len)
924 {
925 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
926 GkmSession *session;
927
928 g_mutex_lock (&pkcs11_module_mutex);
929
930 if (pkcs11_module != NULL) {
931 session = gkm_module_lookup_session (pkcs11_module, handle);
932 if (session != NULL)
933 rv = gkm_session_C_DigestFinal (session, digest, digest_len);
934 else
935 rv = CKR_SESSION_HANDLE_INVALID;
936 }
937
938 g_mutex_unlock (&pkcs11_module_mutex);
939
940 return rv;
941 }
942
943 static CK_RV
944 gkm_C_SignInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
945 CK_OBJECT_HANDLE key)
946 {
947 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
948 GkmSession *session;
949
950 g_mutex_lock (&pkcs11_module_mutex);
951
952 if (pkcs11_module != NULL) {
953 session = gkm_module_lookup_session (pkcs11_module, handle);
954 if (session != NULL)
955 rv = gkm_session_C_SignInit (session, mechanism, key);
956 else
957 rv = CKR_SESSION_HANDLE_INVALID;
958 }
959
960 g_mutex_unlock (&pkcs11_module_mutex);
961
962 return rv;
963 }
964
965 static CK_RV
966 gkm_C_Sign (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
967 CK_BYTE_PTR signature, CK_ULONG_PTR signature_len)
968 {
969 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
970 GkmSession *session;
971
972 g_mutex_lock (&pkcs11_module_mutex);
973
974 if (pkcs11_module != NULL) {
975 session = gkm_module_lookup_session (pkcs11_module, handle);
976 if (session != NULL)
977 rv = gkm_session_C_Sign (session, data, data_len, signature, signature_len);
978 else
979 rv = CKR_SESSION_HANDLE_INVALID;
980 }
981
982 g_mutex_unlock (&pkcs11_module_mutex);
983
984 return rv;
985 }
986
987 static CK_RV
988 gkm_C_SignUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len)
989 {
990 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
991 GkmSession *session;
992
993 g_mutex_lock (&pkcs11_module_mutex);
994
995 if (pkcs11_module != NULL) {
996 session = gkm_module_lookup_session (pkcs11_module, handle);
997 if (session != NULL)
998 rv = gkm_session_C_SignUpdate (session, part, part_len);
999 else
1000 rv = CKR_SESSION_HANDLE_INVALID;
1001 }
1002
1003 g_mutex_unlock (&pkcs11_module_mutex);
1004
1005 return rv;
1006 }
1007
1008 static CK_RV
1009 gkm_C_SignFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature,
1010 CK_ULONG_PTR signature_len)
1011 {
1012 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1013 GkmSession *session;
1014
1015 g_mutex_lock (&pkcs11_module_mutex);
1016
1017 if (pkcs11_module != NULL) {
1018 session = gkm_module_lookup_session (pkcs11_module, handle);
1019 if (session != NULL)
1020 rv = gkm_session_C_SignFinal (session, signature, signature_len);
1021 else
1022 rv = CKR_SESSION_HANDLE_INVALID;
1023 }
1024
1025 g_mutex_unlock (&pkcs11_module_mutex);
1026
1027 return rv;
1028 }
1029
1030 static CK_RV
1031 gkm_C_SignRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1032 CK_OBJECT_HANDLE key)
1033 {
1034 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1035 GkmSession *session;
1036
1037 g_mutex_lock (&pkcs11_module_mutex);
1038
1039 if (pkcs11_module != NULL) {
1040 session = gkm_module_lookup_session (pkcs11_module, handle);
1041 if (session != NULL)
1042 rv = gkm_session_C_SignRecoverInit (session, mechanism, key);
1043 else
1044 rv = CKR_SESSION_HANDLE_INVALID;
1045 }
1046
1047 g_mutex_unlock (&pkcs11_module_mutex);
1048
1049 return rv;
1050 }
1051
1052 static CK_RV
1053 gkm_C_SignRecover (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
1054 CK_BYTE_PTR signature, CK_ULONG_PTR signature_len)
1055 {
1056 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1057 GkmSession *session;
1058
1059 g_mutex_lock (&pkcs11_module_mutex);
1060
1061 if (pkcs11_module != NULL) {
1062 session = gkm_module_lookup_session (pkcs11_module, handle);
1063 if (session != NULL)
1064 rv = gkm_session_C_SignRecover (session, data, data_len, signature, signature_len);
1065 else
1066 rv = CKR_SESSION_HANDLE_INVALID;
1067 }
1068
1069 g_mutex_unlock (&pkcs11_module_mutex);
1070
1071 return rv;
1072 }
1073
1074 static CK_RV
1075 gkm_C_VerifyInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1076 CK_OBJECT_HANDLE key)
1077 {
1078 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1079 GkmSession *session;
1080
1081 g_mutex_lock (&pkcs11_module_mutex);
1082
1083 if (pkcs11_module != NULL) {
1084 session = gkm_module_lookup_session (pkcs11_module, handle);
1085 if (session != NULL)
1086 rv = gkm_session_C_VerifyInit (session, mechanism, key);
1087 else
1088 rv = CKR_SESSION_HANDLE_INVALID;
1089 }
1090
1091 g_mutex_unlock (&pkcs11_module_mutex);
1092
1093 return rv;
1094 }
1095
1096 static CK_RV
1097 gkm_C_Verify (CK_SESSION_HANDLE handle, CK_BYTE_PTR data, CK_ULONG data_len,
1098 CK_BYTE_PTR signature, CK_ULONG signature_len)
1099 {
1100 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1101 GkmSession *session;
1102
1103 g_mutex_lock (&pkcs11_module_mutex);
1104
1105 if (pkcs11_module != NULL) {
1106 session = gkm_module_lookup_session (pkcs11_module, handle);
1107 if (session != NULL)
1108 rv = gkm_session_C_Verify (session, data, data_len, signature, signature_len);
1109 else
1110 rv = CKR_SESSION_HANDLE_INVALID;
1111 }
1112
1113 g_mutex_unlock (&pkcs11_module_mutex);
1114
1115 return rv;
1116 }
1117
1118 static CK_RV
1119 gkm_C_VerifyUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part, CK_ULONG part_len)
1120 {
1121 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1122 GkmSession *session;
1123
1124 g_mutex_lock (&pkcs11_module_mutex);
1125
1126 if (pkcs11_module != NULL) {
1127 session = gkm_module_lookup_session (pkcs11_module, handle);
1128 if (session != NULL)
1129 rv = gkm_session_C_VerifyUpdate (session, part, part_len);
1130 else
1131 rv = CKR_SESSION_HANDLE_INVALID;
1132 }
1133
1134 g_mutex_unlock (&pkcs11_module_mutex);
1135
1136 return rv;
1137 }
1138
1139 static CK_RV
1140 gkm_C_VerifyFinal (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature,
1141 CK_ULONG signature_len)
1142 {
1143 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1144 GkmSession *session;
1145
1146 g_mutex_lock (&pkcs11_module_mutex);
1147
1148 if (pkcs11_module != NULL) {
1149 session = gkm_module_lookup_session (pkcs11_module, handle);
1150 if (session != NULL)
1151 rv = gkm_session_C_VerifyFinal (session, signature, signature_len);
1152 else
1153 rv = CKR_SESSION_HANDLE_INVALID;
1154 }
1155
1156 g_mutex_unlock (&pkcs11_module_mutex);
1157
1158 return rv;
1159 }
1160
1161 static CK_RV
1162 gkm_C_VerifyRecoverInit (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1163 CK_OBJECT_HANDLE key)
1164 {
1165 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1166 GkmSession *session;
1167
1168 g_mutex_lock (&pkcs11_module_mutex);
1169
1170 if (pkcs11_module != NULL) {
1171 session = gkm_module_lookup_session (pkcs11_module, handle);
1172 if (session != NULL)
1173 rv = gkm_session_C_VerifyRecoverInit (session, mechanism, key);
1174 else
1175 rv = CKR_SESSION_HANDLE_INVALID;
1176 }
1177
1178 g_mutex_unlock (&pkcs11_module_mutex);
1179
1180 return rv;
1181 }
1182
1183 static CK_RV
1184 gkm_C_VerifyRecover (CK_SESSION_HANDLE handle, CK_BYTE_PTR signature,
1185 CK_ULONG signature_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len)
1186 {
1187 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1188 GkmSession *session;
1189
1190 g_mutex_lock (&pkcs11_module_mutex);
1191
1192 if (pkcs11_module != NULL) {
1193 session = gkm_module_lookup_session (pkcs11_module, handle);
1194 if (session != NULL)
1195 rv = gkm_session_C_VerifyRecover (session, signature, signature_len, data, data_len);
1196 else
1197 rv = CKR_SESSION_HANDLE_INVALID;
1198 }
1199
1200 g_mutex_unlock (&pkcs11_module_mutex);
1201
1202 return rv;
1203 }
1204
1205 static CK_RV
1206 gkm_C_DigestEncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part,
1207 CK_ULONG part_len, CK_BYTE_PTR enc_part,
1208 CK_ULONG_PTR enc_part_len)
1209 {
1210 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1211 GkmSession *session;
1212
1213 g_mutex_lock (&pkcs11_module_mutex);
1214
1215 if (pkcs11_module != NULL) {
1216 session = gkm_module_lookup_session (pkcs11_module, handle);
1217 if (session != NULL)
1218 rv = gkm_session_C_DigestEncryptUpdate (session, part, part_len, enc_part, enc_part_len);
1219 else
1220 rv = CKR_SESSION_HANDLE_INVALID;
1221 }
1222
1223 g_mutex_unlock (&pkcs11_module_mutex);
1224
1225 return rv;
1226 }
1227
1228 static CK_RV
1229 gkm_C_DecryptDigestUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part,
1230 CK_ULONG enc_part_len, CK_BYTE_PTR part,
1231 CK_ULONG_PTR part_len)
1232 {
1233 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1234 GkmSession *session;
1235
1236 g_mutex_lock (&pkcs11_module_mutex);
1237
1238 if (pkcs11_module != NULL) {
1239 session = gkm_module_lookup_session (pkcs11_module, handle);
1240 if (session != NULL)
1241 rv = gkm_session_C_DecryptDigestUpdate (session, enc_part, enc_part_len, part, part_len);
1242 else
1243 rv = CKR_SESSION_HANDLE_INVALID;
1244 }
1245
1246 g_mutex_unlock (&pkcs11_module_mutex);
1247
1248 return rv;
1249 }
1250
1251 static CK_RV
1252 gkm_C_SignEncryptUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR part,
1253 CK_ULONG part_len, CK_BYTE_PTR enc_part,
1254 CK_ULONG_PTR enc_part_len)
1255 {
1256 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1257 GkmSession *session;
1258
1259 g_mutex_lock (&pkcs11_module_mutex);
1260
1261 if (pkcs11_module != NULL) {
1262 session = gkm_module_lookup_session (pkcs11_module, handle);
1263 if (session != NULL)
1264 rv = gkm_session_C_SignEncryptUpdate (session, part, part_len, enc_part, enc_part_len);
1265 else
1266 rv = CKR_SESSION_HANDLE_INVALID;
1267 }
1268
1269 g_mutex_unlock (&pkcs11_module_mutex);
1270
1271 return rv;
1272 }
1273
1274 static CK_RV
1275 gkm_C_DecryptVerifyUpdate (CK_SESSION_HANDLE handle, CK_BYTE_PTR enc_part,
1276 CK_ULONG enc_part_len, CK_BYTE_PTR part,
1277 CK_ULONG_PTR part_len)
1278 {
1279 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1280 GkmSession *session;
1281
1282 g_mutex_lock (&pkcs11_module_mutex);
1283
1284 if (pkcs11_module != NULL) {
1285 session = gkm_module_lookup_session (pkcs11_module, handle);
1286 if (session != NULL)
1287 rv = gkm_session_C_DecryptVerifyUpdate (session, enc_part, enc_part_len, part, part_len);
1288 else
1289 rv = CKR_SESSION_HANDLE_INVALID;
1290 }
1291
1292 g_mutex_unlock (&pkcs11_module_mutex);
1293
1294 return rv;
1295 }
1296
1297 static CK_RV
1298 gkm_C_GenerateKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1299 CK_ATTRIBUTE_PTR template, CK_ULONG count,
1300 CK_OBJECT_HANDLE_PTR key)
1301 {
1302 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1303 GkmSession *session;
1304
1305 g_mutex_lock (&pkcs11_module_mutex);
1306
1307 if (pkcs11_module != NULL) {
1308 session = gkm_module_lookup_session (pkcs11_module, handle);
1309 if (session != NULL)
1310 rv = gkm_session_C_GenerateKey (session, mechanism, template, count, key);
1311 else
1312 rv = CKR_SESSION_HANDLE_INVALID;
1313 }
1314
1315 g_mutex_unlock (&pkcs11_module_mutex);
1316
1317 return rv;
1318 }
1319
1320 static CK_RV
1321 gkm_C_GenerateKeyPair (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1322 CK_ATTRIBUTE_PTR pub_template, CK_ULONG pub_count,
1323 CK_ATTRIBUTE_PTR priv_template, CK_ULONG priv_count,
1324 CK_OBJECT_HANDLE_PTR pub_key, CK_OBJECT_HANDLE_PTR priv_key)
1325 {
1326 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1327 GkmSession *session;
1328
1329 g_mutex_lock (&pkcs11_module_mutex);
1330
1331 if (pkcs11_module != NULL) {
1332 session = gkm_module_lookup_session (pkcs11_module, handle);
1333 if (session != NULL)
1334 rv = gkm_session_C_GenerateKeyPair (session, mechanism, pub_template, pub_count, priv_template, priv_count, pub_key, priv_key);
1335 else
1336 rv = CKR_SESSION_HANDLE_INVALID;
1337 }
1338
1339 g_mutex_unlock (&pkcs11_module_mutex);
1340
1341 return rv;
1342 }
1343
1344 static CK_RV
1345 gkm_C_WrapKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1346 CK_OBJECT_HANDLE wrapping_key, CK_OBJECT_HANDLE key,
1347 CK_BYTE_PTR wrapped_key, CK_ULONG_PTR wrapped_key_len)
1348 {
1349 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1350 GkmSession *session;
1351
1352 g_mutex_lock (&pkcs11_module_mutex);
1353
1354 if (pkcs11_module != NULL) {
1355 session = gkm_module_lookup_session (pkcs11_module, handle);
1356 if (session != NULL)
1357 rv = gkm_session_C_WrapKey (session, mechanism, wrapping_key, key, wrapped_key, wrapped_key_len);
1358 else
1359 rv = CKR_SESSION_HANDLE_INVALID;
1360 }
1361
1362 g_mutex_unlock (&pkcs11_module_mutex);
1363
1364 return rv;
1365 }
1366
1367 static CK_RV
1368 gkm_C_UnwrapKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1369 CK_OBJECT_HANDLE unwrapping_key, CK_BYTE_PTR wrapped_key,
1370 CK_ULONG wrapped_key_len, CK_ATTRIBUTE_PTR template,
1371 CK_ULONG count, CK_OBJECT_HANDLE_PTR key)
1372 {
1373 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1374 GkmSession *session;
1375
1376 g_mutex_lock (&pkcs11_module_mutex);
1377
1378 if (pkcs11_module != NULL) {
1379 session = gkm_module_lookup_session (pkcs11_module, handle);
1380 if (session != NULL)
1381 rv = gkm_session_C_UnwrapKey (session, mechanism, unwrapping_key, wrapped_key, wrapped_key_len, template, count, key);
1382 else
1383 rv = CKR_SESSION_HANDLE_INVALID;
1384 }
1385
1386 g_mutex_unlock (&pkcs11_module_mutex);
1387
1388 return rv;
1389 }
1390
1391 static CK_RV
1392 gkm_C_DeriveKey (CK_SESSION_HANDLE handle, CK_MECHANISM_PTR mechanism,
1393 CK_OBJECT_HANDLE base_key, CK_ATTRIBUTE_PTR template,
1394 CK_ULONG count, CK_OBJECT_HANDLE_PTR key)
1395 {
1396 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1397 GkmSession *session;
1398
1399 g_mutex_lock (&pkcs11_module_mutex);
1400
1401 if (pkcs11_module != NULL) {
1402 session = gkm_module_lookup_session (pkcs11_module, handle);
1403 if (session != NULL)
1404 rv = gkm_session_C_DeriveKey (session, mechanism, base_key, template, count, key);
1405 else
1406 rv = CKR_SESSION_HANDLE_INVALID;
1407 }
1408
1409 g_mutex_unlock (&pkcs11_module_mutex);
1410
1411 return rv;
1412 }
1413
1414 static CK_RV
1415 gkm_C_SeedRandom (CK_SESSION_HANDLE handle, CK_BYTE_PTR seed, CK_ULONG seed_len)
1416 {
1417 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1418 GkmSession *session;
1419
1420 g_mutex_lock (&pkcs11_module_mutex);
1421
1422 if (pkcs11_module != NULL) {
1423 session = gkm_module_lookup_session (pkcs11_module, handle);
1424 if (session != NULL)
1425 rv = gkm_session_C_SeedRandom (session, seed, seed_len);
1426 else
1427 rv = CKR_SESSION_HANDLE_INVALID;
1428 }
1429
1430 g_mutex_unlock (&pkcs11_module_mutex);
1431
1432 return rv;
1433 }
1434
1435 static CK_RV
1436 gkm_C_GenerateRandom (CK_SESSION_HANDLE handle, CK_BYTE_PTR random_data,
1437 CK_ULONG random_len)
1438 {
1439 CK_RV rv = CKR_CRYPTOKI_NOT_INITIALIZED;
1440 GkmSession *session;
1441
1442 g_mutex_lock (&pkcs11_module_mutex);
1443
1444 if (pkcs11_module != NULL) {
1445 session = gkm_module_lookup_session (pkcs11_module, handle);
1446 if (session != NULL)
1447 rv = gkm_session_C_GenerateRandom (session, random_data, random_len);
1448 else
1449 rv = CKR_SESSION_HANDLE_INVALID;
1450 }
1451
1452 g_mutex_unlock (&pkcs11_module_mutex);
1453
1454 return rv;
1455 }
1456
1457 /* --------------------------------------------------------------------
1458 * MODULE ENTRY POINT
1459 */
1460
1461 /*
1462 * PKCS#11 is broken here. It states that Unix compilers automatically byte
1463 * pack structures. This is wrong. GCC on Linux aligns to 4 by default.
1464 *
1465 * This results in incompatibilities. Where this structure's first version
1466 * members take up too much or too little space depending on how this module
1467 * is compiled.
1468 */
1469
1470 static CK_FUNCTION_LIST gkm_module_function_list = {
1471 { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, /* version */
1472 gkm_C_Initialize,
1473 gkm_C_Finalize,
1474 gkm_C_GetInfo,
1475 gkm_C_GetFunctionList,
1476 gkm_C_GetSlotList,
1477 gkm_C_GetSlotInfo,
1478 gkm_C_GetTokenInfo,
1479 gkm_C_GetMechanismList,
1480 gkm_C_GetMechanismInfo,
1481 gkm_C_InitToken,
1482 gkm_C_InitPIN,
1483 gkm_C_SetPIN,
1484 gkm_C_OpenSession,
1485 gkm_C_CloseSession,
1486 gkm_C_CloseAllSessions,
1487 gkm_C_GetSessionInfo,
1488 gkm_C_GetOperationState,
1489 gkm_C_SetOperationState,
1490 gkm_C_Login,
1491 gkm_C_Logout,
1492 gkm_C_CreateObject,
1493 gkm_C_CopyObject,
1494 gkm_C_DestroyObject,
1495 gkm_C_GetObjectSize,
1496 gkm_C_GetAttributeValue,
1497 gkm_C_SetAttributeValue,
1498 gkm_C_FindObjectsInit,
1499 gkm_C_FindObjects,
1500 gkm_C_FindObjectsFinal,
1501 gkm_C_EncryptInit,
1502 gkm_C_Encrypt,
1503 gkm_C_EncryptUpdate,
1504 gkm_C_EncryptFinal,
1505 gkm_C_DecryptInit,
1506 gkm_C_Decrypt,
1507 gkm_C_DecryptUpdate,
1508 gkm_C_DecryptFinal,
1509 gkm_C_DigestInit,
1510 gkm_C_Digest,
1511 gkm_C_DigestUpdate,
1512 gkm_C_DigestKey,
1513 gkm_C_DigestFinal,
1514 gkm_C_SignInit,
1515 gkm_C_Sign,
1516 gkm_C_SignUpdate,
1517 gkm_C_SignFinal,
1518 gkm_C_SignRecoverInit,
1519 gkm_C_SignRecover,
1520 gkm_C_VerifyInit,
1521 gkm_C_Verify,
1522 gkm_C_VerifyUpdate,
1523 gkm_C_VerifyFinal,
1524 gkm_C_VerifyRecoverInit,
1525 gkm_C_VerifyRecover,
1526 gkm_C_DigestEncryptUpdate,
1527 gkm_C_DecryptDigestUpdate,
1528 gkm_C_SignEncryptUpdate,
1529 gkm_C_DecryptVerifyUpdate,
1530 gkm_C_GenerateKey,
1531 gkm_C_GenerateKeyPair,
1532 gkm_C_WrapKey,
1533 gkm_C_UnwrapKey,
1534 gkm_C_DeriveKey,
1535 gkm_C_SeedRandom,
1536 gkm_C_GenerateRandom,
1537 gkm_C_GetFunctionStatus,
1538 gkm_C_CancelFunction,
1539 gkm_C_WaitForSlotEvent
1540 };