?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
420 remove patch (sparse package) support from svr4 pkg
[illumos-gate.git] / usr / src / lib / libpkg / common / keystore.c
blob633c04b58e4641775f22458e762943019fa5b9b3
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 /*
23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Module: keystore.c
29 * Description: This module contains the structure definitions for processing
30 * package keystore files.
31 */
32
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <unistd.h>
36 #include <strings.h>
37 #include <libintl.h>
38 #include <time.h>
39 #include <ctype.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <openssl/evp.h>
43 #include <openssl/x509.h>
44 #include <openssl/pkcs12.h>
45 #include <openssl/asn1.h>
46 #include <openssl/pem.h>
47 #include <openssl/err.h>
48 #include <openssl/safestack.h>
49 #include <openssl/stack.h>
50 #include "p12lib.h"
51 #include "pkgerr.h"
52 #include "keystore.h"
53 #include "pkglib.h"
54 #include "pkglibmsgs.h"
55
56 typedef struct keystore_t {
57 boolean_t dirty;
58 boolean_t new;
59 char *path;
60 char *passphrase;
61 /* truststore handles */
62 int cafd;
63 STACK_OF(X509) *cacerts;
64 char *capath;
65
66 /* user certificate handles */
67 STACK_OF(X509) *clcerts;
68 char *clpath;
69
70 /* private key handles */
71 STACK_OF(EVP_PKEY) *pkeys;
72 char *keypath;
73 } keystore_t;
74
75 /* local routines */
76 static keystore_t *new_keystore(void);
77 static void free_keystore(keystore_t *);
78 static boolean_t verify_keystore_integrity(PKG_ERR *, keystore_t *);
79 static boolean_t check_password(PKCS12 *, char *);
80 static boolean_t resolve_paths(PKG_ERR *, char *, char *,
81 long, keystore_t *);
82 static boolean_t lock_keystore(PKG_ERR *, long, keystore_t *);
83
84 static boolean_t unlock_keystore(PKG_ERR *, keystore_t *);
85 static boolean_t read_keystore(PKG_ERR *, keystore_t *,
86 keystore_passphrase_cb);
87 static boolean_t write_keystore(PKG_ERR *, keystore_t *,
88 keystore_passphrase_cb);
89 static boolean_t write_keystore_file(PKG_ERR *, char *, PKCS12 *);
90 static boolean_t clear_keystore_file(PKG_ERR *, char *);
91 static PKCS12 *read_keystore_file(PKG_ERR *, char *);
92 static char *get_time_string(ASN1_TIME *);
93
94 /* locking routines */
95 static boolean_t restore_keystore_file(PKG_ERR *, char *);
96 static int file_lock(int, int, int);
97 static int file_unlock(int);
98 static boolean_t file_lock_test(int, int);
99 static boolean_t file_empty(char *);
100 static boolean_t get_keystore_passwd(PKG_ERR *err, PKCS12 *p12,
101 keystore_passphrase_cb cb, keystore_t *keystore);
102 static boolean_t wait_restore(int, char *, char *, char *);
103
104 #define KEYSTORE_PERMS (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
105
106 /* wait on other keystore access for 1 minute before giving up */
107 #define LOCK_TIMEOUT 60
108
109 /*
110 * print_certs - prints certificates out of a keystore, to a file.
111 *
112 * Arguments:
113 * err - Error object to append errors to
114 * keystore - Keystore on which to operate
115 * alias - Name of certificate to print, NULL means print all
116 * format - Format in which to print certificates
117 * outfile - Where to print certificates
118 *
119 * Returns:
120 * 0 - Success
121 * non-zero - Failure, errors added to err
122 */
123 int
124 print_certs(PKG_ERR *err, keystore_handle_t keystore_h, char *alias,
125 keystore_encoding_format_t format, FILE *outfile)
126 {
127 int i;
128 X509 *cert;
129 char *fname = NULL;
130 boolean_t found = B_FALSE;
131 keystore_t *keystore = keystore_h;
132
133 if (keystore->clcerts != NULL) {
134 /* print out each client cert */
135 for (i = 0; i < sk_X509_num(keystore->clcerts); i++) {
136 cert = sk_X509_value(keystore->clcerts, i);
137 (void) sunw_get_cert_fname(GETDO_COPY, cert,
138 &fname);
139
140 if (fname == NULL) {
141 /* no name recorded, keystore is corrupt */
142 pkgerr_add(err, PKGERR_CORRUPT,
143 gettext(ERR_KEYSTORE_NO_ALIAS),
144 get_subject_display_name(cert));
145 return (1);
146 }
147
148 if ((alias != NULL) && (!streq(alias, fname))) {
149 /* name does not match, skip it */
150 (void) OPENSSL_free(fname);
151 fname = NULL;
152 continue;
153 } else {
154 found = B_TRUE;
155 (void) print_cert(err, cert, format,
156 fname, B_FALSE, outfile);
157 (void) OPENSSL_free(fname);
158 fname = NULL;
159 }
160 }
161 }
162
163 if (fname != NULL) {
164 (void) OPENSSL_free(fname);
165 fname = NULL;
166 }
167
168 if (keystore->cacerts != NULL) {
169 /* print out each trusted cert */
170 for (i = 0; i < sk_X509_num(keystore->cacerts); i++) {
171 cert = sk_X509_value(keystore->cacerts, i);
172 (void) sunw_get_cert_fname(GETDO_COPY,
173 cert, &fname);
174
175 if (fname == NULL) {
176 /* no name recorded, keystore is corrupt */
177 pkgerr_add(err, PKGERR_CORRUPT,
178 gettext(ERR_KEYSTORE_NO_ALIAS),
179 get_subject_display_name(cert));
180 return (1);
181 }
182
183 if ((alias != NULL) && (!streq(alias, fname))) {
184 /* name does not match, skip it */
185 (void) OPENSSL_free(fname);
186 fname = NULL;
187 continue;
188 } else {
189 found = B_TRUE;
190 (void) print_cert(err, cert, format,
191 fname, B_TRUE, outfile);
192 (void) OPENSSL_free(fname);
193 fname = NULL;
194 }
195 }
196 }
197
198 if (fname != NULL) {
199 (void) OPENSSL_free(fname);
200 fname = NULL;
201 }
202
203 if (found) {
204 return (0);
205 } else {
206 /* no certs printed */
207 if (alias != NULL) {
208 pkgerr_add(err, PKGERR_NOALIASMATCH,
209 gettext(ERR_KEYSTORE_NOCERT),
210 alias, keystore->path);
211 } else {
212 pkgerr_add(err, PKGERR_NOPUBKEY,
213 gettext(ERR_KEYSTORE_NOPUBCERTS),
214 keystore->path);
215 pkgerr_add(err, PKGERR_NOCACERT,
216 gettext(ERR_KEYSTORE_NOCACERTS),
217 keystore->path);
218 }
219 return (1);
220 }
221 }
222
223 /*
224 * print_cert - prints a single certificate, to a file
225 *
226 * Arguments:
227 * err - Error object to append errors to
228 * x - The certificate to print
229 * alias - Name of certificate to print
230 * format - Format in which to print certificate
231 * outfile - Where to print certificate
232 *
233 * Returns:
234 * 0 - Success
235 * non-zero - Failure, errors added to err
236 */
237 int print_cert(PKG_ERR *err, X509 *x,
238 keystore_encoding_format_t format, char *alias, boolean_t is_trusted,
239 FILE *outfile)
240 {
241
242 char *vdb_str;
243 char *vda_str;
244 char vd_str[ATTR_MAX];
245 int ret = 0;
246 char *cn_str, *icn_str, *typ_str;
247 char *tmp;
248 char *md5_fp;
249 char *sha1_fp;
250 int len;
251
252 /* need to localize the word "Fingerprint", hence these pointers */
253 char md5_label[ATTR_MAX];
254 char sha1_label[ATTR_MAX];
255
256 if (is_trusted) {
257 typ_str = gettext(MSG_KEYSTORE_TRUSTED);
258 } else {
259 typ_str = gettext(MSG_KEYSTORE_UNTRUSTED);
260 }
261
262 if ((cn_str = get_subject_display_name(x)) == NULL) {
263 cn_str = gettext(MSG_KEYSTORE_UNKNOWN);
264 }
265
266 if ((icn_str = get_issuer_display_name(x)) == NULL) {
267 icn_str = gettext(MSG_KEYSTORE_UNKNOWN);
268 }
269
270 vdb_str = xstrdup(get_time_string(X509_get_notBefore(x)));
271 vda_str = xstrdup(get_time_string(X509_get_notAfter(x)));
272 if (((len = snprintf(vd_str, ATTR_MAX, "<%s> - <%s>",
273 vdb_str, vda_str)) < 0) || (len >= ATTR_MAX)) {
274 pkgerr_add(err, PKGERR_WEB, gettext(ERR_LEN), vdb_str);
275 ret = 1;
276 goto cleanup;
277 }
278
279 if ((tmp = get_fingerprint(x, EVP_md5())) == NULL) {
280 md5_fp = gettext(MSG_KEYSTORE_UNKNOWN);
281 } else {
282 /*
283 * make a copy, otherwise the next call to get_fingerprint
284 * will overwrite this one
285 */
286 md5_fp = xstrdup(tmp);
287 }
288
289 if ((tmp = get_fingerprint(x, EVP_sha1())) == NULL) {
290 sha1_fp = gettext(MSG_KEYSTORE_UNKNOWN);
291 } else {
292 sha1_fp = xstrdup(tmp);
293 }
294
295 (void) snprintf(md5_label, ATTR_MAX, "%s %s",
296 OBJ_nid2sn(EVP_MD_type(EVP_md5())),
297 /* i18n: 14 characters max */
298 gettext(MSG_KEYSTORE_FP));
299
300 (void) snprintf(sha1_label, ATTR_MAX, "%s %s",
301 OBJ_nid2sn(EVP_MD_type(EVP_sha1())),
302 /* i18n: 14 characters max */
303 gettext(MSG_KEYSTORE_FP));
304
305 switch (format) {
306 case KEYSTORE_FORMAT_PEM:
307 (void) PEM_write_X509(outfile, x);
308 break;
309 case KEYSTORE_FORMAT_DER:
310 (void) i2d_X509_fp(outfile, x);
311 break;
312 case KEYSTORE_FORMAT_TEXT:
313 (void) fprintf(outfile, "%18s: %s\n",
314 /* i18n: 18 characters max */
315 gettext(MSG_KEYSTORE_AL), alias);
316 (void) fprintf(outfile, "%18s: %s\n",
317 /* i18n: 18 characters max */
318 gettext(MSG_KEYSTORE_CN), cn_str);
319 (void) fprintf(outfile, "%18s: %s\n",
320 /* i18n: 18 characters max */
321 gettext(MSG_KEYSTORE_TY), typ_str);
322 (void) fprintf(outfile, "%18s: %s\n",
323 /* i18n: 18 characters max */
324 gettext(MSG_KEYSTORE_IN), icn_str);
325 (void) fprintf(outfile, "%18s: %s\n",
326 /* i18n: 18 characters max */
327 gettext(MSG_KEYSTORE_VD), vd_str);
328 (void) fprintf(outfile, "%18s: %s\n", md5_label, md5_fp);
329 (void) fprintf(outfile, "%18s: %s\n", sha1_label, sha1_fp);
330 (void) fprintf(outfile, "\n");
331 break;
332 default:
333 pkgerr_add(err, PKGERR_INTERNAL,
334 gettext(ERR_KEYSTORE_INTERNAL),
335 __FILE__, __LINE__);
336 ret = 1;
337 goto cleanup;
338 }
339
340 cleanup:
341 if (md5_fp != NULL)
342 free(md5_fp);
343 if (sha1_fp != NULL)
344 free(sha1_fp);
345 if (vda_str != NULL)
346 free(vda_str);
347 if (vdb_str != NULL)
348 free(vdb_str);
349 return (ret);
350 }
351
352 /*
353 * open_keystore - Initialize new keystore object for
354 * impending access.
355 *
356 * Arguments:
357 * err - Error object to append errors to
358 * keystore_file - Base filename or directory of keystore
359 * app - Application making request
360 * passwd - Password used to decrypt keystore
361 * flags - Control flags used to control access mode and behavior
362 * result - Resulting keystore object stored here on success
363 *
364 * Returns:
365 * 0 - Success - result contains a pointer to the opened keystore
366 * non-zero - Failure, errors added to err
367 */
368 int
369 open_keystore(PKG_ERR *err, char *keystore_file, char *app,
370 keystore_passphrase_cb cb, long flags, keystore_handle_t *result)
371 {
372 int ret = 0;
373 keystore_t *tmpstore;
374
375 tmpstore = new_keystore();
376
377 tmpstore->dirty = B_FALSE;
378 tmpstore->new = B_FALSE;
379 tmpstore->path = xstrdup(keystore_file);
380
381 if (!resolve_paths(err, keystore_file, app, flags, tmpstore)) {
382 /* unable to determine keystore paths */
383 pkgerr_add(err, PKGERR_CORRUPT, gettext(ERR_KEYSTORE_REPAIR),
384 keystore_file);
385 ret = 1;
386 goto cleanup;
387 }
388
389 if (!verify_keystore_integrity(err, tmpstore)) {
390 /* unable to repair keystore */
391 pkgerr_add(err, PKGERR_CORRUPT, gettext(ERR_KEYSTORE_REPAIR),
392 keystore_file);
393 ret = 1;
394 goto cleanup;
395 }
396
397 if (!lock_keystore(err, flags, tmpstore)) {
398 pkgerr_add(err, PKGERR_LOCKED, gettext(ERR_KEYSTORE_LOCKED),
399 keystore_file);
400 ret = 1;
401 goto cleanup;
402 }
403
404 /* now that we have locked the keystore, go ahead and read it */
405 if (!read_keystore(err, tmpstore, cb)) {
406 pkgerr_add(err, PKGERR_READ, gettext(ERR_PARSE),
407 keystore_file);
408 ret = 1;
409 goto cleanup;
410 }
411
412 *result = tmpstore;
413 tmpstore = NULL;
414
415 cleanup:
416 if (tmpstore != NULL)
417 free_keystore(tmpstore);
418 return (ret);
419 }
420
421 /*
422 * new_keystore - Allocates and initializes a Keystore object
423 *
424 * Arguments:
425 * NONE
426 *
427 * Returns:
428 * NULL - out of memory
429 * otherwise, returns a pointer to the newly allocated object,
430 * which should be freed with free_keystore() when no longer
431 * needed.
432 */
433 static keystore_t
434 *new_keystore(void)
435 {
436 keystore_t *tmpstore;
437
438 if ((tmpstore = (keystore_t *)malloc(sizeof (keystore_t))) == NULL) {
439 return (NULL);
440 }
441 tmpstore->dirty = B_FALSE;
442 tmpstore->new = B_FALSE;
443 tmpstore->path = NULL;
444 tmpstore->passphrase = NULL;
445 tmpstore->cafd = -1;
446 tmpstore->cacerts = NULL;
447 tmpstore->capath = NULL;
448 tmpstore->clcerts = NULL;
449 tmpstore->clpath = NULL;
450 tmpstore->pkeys = NULL;
451 tmpstore->keypath = NULL;
452
453 return (tmpstore);
454 }
455
456 /*
457 * free_keystore - Deallocates a Keystore object
458 *
459 * Arguments:
460 * keystore - The keystore to deallocate
461 *
462 * Returns:
463 * NONE
464 */
465 static void
466 free_keystore(keystore_t *keystore)
467 {
468 if (keystore->path != NULL)
469 free(keystore->path);
470 if (keystore->capath != NULL)
471 free(keystore->capath);
472 if (keystore->passphrase != NULL)
473 free(keystore->passphrase);
474 if (keystore->clpath != NULL)
475 free(keystore->clpath);
476 if (keystore->keypath != NULL)
477 free(keystore->keypath);
478
479 if (keystore->pkeys != NULL) {
480 sk_EVP_PKEY_pop_free(keystore->pkeys,
481 sunw_evp_pkey_free);
482 }
483 if (keystore->clcerts != NULL)
484 sk_X509_free(keystore->clcerts);
485 if (keystore->cacerts != NULL)
486 sk_X509_free(keystore->cacerts);
487 free(keystore);
488 }
489
490 /*
491 * close_keystore - Writes keystore to disk if needed, then
492 * unlocks and closes keystore.
493 *
494 * Arguments:
495 * err - Error object to append errors to
496 * keystore - Keystore which should be closed
497 * passwd - Password used to encrypt keystore
498 *
499 * Returns:
500 * 0 - Success - keystore is committed to disk, and unlocked
501 * non-zero - Failure, errors added to err
502 */
503 int
504 close_keystore(PKG_ERR *err, keystore_handle_t keystore_h,
505 keystore_passphrase_cb cb)
506 {
507 int ret = 0;
508 keystore_t *keystore = keystore_h;
509
510 if (keystore->dirty) {
511 /* write out the keystore first */
512 if (!write_keystore(err, keystore, cb)) {
513 pkgerr_add(err, PKGERR_WRITE,
514 gettext(ERR_KEYSTORE_WRITE),
515 keystore->path);
516 ret = 1;
517 goto cleanup;
518 }
519 }
520
521 if (!unlock_keystore(err, keystore)) {
522 pkgerr_add(err, PKGERR_UNLOCK, gettext(ERR_KEYSTORE_UNLOCK),
523 keystore->path);
524 ret = 1;
525 goto cleanup;
526 }
527
528 free_keystore(keystore);
529 cleanup:
530 return (ret);
531 }
532
533 /*
534 * merge_ca_cert - Adds a trusted certificate (trust anchor) to a keystore.
535 * certificate checked for validity dates and non-duplicity.
536 *
537 * Arguments:
538 * err - Error object to add errors to
539 * cacert - Certificate which to merge into keystore
540 * keystore - The keystore into which the certificate is merged
541 *
542 * Returns:
543 * 0 - Success - Certificate passes validity, and
544 * is merged into keystore
545 * non-zero - Failure, errors recorded in err
546 */
547 int
548 merge_ca_cert(PKG_ERR *err, X509 *cacert, keystore_handle_t keystore_h)
549 {
550
551 int ret = 0;
552 X509 *existing = NULL;
553 char *fname;
554 keystore_t *keystore = keystore_h;
555
556 /* check validity dates */
557 if (check_cert(err, cacert) != 0) {
558 ret = 1;
559 goto cleanup;
560 }
561
562 /* create the certificate's friendlyName */
563 fname = get_subject_display_name(cacert);
564
565 if (sunw_set_fname(fname, NULL, cacert) != 0) {
566 pkgerr_add(err, PKGERR_NOMEM, gettext(ERR_MEM));
567 ret = 1;
568 goto cleanup;
569 }
570
571 /* merge certificate into the keystore */
572 if (keystore->cacerts == NULL) {
573 /* no existing truststore, so make a new one */
574 if ((keystore->cacerts = sk_X509_new_null()) == NULL) {
575 pkgerr_add(err, PKGERR_NOMEM, gettext(ERR_MEM));
576 ret = 1;
577 goto cleanup;
578 }
579 } else {
580 /* existing truststore, make sure there's no duplicate */
581 if (sunw_find_fname(fname, NULL, keystore->cacerts,
582 NULL, &existing) < 0) {
583 pkgerr_add(err, PKGERR_INTERNAL,
584 gettext(ERR_KEYSTORE_INTERNAL),
585 __FILE__, __LINE__);
586 ERR_print_errors_fp(stderr);
587 ret = 1;
588 goto cleanup;
589 /* could not search properly! */
590 }
591 if (existing != NULL) {
592 /* whoops, found one already */
593 pkgerr_add(err, PKGERR_DUPLICATE,
594 gettext(ERR_KEYSTORE_DUPLICATECERT), fname);
595 ret = 1;
596 goto cleanup;
597 }
598 }
599
600 (void) sk_X509_push(keystore->cacerts, cacert);
601 keystore->dirty = B_TRUE;
602 cleanup:
603 if (existing != NULL)
604 X509_free(existing);
605 return (ret);
606 }
607
608 /*
609 * find_key_cert_pair - Searches a keystore for a matching
610 * public key certificate and private key, given an alias.
611 *
612 * Arguments:
613 * err - Error object to add errors to
614 * ks - Keystore to search
615 * alias - Name to used to match certificate's alias
616 * key - Resulting key is placed here
617 * cert - Resulting cert is placed here
618 *
619 * Returns:
620 * 0 - Success - Matching cert/key pair placed in key and cert.
621 * non-zero - Failure, errors recorded in err
622 */
623 int
624 find_key_cert_pair(PKG_ERR *err, keystore_handle_t ks_h, char *alias,
625 EVP_PKEY **key, X509 **cert)
626 {
627 X509 *tmpcert = NULL;
628 EVP_PKEY *tmpkey = NULL;
629 int ret = 0;
630 int items_found;
631 keystore_t *ks = ks_h;
632
633 if (key == NULL || cert == NULL) {
634 pkgerr_add(err, PKGERR_NOPUBKEY,
635 gettext(ERR_KEYSTORE_NOPUBCERTS), ks->path);
636 ret = 1;
637 goto cleanup;
638 }
639
640 if (ks->clcerts == NULL) {
641 /* no public certs */
642 pkgerr_add(err, PKGERR_NOPUBKEY,
643 gettext(ERR_KEYSTORE_NOCERTS), ks->path);
644 ret = 1;
645 goto cleanup;
646 }
647 if (ks->pkeys == NULL) {
648 /* no private keys */
649 pkgerr_add(err, PKGERR_NOPRIVKEY,
650 gettext(ERR_KEYSTORE_NOKEYS), ks->path);
651 ret = 1;
652 goto cleanup;
653 }
654
655 /* try the easy case first */
656 if ((sk_EVP_PKEY_num(ks->pkeys) == 1) &&
657 (sk_X509_num(ks->clcerts) == 1)) {
658 tmpkey = sk_EVP_PKEY_value(ks->pkeys, 0);
659 tmpcert = sk_X509_value(ks->clcerts, 0);
660 if (sunw_check_keys(tmpcert, tmpkey)) {
661 /*
662 * only one private key and public key cert, and they
663 * match, so use them
664 */
665 *key = tmpkey;
666 tmpkey = NULL;
667 *cert = tmpcert;
668 tmpcert = NULL;
669 goto cleanup;
670 }
671 }
672
673 /* Attempt to find the right pair given the alias */
674 items_found = sunw_find_fname(alias, ks->pkeys, ks->clcerts,
675 &tmpkey, &tmpcert);
676
677 if ((items_found < 0) ||
678 (items_found & (FOUND_PKEY | FOUND_CERT)) == 0) {
679 /* no key/cert pair found. bail. */
680 pkgerr_add(err, PKGERR_BADALIAS,
681 gettext(ERR_KEYSTORE_NOMATCH), alias);
682 ret = 1;
683 goto cleanup;
684 }
685
686 /* success */
687 *key = tmpkey;
688 tmpkey = NULL;
689 *cert = tmpcert;
690 tmpcert = NULL;
691
692 cleanup:
693
694 if (tmpcert != NULL)
695 (void) X509_free(tmpcert);
696
697 if (tmpkey != NULL)
698 sunw_evp_pkey_free(tmpkey);
699
700 return (ret);
701 }
702
703 /*
704 * find_ca_certs - Searches a keystore for trusted certificates
705 *
706 * Arguments:
707 * err - Error object to add errors to
708 * ks - Keystore to search
709 * cacerts - resulting set of trusted certs are placed here
710 *
711 * Returns:
712 * 0 - Success - trusted cert list returned in cacerts
713 * non-zero - Failure, errors recorded in err
714 */
715 int
716 find_ca_certs(PKG_ERR *err, keystore_handle_t ks_h, STACK_OF(X509) **cacerts)
717 {
718
719 keystore_t *ks = ks_h;
720
721 /* easy */
722 if (cacerts == NULL) {
723 pkgerr_add(err, PKGERR_INTERNAL,
724 gettext(ERR_KEYSTORE_INTERNAL), __FILE__, __LINE__);
725 return (1);
726 }
727
728 *cacerts = ks->cacerts;
729 return (0);
730 }
731
732 /*
733 * find_cl_certs - Searches a keystore for user certificates
734 *
735 * Arguments:
736 * err - Error object to add errors to
737 * ks - Keystore to search
738 * cacerts - resulting set of user certs are placed here
739 *
740 * No matching of any kind is performed.
741 * Returns:
742 * 0 - Success - trusted cert list returned in cacerts
743 * non-zero - Failure, errors recorded in err
744 */
745 /* ARGSUSED */
746 int
747 find_cl_certs(PKG_ERR *err, keystore_handle_t ks_h, STACK_OF(X509) **clcerts)
748 {
749 keystore_t *ks = ks_h;
750
751 /* easy */
752 *clcerts = ks->clcerts;
753 return (0);
754 }
755
756
757 /*
758 * merge_cert_and_key - Adds a user certificate and matching
759 * private key to a keystore.
760 * certificate checked for validity dates and non-duplicity.
761 *
762 * Arguments:
763 * err - Error object to add errors to
764 * cert - Certificate which to merge into keystore
765 * key - matching private key to 'cert'
766 * alias - Name which to store the cert and key under
767 * keystore - The keystore into which the certificate is merged
768 *
769 * Returns:
770 * 0 - Success - Certificate passes validity, and
771 * is merged into keystore, along with key
772 * non-zero - Failure, errors recorded in err
773 */
774 int
775 merge_cert_and_key(PKG_ERR *err, X509 *cert, EVP_PKEY *key, char *alias,
776 keystore_handle_t keystore_h)
777 {
778 X509 *existingcert = NULL;
779 EVP_PKEY *existingkey = NULL;
780 int ret = 0;
781 keystore_t *keystore = keystore_h;
782
783 /* check validity dates */
784 if (check_cert(err, cert) != 0) {
785 ret = 1;
786 goto cleanup;
787 }
788
789 /* set the friendlyName of the key and cert to the supplied alias */
790 if (sunw_set_fname(alias, key, cert) != 0) {
791 pkgerr_add(err, PKGERR_NOMEM, gettext(ERR_MEM));
792 ret = 1;
793 goto cleanup;
794 }
795
796 /* merge certificate and key into the keystore */
797 if (keystore->clcerts == NULL) {
798 /* no existing truststore, so make a new one */
799 if ((keystore->clcerts = sk_X509_new_null()) == NULL) {
800 pkgerr_add(err, PKGERR_NOMEM, gettext(ERR_MEM));
801 ret = 1;
802 goto cleanup;
803 }
804 } else {
805 /* existing certstore, make sure there's no duplicate */
806 if (sunw_find_fname(alias, NULL, keystore->clcerts,
807 NULL, &existingcert) < 0) {
808 pkgerr_add(err, PKGERR_INTERNAL,
809 gettext(ERR_KEYSTORE_INTERNAL),
810 __FILE__, __LINE__);
811 ERR_print_errors_fp(stderr);
812 ret = 1;
813 goto cleanup;
814 /* could not search properly! */
815 }
816 if (existingcert != NULL) {
817 /* whoops, found one already */
818 pkgerr_add(err, PKGERR_DUPLICATE,
819 gettext(ERR_KEYSTORE_DUPLICATECERT), alias);
820 ret = 1;
821 goto cleanup;
822 }
823 }
824
825 if (keystore->pkeys == NULL) {
826 /* no existing keystore, so make a new one */
827 if ((keystore->pkeys = sk_EVP_PKEY_new_null()) == NULL) {
828 pkgerr_add(err, PKGERR_NOMEM, gettext(ERR_MEM));
829 ret = 1;
830 goto cleanup;
831 }
832 } else {
833 /* existing keystore, so make sure there's no duplicate entry */
834 if (sunw_find_fname(alias, keystore->pkeys, NULL,
835 &existingkey, NULL) < 0) {
836 pkgerr_add(err, PKGERR_INTERNAL,
837 gettext(ERR_KEYSTORE_INTERNAL),
838 __FILE__, __LINE__);
839 ERR_print_errors_fp(stderr);
840 ret = 1;
841 goto cleanup;
842 /* could not search properly! */
843 }
844 if (existingkey != NULL) {
845 /* whoops, found one already */
846 pkgerr_add(err, PKGERR_DUPLICATE,
847 gettext(ERR_KEYSTORE_DUPLICATEKEY), alias);
848 ret = 1;
849 goto cleanup;
850 }
851 }
852
853 (void) sk_X509_push(keystore->clcerts, cert);
854 (void) sk_EVP_PKEY_push(keystore->pkeys, key);
855 keystore->dirty = B_TRUE;
856 cleanup:
857 if (existingcert != NULL)
858 (void) X509_free(existingcert);
859 if (existingkey != NULL)
860 (void) sunw_evp_pkey_free(existingkey);
861 return (ret);
862 }
863
864 /*
865 * delete_cert_and_keys - Deletes one or more certificates
866 * and matching private keys from a keystore.
867 *
868 * Arguments:
869 * err - Error object to add errors to
870 * ks - The keystore from which certs and keys are deleted
871 * alias - Name which to search for certificates and keys
872 * to delete
873 *
874 * Returns:
875 * 0 - Success - All trusted certs which match 'alias'
876 * are deleted. All user certificates
877 * which match 'alias' are deleted, along
878 * with the matching private key.
879 * non-zero - Failure, errors recorded in err
880 */
881 int
882 delete_cert_and_keys(PKG_ERR *err, keystore_handle_t ks_h, char *alias)
883 {
884 X509 *existingcert;
885 EVP_PKEY *existingkey;
886 int i;
887 char *fname = NULL;
888 boolean_t found = B_FALSE;
889 keystore_t *ks = ks_h;
890
891 /* delete any and all client certs with the supplied name */
892 if (ks->clcerts != NULL) {
893 for (i = 0; i < sk_X509_num(ks->clcerts); i++) {
894 existingcert = sk_X509_value(ks->clcerts, i);
895 if (sunw_get_cert_fname(GETDO_COPY,
896 existingcert, &fname) >= 0) {
897 if (streq(fname, alias)) {
898 /* match, so nuke it */
899 existingcert =
900 sk_X509_delete(ks->clcerts, i);
901 X509_free(existingcert);
902 existingcert = NULL;
903 found = B_TRUE;
904 }
905 (void) OPENSSL_free(fname);
906 fname = NULL;
907 }
908 }
909 if (sk_X509_num(ks->clcerts) <= 0) {
910 /* we deleted all the client certs */
911 sk_X509_free(ks->clcerts);
912 ks->clcerts = NULL;
913 }
914 }
915
916 /* and now the private keys */
917 if (ks->pkeys != NULL) {
918 for (i = 0; i < sk_EVP_PKEY_num(ks->pkeys); i++) {
919 existingkey = sk_EVP_PKEY_value(ks->pkeys, i);
920 if (sunw_get_pkey_fname(GETDO_COPY,
921 existingkey, &fname) >= 0) {
922 if (streq(fname, alias)) {
923 /* match, so nuke it */
924 existingkey =
925 sk_EVP_PKEY_delete(ks->pkeys, i);
926 sunw_evp_pkey_free(existingkey);
927 existingkey = NULL;
928 found = B_TRUE;
929 }
930 (void) OPENSSL_free(fname);
931 fname = NULL;
932 }
933 }
934 if (sk_EVP_PKEY_num(ks->pkeys) <= 0) {
935 /* we deleted all the private keys */
936 sk_EVP_PKEY_free(ks->pkeys);
937 ks->pkeys = NULL;
938 }
939 }
940
941 /* finally, remove any trust anchors that match */
942
943 if (ks->cacerts != NULL) {
944 for (i = 0; i < sk_X509_num(ks->cacerts); i++) {
945 existingcert = sk_X509_value(ks->cacerts, i);
946 if (sunw_get_cert_fname(GETDO_COPY,
947 existingcert, &fname) >= 0) {
948 if (streq(fname, alias)) {
949 /* match, so nuke it */
950 existingcert =
951 sk_X509_delete(ks->cacerts, i);
952 X509_free(existingcert);
953 existingcert = NULL;
954 found = B_TRUE;
955 }
956 (void) OPENSSL_free(fname);
957 fname = NULL;
958 }
959 }
960 if (sk_X509_num(ks->cacerts) <= 0) {
961 /* we deleted all the CA certs */
962 sk_X509_free(ks->cacerts);
963 ks->cacerts = NULL;
964 }
965 }
966
967 if (found) {
968 ks->dirty = B_TRUE;
969 return (0);
970 } else {
971 /* no certs or keys deleted */
972 pkgerr_add(err, PKGERR_NOALIASMATCH,
973 gettext(ERR_KEYSTORE_NOCERTKEY),
974 alias, ks->path);
975 return (1);
976 }
977 }
978
979 /*
980 * check_cert - Checks certificate validity. This routine
981 * checks that the current time falls within the period
982 * of validity for the cert.
983 *
984 * Arguments:
985 * err - Error object to add errors to
986 * cert - The certificate to check
987 *
988 * Returns:
989 * 0 - Success - Certificate checks out
990 * non-zero - Failure, errors and reasons recorded in err
991 */
992 int
993 check_cert(PKG_ERR *err, X509 *cert)
994 {
995 char currtimestr[ATTR_MAX];
996 time_t currtime;
997 char *r;
998 /* get current time */
999 if ((currtime = time(NULL)) == (time_t)-1) {
1000 pkgerr_add(err, PKGERR_TIME, gettext(ERR_CURR_TIME));
1001 return (1);
1002 }
1003
1004 (void) strlcpy(currtimestr, ctime(&currtime), ATTR_MAX);
1005
1006 /* trim whitespace from end of time string */
1007 for (r = (currtimestr + strlen(currtimestr) - 1); isspace(*r); r--) {
1008 *r = '\0';
1009 }
1010 /* check validity of cert */
1011 switch (sunw_check_cert_times(CHK_BOTH, cert)) {
1012 case CHKERR_TIME_OK:
1013 /* Current time meets requested checks */
1014 break;
1015 case CHKERR_TIME_BEFORE_BAD:
1016 /* 'not before' field is invalid */
1017 case CHKERR_TIME_AFTER_BAD:
1018 /* 'not after' field is invalid */
1019 pkgerr_add(err, PKGERR_TIME, gettext(ERR_CERT_TIME_BAD));
1020 return (1);
1021 case CHKERR_TIME_IS_BEFORE:
1022 /* Current time is before 'not before' */
1023 case CHKERR_TIME_HAS_EXPIRED:
1024 /*
1025 * Ignore expiration time since the trust cert used to
1026 * verify the certs used to sign Sun patches is already
1027 * expired. Once the patches get resigned with the new
1028 * cert we will check expiration against the time the
1029 * patch was signed and not the time it is installed.
1030 */
1031 return (0);
1032 default:
1033 pkgerr_add(err, PKGERR_INTERNAL,
1034 gettext(ERR_KEYSTORE_INTERNAL),
1035 __FILE__, __LINE__);
1036 return (1);
1037 }
1038
1039 /* all checks ok */
1040 return (0);
1041 }
1042
1043 /*
1044 * check_cert - Checks certificate validity. This routine
1045 * checks everything that check_cert checks, and additionally
1046 * verifies that the private key and corresponding public
1047 * key are indeed a pair.
1048 *
1049 * Arguments:
1050 * err - Error object to add errors to
1051 * cert - The certificate to check
1052 * key - the key to check
1053 * Returns:
1054 * 0 - Success - Certificate checks out
1055 * non-zero - Failure, errors and reasons recorded in err
1056 */
1057 int
1058 check_cert_and_key(PKG_ERR *err, X509 *cert, EVP_PKEY *key)
1059 {
1060
1061 /* check validity dates */
1062 if (check_cert(err, cert) != 0) {
1063 return (1);
1064 }
1065
1066 /* check key pair match */
1067 if (sunw_check_keys(cert, key) == 0) {
1068 pkgerr_add(err, PKGERR_VERIFY, gettext(ERR_MISMATCHED_KEYS),
1069 get_subject_display_name(cert));
1070 return (1);
1071 }
1072
1073 /* all checks OK */
1074 return (0);
1075 }
1076
1077 /* ------------------ private functions ---------------------- */
1078
1079 /*
1080 * verify_keystore_integrity - Searches for the remnants
1081 * of a failed or aborted keystore modification, and
1082 * cleans up the files, retstores the keystore to a known
1083 * state.
1084 *
1085 * Arguments:
1086 * err - Error object to add errors to
1087 * keystore_file - Base directory or filename of keystore
1088 * app - Application making request
1089 *
1090 * Returns:
1091 * 0 - Success - Keystore is restored, or untouched in the
1092 * case that cleanup was unnecessary
1093 * non-zero - Failure, errors and reasons recorded in err
1094 */
1095 static boolean_t
1096 verify_keystore_integrity(PKG_ERR *err, keystore_t *keystore)
1097 {
1098 if (keystore->capath != NULL) {
1099 if (!restore_keystore_file(err, keystore->capath)) {
1100 return (B_FALSE);
1101 }
1102 }
1103 if (keystore->clpath != NULL) {
1104 if (!restore_keystore_file(err, keystore->clpath)) {
1105 return (B_FALSE);
1106 }
1107 }
1108 if (keystore->keypath != NULL) {
1109 if (!restore_keystore_file(err, keystore->keypath)) {
1110 return (B_FALSE);
1111 }
1112 }
1113 return (B_TRUE);
1114 }
1115
1116 /*
1117 * restore_keystore_file - restores a keystore file to
1118 * a known state.
1119 *
1120 * Keystore files can possibly be corrupted by a variety
1121 * of error conditions during reading/writing. This
1122 * routine, along with write_keystore_file, tries to
1123 * maintain keystore integrity by writing the files
1124 * out in a particular order, minimizing the time period
1125 * that the keystore is in an indeterminate state.
1126 *
1127 * With the current implementation, there are some failures
1128 * that are wholly unrecoverable, such as disk corruption.
1129 * These routines attempt to minimize the risk, but not
1130 * eliminate it. When better, atomic operations are available
1131 * (such as a trued atabase with commit, rollback, and
1132 * guaranteed atomicity), this implementation should use that.
1133 *
1134 * Arguments:
1135 * err - Error object to add errors to
1136 * keystore_file - keystore file path to restore.
1137 *
1138 * Returns:
1139 * 0 - Success - Keystore file is restored, or untouched in the
1140 * case that cleanup was unnecessary
1141 * non-zero - Failure, errors and reasons recorded in err
1142 */
1143 /* ARGSUSED */
1144 static boolean_t
1145 restore_keystore_file(PKG_ERR *err, char *keystore_file)
1146 {
1147 char newpath[MAXPATHLEN];
1148 char backuppath[MAXPATHLEN];
1149 int newfd;
1150 struct stat buf;
1151 int len;
1152
1153 if (((len = snprintf(newpath, MAXPATHLEN, "%s.new",
1154 keystore_file)) < 0) ||
1155 (len >= ATTR_MAX)) {
1156 pkgerr_add(err, PKGERR_WEB, gettext(ERR_LEN), keystore_file);
1157 return (B_FALSE);
1158 }
1159
1160 if (((len = snprintf(backuppath, MAXPATHLEN, "%s.bak",
1161 keystore_file)) < 0) ||
1162 (len >= ATTR_MAX)) {
1163 pkgerr_add(err, PKGERR_WEB, gettext(ERR_LEN), keystore_file);
1164 return (B_FALSE);
1165 }
1166
1167 if ((newfd = open(newpath, O_RDWR|O_NONBLOCK, 0)) != -1) {
1168 if (fstat(newfd, &buf) != -1) {
1169 if (S_ISREG(buf.st_mode)) {
1170 /*
1171 * restore the file, waiting on it
1172 * to be free for locking, or for
1173 * it to disappear
1174 */
1175 if (!wait_restore(newfd, keystore_file,
1176 newpath, backuppath)) {
1177 pkgerr_add(err, PKGERR_WRITE,
1178 gettext(ERR_WRITE),
1179 newpath, strerror(errno));
1180 (void) close(newfd);
1181 return (B_FALSE);
1182 } else {
1183 return (B_TRUE);
1184 }
1185 } else {
1186 /* "new" file is not a regular file */
1187 pkgerr_add(err, PKGERR_WRITE,
1188 gettext(ERR_NOT_REG), newpath);
1189 (void) close(newfd);
1190 return (B_FALSE);
1191 }
1192 } else {
1193 /* couldn't stat "new" file */
1194 pkgerr_add(err, PKGERR_WRITE,
1195 gettext(ERR_WRITE), newpath,
1196 strerror(errno));
1197 (void) close(newfd);
1198 return (B_FALSE);
1199 }
1200 } else {
1201 /* "new" file doesn't exist */
1202 return (B_TRUE);
1203 }
1204 }
1205
1206 static boolean_t
1207 wait_restore(int newfd, char *keystore_file,
1208 char *origpath, char *backuppath)
1209 {
1210 struct stat buf;
1211 FILE *newstream;
1212 PKCS12 *p12;
1213
1214 (void) alarm(LOCK_TIMEOUT);
1215 if (file_lock(newfd, F_WRLCK, 1) == -1) {
1216 /* could not lock file */
1217 (void) alarm(0);
1218 return (B_FALSE);
1219 }
1220 (void) alarm(0);
1221
1222 if (fstat(newfd, &buf) != -1) {
1223 if (S_ISREG(buf.st_mode)) {
1224 /*
1225 * The new file still
1226 * exists, with no
1227 * owner. It must be
1228 * the result of an
1229 * aborted update.
1230 */
1231 newstream = fdopen(newfd, "r");
1232 if ((p12 =
1233 d2i_PKCS12_fp(newstream,
1234 NULL)) != NULL) {
1235 /*
1236 * The file
1237 * appears
1238 * complete.
1239 * Replace the
1240 * exsisting
1241 * keystore
1242 * file with
1243 * this one
1244 */
1245 (void) rename(keystore_file, backuppath);
1246 (void) rename(origpath, keystore_file);
1247 PKCS12_free(p12);
1248 } else {
1249 /* The file is not complete. Remove it */
1250 (void) remove(origpath);
1251 }
1252 /* remove backup file */
1253 (void) remove(backuppath);
1254 (void) fclose(newstream);
1255 (void) close(newfd);
1256 return (B_TRUE);
1257 } else {
1258 /*
1259 * new file exists, but is not a
1260 * regular file
1261 */
1262 (void) close(newfd);
1263 return (B_FALSE);
1264 }
1265 } else {
1266 /*
1267 * could not stat file. Unless
1268 * the reason was that the file
1269 * is now gone, this is an error
1270 */
1271 if (errno != ENOENT) {
1272 (void) close(newfd);
1273 return (B_FALSE);
1274 }
1275 /*
1276 * otherwise, file is gone. The process
1277 * that held the lock must have
1278 * successfully cleaned up and
1279 * exited with a valid keystore
1280 * state
1281 */
1282 (void) close(newfd);
1283 return (B_TRUE);
1284 }
1285 }
1286
1287 /*
1288 * resolve_paths - figure out if we are dealing with a single-file
1289 * or multi-file keystore
1290 *
1291 * The flags tell resolve_paths how to behave:
1292 *
1293 * KEYSTORE_PATH_SOFT
1294 * If the keystore file does not exist at <base>/<app> then
1295 * use <base> as the path to the keystore. This can be used,
1296 * for example, to access an app-specific keystore iff it
1297 * exists, otherwise revert back to an app-generic keystore.
1298 *
1299 * KEYSTORE_PATH_HARD
1300 * Always use the keystore located at <keystore_path>/<app>.
1301 * In read/write mode, if the files do not exist, then
1302 * they will be created. This is used to avoid falling
1303 * back to an app-generic keystore path when the app-specific
1304 * one does not exist.
1305 *
1306 * Arguments:
1307 * err - Error object to add errors to
1308 * keystore_file - base keystore file path to lock
1309 * app - Application making requests
1310 * flags - Control flags (see above description)
1311 * keystore - object which is being locked
1312 *
1313 * Returns:
1314 * B_TRUE - Success - Keystore file is locked, paths to
1315 * appropriate files placed in keystore.
1316 * B_FALSE - Failure, errors and reasons recorded in err
1317 */
1318 static boolean_t
1319 resolve_paths(PKG_ERR *err, char *keystore_file, char *app,
1320 long flags, keystore_t *keystore)
1321 {
1322 char storepath[PATH_MAX];
1323 struct stat buf;
1324 boolean_t multi = B_FALSE;
1325 int fd1, fd2, len;
1326
1327 /*
1328 * figure out whether we are dealing with a single-file keystore
1329 * or a multi-file keystore
1330 */
1331 if (app != NULL) {
1332 if (((len = snprintf(storepath, PATH_MAX, "%s/%s",
1333 keystore_file, app)) < 0) ||
1334 (len >= ATTR_MAX)) {
1335 pkgerr_add(err, PKGERR_WEB, gettext(ERR_LEN),
1336 keystore_file);
1337 return (B_FALSE);
1338 }
1339
1340 if (((fd1 = open(storepath, O_NONBLOCK|O_RDONLY)) == -1) ||
1341 (fstat(fd1, &buf) == -1) ||
1342 !S_ISDIR(buf.st_mode)) {
1343 /*
1344 * app-specific does not exist
1345 * fallback to app-generic, if flags say we can
1346 */
1347 if ((flags & KEYSTORE_PATH_MASK) ==
1348 KEYSTORE_PATH_SOFT) {
1349
1350 if (((fd2 = open(keystore_file,
1351 O_NONBLOCK|O_RDONLY)) != -1) &&
1352 (fstat(fd2, &buf) != -1)) {
1353 if (S_ISDIR(buf.st_mode)) {
1354 /*
1355 * app-generic dir
1356 * exists, so use it
1357 * as a multi-file
1358 * keystore
1359 */
1360 multi = B_TRUE;
1361 app = NULL;
1362 } else if (S_ISREG(buf.st_mode)) {
1363 /*
1364 * app-generic file exists, so
1365 * use it as a single file ks
1366 */
1367 multi = B_FALSE;
1368 app = NULL;
1369 }
1370 }
1371 }
1372 }
1373 if (fd1 != -1)
1374 (void) close(fd1);
1375 if (fd2 != -1)
1376 (void) close(fd2);
1377 } else {
1378 if (((fd1 = open(keystore_file,
1379 O_NONBLOCK|O_RDONLY)) != -1) &&
1380 (fstat(fd1, &buf) != -1) &&
1381 S_ISDIR(buf.st_mode)) {
1382 /*
1383 * app-generic dir exists, so use
1384 * it as a multi-file keystore
1385 */
1386 multi = B_TRUE;
1387 }
1388 if (fd1 != -1)
1389 (void) close(fd1);
1390 }
1391
1392 if (app != NULL) {
1393 /* app-specific keystore */
1394 (void) snprintf(storepath, PATH_MAX, "%s/%s/%s",
1395 keystore_file, app, TRUSTSTORE);
1396 keystore->capath = xstrdup(storepath);
1397 (void) snprintf(storepath, PATH_MAX, "%s/%s/%s",
1398 keystore_file, app, CERTSTORE);
1399 keystore->clpath = xstrdup(storepath);
1400 (void) snprintf(storepath, PATH_MAX, "%s/%s/%s",
1401 keystore_file, app, KEYSTORE);
1402 keystore->keypath = xstrdup(storepath);
1403 } else {
1404 /* app-generic keystore */
1405 if (!multi) {
1406 /* single-file app-generic keystore */
1407 keystore->capath = xstrdup(keystore_file);
1408 keystore->keypath = NULL;
1409 keystore->clpath = NULL;
1410 } else {
1411 /* multi-file app-generic keystore */
1412 (void) snprintf(storepath, PATH_MAX, "%s/%s",
1413 keystore_file, TRUSTSTORE);
1414 keystore->capath = xstrdup(storepath);
1415 (void) snprintf(storepath, PATH_MAX, "%s/%s",
1416 keystore_file, CERTSTORE);
1417 keystore->clpath = xstrdup(storepath);
1418 (void) snprintf(storepath, PATH_MAX, "%s/%s",
1419 keystore_file, KEYSTORE);
1420 keystore->keypath = xstrdup(storepath);
1421 }
1422 }
1423
1424 return (B_TRUE);
1425 }
1426
1427 /*
1428 * lock_keystore - Locks a keystore for shared (read-only)
1429 * or exclusive (read-write) access.
1430 *
1431 * The flags tell lock_keystore how to behave:
1432 *
1433 * KEYSTORE_ACCESS_READONLY
1434 * opens keystore read-only. Attempts to modify results in an error
1435 *
1436 * KEYSTORE_ACCESS_READWRITE
1437 * opens keystore read-write
1438 *
1439 * KEYSTORE_PATH_SOFT
1440 * If the keystore file does not exist at <base>/<app> then
1441 * use <base> as the path to the keystore. This can be used,
1442 * for example, to access an app-specific keystore iff it
1443 * exists, otherwise revert back to an app-generic keystore.
1444 *
1445 * KEYSTORE_PATH_HARD
1446 * Always use the keystore located at <keystore_path>/<app>.
1447 * In read/write mode, if the files do not exist, then
1448 * they will be created. This is used to avoid falling
1449 * back to an app-generic keystore path when the app-specific
1450 * one does not exist.
1451 *
1452 * Arguments:
1453 * err - Error object to add errors to
1454 * flags - Control flags (see above description)
1455 * keystore - object which is being locked
1456 *
1457 * Returns:
1458 * 0 - Success - Keystore file is locked, paths to
1459 * appropriate files placed in keystore.
1460 * non-zero - Failure, errors and reasons recorded in err
1461 */
1462 static boolean_t
1463 lock_keystore(PKG_ERR *err, long flags, keystore_t *keystore)
1464 {
1465 boolean_t ret = B_TRUE;
1466 struct stat buf;
1467
1468 switch (flags & KEYSTORE_ACCESS_MASK) {
1469 case KEYSTORE_ACCESS_READONLY:
1470 if ((keystore->cafd =
1471 open(keystore->capath, O_NONBLOCK|O_RDONLY)) == -1) {
1472 if (errno == ENOENT) {
1473 /*
1474 * no keystore. try to create an
1475 * empty one so we can lock on it and
1476 * prevent others from gaining
1477 * exclusive access. It will be
1478 * deleted when the keystore is closed.
1479 */
1480 if ((keystore->cafd =
1481 open(keystore->capath,
1482 O_NONBLOCK|O_RDWR|O_CREAT|O_EXCL,
1483 S_IRUSR|S_IWUSR)) == -1) {
1484 pkgerr_add(err, PKGERR_READ,
1485 gettext(ERR_NO_KEYSTORE),
1486 keystore->capath);
1487 ret = B_FALSE;
1488 goto cleanup;
1489 }
1490 } else {
1491 pkgerr_add(err, PKGERR_READ,
1492 gettext(ERR_KEYSTORE_OPEN),
1493 keystore->capath, strerror(errno));
1494 ret = B_FALSE;
1495 goto cleanup;
1496 }
1497 }
1498 if (fstat(keystore->cafd, &buf) != -1) {
1499 if (S_ISREG(buf.st_mode)) {
1500 if (file_lock(keystore->cafd, F_RDLCK,
1501 0) == -1) {
1502 pkgerr_add(err, PKGERR_LOCKED,
1503 gettext(ERR_KEYSTORE_LOCKED_READ),
1504 keystore->capath);
1505 ret = B_FALSE;
1506 goto cleanup;
1507 }
1508 } else {
1509 /* ca file not a regular file! */
1510 pkgerr_add(err, PKGERR_READ,
1511 gettext(ERR_NOT_REG),
1512 keystore->capath);
1513 ret = B_FALSE;
1514 goto cleanup;
1515 }
1516 } else {
1517 pkgerr_add(err, PKGERR_READ,
1518 gettext(ERR_KEYSTORE_OPEN),
1519 keystore->capath, strerror(errno));
1520 ret = B_FALSE;
1521 goto cleanup;
1522 }
1523 break;
1524 case KEYSTORE_ACCESS_READWRITE:
1525
1526 if ((keystore->cafd = open(keystore->capath,
1527 O_RDWR|O_NONBLOCK)) == -1) {
1528 /* does not exist. try to create an empty one */
1529 if (errno == ENOENT) {
1530 if ((keystore->cafd =
1531 open(keystore->capath,
1532 O_NONBLOCK|O_RDWR|O_CREAT|O_EXCL,
1533 S_IRUSR|S_IWUSR)) == -1) {
1534 pkgerr_add(err, PKGERR_READ,
1535 gettext(ERR_KEYSTORE_WRITE),
1536 keystore->capath);
1537 ret = B_FALSE;
1538 goto cleanup;
1539 }
1540 } else {
1541 pkgerr_add(err, PKGERR_READ,
1542 gettext(ERR_KEYSTORE_OPEN),
1543 keystore->capath, strerror(errno));
1544 ret = B_FALSE;
1545 goto cleanup;
1546 }
1547 }
1548 if (fstat(keystore->cafd, &buf) != -1) {
1549 if (S_ISREG(buf.st_mode)) {
1550 if (file_lock(keystore->cafd, F_WRLCK,
1551 0) == -1) {
1552 pkgerr_add(err, PKGERR_LOCKED,
1553 gettext(ERR_KEYSTORE_LOCKED),
1554 keystore->capath);
1555 ret = B_FALSE;
1556 goto cleanup;
1557 }
1558 } else {
1559 /* ca file not a regular file! */
1560 pkgerr_add(err, PKGERR_READ,
1561 gettext(ERR_NOT_REG),
1562 keystore->capath);
1563 ret = B_FALSE;
1564 goto cleanup;
1565 }
1566 } else {
1567 pkgerr_add(err, PKGERR_READ,
1568 gettext(ERR_KEYSTORE_OPEN),
1569 keystore->capath, strerror(errno));
1570 ret = B_FALSE;
1571 goto cleanup;
1572 }
1573
1574 break;
1575 default:
1576 pkgerr_add(err, PKGERR_INTERNAL,
1577 gettext(ERR_KEYSTORE_INTERNAL),
1578 __FILE__, __LINE__);
1579 ret = B_FALSE;
1580 goto cleanup;
1581 }
1582
1583 cleanup:
1584 if (!ret) {
1585 if (keystore->cafd > 0) {
1586 (void) file_unlock(keystore->cafd);
1587 (void) close(keystore->cafd);
1588 keystore->cafd = -1;
1589 }
1590
1591 if (keystore->capath != NULL)
1592 free(keystore->capath);
1593 if (keystore->clpath != NULL)
1594 free(keystore->clpath);
1595 if (keystore->keypath != NULL)
1596 free(keystore->keypath);
1597 keystore->capath = NULL;
1598 keystore->clpath = NULL;
1599 keystore->keypath = NULL;
1600 }
1601
1602 return (ret);
1603 }
1604
1605 /*
1606 * unlock_keystore - Unocks a keystore
1607 *
1608 * Arguments:
1609 * err - Error object to add errors to
1610 * keystore - keystore object to unlock
1611 * Returns:
1612 * 0 - Success - Keystore files are unlocked, files are closed,
1613 * non-zero - Failure, errors and reasons recorded in err
1614 */
1615 /* ARGSUSED */
1616 static boolean_t
1617 unlock_keystore(PKG_ERR *err, keystore_t *keystore)
1618 {
1619
1620 /*
1621 * Release lock on the CA file.
1622 * Delete file if it is empty
1623 */
1624 if (file_empty(keystore->capath)) {
1625 (void) remove(keystore->capath);
1626 }
1627
1628 (void) file_unlock(keystore->cafd);
1629 (void) close(keystore->cafd);
1630 return (B_TRUE);
1631 }
1632
1633 /*
1634 * read_keystore - Reads keystore files of disk, parses
1635 * into internal structures.
1636 *
1637 * Arguments:
1638 * err - Error object to add errors to
1639 * keystore - keystore object to read into
1640 * cb - callback to get password, if required
1641 * Returns:
1642 * 0 - Success - Keystore files are read, and placed
1643 * into keystore structure.
1644 * non-zero - Failure, errors and reasons recorded in err
1645 */
1646 static boolean_t
1647 read_keystore(PKG_ERR *err, keystore_t *keystore, keystore_passphrase_cb cb)
1648 {
1649 boolean_t ret = B_TRUE;
1650 PKCS12 *p12 = NULL;
1651 boolean_t ca_empty;
1652 boolean_t have_passwd = B_FALSE;
1653 boolean_t cl_empty = B_TRUE;
1654 boolean_t key_empty = B_TRUE;
1655
1656 ca_empty = file_empty(keystore->capath);
1657
1658 if (keystore->clpath != NULL)
1659 cl_empty = file_empty(keystore->clpath);
1660 if (keystore->keypath != NULL)
1661 key_empty = file_empty(keystore->keypath);
1662
1663 if (ca_empty && cl_empty && key_empty) {
1664 keystore->new = B_TRUE;
1665 }
1666
1667 if (!ca_empty) {
1668 /* first read the ca file */
1669 if ((p12 = read_keystore_file(err,
1670 keystore->capath)) == NULL) {
1671 pkgerr_add(err, PKGERR_CORRUPT,
1672 gettext(ERR_KEYSTORE_CORRUPT), keystore->capath);
1673 ret = B_FALSE;
1674 goto cleanup;
1675 }
1676
1677 /* Get password, using callback if necessary */
1678 if (!have_passwd) {
1679 if (!get_keystore_passwd(err, p12, cb, keystore)) {
1680 ret = B_FALSE;
1681 goto cleanup;
1682 }
1683 have_passwd = B_TRUE;
1684 }
1685
1686 /* decrypt and parse keystore file */
1687 if (sunw_PKCS12_contents(p12, keystore->passphrase,
1688 &keystore->pkeys, &keystore->cacerts) < 0) {
1689 /* could not parse the contents */
1690 pkgerr_add(err, PKGERR_CORRUPT,
1691 gettext(ERR_KEYSTORE_CORRUPT), keystore->capath);
1692 ret = B_FALSE;
1693 goto cleanup;
1694 }
1695
1696 PKCS12_free(p12);
1697 p12 = NULL;
1698 } else {
1699
1700 /*
1701 * truststore is empty, so we don't have any trusted
1702 * certs
1703 */
1704 keystore->cacerts = NULL;
1705 }
1706
1707 /*
1708 * if there is no cl file or key file, use the cl's and key's found
1709 * in the ca file
1710 */
1711 if (keystore->clpath == NULL && !ca_empty) {
1712 if (sunw_split_certs(keystore->pkeys, keystore->cacerts,
1713 &keystore->clcerts, NULL) < 0) {
1714 pkgerr_add(err, PKGERR_CORRUPT,
1715 gettext(ERR_KEYSTORE_CORRUPT), keystore->capath);
1716 ret = B_FALSE;
1717 goto cleanup;
1718 }
1719 } else {
1720 /*
1721 * files are in separate files. read keys out of the keystore
1722 * certs out of the certstore, if they are not empty
1723 */
1724 if (!cl_empty) {
1725 if ((p12 = read_keystore_file(err,
1726 keystore->clpath)) == NULL) {
1727 pkgerr_add(err, PKGERR_CORRUPT,
1728 gettext(ERR_KEYSTORE_CORRUPT),
1729 keystore->clpath);
1730 ret = B_FALSE;
1731 goto cleanup;
1732 }
1733
1734 /* Get password, using callback if necessary */
1735 if (!have_passwd) {
1736 if (!get_keystore_passwd(err, p12, cb,
1737 keystore)) {
1738 ret = B_FALSE;
1739 goto cleanup;
1740 }
1741 have_passwd = B_TRUE;
1742 }
1743
1744 if (check_password(p12,
1745 keystore->passphrase) == B_FALSE) {
1746 /*
1747 * password in client cert file
1748 * is different than
1749 * the one in the other files!
1750 */
1751 pkgerr_add(err, PKGERR_BADPASS,
1752 gettext(ERR_MISMATCHPASS),
1753 keystore->clpath,
1754 keystore->capath, keystore->path);
1755 ret = B_FALSE;
1756 goto cleanup;
1757 }
1758
1759 if (sunw_PKCS12_contents(p12, keystore->passphrase,
1760 NULL, &keystore->clcerts) < 0) {
1761 /* could not parse the contents */
1762 pkgerr_add(err, PKGERR_CORRUPT,
1763 gettext(ERR_KEYSTORE_CORRUPT),
1764 keystore->clpath);
1765 ret = B_FALSE;
1766 goto cleanup;
1767 }
1768
1769 PKCS12_free(p12);
1770 p12 = NULL;
1771 } else {
1772 keystore->clcerts = NULL;
1773 }
1774
1775 if (!key_empty) {
1776 if ((p12 = read_keystore_file(err,
1777 keystore->keypath)) == NULL) {
1778 pkgerr_add(err, PKGERR_CORRUPT,
1779 gettext(ERR_KEYSTORE_CORRUPT),
1780 keystore->keypath);
1781 ret = B_FALSE;
1782 goto cleanup;
1783 }
1784
1785 /* Get password, using callback if necessary */
1786 if (!have_passwd) {
1787 if (!get_keystore_passwd(err, p12, cb,
1788 keystore)) {
1789 ret = B_FALSE;
1790 goto cleanup;
1791 }
1792 have_passwd = B_TRUE;
1793 }
1794
1795 if (check_password(p12,
1796 keystore->passphrase) == B_FALSE) {
1797 pkgerr_add(err, PKGERR_BADPASS,
1798 gettext(ERR_MISMATCHPASS),
1799 keystore->keypath,
1800 keystore->capath, keystore->path);
1801 ret = B_FALSE;
1802 goto cleanup;
1803 }
1804
1805 if (sunw_PKCS12_contents(p12, keystore->passphrase,
1806 &keystore->pkeys, NULL) < 0) {
1807 /* could not parse the contents */
1808 pkgerr_add(err, PKGERR_CORRUPT,
1809 gettext(ERR_KEYSTORE_CORRUPT),
1810 keystore->keypath);
1811 ret = B_FALSE;
1812 goto cleanup;
1813 }
1814
1815 PKCS12_free(p12);
1816 p12 = NULL;
1817 } else {
1818 keystore->pkeys = NULL;
1819 }
1820 }
1821
1822 cleanup:
1823 if (p12 != NULL)
1824 PKCS12_free(p12);
1825 return (ret);
1826 }
1827
1828 /*
1829 * get_keystore_password - retrieves pasword used to
1830 * decrypt PKCS12 structure.
1831 *
1832 * Arguments:
1833 * err - Error object to add errors to
1834 * p12 - PKCS12 structure which returned password should
1835 * decrypt
1836 * cb - callback to collect password.
1837 * keystore - The keystore in which the PKCS12 structure
1838 * will eventually populate.
1839 * Returns:
1840 * B_TRUE - success.
1841 * keystore password is set in keystore->passphrase.
1842 * B_FALSE - failure, errors logged
1843 */
1844 static boolean_t
1845 get_keystore_passwd(PKG_ERR *err, PKCS12 *p12, keystore_passphrase_cb cb,
1846 keystore_t *keystore)
1847 {
1848 char *passwd;
1849 char passbuf[KEYSTORE_PASS_MAX + 1];
1850 keystore_passphrase_data data;
1851
1852 /* see if no password is the right password */
1853 if (check_password(p12, "") == B_TRUE) {
1854 passwd = "";
1855 } else if (check_password(p12, NULL) == B_TRUE) {
1856 passwd = NULL;
1857 } else {
1858 /* oops, it's encrypted. get password */
1859 data.err = err;
1860 if (cb(passbuf, KEYSTORE_PASS_MAX, 0,
1861 &data) == -1) {
1862 /* could not get password */
1863 return (B_FALSE);
1864 }
1865
1866 if (check_password(p12, passbuf) == B_FALSE) {
1867 /* wrong password */
1868 pkgerr_add(err, PKGERR_BADPASS,
1869 gettext(ERR_BADPASS));
1870 return (B_FALSE);
1871 }
1872
1873 /*
1874 * make copy of password buffer, since it
1875 * goes away upon return
1876 */
1877 passwd = xstrdup(passbuf);
1878 }
1879 keystore->passphrase = passwd;
1880 return (B_TRUE);
1881 }
1882
1883 /*
1884 * write_keystore - Writes keystore files to disk
1885 *
1886 * Arguments:
1887 * err - Error object to add errors to
1888 * keystore - keystore object to write from
1889 * passwd - password used to encrypt keystore
1890 * Returns:
1891 * 0 - Success - Keystore contents are written out to
1892 * the same locations as read from
1893 * non-zero - Failure, errors and reasons recorded in err
1894 */
1895 static boolean_t
1896 write_keystore(PKG_ERR *err, keystore_t *keystore,
1897 keystore_passphrase_cb cb)
1898 {
1899 PKCS12 *p12 = NULL;
1900 boolean_t ret = B_TRUE;
1901 keystore_passphrase_data data;
1902 char passbuf[KEYSTORE_PASS_MAX + 1];
1903
1904 if (keystore->capath != NULL && keystore->clpath == NULL &&
1905 keystore->keypath == NULL) {
1906
1907 /*
1908 * keystore is a file.
1909 * just write out a single file
1910 */
1911 if ((keystore->pkeys == NULL) &&
1912 (keystore->clcerts == NULL) &&
1913 (keystore->cacerts == NULL)) {
1914 if (!clear_keystore_file(err, keystore->capath)) {
1915 /*
1916 * no keys or certs to write out, so
1917 * blank the ca file. we do not
1918 * delete it since it is used as a
1919 * lock by lock_keystore() in
1920 * subsequent invocations
1921 */
1922 pkgerr_add(err, PKGERR_WRITE,
1923 gettext(ERR_KEYSTORE_WRITE),
1924 keystore->capath);
1925 ret = B_FALSE;
1926 goto cleanup;
1927 }
1928 } else {
1929 /*
1930 * if the keystore is being created for the first time,
1931 * prompt for a passphrase for encryption
1932 */
1933 if (keystore->new) {
1934 data.err = err;
1935 if (cb(passbuf, KEYSTORE_PASS_MAX,
1936 1, &data) == -1) {
1937 ret = B_FALSE;
1938 goto cleanup;
1939 }
1940 } else {
1941 /*
1942 * use the one used when the keystore
1943 * was read
1944 */
1945 (void) strlcpy(passbuf, keystore->passphrase,
1946 KEYSTORE_PASS_MAX);
1947 }
1948
1949 p12 = sunw_PKCS12_create(passbuf, keystore->pkeys,
1950 keystore->clcerts, keystore->cacerts);
1951
1952 if (p12 == NULL) {
1953 pkgerr_add(err, PKGERR_WRITE,
1954 gettext(ERR_KEYSTORE_FORM),
1955 keystore->capath);
1956 ret = B_FALSE;
1957 goto cleanup;
1958 }
1959
1960 if (!write_keystore_file(err, keystore->capath, p12)) {
1961 pkgerr_add(err, PKGERR_WRITE,
1962 gettext(ERR_KEYSTORE_WRITE),
1963 keystore->capath);
1964 ret = B_FALSE;
1965 goto cleanup;
1966 }
1967 }
1968
1969 } else {
1970 /* files are seprate. Do one at a time */
1971
1972 /*
1973 * if the keystore is being created for the first time,
1974 * prompt for a passphrase for encryption
1975 */
1976 if (keystore->new && ((keystore->pkeys != NULL) ||
1977 (keystore->clcerts != NULL) ||
1978 (keystore->cacerts != NULL))) {
1979 data.err = err;
1980 if (cb(passbuf, KEYSTORE_PASS_MAX,
1981 1, &data) == -1) {
1982 ret = B_FALSE;
1983 goto cleanup;
1984 }
1985 } else {
1986 /* use the one used when the keystore was read */
1987 (void) strlcpy(passbuf, keystore->passphrase,
1988 KEYSTORE_PASS_MAX);
1989 }
1990
1991 /* do private keys first */
1992 if (keystore->pkeys != NULL) {
1993 p12 = sunw_PKCS12_create(passbuf, keystore->pkeys,
1994 NULL, NULL);
1995
1996 if (p12 == NULL) {
1997 pkgerr_add(err, PKGERR_WRITE,
1998 gettext(ERR_KEYSTORE_FORM),
1999 keystore->keypath);
2000 ret = B_FALSE;
2001 goto cleanup;
2002 }
2003
2004 if (!write_keystore_file(err, keystore->keypath,
2005 p12)) {
2006 pkgerr_add(err, PKGERR_WRITE,
2007 gettext(ERR_KEYSTORE_WRITE),
2008 keystore->keypath);
2009 ret = B_FALSE;
2010 goto cleanup;
2011 }
2012
2013 PKCS12_free(p12);
2014 } else {
2015 if ((remove(keystore->keypath) != 0) &&
2016 (errno != ENOENT)) {
2017 pkgerr_add(err, PKGERR_WRITE,
2018 gettext(ERR_KEYSTORE_REMOVE),
2019 keystore->keypath);
2020 ret = B_FALSE;
2021 goto cleanup;
2022 }
2023 }
2024
2025 /* do user certs next */
2026 if (keystore->clcerts != NULL) {
2027 p12 = sunw_PKCS12_create(passbuf, NULL,
2028 keystore->clcerts, NULL);
2029
2030 if (p12 == NULL) {
2031 pkgerr_add(err, PKGERR_WRITE,
2032 gettext(ERR_KEYSTORE_FORM),
2033 keystore->clpath);
2034 ret = B_FALSE;
2035 goto cleanup;
2036 }
2037
2038 if (!write_keystore_file(err, keystore->clpath, p12)) {
2039 pkgerr_add(err, PKGERR_WRITE,
2040 gettext(ERR_KEYSTORE_WRITE),
2041 keystore->clpath);
2042 ret = B_FALSE;
2043 goto cleanup;
2044 }
2045
2046 PKCS12_free(p12);
2047 } else {
2048 if ((remove(keystore->clpath) != 0) &&
2049 (errno != ENOENT)) {
2050 pkgerr_add(err, PKGERR_WRITE,
2051 gettext(ERR_KEYSTORE_REMOVE),
2052 keystore->clpath);
2053 ret = B_FALSE;
2054 goto cleanup;
2055 }
2056 }
2057
2058
2059 /* finally do CA cert file */
2060 if (keystore->cacerts != NULL) {
2061 p12 = sunw_PKCS12_create(passbuf, NULL,
2062 NULL, keystore->cacerts);
2063
2064 if (p12 == NULL) {
2065 pkgerr_add(err, PKGERR_WRITE,
2066 gettext(ERR_KEYSTORE_FORM),
2067 keystore->capath);
2068 ret = B_FALSE;
2069 goto cleanup;
2070 }
2071
2072 if (!write_keystore_file(err, keystore->capath, p12)) {
2073 pkgerr_add(err, PKGERR_WRITE,
2074 gettext(ERR_KEYSTORE_WRITE),
2075 keystore->capath);
2076 ret = B_FALSE;
2077 goto cleanup;
2078 }
2079
2080 PKCS12_free(p12);
2081 p12 = NULL;
2082 } else {
2083 /*
2084 * nothing to write out, so truncate the file
2085 * (it will be deleted during close_keystore)
2086 */
2087 if (!clear_keystore_file(err, keystore->capath)) {
2088 pkgerr_add(err, PKGERR_WRITE,
2089 gettext(ERR_KEYSTORE_WRITE),
2090 keystore->capath);
2091 ret = B_FALSE;
2092 goto cleanup;
2093 }
2094 }
2095 }
2096
2097 cleanup:
2098 if (p12 != NULL)
2099 PKCS12_free(p12);
2100
2101 return (ret);
2102 }
2103
2104 /*
2105 * clear_keystore_file - Clears (zeros out) a keystore file.
2106 *
2107 * Arguments:
2108 * err - Error object to add errors to
2109 * dest - Path of keystore file to zero out.
2110 * Returns:
2111 * 0 - Success - Keystore file is truncated to zero length
2112 * non-zero - Failure, errors and reasons recorded in err
2113 */
2114 static boolean_t
2115 clear_keystore_file(PKG_ERR *err, char *dest)
2116 {
2117 int fd;
2118 struct stat buf;
2119
2120 fd = open(dest, O_RDWR|O_NONBLOCK);
2121 if (fd == -1) {
2122 /* can't open for writing */
2123 pkgerr_add(err, PKGERR_WRITE, gettext(MSG_OPEN),
2124 errno);
2125 return (B_FALSE);
2126 }
2127
2128 if ((fstat(fd, &buf) == -1) || !S_ISREG(buf.st_mode)) {
2129 /* not a regular file */
2130 (void) close(fd);
2131 pkgerr_add(err, PKGERR_WRITE, gettext(ERR_NOT_REG),
2132 dest);
2133 return (B_FALSE);
2134 }
2135
2136 if (ftruncate(fd, 0) == -1) {
2137 (void) close(fd);
2138 pkgerr_add(err, PKGERR_WRITE, gettext(ERR_WRITE),
2139 dest, strerror(errno));
2140 return (B_FALSE);
2141 }
2142
2143 (void) close(fd);
2144 return (B_TRUE);
2145 }
2146
2147 /*
2148 * write_keystore_file - Writes keystore file to disk.
2149 *
2150 * Keystore files can possibly be corrupted by a variety
2151 * of error conditions during reading/writing. This
2152 * routine, along with restore_keystore_file, tries to
2153 * maintain keystore integity by writing the files
2154 * out in a particular order, minimizing the time period
2155 * that the keystore is in an indeterminate state.
2156 *
2157 * With the current implementation, there are some failures
2158 * that are wholly unrecoverable, such as disk corruption.
2159 * These routines attempt to minimize the risk, but not
2160 * eliminate it. When better, atomic operations are available
2161 * (such as a true database with commit, rollback, and
2162 * guaranteed atomicity), this implementation should use that.
2163 *
2164 *
2165 * Arguments:
2166 * err - Error object to add errors to
2167 * dest - Destination filename
2168 * contents - Contents to write to the file
2169 * Returns:
2170 * 0 - Success - Keystore contents are written out to
2171 * the destination.
2172 * non-zero - Failure, errors and reasons recorded in err
2173 */
2174 static boolean_t
2175 write_keystore_file(PKG_ERR *err, char *dest, PKCS12 *contents)
2176 {
2177 FILE *newfile = NULL;
2178 boolean_t ret = B_TRUE;
2179 char newpath[MAXPATHLEN];
2180 char backuppath[MAXPATHLEN];
2181 struct stat buf;
2182 int fd;
2183
2184 (void) snprintf(newpath, MAXPATHLEN, "%s.new", dest);
2185 (void) snprintf(backuppath, MAXPATHLEN, "%s.bak", dest);
2186
2187 if ((fd = open(newpath, O_CREAT|O_EXCL|O_WRONLY|O_NONBLOCK,
2188 S_IRUSR|S_IWUSR)) == -1) {
2189 pkgerr_add(err, PKGERR_READ, gettext(ERR_KEYSTORE_OPEN),
2190 newpath, strerror(errno));
2191 ret = B_FALSE;
2192 goto cleanup;
2193 }
2194
2195 if (fstat(fd, &buf) == -1) {
2196 pkgerr_add(err, PKGERR_READ, gettext(ERR_KEYSTORE_OPEN),
2197 newpath, strerror(errno));
2198 ret = B_FALSE;
2199 goto cleanup;
2200 }
2201
2202 if (!S_ISREG(buf.st_mode)) {
2203 pkgerr_add(err, PKGERR_READ, gettext(ERR_NOT_REG),
2204 newpath);
2205 ret = B_FALSE;
2206 goto cleanup;
2207 }
2208
2209 if ((newfile = fdopen(fd, "w")) == NULL) {
2210 pkgerr_add(err, PKGERR_READ, gettext(ERR_KEYSTORE_OPEN),
2211 newpath, strerror(errno));
2212 ret = B_FALSE;
2213 goto cleanup;
2214 }
2215
2216 if (i2d_PKCS12_fp(newfile, contents) == 0) {
2217 pkgerr_add(err, PKGERR_WRITE, gettext(ERR_KEYSTORE_WRITE),
2218 newpath);
2219 ret = B_FALSE;
2220 goto cleanup;
2221 }
2222
2223 /* flush, then close */
2224 (void) fflush(newfile);
2225 (void) fclose(newfile);
2226 newfile = NULL;
2227
2228 /* now back up the original file */
2229 (void) rename(dest, backuppath);
2230
2231 /* put new one in its place */
2232 (void) rename(newpath, dest);
2233
2234 /* remove backup */
2235 (void) remove(backuppath);
2236
2237 cleanup:
2238 if (newfile != NULL)
2239 (void) fclose(newfile);
2240 if (fd != -1)
2241 (void) close(fd);
2242
2243 return (ret);
2244 }
2245
2246 /*
2247 * read_keystore_file - Reads single keystore file
2248 * off disk in PKCS12 format.
2249 *
2250 * Arguments:
2251 * err - Error object to add errors to
2252 * file - File path to read
2253 * Returns:
2254 * PKCS12 contents of file, or NULL if an error occurred.
2255 * errors recorded in 'err'.
2256 */
2257 static PKCS12
2258 *read_keystore_file(PKG_ERR *err, char *file)
2259 {
2260 int fd;
2261 struct stat buf;
2262 FILE *newfile;
2263 PKCS12 *p12 = NULL;
2264
2265 if ((fd = open(file, O_RDONLY|O_NONBLOCK)) == -1) {
2266 pkgerr_add(err, PKGERR_READ, gettext(ERR_KEYSTORE_OPEN),
2267 file, strerror(errno));
2268 goto cleanup;
2269 }
2270
2271 if (fstat(fd, &buf) == -1) {
2272 pkgerr_add(err, PKGERR_READ, gettext(ERR_KEYSTORE_OPEN),
2273 file, strerror(errno));
2274 goto cleanup;
2275 }
2276
2277 if (!S_ISREG(buf.st_mode)) {
2278 pkgerr_add(err, PKGERR_READ, gettext(ERR_NOT_REG),
2279 file);
2280 goto cleanup;
2281 }
2282
2283 if ((newfile = fdopen(fd, "r")) == NULL) {
2284 pkgerr_add(err, PKGERR_READ, gettext(ERR_KEYSTORE_OPEN),
2285 file, strerror(errno));
2286 goto cleanup;
2287 }
2288
2289 if ((p12 = d2i_PKCS12_fp(newfile, NULL)) == NULL) {
2290 pkgerr_add(err, PKGERR_CORRUPT,
2291 gettext(ERR_KEYSTORE_CORRUPT), file);
2292 goto cleanup;
2293 }
2294
2295 cleanup:
2296 if (newfile != NULL)
2297 (void) fclose(newfile);
2298 if (fd != -1)
2299 (void) close(fd);
2300
2301 return (p12);
2302 }
2303
2304
2305 /*
2306 * Locks the specified file.
2307 */
2308 static int
2309 file_lock(int fd, int type, int wait)
2310 {
2311 struct flock lock;
2312
2313 lock.l_type = type;
2314 lock.l_start = 0;
2315 lock.l_whence = SEEK_SET;
2316 lock.l_len = 0;
2317
2318 if (!wait) {
2319 if (file_lock_test(fd, type)) {
2320 /*
2321 * The caller would have to wait to get the
2322 * lock on this file.
2323 */
2324 return (-1);
2325 }
2326 }
2327
2328 return (fcntl(fd, F_SETLKW, &lock));
2329 }
2330
2331 /*
2332 * Returns FALSE if the file is not locked; TRUE
2333 * otherwise.
2334 */
2335 static boolean_t
2336 file_lock_test(int fd, int type)
2337 {
2338 struct flock lock;
2339
2340 lock.l_type = type;
2341 lock.l_start = 0;
2342 lock.l_whence = SEEK_SET;
2343 lock.l_len = 0;
2344
2345 if (fcntl(fd, F_GETLK, &lock) != -1) {
2346 if (lock.l_type != F_UNLCK) {
2347 /*
2348 * The caller would have to wait to get the
2349 * lock on this file.
2350 */
2351 return (B_TRUE);
2352 }
2353 }
2354
2355 /*
2356 * The file is not locked.
2357 */
2358 return (B_FALSE);
2359 }
2360
2361 /*
2362 * Unlocks the specified file.
2363 */
2364 static int
2365 file_unlock(int fd)
2366 {
2367 struct flock lock;
2368
2369 lock.l_type = F_UNLCK;
2370 lock.l_start = 0;
2371 lock.l_whence = SEEK_SET;
2372 lock.l_len = 0;
2373
2374 return (fcntl(fd, F_SETLK, &lock));
2375 }
2376
2377 /*
2378 * Determines if file has a length of 0 or not
2379 */
2380 static boolean_t
2381 file_empty(char *path)
2382 {
2383 struct stat buf;
2384
2385 /* file is empty if size = 0 or it doesn't exist */
2386 if (lstat(path, &buf) == 0) {
2387 if (buf.st_size == 0) {
2388 return (B_TRUE);
2389 }
2390 } else {
2391 if (errno == ENOENT) {
2392 return (B_TRUE);
2393 }
2394 }
2395
2396 return (B_FALSE);
2397 }
2398
2399 /*
2400 * Name: get_time_string
2401 * Description: Generates a human-readable string from an ASN1_TIME
2402 *
2403 * Arguments: intime - The time to convert
2404 *
2405 * Returns : A pointer to a static string representing the passed-in time.
2406 */
2407 static char
2408 *get_time_string(ASN1_TIME *intime)
2409 {
2410
2411 static char time[ATTR_MAX];
2412 BIO *mem;
2413 char *p;
2414
2415 if (intime == NULL) {
2416 return (NULL);
2417 }
2418 if ((mem = BIO_new(BIO_s_mem())) == NULL) {
2419 return (NULL);
2420 }
2421
2422 if (ASN1_TIME_print(mem, intime) == 0) {
2423 (void) BIO_free(mem);
2424 return (NULL);
2425 }
2426
2427 if (BIO_gets(mem, time, ATTR_MAX) <= 0) {
2428 (void) BIO_free(mem);
2429 return (NULL);
2430 }
2431
2432 (void) BIO_free(mem);
2433
2434 /* trim the end of the string */
2435 for (p = time + strlen(time) - 1; isspace(*p); p--) {
2436 *p = '\0';
2437 }
2438
2439 return (time);
2440 }
2441
2442 /*
2443 * check_password - do various password checks to see if the current password
2444 * will work or we need to prompt for a new one.
2445 *
2446 * Arguments:
2447 * pass - password to check
2448 *
2449 * Returns:
2450 * B_TRUE - Password is OK.
2451 * B_FALSE - Password not valid.
2452 */
2453 static boolean_t
2454 check_password(PKCS12 *p12, char *pass)
2455 {
2456 boolean_t ret = B_TRUE;
2457
2458 /*
2459 * If password is zero length or NULL then try verifying both cases
2460 * to determine which password is correct. The reason for this is that
2461 * under PKCS#12 password based encryption no password and a zero
2462 * length password are two different things...
2463 */
2464
2465 /* Check the mac */
2466 if (pass == NULL || *pass == '\0') {
2467 if (PKCS12_verify_mac(p12, NULL, 0) == 0 &&
2468 PKCS12_verify_mac(p12, "", 0) == 0)
2469 ret = B_FALSE;
2470 } else if (PKCS12_verify_mac(p12, pass, -1) == 0) {
2471 ret = B_FALSE;
2472 }
2473 return (ret);
2474 }
Community developed and maintained version of the OS/Net consolidation