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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2018, Joyent, Inc.
24 */
25
26 #include <crypt.h>
27 #include <cryptoutil.h>
28 #include <pwd.h>
29 #include <pthread.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <strings.h>
33 #include <sys/types.h>
34 #include <sys/sysmacros.h>
35 #include <security/cryptoki.h>
36 #include "softGlobal.h"
37 #include "softCrypt.h"
38 #include "softSession.h"
39 #include "softObject.h"
40 #include "softKeys.h"
41 #include "softKeystore.h"
42 #include "softKeystoreUtil.h"
43 #include "softMAC.h"
44 #include "softOps.h"
45
46 soft_session_t token_session;
47
48 /*
49 * soft_gen_hashed_pin()
50 *
51 * Arguments:
52 *
53 * pPin: pointer to caller provided Pin
54 * result: output argument which contains the address of the
55 * pointer to the hashed pin
56 * salt: input argument (if non-NULL), or
57 * output argument (if NULL):
58 * address of pointer to the "salt" of the hashed pin
59 *
60 * Description:
61 *
62 * Generate a hashed pin using system provided crypt(3C) function.
63 *
64 * Returns:
65 *
66 * 0: no error
67 * -1: some error occurred while generating the hashed pin
68 *
69 */
70 int
71 soft_gen_hashed_pin(CK_UTF8CHAR_PTR pPin, char **result, char **salt)
72 {
73
74 uid_t uid;
75 struct passwd pwd, *pw;
76 char pwdbuf[PWD_BUFFER_SIZE];
77 boolean_t new_salt = B_FALSE;
78
79 /*
80 * We need to get the passwd entry of the application, which is required
81 * by the crypt_gensalt() below.
82 */
83 uid = geteuid();
84 if (getpwuid_r(uid, &pwd, pwdbuf, PWD_BUFFER_SIZE, &pw) != 0) {
85 return (-1);
86 }
87
88 if (*salt == NULL) {
89 new_salt = B_TRUE;
90 /*
91 * crypt_gensalt() will allocate memory to store the new salt.
92 * on return. Pass "$5" here to default to crypt_sha256 since
93 * SHA256 is a FIPS 140-2 certified algorithm and we shouldn't
94 * assume the system default is that strong.
95 */
96 if ((*salt = crypt_gensalt("$5", pw)) == NULL) {
97 return (-1);
98 }
99 }
100
101 if ((*result = crypt((char *)pPin, *salt)) == NULL) {
102 if (new_salt) {
103 size_t saltlen = strlen(*salt) + 1;
104
105 freezero(*salt, saltlen);
106 }
107 return (-1);
108 }
109
110 return (0);
111 }
112
113 /*
114 * Authenticate user's PIN for C_Login.
115 */
116 CK_RV
117 soft_verify_pin(CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
118 {
119
120 char *user_cryptpin = NULL;
121 char *ks_cryptpin = NULL;
122 char *salt = NULL;
123 uchar_t *tmp_pin = NULL;
124 boolean_t pin_initialized = B_FALSE;
125 CK_RV rv = CKR_OK;
126 size_t len = 0;
127
128 /*
129 * Check to see if keystore is initialized.
130 */
131 rv = soft_keystore_pin_initialized(&pin_initialized, &ks_cryptpin,
132 B_FALSE);
133 if (rv != CKR_OK)
134 return (rv);
135
136 /*
137 * Authenticate user's PIN for C_Login.
138 */
139 if (pin_initialized) {
140
141 if (soft_keystore_get_pin_salt(&salt) < 0) {
142 rv = CKR_FUNCTION_FAILED;
143 goto cleanup;
144 }
145
146 /*
147 * Generate the hashed value based on the user's supplied pin.
148 */
149 tmp_pin = malloc(ulPinLen + 1);
150 if (tmp_pin == NULL) {
151 rv = CKR_HOST_MEMORY;
152 goto cleanup;
153 }
154
155 (void) memcpy(tmp_pin, pPin, ulPinLen);
156 tmp_pin[ulPinLen] = '\0';
157
158 if (soft_gen_hashed_pin(tmp_pin, &user_cryptpin, &salt) < 0) {
159 rv = CKR_FUNCTION_FAILED;
160 goto cleanup;
161 }
162
163 /*
164 * Compare hash value of the user supplied PIN with
165 * hash value of the keystore PIN.
166 */
167 if (strcmp(user_cryptpin, ks_cryptpin) != 0) {
168 rv = CKR_PIN_INCORRECT;
169 goto cleanup;
170 }
171
172 /*
173 * Provide the user's PIN to low-level keystore so that
174 * it can use it to generate encryption key as needed for
175 * encryption/decryption of the private objects in
176 * keystore.
177 */
178 if (soft_keystore_authpin(tmp_pin) != 0) {
179 rv = CKR_FUNCTION_FAILED;
180 } else {
181 rv = CKR_OK;
182 }
183 goto cleanup;
184 } else {
185 /*
186 * The PIN is not initialized in the keystore
187 * We will let it pass the authentication anyway but set the
188 * "userpin_change_needed" flag so that the application
189 * will get CKR_PIN_EXPIRED by other C_functions such as
190 * C_CreateObject, C_FindObjectInit, C_GenerateKey etc.
191 */
192 soft_slot.userpin_change_needed = 1;
193 rv = CKR_OK;
194 }
195
196 cleanup:
197 if (salt) {
198 len = strlen(salt) + 1;
199 freezero(salt, len);
200 }
201 if (tmp_pin) {
202 len = strlen((char *)tmp_pin) + 1;
203 freezero(tmp_pin, len);
204 }
205 if (ks_cryptpin) {
206 len = strlen(ks_cryptpin) + 1;
207 freezero(ks_cryptpin, len);
208 }
209 return (rv);
210 }
211
212 /*
213 * The second level C_SetPIN function.
214 */
215 CK_RV
216 soft_setpin(CK_UTF8CHAR_PTR pOldPin, CK_ULONG ulOldPinLen,
217 CK_UTF8CHAR_PTR pNewPin, CK_ULONG ulNewPinLen)
218 {
219
220 char *user_cryptpin = NULL;
221 char *ks_cryptpin = NULL;
222 char *salt = NULL;
223 boolean_t pin_initialized = B_FALSE;
224 uchar_t *tmp_old_pin = NULL, *tmp_new_pin = NULL;
225 CK_RV rv = CKR_OK;
226 size_t len = 0;
227
228 /*
229 * Check to see if keystore is initialized.
230 */
231 rv = soft_keystore_pin_initialized(&pin_initialized, &ks_cryptpin,
232 B_FALSE);
233 if (rv != CKR_OK)
234 return (rv);
235
236 /*
237 * Authenticate user's PIN for C_SetPIN.
238 */
239 if (pin_initialized) {
240 /*
241 * Generate the hashed value based on the user supplied PIN.
242 */
243 if (soft_keystore_get_pin_salt(&salt) < 0) {
244 rv = CKR_FUNCTION_FAILED;
245 goto cleanup;
246 }
247
248 tmp_old_pin = malloc(ulOldPinLen + 1);
249 if (tmp_old_pin == NULL) {
250 rv = CKR_HOST_MEMORY;
251 goto cleanup;
252 }
253 (void) memcpy(tmp_old_pin, pOldPin, ulOldPinLen);
254 tmp_old_pin[ulOldPinLen] = '\0';
255
256 if (soft_gen_hashed_pin(tmp_old_pin, &user_cryptpin,
257 &salt) < 0) {
258 rv = CKR_FUNCTION_FAILED;
259 goto cleanup;
260 }
261
262 /*
263 * Compare hashed value of the user supplied PIN with the
264 * hashed value of the keystore PIN.
265 */
266 if (strcmp(user_cryptpin, ks_cryptpin) != 0) {
267 rv = CKR_PIN_INCORRECT;
268 goto cleanup;
269 }
270 } else {
271 /*
272 * This is the first time to setpin, the oldpin must be
273 * "changeme".
274 */
275 if (strncmp("changeme", (const char *)pOldPin,
276 ulOldPinLen) != 0) {
277 rv = CKR_PIN_INCORRECT;
278 goto cleanup;
279 }
280 }
281
282 tmp_new_pin = malloc(ulNewPinLen + 1);
283 if (tmp_new_pin == NULL) {
284 rv = CKR_HOST_MEMORY;
285 goto cleanup;
286 }
287 (void) memcpy(tmp_new_pin, pNewPin, ulNewPinLen);
288 tmp_new_pin[ulNewPinLen] = '\0';
289
290 /*
291 * Set the new pin after the old pin is authenticated.
292 */
293 if (soft_keystore_setpin(tmp_old_pin, tmp_new_pin, B_FALSE)) {
294 rv = CKR_FUNCTION_FAILED;
295 goto cleanup;
296 } else {
297 (void) pthread_mutex_lock(&soft_giant_mutex);
298 soft_slot.userpin_change_needed = 0;
299 (void) pthread_mutex_unlock(&soft_giant_mutex);
300 rv = CKR_OK;
301 }
302
303 cleanup:
304 if (salt) {
305 len = strlen(salt) + 1;
306 freezero(salt, len);
307 }
308 if (ks_cryptpin) {
309 len = strlen(ks_cryptpin) + 1;
310 freezero(ks_cryptpin, len);
311 }
312 if (tmp_old_pin) {
313 len = strlen((char *)tmp_old_pin) + 1;
314 freezero(tmp_old_pin, len);
315 }
316 if (tmp_new_pin) {
317 len = strlen((char *)tmp_new_pin) + 1;
318 freezero(tmp_new_pin, len);
319 }
320
321 return (rv);
322 }
323
324 /*
325 * soft_keystore_pack_obj()
326 *
327 * Arguments:
328 *
329 * obj: pointer to the soft_object_t of the token object to
330 * be packed
331 * ks_buf: output argument which contains the address of the
332 * pointer to the buf of the packed token object
333 * soft_keystore_pack_obj() will allocate memory for the buf,
334 * it is caller's responsibility to free it.
335 * len: output argument which contains the address of the
336 * buffer length of the packed token object
337 *
338 * Description:
339 *
340 * Pack the in-core token object into the keystore format.
341 *
342 * Returns:
343 *
344 * CKR_OK: no error
345 * Other: some error occurred while packing the object
346 *
347 */
348 CK_RV
349 soft_keystore_pack_obj(soft_object_t *obj, uchar_t **ks_buf, size_t *len)
350 {
351 ks_obj_hdr_t hdr;
352 ks_attr_hdr_t attr_hdr;
353 CK_ATTRIBUTE_INFO_PTR extra_attr;
354 int num_attrs = 0;
355 ulong_t len_attrs = 0;
356 size_t ks_len;
357 uchar_t *buf, *buf1;
358 CK_RV rv;
359 int i;
360
361 (void) memset(&hdr, 0, sizeof (ks_obj_hdr_t));
362
363 /*
364 * The first part of the packed format contains
365 * the ks_obj_hdr_t struct.
366 */
367 hdr.class = SWAP64((uint64_t)obj->class);
368 hdr.key_type = SWAP64((uint64_t)obj->key_type);
369 hdr.cert_type = SWAP64((uint64_t)obj->cert_type);
370 hdr.bool_attr_mask = SWAP64(obj->bool_attr_mask);
371 hdr.mechanism = SWAP64((uint64_t)obj->mechanism);
372 hdr.object_type = obj->object_type;
373
374 /*
375 * The second part of the packed format contains
376 * the attributes from the extra atrribute list.
377 */
378 extra_attr = obj->extra_attrlistp;
379
380 while (extra_attr) {
381 num_attrs++;
382 len_attrs += ROUNDUP(extra_attr->attr.ulValueLen, 8);
383 extra_attr = extra_attr->next;
384 }
385 hdr.num_attrs = SWAP32(num_attrs);
386 ks_len = soft_pack_object_size(obj);
387 ks_len += sizeof (ks_obj_hdr_t) + len_attrs +
388 2 * num_attrs * sizeof (uint64_t);
389 buf = calloc(1, ks_len);
390 if (buf == NULL) {
391 return (CKR_HOST_MEMORY);
392 }
393 (void) memcpy(buf, &hdr, sizeof (ks_obj_hdr_t));
394 buf1 = buf + sizeof (ks_obj_hdr_t);
395 extra_attr = obj->extra_attrlistp;
396 for (i = 0; i < num_attrs; i++) {
397 attr_hdr.type = SWAP64((uint64_t)extra_attr->attr.type);
398 attr_hdr.ulValueLen =
399 SWAP64((uint64_t)extra_attr->attr.ulValueLen);
400 (void) memcpy(buf1, &attr_hdr, sizeof (ks_attr_hdr_t));
401 buf1 = buf1 + sizeof (ks_attr_hdr_t);
402 (void) memcpy(buf1, extra_attr->attr.pValue,
403 extra_attr->attr.ulValueLen);
404 buf1 = buf1 + ROUNDUP(extra_attr->attr.ulValueLen, 8);
405 extra_attr = extra_attr->next;
406 }
407
408 /*
409 * The third part of the packed format contains
410 * the key itself.
411 */
412 rv = soft_pack_object(obj, buf1);
413 *len = ks_len;
414 *ks_buf = buf;
415
416 return (rv);
417
418 }
419
420 /*
421 * soft_keystore_unpack_obj()
422 *
423 * Arguments:
424 *
425 * obj: pointer to the soft_object_t to store the unpacked
426 * token object
427 * ks_obj: input argument which contains the pointer to the
428 * ks_obj_t struct of packed token object to be unpacked
429 *
430 * Description:
431 *
432 * Unpack the token object in keystore format to in-core soft_object_t.
433 *
434 * Returns:
435 *
436 * CKR_OK: no error
437 * Other: some error occurred while unpacking the object
438 *
439 */
440 CK_RV
441 soft_keystore_unpack_obj(soft_object_t *obj, ks_obj_t *ks_obj)
442 {
443
444 CK_RV rv;
445 ks_obj_hdr_t *hdr;
446 ks_attr_hdr_t *attr_hdr;
447 CK_ATTRIBUTE template;
448 int i;
449 uchar_t *buf;
450
451 /*
452 * Unpack the common area.
453 */
454 (void) strcpy((char *)obj->ks_handle.name,
455 (char *)ks_obj->ks_handle.name);
456 obj->ks_handle.public = ks_obj->ks_handle.public;
457 /* LINTED: pointer alignment */
458 hdr = (ks_obj_hdr_t *)ks_obj->buf;
459 obj->version = ks_obj->obj_version;
460 obj->class = (CK_OBJECT_CLASS)(SWAP64(hdr->class));
461 obj->key_type = (CK_KEY_TYPE)(SWAP64(hdr->key_type));
462 obj->cert_type = (CK_CERTIFICATE_TYPE)(SWAP64(hdr->cert_type));
463 obj->bool_attr_mask = SWAP64(hdr->bool_attr_mask);
464 obj->mechanism = (CK_MECHANISM_TYPE)(SWAP64(hdr->mechanism));
465 obj->object_type = hdr->object_type;
466
467 /*
468 * Initialize other stuffs which were not from keystore.
469 */
470 (void) pthread_mutex_init(&obj->object_mutex, NULL);
471 obj->magic_marker = SOFTTOKEN_OBJECT_MAGIC;
472 obj->session_handle = (CK_SESSION_HANDLE)NULL;
473
474 buf = ks_obj->buf + sizeof (ks_obj_hdr_t);
475
476 /*
477 * Unpack extra attribute list.
478 */
479 for (i = 0; i < SWAP32(hdr->num_attrs); i++) {
480 /* LINTED: pointer alignment */
481 attr_hdr = (ks_attr_hdr_t *)buf;
482 (void) memset(&template, 0, sizeof (CK_ATTRIBUTE));
483 template.type = (CK_ATTRIBUTE_TYPE)(SWAP64(attr_hdr->type));
484 template.ulValueLen = (CK_ULONG)(SWAP64(attr_hdr->ulValueLen));
485 buf = buf + sizeof (ks_attr_hdr_t);
486 /* Allocate storage for the value of the attribute. */
487 if (template.ulValueLen > 0) {
488 template.pValue = malloc(template.ulValueLen);
489 if (template.pValue == NULL) {
490 return (CKR_HOST_MEMORY);
491 }
492 (void) memcpy(template.pValue, buf,
493 template.ulValueLen);
494 }
495
496 rv = soft_add_extra_attr(&template, obj);
497 freezero(template.pValue, template.ulValueLen);
498
499 if (rv != CKR_OK) {
500 return (rv);
501 }
502
503 buf = buf + ROUNDUP(template.ulValueLen, 8);
504 }
505
506 /*
507 * Unpack the key itself.
508 */
509 rv = soft_unpack_object(obj, buf);
510 return (rv);
511
512 }
513
514
515 /*
516 * soft_unpack_obj_attribute()
517 *
518 * Arguments:
519 *
520 * buf: contains the packed data (attributes) from keystore
521 * key_dest: the key attribute will be unpacked and save in key_dest
522 * cert_dest: the certificate attribute will be unpacked an
523 * in cert_dest
524 * offset: length of the current attribute occupies.
525 * The caller should use this returned "offset" to
526 * advance the buffer pointer to next attribute.
527 * cert: TRUE for certificate (use cert_dest)
528 * FALSE for key (use key_dest)
529 *
530 * Description:
531 *
532 * Unpack the attribute from keystore format to the big integer format.
533 *
534 * Returns:
535 *
536 * CKR_OK: no error
537 * Other: some error occurred while unpacking the object attribute
538 *
539 */
540 CK_RV
541 soft_unpack_obj_attribute(uchar_t *buf, biginteger_t *key_dest,
542 cert_attr_t **cert_dest, ulong_t *offset, boolean_t cert)
543 {
544
545 CK_RV rv;
546 CK_ATTRIBUTE template;
547
548 /* LINTED: pointer alignment */
549 template.ulValueLen = SWAP64(*(uint64_t *)buf);
550 buf = buf + sizeof (uint64_t);
551 template.pValue = malloc(template.ulValueLen);
552 if (template.pValue == NULL) {
553 return (CKR_HOST_MEMORY);
554 }
555
556 (void) memcpy(template.pValue, buf, template.ulValueLen);
557 if (cert) {
558 rv = get_cert_attr_from_template(cert_dest, &template);
559 } else {
560 rv = get_bigint_attr_from_template(key_dest, &template);
561 }
562
563 freezero(template.pValue, template.ulValueLen);
564 if (rv != CKR_OK) {
565 return (rv);
566 }
567
568 *offset = sizeof (uint64_t) + template.ulValueLen;
569 return (CKR_OK);
570 }
571
572
573 /*
574 * Calculate the total buffer length required to store the
575 * object key (the third part) in a keystore format.
576 */
577 ulong_t
578 soft_pack_object_size(soft_object_t *objp)
579 {
580
581 CK_OBJECT_CLASS class = objp->class;
582 CK_KEY_TYPE keytype = objp->key_type;
583 CK_CERTIFICATE_TYPE certtype = objp->cert_type;
584
585 switch (class) {
586 case CKO_PUBLIC_KEY:
587 switch (keytype) {
588 case CKK_RSA:
589 /*
590 * modulus_bits + modulus_len + modulus +
591 * pubexpo_len + pubexpo
592 */
593 return (ROUNDUP(((biginteger_t *)
594 OBJ_PUB_RSA_MOD(objp))->big_value_len, 8) +
595 ROUNDUP(((biginteger_t *)
596 OBJ_PUB_RSA_PUBEXPO(objp))->big_value_len, 8) +
597 3 * sizeof (uint64_t));
598
599 case CKK_DSA:
600 /*
601 * prime_len + prime + subprime_len + subprime +
602 * base_len + base + value_len + value
603 */
604 return (ROUNDUP(((biginteger_t *)
605 OBJ_PUB_DSA_PRIME(objp))->big_value_len, 8) +
606 ROUNDUP(((biginteger_t *)
607 OBJ_PUB_DSA_SUBPRIME(objp))->big_value_len, 8) +
608 ROUNDUP(((biginteger_t *)
609 OBJ_PUB_DSA_BASE(objp))->big_value_len, 8) +
610 ROUNDUP(((biginteger_t *)
611 OBJ_PUB_DSA_VALUE(objp))->big_value_len, 8) +
612 4 * sizeof (uint64_t));
613 case CKK_EC:
614 /*
615 * ec_point_len + ec_point
616 */
617 return (ROUNDUP(((biginteger_t *)
618 OBJ_PUB_EC_POINT(objp))->big_value_len, 8) +
619 sizeof (uint64_t));
620 case CKK_DH:
621 /*
622 * prime_len + prime + base_len + base +
623 * value_len + value
624 */
625 return (ROUNDUP(((biginteger_t *)
626 OBJ_PUB_DH_PRIME(objp))->big_value_len, 8) +
627 ROUNDUP(((biginteger_t *)
628 OBJ_PUB_DH_BASE(objp))->big_value_len, 8) +
629 ROUNDUP(((biginteger_t *)
630 OBJ_PUB_DH_VALUE(objp))->big_value_len, 8) +
631 3 * sizeof (uint64_t));
632
633 case CKK_X9_42_DH:
634 /*
635 * prime_len + prime + base_len + base +
636 * subprime_len + subprime + value_len + value
637 */
638 return (ROUNDUP(((biginteger_t *)
639 OBJ_PUB_DH942_PRIME(objp))->big_value_len, 8) +
640 ROUNDUP(((biginteger_t *)
641 OBJ_PUB_DH942_BASE(objp))->big_value_len, 8) +
642 ROUNDUP(((biginteger_t *)
643 OBJ_PUB_DH942_SUBPRIME(objp))->big_value_len, 8) +
644 ROUNDUP(((biginteger_t *)
645 OBJ_PUB_DH942_VALUE(objp))->big_value_len, 8) +
646 4 * sizeof (uint64_t));
647 } /* keytype */
648
649 break;
650
651 case CKO_PRIVATE_KEY:
652 switch (keytype) {
653 case CKK_RSA:
654 /*
655 * modulus_len + modulus + pubexpo_len + pubexpo +
656 * priexpo_len + priexpo + prime1_len + prime1 +
657 * prime2_len + prime2 + expo1_len + expo1 +
658 * expo2_len + expo2 + coef_len + coef
659 */
660 return (ROUNDUP(((biginteger_t *)
661 OBJ_PRI_RSA_MOD(objp))->big_value_len, 8) +
662 ROUNDUP(((biginteger_t *)
663 OBJ_PRI_RSA_PUBEXPO(objp))->big_value_len, 8) +
664 ROUNDUP(((biginteger_t *)
665 OBJ_PRI_RSA_PRIEXPO(objp))->big_value_len, 8) +
666 ROUNDUP(((biginteger_t *)
667 OBJ_PRI_RSA_PRIME1(objp))->big_value_len, 8) +
668 ROUNDUP(((biginteger_t *)
669 OBJ_PRI_RSA_PRIME2(objp))->big_value_len, 8) +
670 ROUNDUP(((biginteger_t *)
671 OBJ_PRI_RSA_EXPO1(objp))->big_value_len, 8) +
672 ROUNDUP(((biginteger_t *)
673 OBJ_PRI_RSA_EXPO2(objp))->big_value_len, 8) +
674 ROUNDUP(((biginteger_t *)
675 OBJ_PRI_RSA_COEF(objp))->big_value_len, 8) +
676 8 * sizeof (uint64_t));
677
678 case CKK_DSA:
679 /*
680 * prime_len + prime + subprime_len + subprime +
681 * base_len + base + value_len + value
682 */
683 return (ROUNDUP(((biginteger_t *)
684 OBJ_PRI_DSA_PRIME(objp))->big_value_len, 8) +
685 ROUNDUP(((biginteger_t *)
686 OBJ_PRI_DSA_SUBPRIME(objp))->big_value_len, 8) +
687 ROUNDUP(((biginteger_t *)
688 OBJ_PRI_DSA_BASE(objp))->big_value_len, 8) +
689 ROUNDUP(((biginteger_t *)
690 OBJ_PRI_DSA_VALUE(objp))->big_value_len, 8) +
691 4 * sizeof (uint64_t));
692
693 case CKK_DH:
694 /*
695 * value_bits + prime_len + prime + base_len + base +
696 * value_len + value
697 */
698 return (ROUNDUP(((biginteger_t *)
699 OBJ_PRI_DH_PRIME(objp))->big_value_len, 8) +
700 ROUNDUP(((biginteger_t *)
701 OBJ_PRI_DH_BASE(objp))->big_value_len, 8) +
702 ROUNDUP(((biginteger_t *)
703 OBJ_PRI_DH_VALUE(objp))->big_value_len, 8) +
704 4 * sizeof (uint64_t));
705
706 case CKK_EC:
707 /*
708 * value_len + value
709 */
710 return (ROUNDUP(((biginteger_t *)
711 OBJ_PRI_EC_VALUE(objp))->big_value_len, 8) +
712 sizeof (uint64_t));
713
714 case CKK_X9_42_DH:
715 /*
716 * prime_len + prime + base_len + base +
717 * subprime_len + subprime + value_len + value
718 */
719 return (ROUNDUP(((biginteger_t *)
720 OBJ_PRI_DH942_PRIME(objp))->big_value_len, 8) +
721 ROUNDUP(((biginteger_t *)
722 OBJ_PRI_DH942_BASE(objp))->big_value_len, 8) +
723 ROUNDUP(((biginteger_t *)
724 OBJ_PRI_DH942_SUBPRIME(objp))->big_value_len, 8) +
725 ROUNDUP(((biginteger_t *)
726 OBJ_PRI_DH942_VALUE(objp))->big_value_len, 8) +
727 4 * sizeof (uint64_t));
728
729 } /* keytype */
730
731 break;
732
733 case CKO_SECRET_KEY:
734 /*
735 * value_len + value
736 */
737 return (ROUNDUP(OBJ_SEC_VALUE_LEN(objp), 8) +
738 sizeof (uint64_t));
739
740 case CKO_CERTIFICATE:
741 switch (certtype) {
742 case CKC_X_509:
743 /*
744 * subject_len + subject + value_len + value
745 */
746 return (ROUNDUP(((cert_attr_t *)
747 X509_CERT_SUBJECT(objp))->length, 8) +
748 ROUNDUP(((cert_attr_t *)
749 X509_CERT_VALUE(objp))->length, 8) +
750 2 * sizeof (uint64_t));
751
752 case CKC_X_509_ATTR_CERT:
753 /*
754 * owner_len + owner + value_len + value
755 */
756 return (ROUNDUP(((cert_attr_t *)
757 X509_ATTR_CERT_OWNER(objp))->length, 8) +
758 ROUNDUP(((cert_attr_t *)
759 X509_ATTR_CERT_VALUE(objp))->length, 8) +
760 2 * sizeof (uint64_t));
761 }
762 return (0);
763
764 case CKO_DOMAIN_PARAMETERS:
765
766 return (0);
767 }
768 return (0);
769 }
770
771 /*
772 * Pack the object key (the third part) from the soft_object_t
773 * into the keystore format.
774 */
775 CK_RV
776 soft_pack_object(soft_object_t *objp, uchar_t *buf)
777 {
778
779 CK_OBJECT_CLASS class = objp->class;
780 CK_KEY_TYPE keytype = objp->key_type;
781 CK_CERTIFICATE_TYPE certtype = objp->cert_type;
782 uint64_t tmp_val;
783
784 switch (class) {
785 case CKO_PUBLIC_KEY:
786 switch (keytype) {
787 case CKK_RSA:
788 /* modulus_bits */
789 tmp_val = SWAP64((uint64_t)OBJ_PUB_RSA_MOD_BITS(objp));
790 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
791 buf = buf + sizeof (uint64_t);
792
793 /* modulus_len + modulus */
794 tmp_val = SWAP64((uint64_t)(((biginteger_t *)
795 OBJ_PUB_RSA_MOD(objp))->big_value_len));
796 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
797 buf = buf + sizeof (uint64_t);
798
799 (void) memcpy(buf, (char *)(((biginteger_t *)
800 OBJ_PUB_RSA_MOD(objp))->big_value),
801 ((biginteger_t *)
802 OBJ_PUB_RSA_MOD(objp))->big_value_len);
803 buf = buf + ROUNDUP(((biginteger_t *)
804 OBJ_PUB_RSA_MOD(objp))->big_value_len, 8);
805
806 /* pubexpo_len + pubexpo */
807 tmp_val = SWAP64((uint64_t)((biginteger_t *)
808 OBJ_PUB_RSA_PUBEXPO(objp))->big_value_len);
809 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
810 buf = buf + sizeof (uint64_t);
811
812 (void) memcpy(buf, (char *)(((biginteger_t *)
813 OBJ_PUB_RSA_PUBEXPO(objp))->big_value),
814 ((biginteger_t *)
815 OBJ_PUB_RSA_PUBEXPO(objp))->big_value_len);
816 break;
817
818 case CKK_DSA:
819 /* prime_len + prime */
820 tmp_val = SWAP64((uint64_t)((biginteger_t *)
821 OBJ_PUB_DSA_PRIME(objp))->big_value_len);
822 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
823 buf = buf + sizeof (uint64_t);
824
825 (void) memcpy(buf, (char *)((biginteger_t *)
826 OBJ_PUB_DSA_PRIME(objp))->big_value,
827 ((biginteger_t *)
828 OBJ_PUB_DSA_PRIME(objp))->big_value_len);
829 buf = buf + ROUNDUP(((biginteger_t *)
830 OBJ_PUB_DSA_PRIME(objp))->big_value_len, 8);
831
832 /* subprime_len + subprime */
833 tmp_val = SWAP64((uint64_t)((biginteger_t *)
834 OBJ_PUB_DSA_SUBPRIME(objp))->big_value_len);
835 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
836 buf = buf + sizeof (uint64_t);
837
838 (void) memcpy(buf, (char *)((biginteger_t *)
839 OBJ_PUB_DSA_SUBPRIME(objp))->big_value,
840 ((biginteger_t *)
841 OBJ_PUB_DSA_SUBPRIME(objp))->big_value_len);
842 buf = buf + ROUNDUP(((biginteger_t *)
843 OBJ_PUB_DSA_SUBPRIME(objp))->big_value_len, 8);
844
845 /* base_len + base */
846 tmp_val = SWAP64((uint64_t)((biginteger_t *)
847 OBJ_PUB_DSA_BASE(objp))->big_value_len);
848 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
849 buf = buf + sizeof (uint64_t);
850
851 (void) memcpy(buf, (char *)((biginteger_t *)
852 OBJ_PUB_DSA_BASE(objp))->big_value,
853 ((biginteger_t *)
854 OBJ_PUB_DSA_BASE(objp))->big_value_len);
855 buf = buf + ROUNDUP(((biginteger_t *)
856 OBJ_PUB_DSA_BASE(objp))->big_value_len, 8);
857
858 /* value_len + value */
859 tmp_val = SWAP64((uint64_t)((biginteger_t *)
860 OBJ_PUB_DSA_VALUE(objp))->big_value_len);
861 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
862 buf = buf + sizeof (uint64_t);
863
864 (void) memcpy(buf, (char *)((biginteger_t *)
865 OBJ_PUB_DSA_VALUE(objp))->big_value,
866 ((biginteger_t *)
867 OBJ_PUB_DSA_VALUE(objp))->big_value_len);
868
869 break;
870 case CKK_EC:
871 /* point_len + point */
872 tmp_val = SWAP64((uint64_t)((biginteger_t *)
873 OBJ_PUB_EC_POINT(objp))->big_value_len);
874 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
875 buf = buf + sizeof (uint64_t);
876
877 (void) memcpy(buf, (char *)((biginteger_t *)
878 OBJ_PUB_EC_POINT(objp))->big_value,
879 ((biginteger_t *)
880 OBJ_PUB_EC_POINT(objp))->big_value_len);
881 break;
882
883 case CKK_DH:
884 /* prime_len + prime */
885 tmp_val = SWAP64((uint64_t)((biginteger_t *)
886 OBJ_PUB_DH_PRIME(objp))->big_value_len);
887 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
888 buf = buf + sizeof (uint64_t);
889
890 (void) memcpy(buf, (char *)((biginteger_t *)
891 OBJ_PUB_DH_PRIME(objp))->big_value,
892 ((biginteger_t *)
893 OBJ_PUB_DH_PRIME(objp))->big_value_len);
894 buf = buf + ROUNDUP(((biginteger_t *)
895 OBJ_PUB_DH_PRIME(objp))->big_value_len, 8);
896
897 /* base_len + base */
898 tmp_val = SWAP64((uint64_t)((biginteger_t *)
899 OBJ_PUB_DH_BASE(objp))->big_value_len);
900 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
901 buf = buf + sizeof (uint64_t);
902
903 (void) memcpy(buf, (char *)((biginteger_t *)
904 OBJ_PUB_DH_BASE(objp))->big_value,
905 ((biginteger_t *)
906 OBJ_PUB_DH_BASE(objp))->big_value_len);
907 buf = buf + ROUNDUP(((biginteger_t *)
908 OBJ_PUB_DH_BASE(objp))->big_value_len, 8);
909
910 /* value_len + value */
911 tmp_val = SWAP64((uint64_t)((biginteger_t *)
912 OBJ_PUB_DH_VALUE(objp))->big_value_len);
913 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
914 buf = buf + sizeof (uint64_t);
915
916 (void) memcpy(buf, (char *)((biginteger_t *)
917 OBJ_PUB_DH_VALUE(objp))->big_value,
918 ((biginteger_t *)
919 OBJ_PUB_DH_VALUE(objp))->big_value_len);
920
921 break;
922
923 case CKK_X9_42_DH:
924 /* prime_len + prime */
925 tmp_val = SWAP64((uint64_t)((biginteger_t *)
926 OBJ_PUB_DH942_PRIME(objp))->big_value_len);
927 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
928 buf = buf + sizeof (uint64_t);
929
930 (void) memcpy(buf, (char *)((biginteger_t *)
931 OBJ_PUB_DH942_PRIME(objp))->big_value,
932 ((biginteger_t *)
933 OBJ_PUB_DH942_PRIME(objp))->big_value_len);
934 buf = buf + ROUNDUP(((biginteger_t *)
935 OBJ_PUB_DH942_PRIME(objp))->big_value_len, 8);
936
937 /* base_len + base */
938 tmp_val = SWAP64((uint64_t)((biginteger_t *)
939 OBJ_PUB_DH942_BASE(objp))->big_value_len);
940 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
941 buf = buf + sizeof (uint64_t);
942
943 (void) memcpy(buf, (char *)((biginteger_t *)
944 OBJ_PUB_DH942_BASE(objp))->big_value,
945 ((biginteger_t *)
946 OBJ_PUB_DH942_BASE(objp))->big_value_len);
947 buf = buf + ROUNDUP(((biginteger_t *)
948 OBJ_PUB_DH942_BASE(objp))->big_value_len, 8);
949
950 /* subprime_len + subprime */
951 tmp_val = SWAP64((uint64_t)((biginteger_t *)
952 OBJ_PUB_DH942_SUBPRIME(objp))->big_value_len);
953 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
954 buf = buf + sizeof (uint64_t);
955
956 (void) memcpy(buf, (char *)((biginteger_t *)
957 OBJ_PUB_DH942_SUBPRIME(objp))->big_value,
958 ((biginteger_t *)
959 OBJ_PUB_DH942_SUBPRIME(objp))->big_value_len);
960 buf = buf + ROUNDUP(((biginteger_t *)
961 OBJ_PUB_DH942_SUBPRIME(objp))->big_value_len, 8);
962
963 /* value_len + value */
964 tmp_val = SWAP64((uint64_t)((biginteger_t *)
965 OBJ_PUB_DH942_VALUE(objp))->big_value_len);
966 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
967 buf = buf + sizeof (uint64_t);
968
969 (void) memcpy(buf, (char *)((biginteger_t *)
970 OBJ_PUB_DH942_VALUE(objp))->big_value,
971 ((biginteger_t *)
972 OBJ_PUB_DH942_VALUE(objp))->big_value_len);
973
974 break;
975 } /* keytype */
976
977 break;
978
979 case CKO_PRIVATE_KEY:
980 switch (keytype) {
981 case CKK_RSA:
982 /* modulus_len + modulus */
983 tmp_val = SWAP64((uint64_t)((biginteger_t *)
984 OBJ_PRI_RSA_MOD(objp))->big_value_len);
985 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
986 buf = buf + sizeof (uint64_t);
987
988 (void) memcpy(buf, (char *)((biginteger_t *)
989 OBJ_PRI_RSA_MOD(objp))->big_value,
990 ((biginteger_t *)
991 OBJ_PRI_RSA_MOD(objp))->big_value_len);
992 buf = buf + ROUNDUP(((biginteger_t *)
993 OBJ_PRI_RSA_MOD(objp))->big_value_len, 8);
994
995 /* pubexpo_len + pubexpo */
996 tmp_val = SWAP64((uint64_t)((biginteger_t *)
997 OBJ_PRI_RSA_PUBEXPO(objp))->big_value_len);
998 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
999 buf = buf + sizeof (uint64_t);
1000
1001 (void) memcpy(buf, (char *)((biginteger_t *)
1002 OBJ_PRI_RSA_PUBEXPO(objp))->big_value,
1003 ((biginteger_t *)
1004 OBJ_PRI_RSA_PUBEXPO(objp))->big_value_len);
1005 buf = buf + ROUNDUP(((biginteger_t *)
1006 OBJ_PRI_RSA_PUBEXPO(objp))->big_value_len, 8);
1007
1008 /* priexpo_len + priexpo */
1009 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1010 OBJ_PRI_RSA_PRIEXPO(objp))->big_value_len);
1011 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1012 buf = buf + sizeof (uint64_t);
1013
1014 (void) memcpy(buf, (char *)((biginteger_t *)
1015 OBJ_PRI_RSA_PRIEXPO(objp))->big_value,
1016 ((biginteger_t *)
1017 OBJ_PRI_RSA_PRIEXPO(objp))->big_value_len);
1018 buf = buf + ROUNDUP(((biginteger_t *)
1019 OBJ_PRI_RSA_PRIEXPO(objp))->big_value_len, 8);
1020
1021 /* prime1_len + prime1 */
1022 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1023 OBJ_PRI_RSA_PRIME1(objp))->big_value_len);
1024 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1025 buf = buf + sizeof (uint64_t);
1026
1027 (void) memcpy(buf, (char *)((biginteger_t *)
1028 OBJ_PRI_RSA_PRIME1(objp))->big_value,
1029 ((biginteger_t *)
1030 OBJ_PRI_RSA_PRIME1(objp))->big_value_len);
1031 buf = buf + ROUNDUP(((biginteger_t *)
1032 OBJ_PRI_RSA_PRIME1(objp))->big_value_len, 8);
1033
1034 /* prime2_len + prime2 */
1035 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1036 OBJ_PRI_RSA_PRIME2(objp))->big_value_len);
1037 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1038 buf = buf + sizeof (uint64_t);
1039
1040 (void) memcpy(buf, (char *)((biginteger_t *)
1041 OBJ_PRI_RSA_PRIME2(objp))->big_value,
1042 ((biginteger_t *)
1043 OBJ_PRI_RSA_PRIME2(objp))->big_value_len);
1044 buf = buf + ROUNDUP(((biginteger_t *)
1045 OBJ_PRI_RSA_PRIME2(objp))->big_value_len, 8);
1046
1047 /* expo1_len + expo1 */
1048 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1049 OBJ_PRI_RSA_EXPO1(objp))->big_value_len);
1050 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1051 buf = buf + sizeof (uint64_t);
1052
1053 (void) memcpy(buf, (char *)((biginteger_t *)
1054 OBJ_PRI_RSA_EXPO1(objp))->big_value,
1055 ((biginteger_t *)
1056 OBJ_PRI_RSA_EXPO1(objp))->big_value_len);
1057 buf = buf + ROUNDUP(((biginteger_t *)
1058 OBJ_PRI_RSA_EXPO1(objp))->big_value_len, 8);
1059
1060 /* expo2_len + expo2 */
1061 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1062 OBJ_PRI_RSA_EXPO2(objp))->big_value_len);
1063 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1064 buf = buf + sizeof (uint64_t);
1065
1066 (void) memcpy(buf, (char *)((biginteger_t *)
1067 OBJ_PRI_RSA_EXPO2(objp))->big_value,
1068 ((biginteger_t *)
1069 OBJ_PRI_RSA_EXPO2(objp))->big_value_len);
1070 buf = buf + ROUNDUP(((biginteger_t *)
1071 OBJ_PRI_RSA_EXPO2(objp))->big_value_len, 8);
1072
1073 /* coef_len + coef */
1074 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1075 OBJ_PRI_RSA_COEF(objp))->big_value_len);
1076 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1077 buf = buf + sizeof (uint64_t);
1078
1079 (void) memcpy(buf, (char *)((biginteger_t *)
1080 OBJ_PRI_RSA_COEF(objp))->big_value,
1081 ((biginteger_t *)
1082 OBJ_PRI_RSA_COEF(objp))->big_value_len);
1083 buf = buf + ROUNDUP(((biginteger_t *)
1084 OBJ_PRI_RSA_COEF(objp))->big_value_len, 8);
1085
1086 break;
1087
1088 case CKK_DSA:
1089 /* prime_len + prime */
1090 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1091 OBJ_PRI_DSA_PRIME(objp))->big_value_len);
1092 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1093 buf = buf + sizeof (uint64_t);
1094
1095 (void) memcpy(buf, (char *)((biginteger_t *)
1096 OBJ_PRI_DSA_PRIME(objp))->big_value,
1097 ((biginteger_t *)
1098 OBJ_PRI_DSA_PRIME(objp))->big_value_len);
1099 buf = buf + ROUNDUP(((biginteger_t *)
1100 OBJ_PRI_DSA_PRIME(objp))->big_value_len, 8);
1101
1102 /* subprime_len + subprime */
1103 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1104 OBJ_PRI_DSA_SUBPRIME(objp))->big_value_len);
1105 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1106 buf = buf + sizeof (uint64_t);
1107
1108 (void) memcpy(buf, (char *)((biginteger_t *)
1109 OBJ_PRI_DSA_SUBPRIME(objp))->big_value,
1110 ((biginteger_t *)
1111 OBJ_PRI_DSA_SUBPRIME(objp))->big_value_len);
1112 buf = buf + ROUNDUP(((biginteger_t *)
1113 OBJ_PRI_DSA_SUBPRIME(objp))->big_value_len, 8);
1114
1115 /* base_len + base */
1116 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1117 OBJ_PRI_DSA_BASE(objp))->big_value_len);
1118 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1119 buf = buf + sizeof (uint64_t);
1120
1121 (void) memcpy(buf, (char *)((biginteger_t *)
1122 OBJ_PRI_DSA_BASE(objp))->big_value,
1123 ((biginteger_t *)
1124 OBJ_PRI_DSA_BASE(objp))->big_value_len);
1125 buf = buf + ROUNDUP(((biginteger_t *)
1126 OBJ_PRI_DSA_BASE(objp))->big_value_len, 8);
1127
1128 /* value_len + value */
1129 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1130 OBJ_PRI_DSA_VALUE(objp))->big_value_len);
1131 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1132 buf = buf + sizeof (uint64_t);
1133
1134 (void) memcpy(buf, (char *)((biginteger_t *)
1135 OBJ_PRI_DSA_VALUE(objp))->big_value,
1136 ((biginteger_t *)
1137 OBJ_PRI_DSA_VALUE(objp))->big_value_len);
1138
1139 break;
1140 case CKK_EC:
1141 /* value_len + value */
1142 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1143 OBJ_PRI_EC_VALUE(objp))->big_value_len);
1144 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1145 buf = buf + sizeof (uint64_t);
1146
1147 (void) memcpy(buf, (char *)((biginteger_t *)
1148 OBJ_PRI_EC_VALUE(objp))->big_value,
1149 ((biginteger_t *)
1150 OBJ_PRI_EC_VALUE(objp))->big_value_len);
1151 break;
1152
1153 case CKK_DH:
1154 /* value_bits */
1155 tmp_val = SWAP64((uint64_t)OBJ_PRI_DH_VAL_BITS(objp));
1156 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1157 buf = buf + sizeof (uint64_t);
1158
1159 /* prime_len + prime */
1160 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1161 OBJ_PRI_DH_PRIME(objp))->big_value_len);
1162 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1163 buf = buf + sizeof (uint64_t);
1164
1165 (void) memcpy(buf, (char *)((biginteger_t *)
1166 OBJ_PRI_DH_PRIME(objp))->big_value,
1167 ((biginteger_t *)
1168 OBJ_PRI_DH_PRIME(objp))->big_value_len);
1169 buf = buf + ROUNDUP(((biginteger_t *)
1170 OBJ_PRI_DH_PRIME(objp))->big_value_len, 8);
1171
1172 /* base_len + base */
1173 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1174 OBJ_PRI_DH_BASE(objp))->big_value_len);
1175 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1176 buf = buf + sizeof (uint64_t);
1177
1178 (void) memcpy(buf, (char *)((biginteger_t *)
1179 OBJ_PRI_DH_BASE(objp))->big_value,
1180 ((biginteger_t *)
1181 OBJ_PRI_DH_BASE(objp))->big_value_len);
1182 buf = buf + ROUNDUP(((biginteger_t *)
1183 OBJ_PRI_DH_BASE(objp))->big_value_len, 8);
1184
1185 /* value_len + value */
1186 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1187 OBJ_PRI_DH_VALUE(objp))->big_value_len);
1188 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1189 buf = buf + sizeof (uint64_t);
1190
1191 (void) memcpy(buf, (char *)((biginteger_t *)
1192 OBJ_PRI_DH_VALUE(objp))->big_value,
1193 ((biginteger_t *)
1194 OBJ_PRI_DH_VALUE(objp))->big_value_len);
1195
1196 break;
1197
1198 case CKK_X9_42_DH:
1199 /* prime_len + prime */
1200 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1201 OBJ_PRI_DH942_PRIME(objp))->big_value_len);
1202 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1203 buf = buf + sizeof (uint64_t);
1204
1205 (void) memcpy(buf, (char *)((biginteger_t *)
1206 OBJ_PRI_DH942_PRIME(objp))->big_value,
1207 ((biginteger_t *)
1208 OBJ_PRI_DH942_PRIME(objp))->big_value_len);
1209 buf = buf + ROUNDUP(((biginteger_t *)
1210 OBJ_PRI_DH942_PRIME(objp))->big_value_len, 8);
1211
1212 /* base_len + base */
1213 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1214 OBJ_PRI_DH942_BASE(objp))->big_value_len);
1215 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1216 buf = buf + sizeof (uint64_t);
1217
1218 (void) memcpy(buf, (char *)((biginteger_t *)
1219 OBJ_PRI_DH942_BASE(objp))->big_value,
1220 ((biginteger_t *)
1221 OBJ_PRI_DH942_BASE(objp))->big_value_len);
1222 buf = buf + ROUNDUP(((biginteger_t *)
1223 OBJ_PRI_DH942_BASE(objp))->big_value_len, 8);
1224
1225 /* subprime_len + subprime */
1226 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1227 OBJ_PRI_DH942_SUBPRIME(objp))->big_value_len);
1228 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1229 buf = buf + sizeof (uint64_t);
1230
1231 (void) memcpy(buf, (char *)((biginteger_t *)
1232 OBJ_PRI_DH942_SUBPRIME(objp))->big_value,
1233 ((biginteger_t *)
1234 OBJ_PRI_DH942_SUBPRIME(objp))->big_value_len);
1235 buf = buf + ROUNDUP(((biginteger_t *)
1236 OBJ_PRI_DH942_SUBPRIME(objp))->big_value_len, 8);
1237
1238 /* value_len + value */
1239 tmp_val = SWAP64((uint64_t)((biginteger_t *)
1240 OBJ_PRI_DH942_VALUE(objp))->big_value_len);
1241 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1242 buf = buf + sizeof (uint64_t);
1243
1244 (void) memcpy(buf, (char *)((biginteger_t *)
1245 OBJ_PRI_DH942_VALUE(objp))->big_value,
1246 ((biginteger_t *)
1247 OBJ_PRI_DH942_VALUE(objp))->big_value_len);
1248
1249 break;
1250
1251 } /* keytype */
1252
1253 break;
1254
1255 case CKO_SECRET_KEY:
1256 /* value_len + value */
1257 tmp_val = SWAP64((uint64_t)OBJ_SEC_VALUE_LEN(objp));
1258 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1259 buf = buf + sizeof (uint64_t);
1260
1261 if (OBJ_SEC_VALUE_LEN(objp) > 0) {
1262 (void) memcpy(buf, (char *)OBJ_SEC_VALUE(objp),
1263 OBJ_SEC_VALUE_LEN(objp));
1264 buf = buf + ROUNDUP(OBJ_SEC_VALUE_LEN(objp), 8);
1265 }
1266
1267 break;
1268
1269 case CKO_CERTIFICATE:
1270
1271 switch (certtype) {
1272 case CKC_X_509:
1273 /* subject_len + subject */
1274 tmp_val = SWAP64((uint64_t)(((cert_attr_t *)
1275 X509_CERT_SUBJECT(objp))->length));
1276 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1277 buf = buf + sizeof (uint64_t);
1278
1279 (void) memcpy(buf, (char *)((cert_attr_t *)
1280 X509_CERT_SUBJECT(objp))->value,
1281 ((cert_attr_t *)
1282 X509_CERT_SUBJECT(objp))->length);
1283 buf = buf + ROUNDUP(((cert_attr_t *)
1284 X509_CERT_SUBJECT(objp))->length, 8);
1285
1286 /* value_len + value */
1287 tmp_val = SWAP64((uint64_t)(((cert_attr_t *)
1288 X509_CERT_VALUE(objp))->length));
1289 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1290 buf = buf + sizeof (uint64_t);
1291
1292 (void) memcpy(buf, (char *)((cert_attr_t *)
1293 X509_CERT_VALUE(objp))->value,
1294 ((cert_attr_t *)
1295 X509_CERT_VALUE(objp))->length);
1296 break;
1297
1298 case CKC_X_509_ATTR_CERT:
1299 /* owner_len + owner */
1300 tmp_val = SWAP64((uint64_t)(((cert_attr_t *)
1301 X509_ATTR_CERT_OWNER(objp))->length));
1302 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1303 buf = buf + sizeof (uint64_t);
1304
1305 (void) memcpy(buf, (char *)((cert_attr_t *)
1306 X509_ATTR_CERT_OWNER(objp))->value,
1307 ((cert_attr_t *)
1308 X509_ATTR_CERT_OWNER(objp))->length);
1309 buf = buf + ROUNDUP(((cert_attr_t *)
1310 X509_ATTR_CERT_OWNER(objp))->length, 8);
1311
1312 /* value_len + value */
1313 tmp_val = SWAP64((uint64_t)(((cert_attr_t *)
1314 X509_ATTR_CERT_VALUE(objp))->length));
1315 (void) memcpy(buf, (char *)&tmp_val, sizeof (uint64_t));
1316 buf = buf + sizeof (uint64_t);
1317
1318 (void) memcpy(buf, (char *)((cert_attr_t *)
1319 X509_ATTR_CERT_VALUE(objp))->value,
1320 ((cert_attr_t *)
1321 X509_ATTR_CERT_VALUE(objp))->length);
1322 break;
1323 }
1324 break;
1325
1326 case CKO_DOMAIN_PARAMETERS:
1327
1328 return (0);
1329 }
1330 return (CKR_OK);
1331 }
1332
1333 /*
1334 * Unpack the object key in keystore format (the third part)
1335 * into soft_object_t.
1336 */
1337 CK_RV
1338 soft_unpack_object(soft_object_t *objp, uchar_t *buf)
1339 {
1340
1341 public_key_obj_t *pbk;
1342 private_key_obj_t *pvk;
1343 secret_key_obj_t *sck;
1344 certificate_obj_t *cert;
1345 CK_OBJECT_CLASS class = objp->class;
1346 CK_KEY_TYPE keytype = objp->key_type;
1347 CK_CERTIFICATE_TYPE certtype = objp->cert_type;
1348
1349 biginteger_t modulus;
1350 biginteger_t pubexpo;
1351 biginteger_t prime;
1352 biginteger_t subprime;
1353 biginteger_t base;
1354 biginteger_t value;
1355
1356 biginteger_t priexpo;
1357 biginteger_t prime1;
1358 biginteger_t prime2;
1359 biginteger_t expo1;
1360 biginteger_t expo2;
1361 biginteger_t coef;
1362 CK_RV rv = CKR_OK;
1363 ulong_t offset = 0;
1364 uint64_t tmp_val;
1365
1366 /* prevent bigint_attr_cleanup from freeing invalid attr value */
1367 (void) memset(&modulus, 0x0, sizeof (biginteger_t));
1368 (void) memset(&pubexpo, 0x0, sizeof (biginteger_t));
1369 (void) memset(&prime, 0x0, sizeof (biginteger_t));
1370 (void) memset(&subprime, 0x0, sizeof (biginteger_t));
1371 (void) memset(&base, 0x0, sizeof (biginteger_t));
1372 (void) memset(&value, 0x0, sizeof (biginteger_t));
1373
1374 (void) memset(&priexpo, 0x0, sizeof (biginteger_t));
1375 (void) memset(&prime1, 0x0, sizeof (biginteger_t));
1376 (void) memset(&prime2, 0x0, sizeof (biginteger_t));
1377 (void) memset(&expo1, 0x0, sizeof (biginteger_t));
1378 (void) memset(&expo2, 0x0, sizeof (biginteger_t));
1379 (void) memset(&coef, 0x0, sizeof (biginteger_t));
1380
1381 switch (class) {
1382
1383 case CKO_PUBLIC_KEY:
1384 /* Allocate storage for Public Key Object. */
1385 pbk = calloc(1, sizeof (public_key_obj_t));
1386 if (pbk == NULL) {
1387 rv = CKR_HOST_MEMORY;
1388 return (rv);
1389 }
1390
1391 objp->object_class_u.public_key = pbk;
1392
1393 switch (keytype) {
1394 case CKK_RSA: /* modulus_bits */
1395 (void) memcpy(&tmp_val, buf, sizeof (uint64_t));
1396 KEY_PUB_RSA_MOD_BITS(pbk) = (CK_ULONG)(SWAP64(tmp_val));
1397 buf = buf + sizeof (uint64_t);
1398
1399 /* modulus */
1400 if ((rv = soft_unpack_obj_attribute(buf, &modulus,
1401 NULL, &offset, B_FALSE)) != CKR_OK)
1402 goto pub_cleanup;
1403
1404 copy_bigint_attr(&modulus, KEY_PUB_RSA_MOD(pbk));
1405
1406 buf += ROUNDUP(offset, 8);
1407
1408 /* pubexpo */
1409 if ((rv = soft_unpack_obj_attribute(buf, &pubexpo,
1410 NULL, &offset, B_FALSE)) != CKR_OK)
1411 goto pub_cleanup;
1412
1413 copy_bigint_attr(&pubexpo, KEY_PUB_RSA_PUBEXPO(pbk));
1414
1415 break;
1416
1417 case CKK_DSA:
1418 /* prime */
1419 if ((rv = soft_unpack_obj_attribute(buf, &prime,
1420 NULL, &offset, B_FALSE)) != CKR_OK)
1421 goto pub_cleanup;
1422
1423 copy_bigint_attr(&prime, KEY_PUB_DSA_PRIME(pbk));
1424
1425 buf += ROUNDUP(offset, 8);
1426
1427 /* subprime */
1428 if ((rv = soft_unpack_obj_attribute(buf, &subprime,
1429 NULL, &offset, B_FALSE)) != CKR_OK)
1430 goto pub_cleanup;
1431
1432 copy_bigint_attr(&subprime, KEY_PUB_DSA_SUBPRIME(pbk));
1433
1434 buf += ROUNDUP(offset, 8);
1435
1436 /* base */
1437 if ((rv = soft_unpack_obj_attribute(buf, &base,
1438 NULL, &offset, B_FALSE)) != CKR_OK)
1439 goto pub_cleanup;
1440
1441 copy_bigint_attr(&base, KEY_PUB_DSA_BASE(pbk));
1442
1443 buf += ROUNDUP(offset, 8);
1444
1445 /* value */
1446 if ((rv = soft_unpack_obj_attribute(buf, &value,
1447 NULL, &offset, B_FALSE)) != CKR_OK)
1448 goto pub_cleanup;
1449
1450 copy_bigint_attr(&value, KEY_PUB_DSA_VALUE(pbk));
1451
1452 break;
1453
1454 case CKK_DH:
1455 /* prime */
1456 if ((rv = soft_unpack_obj_attribute(buf, &prime,
1457 NULL, &offset, B_FALSE)) != CKR_OK)
1458 goto pub_cleanup;
1459
1460 copy_bigint_attr(&prime, KEY_PUB_DH_PRIME(pbk));
1461
1462 buf += ROUNDUP(offset, 8);
1463
1464 /* base */
1465 if ((rv = soft_unpack_obj_attribute(buf, &base,
1466 NULL, &offset, B_FALSE)) != CKR_OK)
1467 goto pub_cleanup;
1468
1469 copy_bigint_attr(&base, KEY_PUB_DH_BASE(pbk));
1470
1471 buf += ROUNDUP(offset, 8);
1472
1473 /* value */
1474 if ((rv = soft_unpack_obj_attribute(buf, &value,
1475 NULL, &offset, B_FALSE)) != CKR_OK)
1476 goto pub_cleanup;
1477
1478 copy_bigint_attr(&value, KEY_PUB_DH_VALUE(pbk));
1479
1480 break;
1481
1482 case CKK_EC:
1483 /* ec_point */
1484 if ((rv = soft_unpack_obj_attribute(buf, &value,
1485 NULL, &offset, B_FALSE)) != CKR_OK)
1486 goto pri_cleanup;
1487
1488 copy_bigint_attr(&value, KEY_PUB_EC_POINT(pbk));
1489 break;
1490
1491 case CKK_X9_42_DH:
1492 /* prime */
1493 if ((rv = soft_unpack_obj_attribute(buf, &prime,
1494 NULL, &offset, B_FALSE)) != CKR_OK)
1495 goto pub_cleanup;
1496
1497 copy_bigint_attr(&prime, KEY_PUB_DH942_PRIME(pbk));
1498
1499 buf += ROUNDUP(offset, 8);
1500
1501 /* base */
1502 if ((rv = soft_unpack_obj_attribute(buf, &base,
1503 NULL, &offset, B_FALSE)) != CKR_OK)
1504 goto pub_cleanup;
1505
1506 copy_bigint_attr(&base, KEY_PUB_DH942_BASE(pbk));
1507
1508 buf += ROUNDUP(offset, 8);
1509
1510 /* subprime */
1511 if ((rv = soft_unpack_obj_attribute(buf, &subprime,
1512 NULL, &offset, B_FALSE)) != CKR_OK)
1513 goto pub_cleanup;
1514
1515 copy_bigint_attr(&subprime,
1516 KEY_PUB_DH942_SUBPRIME(pbk));
1517
1518 buf += ROUNDUP(offset, 8);
1519
1520 /* value */
1521 if ((rv = soft_unpack_obj_attribute(buf, &value,
1522 NULL, &offset, B_FALSE)) != CKR_OK)
1523 goto pub_cleanup;
1524
1525 copy_bigint_attr(&value, KEY_PUB_DH942_VALUE(pbk));
1526
1527 break;
1528 } /* keytype */
1529
1530 break;
1531
1532 case CKO_PRIVATE_KEY:
1533 /* Allocate storage for Private Key Object. */
1534 pvk = calloc(1, sizeof (private_key_obj_t));
1535 if (pvk == NULL) {
1536 rv = CKR_HOST_MEMORY;
1537 return (rv);
1538 }
1539
1540 objp->object_class_u.private_key = pvk;
1541
1542 switch (keytype) {
1543 case CKK_RSA:
1544 /* modulus */
1545 if ((rv = soft_unpack_obj_attribute(buf, &modulus,
1546 NULL, &offset, B_FALSE)) != CKR_OK)
1547 goto pri_cleanup;
1548
1549 copy_bigint_attr(&modulus, KEY_PRI_RSA_MOD(pvk));
1550
1551 buf += ROUNDUP(offset, 8);
1552
1553 /* pubexpo */
1554 if ((rv = soft_unpack_obj_attribute(buf, &pubexpo,
1555 NULL, &offset, B_FALSE)) != CKR_OK)
1556 goto pri_cleanup;
1557
1558 copy_bigint_attr(&pubexpo, KEY_PRI_RSA_PUBEXPO(pvk));
1559
1560 buf += ROUNDUP(offset, 8);
1561
1562 /* priexpo */
1563 if ((rv = soft_unpack_obj_attribute(buf, &priexpo,
1564 NULL, &offset, B_FALSE)) != CKR_OK)
1565 goto pri_cleanup;
1566
1567 copy_bigint_attr(&priexpo, KEY_PRI_RSA_PRIEXPO(pvk));
1568
1569 buf += ROUNDUP(offset, 8);
1570
1571 /* prime1 */
1572 if ((rv = soft_unpack_obj_attribute(buf, &prime1,
1573 NULL, &offset, B_FALSE)) != CKR_OK)
1574 goto pri_cleanup;
1575
1576 copy_bigint_attr(&prime1, KEY_PRI_RSA_PRIME1(pvk));
1577
1578 buf += ROUNDUP(offset, 8);
1579
1580 /* prime2 */
1581 if ((rv = soft_unpack_obj_attribute(buf, &prime2,
1582 NULL, &offset, B_FALSE)) != CKR_OK)
1583 goto pri_cleanup;
1584
1585 copy_bigint_attr(&prime2, KEY_PRI_RSA_PRIME2(pvk));
1586
1587 buf += ROUNDUP(offset, 8);
1588
1589 /* expo1 */
1590 if ((rv = soft_unpack_obj_attribute(buf, &expo1,
1591 NULL, &offset, B_FALSE)) != CKR_OK)
1592 goto pri_cleanup;
1593
1594 copy_bigint_attr(&expo1, KEY_PRI_RSA_EXPO1(pvk));
1595
1596 buf += ROUNDUP(offset, 8);
1597
1598 /* expo2 */
1599 if ((rv = soft_unpack_obj_attribute(buf, &expo2,
1600 NULL, &offset, B_FALSE)) != CKR_OK)
1601 goto pri_cleanup;
1602
1603 copy_bigint_attr(&expo2, KEY_PRI_RSA_EXPO2(pvk));
1604
1605 buf += ROUNDUP(offset, 8);
1606
1607 /* coef */
1608 if ((rv = soft_unpack_obj_attribute(buf, &coef,
1609 NULL, &offset, B_FALSE)) != CKR_OK)
1610 goto pri_cleanup;
1611
1612 copy_bigint_attr(&coef, KEY_PRI_RSA_COEF(pvk));
1613
1614 break;
1615
1616 case CKK_DSA:
1617 /* prime */
1618 if ((rv = soft_unpack_obj_attribute(buf, &prime,
1619 NULL, &offset, B_FALSE)) != CKR_OK)
1620 goto pri_cleanup;
1621
1622 copy_bigint_attr(&prime, KEY_PRI_DSA_PRIME(pvk));
1623
1624 buf += ROUNDUP(offset, 8);
1625
1626 /* subprime */
1627 if ((rv = soft_unpack_obj_attribute(buf, &subprime,
1628 NULL, &offset, B_FALSE)) != CKR_OK)
1629 goto pri_cleanup;
1630
1631 copy_bigint_attr(&subprime, KEY_PRI_DSA_SUBPRIME(pvk));
1632
1633 buf += ROUNDUP(offset, 8);
1634
1635 /* base */
1636 if ((rv = soft_unpack_obj_attribute(buf, &base,
1637 NULL, &offset, B_FALSE)) != CKR_OK)
1638 goto pri_cleanup;
1639
1640 copy_bigint_attr(&base, KEY_PRI_DSA_BASE(pvk));
1641
1642 buf += ROUNDUP(offset, 8);
1643
1644 /* value */
1645 if ((rv = soft_unpack_obj_attribute(buf, &value,
1646 NULL, &offset, B_FALSE)) != CKR_OK)
1647 goto pri_cleanup;
1648
1649 copy_bigint_attr(&value, KEY_PRI_DSA_VALUE(pvk));
1650
1651 break;
1652
1653 case CKK_DH:
1654 /* value_bits */
1655 (void) memcpy(&tmp_val, buf, sizeof (uint64_t));
1656 KEY_PRI_DH_VAL_BITS(pvk) = (CK_ULONG)(SWAP64(tmp_val));
1657 buf = buf + sizeof (uint64_t);
1658
1659 /* prime */
1660 if ((rv = soft_unpack_obj_attribute(buf, &prime,
1661 NULL, &offset, B_FALSE)) != CKR_OK)
1662 goto pri_cleanup;
1663
1664 copy_bigint_attr(&prime, KEY_PRI_DH_PRIME(pvk));
1665
1666 buf += ROUNDUP(offset, 8);
1667
1668 /* base */
1669 if ((rv = soft_unpack_obj_attribute(buf, &base,
1670 NULL, &offset, B_FALSE)) != CKR_OK)
1671 goto pri_cleanup;
1672
1673 copy_bigint_attr(&base, KEY_PRI_DH_BASE(pvk));
1674
1675 buf += ROUNDUP(offset, 8);
1676
1677 /* value */
1678 if ((rv = soft_unpack_obj_attribute(buf, &value,
1679 NULL, &offset, B_FALSE)) != CKR_OK)
1680 goto pri_cleanup;
1681
1682 copy_bigint_attr(&value, KEY_PRI_DH_VALUE(pvk));
1683
1684 break;
1685
1686 case CKK_EC:
1687 /* value */
1688 if ((rv = soft_unpack_obj_attribute(buf, &value,
1689 NULL, &offset, B_FALSE)) != CKR_OK)
1690 goto pri_cleanup;
1691
1692 copy_bigint_attr(&value, KEY_PRI_EC_VALUE(pvk));
1693 break;
1694
1695 case CKK_X9_42_DH:
1696 /* prime */
1697 if ((rv = soft_unpack_obj_attribute(buf, &prime,
1698 NULL, &offset, B_FALSE)) != CKR_OK)
1699 goto pri_cleanup;
1700
1701 copy_bigint_attr(&prime, KEY_PRI_DH942_PRIME(pvk));
1702
1703 buf += ROUNDUP(offset, 8);
1704
1705 /* base */
1706 if ((rv = soft_unpack_obj_attribute(buf, &base,
1707 NULL, &offset, B_FALSE)) != CKR_OK)
1708 goto pri_cleanup;
1709
1710 copy_bigint_attr(&base, KEY_PRI_DH942_BASE(pvk));
1711
1712 buf += ROUNDUP(offset, 8);
1713
1714 /* subprime */
1715 if ((rv = soft_unpack_obj_attribute(buf, &subprime,
1716 NULL, &offset, B_FALSE)) != CKR_OK)
1717 goto pri_cleanup;
1718
1719 copy_bigint_attr(&subprime, KEY_PRI_DH942_BASE(pvk));
1720
1721 buf += ROUNDUP(offset, 8);
1722
1723 /* value */
1724 if ((rv = soft_unpack_obj_attribute(buf, &value,
1725 NULL, &offset, B_FALSE)) != CKR_OK)
1726 goto pri_cleanup;
1727
1728 copy_bigint_attr(&value, KEY_PRI_DH942_VALUE(pvk));
1729
1730 break;
1731 } /* keytype */
1732
1733 break;
1734
1735 case CKO_SECRET_KEY:
1736 /* Allocate storage for Secret Key Object. */
1737 sck = calloc(1, sizeof (secret_key_obj_t));
1738 if (sck == NULL) {
1739 return (CKR_HOST_MEMORY);
1740 }
1741
1742 objp->object_class_u.secret_key = sck;
1743
1744 /* value */
1745 (void) memcpy((void *)&tmp_val, buf, sizeof (uint64_t));
1746 OBJ_SEC_VALUE_LEN(objp) = (CK_ULONG)(SWAP64(tmp_val));
1747 buf = buf + sizeof (uint64_t);
1748
1749 if (OBJ_SEC_VALUE_LEN(objp) > 0) {
1750 OBJ_SEC_VALUE(objp) = malloc(OBJ_SEC_VALUE_LEN(objp));
1751 if (OBJ_SEC_VALUE(objp) == NULL) {
1752 free(sck);
1753 return (CKR_HOST_MEMORY);
1754 }
1755 (void) memcpy(OBJ_SEC_VALUE(objp), buf,
1756 OBJ_SEC_VALUE_LEN(objp));
1757
1758 buf = buf + ROUNDUP(OBJ_SEC_VALUE_LEN(objp), 8);
1759 }
1760
1761 return (rv);
1762
1763 case CKO_CERTIFICATE:
1764 /* Allocate storage for Certificate Object. */
1765 cert = calloc(1, sizeof (certificate_obj_t));
1766 if (cert == NULL) {
1767 return (CKR_HOST_MEMORY);
1768 }
1769 (void) memset((void *)cert, 0, sizeof (certificate_obj_t));
1770
1771 cert->certificate_type = certtype;
1772 objp->object_class_u.certificate = cert;
1773
1774 switch (certtype) {
1775 case CKC_X_509:
1776 /* subject */
1777 if ((rv = soft_unpack_obj_attribute(buf, NULL,
1778 &cert->cert_type_u.x509.subject,
1779 &offset, B_TRUE)) != CKR_OK) {
1780 free(cert);
1781 return (rv);
1782 }
1783
1784 buf += ROUNDUP(offset, 8);
1785
1786 /* value */
1787 if ((rv = soft_unpack_obj_attribute(buf, NULL,
1788 &cert->cert_type_u.x509.value,
1789 &offset, B_TRUE)) != CKR_OK) {
1790 free(cert);
1791 return (rv);
1792 }
1793
1794 break;
1795
1796 case CKC_X_509_ATTR_CERT:
1797 /* owner */
1798 if ((rv = soft_unpack_obj_attribute(buf, NULL,
1799 &cert->cert_type_u.x509_attr.owner,
1800 &offset, B_TRUE)) != CKR_OK) {
1801 free(cert);
1802 return (rv);
1803 }
1804
1805 buf += ROUNDUP(offset, 8);
1806
1807 /* value */
1808 if ((rv = soft_unpack_obj_attribute(buf, NULL,
1809 &cert->cert_type_u.x509_attr.value,
1810 &offset, B_TRUE)) != CKR_OK) {
1811 free(cert);
1812 return (rv);
1813 }
1814
1815 break;
1816 }
1817
1818 return (rv);
1819
1820 case CKO_DOMAIN_PARAMETERS:
1821
1822 break;
1823 }
1824
1825 pub_cleanup:
1826 /*
1827 * cleanup the storage allocated to the local variables.
1828 */
1829 if (rv != CKR_OK)
1830 free(pbk);
1831 bigint_attr_cleanup(&modulus);
1832 bigint_attr_cleanup(&pubexpo);
1833 bigint_attr_cleanup(&prime);
1834 bigint_attr_cleanup(&subprime);
1835 bigint_attr_cleanup(&base);
1836 bigint_attr_cleanup(&value);
1837 return (rv);
1838
1839 pri_cleanup:
1840 /*
1841 * cleanup the storage allocated to the local variables.
1842 */
1843 if (rv != CKR_OK)
1844 free(pvk);
1845 bigint_attr_cleanup(&modulus);
1846 bigint_attr_cleanup(&priexpo);
1847 bigint_attr_cleanup(&prime);
1848 bigint_attr_cleanup(&subprime);
1849 bigint_attr_cleanup(&base);
1850 bigint_attr_cleanup(&value);
1851 bigint_attr_cleanup(&pubexpo);
1852 bigint_attr_cleanup(&prime1);
1853 bigint_attr_cleanup(&prime2);
1854 bigint_attr_cleanup(&expo1);
1855 bigint_attr_cleanup(&expo2);
1856 bigint_attr_cleanup(&coef);
1857 return (rv);
1858 }
1859
1860
1861 /*
1862 * Store the token object to a keystore file.
1863 */
1864 CK_RV
1865 soft_put_object_to_keystore(soft_object_t *objp)
1866 {
1867
1868 uchar_t *buf;
1869 size_t len;
1870 CK_RV rv;
1871
1872 rv = soft_keystore_pack_obj(objp, &buf, &len);
1873 if (rv != CKR_OK)
1874 return (rv);
1875
1876 (void) pthread_mutex_lock(&soft_slot.slot_mutex);
1877 if (soft_keystore_put_new_obj(buf, len,
1878 !!(objp->object_type == TOKEN_PUBLIC), B_FALSE,
1879 &objp->ks_handle) == -1) {
1880 rv = CKR_FUNCTION_FAILED;
1881 }
1882 (void) pthread_mutex_unlock(&soft_slot.slot_mutex);
1883
1884 freezero(buf, len);
1885 return (rv);
1886 }
1887
1888 /*
1889 * Modify the in-core token object and then write it to
1890 * a keystore file.
1891 */
1892 CK_RV
1893 soft_modify_object_to_keystore(soft_object_t *objp)
1894 {
1895
1896 uchar_t *buf;
1897 size_t len;
1898 CK_RV rv;
1899
1900 rv = soft_keystore_pack_obj(objp, &buf, &len);
1901 if (rv != CKR_OK)
1902 return (rv);
1903
1904 /* B_TRUE: caller has held a writelock on the keystore */
1905 if (soft_keystore_modify_obj(&objp->ks_handle, buf, len,
1906 B_TRUE) < 0) {
1907 rv = CKR_FUNCTION_FAILED;
1908 }
1909
1910 freezero(buf, len);
1911 return (rv);
1912
1913 }
1914
1915 /*
1916 * Read the token object from the keystore file.
1917 */
1918 CK_RV
1919 soft_get_token_objects_from_keystore(ks_search_type_t type)
1920 {
1921 CK_RV rv;
1922 ks_obj_t *ks_obj = NULL, *ks_obj_next;
1923 soft_object_t *new_objp = NULL;
1924
1925 /* Load the token object from keystore based on the object type */
1926 rv = soft_keystore_get_objs(type, &ks_obj, B_FALSE);
1927 if (rv != CKR_OK) {
1928 return (rv);
1929 }
1930
1931 while (ks_obj) {
1932
1933 new_objp = calloc(1, sizeof (soft_object_t));
1934 if (new_objp == NULL) {
1935 rv = CKR_HOST_MEMORY;
1936 goto cleanup;
1937 }
1938 /* Convert the keystore format to memory format */
1939 rv = soft_keystore_unpack_obj(new_objp, ks_obj);
1940 if (rv != CKR_OK) {
1941 if (new_objp->class == CKO_CERTIFICATE)
1942 soft_cleanup_cert_object(new_objp);
1943 else
1944 soft_cleanup_object(new_objp);
1945 goto cleanup;
1946 }
1947
1948 soft_add_token_object_to_slot(new_objp);
1949
1950 /* Free the ks_obj list */
1951 ks_obj_next = ks_obj->next;
1952 freezero(ks_obj->buf, ks_obj->size);
1953 free(ks_obj);
1954 ks_obj = ks_obj_next;
1955 }
1956
1957 return (CKR_OK);
1958
1959 cleanup:
1960 while (ks_obj) {
1961 ks_obj_next = ks_obj->next;
1962 freezero(ks_obj->buf, ks_obj->size);
1963 free(ks_obj);
1964 ks_obj = ks_obj_next;
1965 }
1966 return (rv);
1967 }
1968
1969 /*
1970 * soft_gen_crypt_key()
1971 *
1972 * Arguments:
1973 *
1974 * pPIN: pointer to caller provided Pin
1975 * key: output argument which contains the address of the
1976 * pointer to encryption key in the soft_object_t.
1977 * It is caller's responsibility to call soft_delete_object()
1978 * if this key is no longer in use.
1979 * saltdata: input argument (if non-NULL), or
1980 * output argument (if NULL):
1981 * address of pointer to the "salt" of the encryption key
1982 *
1983 * Description:
1984 *
1985 * Generate an encryption key of the input PIN.
1986 *
1987 * Returns:
1988 *
1989 * CKR_OK: no error
1990 * Other: some error occurred while generating the encryption key
1991 *
1992 */
1993 CK_RV
1994 soft_gen_crypt_key(uchar_t *pPIN, soft_object_t **key, CK_BYTE **saltdata)
1995 {
1996 CK_OBJECT_CLASS class = CKO_SECRET_KEY;
1997 CK_ATTRIBUTE tmpl[5];
1998 int attrs = 0;
1999 CK_RV rv;
2000 CK_MECHANISM Mechanism;
2001 CK_PKCS5_PBKD2_PARAMS params;
2002 CK_BYTE salt[PBKD2_SALT_SIZE];
2003 CK_ULONG keylen = AES_MIN_KEY_BYTES;
2004 CK_KEY_TYPE keytype = CKK_AES;
2005 static CK_BBOOL truevalue = TRUE;
2006 soft_object_t *secret_key;
2007 CK_OBJECT_HANDLE hKey;
2008 CK_ULONG passwd_size;
2009
2010 if (pPIN == NULL)
2011 return (CKR_FUNCTION_FAILED);
2012
2013 tmpl[attrs].type = CKA_CLASS;
2014 tmpl[attrs].pValue = &class;
2015 tmpl[attrs].ulValueLen = sizeof (class);
2016 attrs++;
2017
2018 tmpl[attrs].type = CKA_KEY_TYPE;
2019 tmpl[attrs].pValue = &keytype;
2020 tmpl[attrs].ulValueLen = sizeof (keytype);
2021 attrs++;
2022
2023 tmpl[attrs].type = CKA_ENCRYPT;
2024 tmpl[attrs].pValue = &truevalue;
2025 tmpl[attrs].ulValueLen = sizeof (CK_BBOOL);
2026 attrs++;
2027
2028 tmpl[attrs].type = CKA_DECRYPT;
2029 tmpl[attrs].pValue = &truevalue;
2030 tmpl[attrs].ulValueLen = sizeof (CK_BBOOL);
2031 attrs++;
2032
2033 tmpl[attrs].type = CKA_VALUE_LEN;
2034 tmpl[attrs].pValue = &keylen;
2035 tmpl[attrs].ulValueLen = sizeof (keylen);
2036 attrs++;
2037
2038 if (*saltdata == NULL) {
2039 bzero(salt, sizeof (salt));
2040 (void) pkcs11_get_nzero_urandom(salt, sizeof (salt));
2041 *saltdata = malloc(PBKD2_SALT_SIZE);
2042 if (*saltdata == NULL)
2043 return (CKR_HOST_MEMORY);
2044 (void) memcpy(*saltdata, salt, PBKD2_SALT_SIZE);
2045 } else {
2046 bzero(salt, sizeof (salt));
2047 (void) memcpy(salt, *saltdata, PBKD2_SALT_SIZE);
2048 }
2049
2050 Mechanism.mechanism = CKM_PKCS5_PBKD2;
2051 Mechanism.pParameter = ¶ms;
2052 Mechanism.ulParameterLen = sizeof (params);
2053 passwd_size = (CK_ULONG)strlen((const char *)pPIN);
2054
2055 params.saltSource = CKZ_SALT_SPECIFIED;
2056 params.pSaltSourceData = (void *)salt;
2057 params.ulSaltSourceDataLen = sizeof (salt);
2058 params.iterations = PBKD2_ITERATIONS;
2059 params.prf = CKP_PKCS5_PBKD2_HMAC_SHA1;
2060 params.pPrfData = NULL;
2061 params.ulPrfDataLen = 0;
2062 params.pPassword = (CK_UTF8CHAR_PTR)pPIN;
2063 params.ulPasswordLen = &passwd_size;
2064
2065 rv = soft_gen_keyobject(tmpl, attrs, &hKey, &token_session,
2066 CKO_SECRET_KEY, CKK_AES, 0, SOFT_GEN_KEY, B_TRUE);
2067
2068 if (rv != CKR_OK) {
2069 return (rv);
2070 }
2071
2072 /* Obtain the secret object pointer. */
2073 secret_key = (soft_object_t *)hKey;
2074 keylen = OBJ_SEC_VALUE_LEN(secret_key);
2075 if ((OBJ_SEC_VALUE(secret_key) = malloc(keylen)) == NULL) {
2076 soft_delete_object(&token_session, secret_key,
2077 B_FALSE, B_FALSE);
2078 return (CKR_HOST_MEMORY);
2079 }
2080
2081 rv = soft_generate_pkcs5_pbkdf2_key(&token_session, &Mechanism,
2082 secret_key);
2083
2084 if (rv != CKR_OK)
2085 soft_delete_object(&token_session, secret_key,
2086 B_FALSE, B_FALSE);
2087 else
2088 *key = secret_key;
2089
2090 return (rv);
2091
2092 }
2093
2094 /*
2095 * soft_gen_hmac_key()
2096 *
2097 * Arguments:
2098 *
2099 * pPIN: pointer to caller provided Pin
2100 * key: output argument which contains the address of the
2101 * pointer to hmac key in the soft_object_t.
2102 * It is caller's responsibility to call soft_delete_object()
2103 * if this key is no longer in use.
2104 * saltdata: input argument (if non-NULL), or
2105 * output argument (if NULL):
2106 * address of pointer to the "salt" of the hmac key
2107 *
2108 * Description:
2109 *
2110 * Generate a hmac key of the input PIN.
2111 *
2112 * Returns:
2113 *
2114 * CKR_OK: no error
2115 * Other: some error occurred while generating the hmac key
2116 *
2117 */
2118 CK_RV
2119 soft_gen_hmac_key(uchar_t *pPIN, soft_object_t **key, CK_BYTE **saltdata)
2120 {
2121 CK_OBJECT_CLASS class = CKO_SECRET_KEY;
2122 CK_ATTRIBUTE tmpl[5];
2123 int attrs = 0;
2124 CK_RV rv;
2125 CK_MECHANISM Mechanism;
2126 CK_PKCS5_PBKD2_PARAMS params;
2127 CK_BYTE salt[PBKD2_SALT_SIZE];
2128 CK_ULONG keylen = 16;
2129 CK_KEY_TYPE keytype = CKK_GENERIC_SECRET;
2130 static CK_BBOOL truevalue = TRUE;
2131 soft_object_t *secret_key;
2132 CK_OBJECT_HANDLE hKey;
2133 CK_ULONG passwd_size;
2134
2135 if (pPIN == NULL)
2136 return (CKR_FUNCTION_FAILED);
2137
2138 tmpl[attrs].type = CKA_CLASS;
2139 tmpl[attrs].pValue = &class;
2140 tmpl[attrs].ulValueLen = sizeof (class);
2141 attrs++;
2142
2143 tmpl[attrs].type = CKA_KEY_TYPE;
2144 tmpl[attrs].pValue = &keytype;
2145 tmpl[attrs].ulValueLen = sizeof (keytype);
2146 attrs++;
2147
2148 tmpl[attrs].type = CKA_SIGN;
2149 tmpl[attrs].pValue = &truevalue;
2150 tmpl[attrs].ulValueLen = sizeof (CK_BBOOL);
2151 attrs++;
2152
2153 tmpl[attrs].type = CKA_VERIFY;
2154 tmpl[attrs].pValue = &truevalue;
2155 tmpl[attrs].ulValueLen = sizeof (CK_BBOOL);
2156 attrs++;
2157
2158 tmpl[attrs].type = CKA_VALUE_LEN;
2159 tmpl[attrs].pValue = &keylen;
2160 tmpl[attrs].ulValueLen = sizeof (keylen);
2161 attrs++;
2162
2163 if (*saltdata == NULL) {
2164 bzero(salt, sizeof (salt));
2165 (void) pkcs11_get_nzero_urandom(salt, sizeof (salt));
2166 *saltdata = malloc(PBKD2_SALT_SIZE);
2167 if (*saltdata == NULL)
2168 return (CKR_HOST_MEMORY);
2169 (void) memcpy(*saltdata, salt, PBKD2_SALT_SIZE);
2170 } else {
2171 bzero(salt, sizeof (salt));
2172 (void) memcpy(salt, *saltdata, PBKD2_SALT_SIZE);
2173 }
2174
2175 Mechanism.mechanism = CKM_PKCS5_PBKD2;
2176 Mechanism.pParameter = ¶ms;
2177 Mechanism.ulParameterLen = sizeof (params);
2178 passwd_size = (CK_ULONG)strlen((const char *)pPIN);
2179
2180 params.saltSource = CKZ_SALT_SPECIFIED;
2181 params.pSaltSourceData = (void *)salt;
2182 params.ulSaltSourceDataLen = sizeof (salt);
2183 params.iterations = PBKD2_ITERATIONS;
2184 params.prf = CKP_PKCS5_PBKD2_HMAC_SHA1;
2185 params.pPrfData = NULL;
2186 params.ulPrfDataLen = 0;
2187 params.pPassword = (CK_UTF8CHAR_PTR)pPIN;
2188 params.ulPasswordLen = &passwd_size;
2189
2190 rv = soft_gen_keyobject(tmpl, attrs, &hKey, &token_session,
2191 CKO_SECRET_KEY, CKK_GENERIC_SECRET, 0, SOFT_GEN_KEY, B_TRUE);
2192
2193 if (rv != CKR_OK) {
2194 return (rv);
2195 }
2196
2197 /* Obtain the secret object pointer. */
2198 secret_key = (soft_object_t *)hKey;
2199 keylen = OBJ_SEC_VALUE_LEN(secret_key);
2200 if ((OBJ_SEC_VALUE(secret_key) = malloc(keylen)) == NULL) {
2201 soft_delete_object(&token_session, secret_key,
2202 B_FALSE, B_FALSE);
2203 return (CKR_HOST_MEMORY);
2204 }
2205
2206 rv = soft_generate_pkcs5_pbkdf2_key(&token_session, &Mechanism,
2207 secret_key);
2208
2209 if (rv != CKR_OK)
2210 soft_delete_object(&token_session, secret_key,
2211 B_FALSE, B_FALSE);
2212 else
2213 *key = secret_key;
2214
2215 return (rv);
2216
2217 }
2218
2219 /*
2220 * The token session is just a psuedo session (a place holder)
2221 * to hold some information during encryption/decryption and
2222 * sign/verify operations when writing/reading the keystore
2223 * token object.
2224 */
2225 CK_RV
2226 soft_init_token_session(void)
2227 {
2228
2229
2230 token_session.magic_marker = SOFTTOKEN_SESSION_MAGIC;
2231 token_session.pApplication = NULL_PTR;
2232 token_session.Notify = NULL;
2233 token_session.flags = CKF_SERIAL_SESSION;
2234 token_session.state = CKS_RO_PUBLIC_SESSION;
2235 token_session.object_list = NULL;
2236 token_session.ses_refcnt = 0;
2237 token_session.ses_close_sync = 0;
2238 token_session.next = NULL;
2239 token_session.prev = NULL;
2240
2241 /* Initialize the lock for the token session */
2242 if (pthread_mutex_init(&token_session.session_mutex, NULL) != 0) {
2243 return (CKR_CANT_LOCK);
2244 }
2245
2246 (void) pthread_cond_init(&token_session.ses_free_cond, NULL);
2247
2248 return (CKR_OK);
2249
2250 }
2251
2252 void
2253 soft_destroy_token_session(void)
2254 {
2255
2256 (void) pthread_cond_destroy(&token_session.ses_free_cond);
2257 (void) pthread_mutex_destroy(&token_session.session_mutex);
2258
2259 }
2260
2261 /*
2262 * Encrypt/Decrypt the private token object when dealing with the keystore.
2263 * This function only applies to the private token object.
2264 */
2265 CK_RV
2266 soft_keystore_crypt(soft_object_t *key_p, uchar_t *ivec, boolean_t encrypt,
2267 CK_BYTE_PTR in, CK_ULONG in_len, CK_BYTE_PTR out, CK_ULONG_PTR out_len)
2268 {
2269 CK_MECHANISM mech;
2270 soft_aes_ctx_t *soft_aes_ctx;
2271 CK_RV rv;
2272 CK_ULONG tmplen, tmplen1;
2273
2274 /*
2275 * The caller will pass NULL for "out" (output buffer) to find out
2276 * the output buffer size that it need to allocate for the encrption
2277 * or decryption.
2278 */
2279 if (out == NULL) {
2280 mech.mechanism = CKM_AES_CBC_PAD;
2281 mech.pParameter = (void *)ivec;
2282 mech.ulParameterLen = AES_BLOCK_LEN;
2283
2284 if (encrypt)
2285 rv = soft_aes_crypt_init_common(&token_session, &mech,
2286 key_p, B_TRUE);
2287 else
2288 rv = soft_aes_crypt_init_common(&token_session, &mech,
2289 key_p, B_FALSE);
2290
2291 if (rv != CKR_OK)
2292 return (rv);
2293
2294
2295 (void) pthread_mutex_lock(&token_session.session_mutex);
2296
2297 if (encrypt)
2298 soft_aes_ctx =
2299 (soft_aes_ctx_t *)token_session.encrypt.context;
2300 else
2301 soft_aes_ctx =
2302 (soft_aes_ctx_t *)token_session.decrypt.context;
2303
2304 /* Copy Initialization Vector (IV) into the context. */
2305 (void) memcpy(soft_aes_ctx->ivec, ivec, AES_BLOCK_LEN);
2306
2307 /* Allocate a context for AES cipher-block chaining. */
2308 soft_aes_ctx->aes_cbc = (void *)aes_cbc_ctx_init(
2309 soft_aes_ctx->key_sched, soft_aes_ctx->keysched_len,
2310 soft_aes_ctx->ivec);
2311
2312 if (soft_aes_ctx->aes_cbc == NULL) {
2313 freezero(soft_aes_ctx->key_sched,
2314 soft_aes_ctx->keysched_len);
2315 if (encrypt) {
2316 free(token_session.encrypt.context);
2317 token_session.encrypt.context = NULL;
2318 } else {
2319 free(token_session.encrypt.context);
2320 token_session.encrypt.context = NULL;
2321 }
2322
2323 (void) pthread_mutex_unlock(&token_session.
2324 session_mutex);
2325 return (CKR_HOST_MEMORY);
2326 }
2327
2328 (void) pthread_mutex_unlock(&token_session.session_mutex);
2329 /*
2330 * Since out == NULL, the soft_aes_xxcrypt_common() will
2331 * simply return the output buffer length to the caller.
2332 */
2333 if (encrypt) {
2334 rv = soft_aes_encrypt_common(&token_session, in,
2335 in_len, out, out_len, B_FALSE);
2336 } else {
2337 rv = soft_aes_decrypt_common(&token_session, in,
2338 in_len, out, out_len, B_FALSE);
2339 }
2340
2341 } else {
2342 /*
2343 * The caller has allocated the output buffer, so that we
2344 * are doing the real encryption/decryption this time.
2345 */
2346 tmplen = *out_len;
2347 if (encrypt) {
2348 rv = soft_aes_encrypt_common(&token_session, in,
2349 in_len, out, &tmplen, B_TRUE);
2350 if (rv == CKR_OK) {
2351 tmplen1 = *out_len - tmplen;
2352 rv = soft_encrypt_final(&token_session,
2353 out+tmplen, &tmplen1);
2354 *out_len = tmplen + tmplen1;
2355 }
2356 } else {
2357 rv = soft_aes_decrypt_common(&token_session, in,
2358 in_len, out, &tmplen, B_TRUE);
2359 if (rv == CKR_OK) {
2360 tmplen1 = *out_len - tmplen;
2361 rv = soft_decrypt_final(&token_session,
2362 out+tmplen, &tmplen1);
2363 *out_len = tmplen + tmplen1;
2364 }
2365 }
2366 }
2367
2368 return (rv);
2369
2370 }
2371
2372 /*
2373 * Sign/Verify the private token object for checking its data integrity
2374 * when dealing with the keystore.
2375 * This function only applies to the private token object.
2376 */
2377 CK_RV
2378 soft_keystore_hmac(soft_object_t *key_p, boolean_t sign,
2379 CK_BYTE_PTR in, CK_ULONG in_len, CK_BYTE_PTR out, CK_ULONG_PTR out_len)
2380 {
2381 CK_MECHANISM mech;
2382 CK_RV rv;
2383
2384 mech.mechanism = CKM_MD5_HMAC;
2385 mech.pParameter = NULL_PTR;
2386 mech.ulParameterLen = 0;
2387
2388 rv = soft_hmac_sign_verify_init_common(&token_session, &mech,
2389 key_p, sign);
2390
2391 if (rv != CKR_OK)
2392 return (rv);
2393
2394 if (sign) {
2395 rv = soft_sign(&token_session, in, in_len, out, out_len);
2396 } else {
2397 rv = soft_verify(&token_session, in, in_len, out, *out_len);
2398 }
2399
2400 return (rv);
2401 }