1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <strings.h>
27 #include <errno.h>
28 #include <cryptoutil.h>
29 #include <unistd.h> /* for pid_t */
30 #include <pthread.h>
31 #include <security/cryptoki.h>
32 #include "softGlobal.h"
33 #include "softSession.h"
34 #include "softObject.h"
35 #include "softKeystore.h"
36 #include "softKeystoreUtil.h"
37
38 #pragma init(softtoken_init)
39 #pragma fini(softtoken_fini)
40
41 extern soft_session_t token_session; /* for fork handler */
42
43 static struct CK_FUNCTION_LIST functionList = {
44 { 2, 20 }, /* version */
45 C_Initialize,
46 C_Finalize,
47 C_GetInfo,
48 C_GetFunctionList,
49 C_GetSlotList,
50 C_GetSlotInfo,
51 C_GetTokenInfo,
52 C_GetMechanismList,
53 C_GetMechanismInfo,
54 C_InitToken,
55 C_InitPIN,
56 C_SetPIN,
57 C_OpenSession,
58 C_CloseSession,
59 C_CloseAllSessions,
60 C_GetSessionInfo,
61 C_GetOperationState,
62 C_SetOperationState,
63 C_Login,
64 C_Logout,
65 C_CreateObject,
66 C_CopyObject,
67 C_DestroyObject,
68 C_GetObjectSize,
69 C_GetAttributeValue,
70 C_SetAttributeValue,
71 C_FindObjectsInit,
72 C_FindObjects,
73 C_FindObjectsFinal,
74 C_EncryptInit,
75 C_Encrypt,
76 C_EncryptUpdate,
77 C_EncryptFinal,
78 C_DecryptInit,
79 C_Decrypt,
80 C_DecryptUpdate,
81 C_DecryptFinal,
82 C_DigestInit,
83 C_Digest,
84 C_DigestUpdate,
85 C_DigestKey,
86 C_DigestFinal,
87 C_SignInit,
88 C_Sign,
89 C_SignUpdate,
90 C_SignFinal,
91 C_SignRecoverInit,
92 C_SignRecover,
93 C_VerifyInit,
94 C_Verify,
95 C_VerifyUpdate,
96 C_VerifyFinal,
97 C_VerifyRecoverInit,
98 C_VerifyRecover,
99 C_DigestEncryptUpdate,
100 C_DecryptDigestUpdate,
101 C_SignEncryptUpdate,
102 C_DecryptVerifyUpdate,
103 C_GenerateKey,
104 C_GenerateKeyPair,
105 C_WrapKey,
106 C_UnwrapKey,
107 C_DeriveKey,
108 C_SeedRandom,
109 C_GenerateRandom,
110 C_GetFunctionStatus,
111 C_CancelFunction,
112 C_WaitForSlotEvent
113 };
114
115 boolean_t softtoken_initialized = B_FALSE;
116
117 static pid_t softtoken_pid = 0;
118
119 /* This mutex protects soft_session_list, all_sessions_closing */
120 pthread_mutex_t soft_sessionlist_mutex;
121 soft_session_t *soft_session_list = NULL;
122
123 int all_sessions_closing = 0;
124
125 slot_t soft_slot;
126 obj_to_be_freed_list_t obj_delay_freed;
127 ses_to_be_freed_list_t ses_delay_freed;
128
129 /* protects softtoken_initialized and access to C_Initialize/C_Finalize */
130 pthread_mutex_t soft_giant_mutex = PTHREAD_MUTEX_INITIALIZER;
131
132 /* fips mode setting */
133 int softtoken_fips_mode = CRYPTO_FIPS_MODE_DISABLED;
134
135 static CK_RV finalize_common(boolean_t force, CK_VOID_PTR pReserved);
136 static void softtoken_init();
137 static void softtoken_fini();
138 static void softtoken_fork_prepare();
139 static void softtoken_fork_after();
140
141 CK_RV
C_Initialize(CK_VOID_PTR pInitArgs)142 C_Initialize(CK_VOID_PTR pInitArgs)
143 {
144
145 int initialize_pid;
146 boolean_t supplied_ok;
147 CK_RV rv;
148
149 /*
150 * Get lock to insure only one thread enters this
151 * function at a time.
152 */
153 (void) pthread_mutex_lock(&soft_giant_mutex);
154
155 initialize_pid = getpid();
156
157 if (softtoken_initialized) {
158 if (initialize_pid == softtoken_pid) {
159 /*
160 * This process has called C_Initialize already
161 */
162 (void) pthread_mutex_unlock(&soft_giant_mutex);
163 return (CKR_CRYPTOKI_ALREADY_INITIALIZED);
164 } else {
165 /*
166 * A fork has happened and the child is
167 * reinitializing. Do a finalize_common to close
168 * out any state from the parent, and then
169 * continue on.
170 */
171 (void) finalize_common(B_TRUE, NULL);
172 }
173 }
174
175 if (pInitArgs != NULL) {
176 CK_C_INITIALIZE_ARGS *initargs1 =
177 (CK_C_INITIALIZE_ARGS *) pInitArgs;
178
179 /* pReserved must be NULL */
180 if (initargs1->pReserved != NULL) {
181 (void) pthread_mutex_unlock(&soft_giant_mutex);
182 return (CKR_ARGUMENTS_BAD);
183 }
184
185 /*
186 * ALL supplied function pointers need to have the value
187 * either NULL or non-NULL.
188 */
189 supplied_ok = (initargs1->CreateMutex == NULL &&
190 initargs1->DestroyMutex == NULL &&
191 initargs1->LockMutex == NULL &&
192 initargs1->UnlockMutex == NULL) ||
193 (initargs1->CreateMutex != NULL &&
194 initargs1->DestroyMutex != NULL &&
195 initargs1->LockMutex != NULL &&
196 initargs1->UnlockMutex != NULL);
197
198 if (!supplied_ok) {
199 (void) pthread_mutex_unlock(&soft_giant_mutex);
200 return (CKR_ARGUMENTS_BAD);
201 }
202
203 /*
204 * When the CKF_OS_LOCKING_OK flag isn't set and mutex
205 * function pointers are supplied by an application,
206 * return an error. We must be able to use our own primitives.
207 */
208 if (!(initargs1->flags & CKF_OS_LOCKING_OK) &&
209 (initargs1->CreateMutex != NULL)) {
210 (void) pthread_mutex_unlock(&soft_giant_mutex);
211 return (CKR_CANT_LOCK);
212 }
213 }
214
215 /* Initialize the session list lock */
216 if (pthread_mutex_init(&soft_sessionlist_mutex, NULL) != 0) {
217 (void) pthread_mutex_unlock(&soft_giant_mutex);
218 return (CKR_CANT_LOCK);
219 }
220
221 /*
222 * token object related initialization
223 */
224 soft_slot.authenticated = 0;
225 soft_slot.userpin_change_needed = 0;
226 soft_slot.token_object_list = NULL;
227 soft_slot.keystore_load_status = KEYSTORE_UNINITIALIZED;
228
229 if ((rv = soft_init_token_session()) != CKR_OK) {
230 (void) pthread_mutex_destroy(&soft_sessionlist_mutex);
231 (void) pthread_mutex_unlock(&soft_giant_mutex);
232 return (rv);
233 }
234
235 /* Initialize the slot lock */
236 if (pthread_mutex_init(&soft_slot.slot_mutex, NULL) != 0) {
237 (void) pthread_mutex_destroy(&soft_sessionlist_mutex);
238 (void) soft_destroy_token_session();
239 (void) pthread_mutex_unlock(&soft_giant_mutex);
240 return (CKR_CANT_LOCK);
241 }
242
243 /* Initialize the keystore lock */
244 if (pthread_mutex_init(&soft_slot.keystore_mutex, NULL) != 0) {
245 (void) pthread_mutex_destroy(&soft_slot.slot_mutex);
246 (void) pthread_mutex_destroy(&soft_sessionlist_mutex);
247 (void) soft_destroy_token_session();
248 (void) pthread_mutex_unlock(&soft_giant_mutex);
249 return (CKR_CANT_LOCK);
250 }
251
252 /* Initialize the object_to_be_freed list */
253 if (pthread_mutex_init(&obj_delay_freed.obj_to_be_free_mutex, NULL)
254 != 0) {
255 (void) pthread_mutex_destroy(&soft_slot.keystore_mutex);
256 (void) pthread_mutex_destroy(&soft_slot.slot_mutex);
257 (void) pthread_mutex_destroy(&soft_sessionlist_mutex);
258 (void) soft_destroy_token_session();
259 (void) pthread_mutex_unlock(&soft_giant_mutex);
260 return (CKR_CANT_LOCK);
261 }
262 obj_delay_freed.count = 0;
263 obj_delay_freed.first = NULL;
264 obj_delay_freed.last = NULL;
265
266 if (pthread_mutex_init(&ses_delay_freed.ses_to_be_free_mutex, NULL)
267 != 0) {
268 (void) pthread_mutex_destroy(
269 &obj_delay_freed.obj_to_be_free_mutex);
270 (void) pthread_mutex_destroy(&soft_slot.keystore_mutex);
271 (void) pthread_mutex_destroy(&soft_slot.slot_mutex);
272 (void) pthread_mutex_destroy(&soft_sessionlist_mutex);
273 (void) soft_destroy_token_session();
274 (void) pthread_mutex_unlock(&soft_giant_mutex);
275 return (CKR_CANT_LOCK);
276 }
277 ses_delay_freed.count = 0;
278 ses_delay_freed.first = NULL;
279 ses_delay_freed.last = NULL;
280
281 /*
282 * Perform POST when fips mode is enabled.
283 */
284 if ((rv = get_fips_mode(&softtoken_fips_mode)) == CKR_OK) {
285 if (softtoken_fips_mode == CRYPTO_FIPS_MODE_ENABLED) {
286 rv = soft_fips_post();
287 }
288 }
289
290 if (rv != CKR_OK) {
291 (void) pthread_mutex_destroy(
292 &ses_delay_freed.ses_to_be_free_mutex);
293 (void) pthread_mutex_destroy(
294 &obj_delay_freed.obj_to_be_free_mutex);
295 (void) pthread_mutex_destroy(&soft_slot.keystore_mutex);
296 (void) pthread_mutex_destroy(&soft_slot.slot_mutex);
297 (void) pthread_mutex_destroy(&soft_sessionlist_mutex);
298 (void) soft_destroy_token_session();
299 (void) pthread_mutex_unlock(&soft_giant_mutex);
300 return (CKR_FUNCTION_FAILED);
301 }
302
303 softtoken_pid = initialize_pid;
304 softtoken_initialized = B_TRUE;
305 (void) pthread_mutex_unlock(&soft_giant_mutex);
306
307 return (CKR_OK);
308 }
309
310 /*
311 * C_Finalize is a wrapper around finalize_common. The
312 * soft_giant_mutex should be locked by C_Finalize().
313 */
314 CK_RV
C_Finalize(CK_VOID_PTR pReserved)315 C_Finalize(CK_VOID_PTR pReserved)
316 {
317
318 CK_RV rv;
319
320 (void) pthread_mutex_lock(&soft_giant_mutex);
321
322 rv = finalize_common(B_FALSE, pReserved);
323
324 (void) pthread_mutex_unlock(&soft_giant_mutex);
325
326 return (rv);
327
328 }
329
330 /*
331 * finalize_common() does the work for C_Finalize. soft_giant_mutex
332 * must be held before calling this function.
333 */
334 static CK_RV
finalize_common(boolean_t force,CK_VOID_PTR pReserved)335 finalize_common(boolean_t force, CK_VOID_PTR pReserved) {
336
337 CK_RV rv = CKR_OK;
338 struct object *delay_free_obj, *tmpo;
339 struct session *delay_free_ses, *tmps;
340
341 if (!softtoken_initialized) {
342 return (CKR_CRYPTOKI_NOT_INITIALIZED);
343 }
344
345 /* Check to see if pReseved is NULL */
346 if (pReserved != NULL) {
347 return (CKR_ARGUMENTS_BAD);
348 }
349
350 (void) pthread_mutex_lock(&soft_sessionlist_mutex);
351 /*
352 * Set all_sessions_closing flag so any access to any
353 * existing sessions will be rejected.
354 */
355 all_sessions_closing = 1;
356 (void) pthread_mutex_unlock(&soft_sessionlist_mutex);
357
358 /* Delete all the sessions and release the allocated resources */
359 rv = soft_delete_all_sessions(force);
360
361 (void) pthread_mutex_lock(&soft_sessionlist_mutex);
362 /* Reset all_sessions_closing flag. */
363 all_sessions_closing = 0;
364 (void) pthread_mutex_unlock(&soft_sessionlist_mutex);
365
366 softtoken_initialized = B_FALSE;
367 softtoken_pid = 0;
368
369 pkcs11_close_urandom();
370 pkcs11_close_urandom_seed();
371 pkcs11_close_random();
372
373 /* Destroy the session list lock here */
374 (void) pthread_mutex_destroy(&soft_sessionlist_mutex);
375
376 /*
377 * Destroy token object related stuffs
378 * 1. Clean up the token object list
379 * 2. Destroy slot mutex
380 * 3. Destroy mutex in token_session
381 */
382 soft_delete_all_in_core_token_objects(ALL_TOKEN);
383 (void) pthread_mutex_destroy(&soft_slot.slot_mutex);
384 (void) pthread_mutex_destroy(&soft_slot.keystore_mutex);
385 (void) soft_destroy_token_session();
386
387 /*
388 * free all entries in the delay_freed list
389 */
390 delay_free_obj = obj_delay_freed.first;
391 while (delay_free_obj != NULL) {
392 tmpo = delay_free_obj->next;
393 free(delay_free_obj);
394 delay_free_obj = tmpo;
395 }
396
397 soft_slot.keystore_load_status = KEYSTORE_UNINITIALIZED;
398 (void) pthread_mutex_destroy(&obj_delay_freed.obj_to_be_free_mutex);
399
400 delay_free_ses = ses_delay_freed.first;
401 while (delay_free_ses != NULL) {
402 tmps = delay_free_ses->next;
403 free(delay_free_ses);
404 delay_free_ses = tmps;
405 }
406 (void) pthread_mutex_destroy(&ses_delay_freed.ses_to_be_free_mutex);
407
408 return (rv);
409 }
410
411 static void
softtoken_init()412 softtoken_init()
413 {
414 /* Children inherit parent's atfork handlers */
415 (void) pthread_atfork(softtoken_fork_prepare,
416 softtoken_fork_after, softtoken_fork_after);
417 }
418
419 /*
420 * softtoken_fini() function required to make sure complete cleanup
421 * is done if softtoken is ever unloaded without a C_Finalize() call.
422 */
423 static void
softtoken_fini()424 softtoken_fini()
425 {
426 (void) pthread_mutex_lock(&soft_giant_mutex);
427
428 /* if we're not initilized, do not attempt to finalize */
429 if (!softtoken_initialized) {
430 (void) pthread_mutex_unlock(&soft_giant_mutex);
431 return;
432 }
433
434 (void) finalize_common(B_TRUE, NULL_PTR);
435
436 (void) pthread_mutex_unlock(&soft_giant_mutex);
437 }
438
439 CK_RV
C_GetInfo(CK_INFO_PTR pInfo)440 C_GetInfo(CK_INFO_PTR pInfo)
441 {
442 if (!softtoken_initialized)
443 return (CKR_CRYPTOKI_NOT_INITIALIZED);
444
445 if (pInfo == NULL) {
446 return (CKR_ARGUMENTS_BAD);
447 }
448
449 /* Provide general information in the provided buffer */
450 pInfo->cryptokiVersion.major = CRYPTOKI_VERSION_MAJOR;
451 pInfo->cryptokiVersion.minor = CRYPTOKI_VERSION_MINOR;
452 (void) strncpy((char *)pInfo->manufacturerID,
453 SOFT_MANUFACTURER_ID, 32);
454 pInfo->flags = 0;
455 (void) strncpy((char *)pInfo->libraryDescription,
456 LIBRARY_DESCRIPTION, 32);
457 pInfo->libraryVersion.major = LIBRARY_VERSION_MAJOR;
458 pInfo->libraryVersion.minor = LIBRARY_VERSION_MINOR;
459
460 return (CKR_OK);
461 }
462
463 CK_RV
C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)464 C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)
465 {
466 if (ppFunctionList == NULL) {
467 return (CKR_ARGUMENTS_BAD);
468 }
469
470 *ppFunctionList = &functionList;
471
472 return (CKR_OK);
473 }
474
475 /*
476 * PKCS#11 states that C_GetFunctionStatus should always return
477 * CKR_FUNCTION_NOT_PARALLEL
478 */
479 /*ARGSUSED*/
480 CK_RV
C_GetFunctionStatus(CK_SESSION_HANDLE hSession)481 C_GetFunctionStatus(CK_SESSION_HANDLE hSession)
482 {
483 return (CKR_FUNCTION_NOT_PARALLEL);
484 }
485
486 /*
487 * PKCS#11 states that C_CancelFunction should always return
488 * CKR_FUNCTION_NOT_PARALLEL
489 */
490 /*ARGSUSED*/
491 CK_RV
C_CancelFunction(CK_SESSION_HANDLE hSession)492 C_CancelFunction(CK_SESSION_HANDLE hSession)
493 {
494 return (CKR_FUNCTION_NOT_PARALLEL);
495 }
496
497 /*
498 * Take out all mutexes before fork.
499 *
500 * Order:
501 * 1. soft_giant_mutex
502 * 2. soft_sessionlist_mutex
503 * 3. soft_slot.slot_mutex
504 * 4. soft_slot.keystore_mutex
505 * 5. token_session mutexes via soft_acquire_all_session_mutexes()
506 * 6. all soft_session_list mutexes via soft_acquire_all_session_mutexes()
507 * 7. obj_delay_freed.obj_to_be_free_mutex;
508 * 8. ses_delay_freed.ses_to_be_free_mutex
509 */
510 void
softtoken_fork_prepare()511 softtoken_fork_prepare()
512 {
513 (void) pthread_mutex_lock(&soft_giant_mutex);
514 if (softtoken_initialized) {
515 (void) pthread_mutex_lock(&soft_sessionlist_mutex);
516 (void) pthread_mutex_lock(&soft_slot.slot_mutex);
517 (void) pthread_mutex_lock(&soft_slot.keystore_mutex);
518 soft_acquire_all_session_mutexes(&token_session);
519 soft_acquire_all_session_mutexes(soft_session_list);
520 (void) pthread_mutex_lock(
521 &obj_delay_freed.obj_to_be_free_mutex);
522 (void) pthread_mutex_lock(
523 &ses_delay_freed.ses_to_be_free_mutex);
524 }
525 }
526
527 /*
528 * Release in opposite order to softtoken_fork_prepare().
529 * Function is used for parent and child.
530 */
531 void
softtoken_fork_after()532 softtoken_fork_after()
533 {
534 if (softtoken_initialized) {
535 (void) pthread_mutex_unlock(
536 &ses_delay_freed.ses_to_be_free_mutex);
537 (void) pthread_mutex_unlock(
538 &obj_delay_freed.obj_to_be_free_mutex);
539 soft_release_all_session_mutexes(soft_session_list);
540 soft_release_all_session_mutexes(&token_session);
541 (void) pthread_mutex_unlock(&soft_slot.keystore_mutex);
542 (void) pthread_mutex_unlock(&soft_slot.slot_mutex);
543 (void) pthread_mutex_unlock(&soft_sessionlist_mutex);
544 }
545 (void) pthread_mutex_unlock(&soft_giant_mutex);
546 }
547