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