1 /* $NetBSD: ks_file.c,v 1.1.1.2 2014/04/24 12:45:41 pettai Exp $ */
2
3 /*
4 * Copyright (c) 2005 - 2007 Kungliga Tekniska Högskolan
5 * (Royal Institute of Technology, Stockholm, Sweden).
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the Institute nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #include "hx_locl.h"
37
38 typedef enum { USE_PEM, USE_DER } outformat;
39
40 struct ks_file {
41 hx509_certs certs;
42 char *fn;
43 outformat format;
44 };
45
46 /*
47 *
48 */
49
50 static int
parse_certificate(hx509_context context,const char * fn,struct hx509_collector * c,const hx509_pem_header * headers,const void * data,size_t len,const AlgorithmIdentifier * ai)51 parse_certificate(hx509_context context, const char *fn,
52 struct hx509_collector *c,
53 const hx509_pem_header *headers,
54 const void *data, size_t len,
55 const AlgorithmIdentifier *ai)
56 {
57 hx509_cert cert;
58 int ret;
59
60 ret = hx509_cert_init_data(context, data, len, &cert);
61 if (ret)
62 return ret;
63
64 ret = _hx509_collector_certs_add(context, c, cert);
65 hx509_cert_free(cert);
66 return ret;
67 }
68
69 static int
try_decrypt(hx509_context context,struct hx509_collector * collector,const AlgorithmIdentifier * alg,const EVP_CIPHER * c,const void * ivdata,const void * password,size_t passwordlen,const void * cipher,size_t len)70 try_decrypt(hx509_context context,
71 struct hx509_collector *collector,
72 const AlgorithmIdentifier *alg,
73 const EVP_CIPHER *c,
74 const void *ivdata,
75 const void *password,
76 size_t passwordlen,
77 const void *cipher,
78 size_t len)
79 {
80 heim_octet_string clear;
81 size_t keylen;
82 void *key;
83 int ret;
84
85 keylen = EVP_CIPHER_key_length(c);
86
87 key = malloc(keylen);
88 if (key == NULL) {
89 hx509_clear_error_string(context);
90 return ENOMEM;
91 }
92
93 ret = EVP_BytesToKey(c, EVP_md5(), ivdata,
94 password, passwordlen,
95 1, key, NULL);
96 if (ret <= 0) {
97 hx509_set_error_string(context, 0, HX509_CRYPTO_INTERNAL_ERROR,
98 "Failed to do string2key for private key");
99 return HX509_CRYPTO_INTERNAL_ERROR;
100 }
101
102 clear.data = malloc(len);
103 if (clear.data == NULL) {
104 hx509_set_error_string(context, 0, ENOMEM,
105 "Out of memory to decrypt for private key");
106 ret = ENOMEM;
107 goto out;
108 }
109 clear.length = len;
110
111 {
112 EVP_CIPHER_CTX ctx;
113 EVP_CIPHER_CTX_init(&ctx);
114 EVP_CipherInit_ex(&ctx, c, NULL, key, ivdata, 0);
115 EVP_Cipher(&ctx, clear.data, cipher, len);
116 EVP_CIPHER_CTX_cleanup(&ctx);
117 }
118
119 ret = _hx509_collector_private_key_add(context,
120 collector,
121 alg,
122 NULL,
123 &clear,
124 NULL);
125
126 memset(clear.data, 0, clear.length);
127 free(clear.data);
128 out:
129 memset(key, 0, keylen);
130 free(key);
131 return ret;
132 }
133
134 static int
parse_pkcs8_private_key(hx509_context context,const char * fn,struct hx509_collector * c,const hx509_pem_header * headers,const void * data,size_t length,const AlgorithmIdentifier * ai)135 parse_pkcs8_private_key(hx509_context context, const char *fn,
136 struct hx509_collector *c,
137 const hx509_pem_header *headers,
138 const void *data, size_t length,
139 const AlgorithmIdentifier *ai)
140 {
141 PKCS8PrivateKeyInfo ki;
142 heim_octet_string keydata;
143
144 int ret;
145
146 ret = decode_PKCS8PrivateKeyInfo(data, length, &ki, NULL);
147 if (ret)
148 return ret;
149
150 keydata.data = rk_UNCONST(data);
151 keydata.length = length;
152
153 ret = _hx509_collector_private_key_add(context,
154 c,
155 &ki.privateKeyAlgorithm,
156 NULL,
157 &ki.privateKey,
158 &keydata);
159 free_PKCS8PrivateKeyInfo(&ki);
160 return ret;
161 }
162
163 static int
parse_pem_private_key(hx509_context context,const char * fn,struct hx509_collector * c,const hx509_pem_header * headers,const void * data,size_t len,const AlgorithmIdentifier * ai)164 parse_pem_private_key(hx509_context context, const char *fn,
165 struct hx509_collector *c,
166 const hx509_pem_header *headers,
167 const void *data, size_t len,
168 const AlgorithmIdentifier *ai)
169 {
170 int ret = 0;
171 const char *enc;
172
173 enc = hx509_pem_find_header(headers, "Proc-Type");
174 if (enc) {
175 const char *dek;
176 char *type, *iv;
177 ssize_t ssize, size;
178 void *ivdata;
179 const EVP_CIPHER *cipher;
180 const struct _hx509_password *pw;
181 hx509_lock lock;
182 int decrypted = 0;
183 size_t i;
184
185 lock = _hx509_collector_get_lock(c);
186 if (lock == NULL) {
187 hx509_set_error_string(context, 0, HX509_ALG_NOT_SUPP,
188 "Failed to get password for "
189 "password protected file %s", fn);
190 return HX509_ALG_NOT_SUPP;
191 }
192
193 if (strcmp(enc, "4,ENCRYPTED") != 0) {
194 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
195 "Private key encrypted in unknown method %s "
196 "in file",
197 enc, fn);
198 hx509_clear_error_string(context);
199 return HX509_PARSING_KEY_FAILED;
200 }
201
202 dek = hx509_pem_find_header(headers, "DEK-Info");
203 if (dek == NULL) {
204 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
205 "Encrypted private key missing DEK-Info");
206 return HX509_PARSING_KEY_FAILED;
207 }
208
209 type = strdup(dek);
210 if (type == NULL) {
211 hx509_clear_error_string(context);
212 return ENOMEM;
213 }
214
215 iv = strchr(type, ',');
216 if (iv == NULL) {
217 free(type);
218 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
219 "IV missing");
220 return HX509_PARSING_KEY_FAILED;
221 }
222
223 *iv++ = '\0';
224
225 size = strlen(iv);
226 ivdata = malloc(size);
227 if (ivdata == NULL) {
228 hx509_clear_error_string(context);
229 free(type);
230 return ENOMEM;
231 }
232
233 cipher = EVP_get_cipherbyname(type);
234 if (cipher == NULL) {
235 free(ivdata);
236 hx509_set_error_string(context, 0, HX509_ALG_NOT_SUPP,
237 "Private key encrypted with "
238 "unsupported cipher: %s",
239 type);
240 free(type);
241 return HX509_ALG_NOT_SUPP;
242 }
243
244 #define PKCS5_SALT_LEN 8
245
246 ssize = hex_decode(iv, ivdata, size);
247 free(type);
248 type = NULL;
249 iv = NULL;
250
251 if (ssize < 0 || ssize < PKCS5_SALT_LEN || ssize < EVP_CIPHER_iv_length(cipher)) {
252 free(ivdata);
253 hx509_set_error_string(context, 0, HX509_PARSING_KEY_FAILED,
254 "Salt have wrong length in "
255 "private key file");
256 return HX509_PARSING_KEY_FAILED;
257 }
258
259 pw = _hx509_lock_get_passwords(lock);
260 if (pw != NULL) {
261 const void *password;
262 size_t passwordlen;
263
264 for (i = 0; i < pw->len; i++) {
265 password = pw->val[i];
266 passwordlen = strlen(password);
267
268 ret = try_decrypt(context, c, ai, cipher, ivdata,
269 password, passwordlen, data, len);
270 if (ret == 0) {
271 decrypted = 1;
272 break;
273 }
274 }
275 }
276 if (!decrypted) {
277 hx509_prompt prompt;
278 char password[128];
279
280 memset(&prompt, 0, sizeof(prompt));
281
282 prompt.prompt = "Password for keyfile: ";
283 prompt.type = HX509_PROMPT_TYPE_PASSWORD;
284 prompt.reply.data = password;
285 prompt.reply.length = sizeof(password);
286
287 ret = hx509_lock_prompt(lock, &prompt);
288 if (ret == 0)
289 ret = try_decrypt(context, c, ai, cipher, ivdata, password,
290 strlen(password), data, len);
291 /* XXX add password to lock password collection ? */
292 memset(password, 0, sizeof(password));
293 }
294 free(ivdata);
295
296 } else {
297 heim_octet_string keydata;
298
299 keydata.data = rk_UNCONST(data);
300 keydata.length = len;
301
302 ret = _hx509_collector_private_key_add(context, c, ai, NULL,
303 &keydata, NULL);
304 }
305
306 return ret;
307 }
308
309
310 struct pem_formats {
311 const char *name;
312 int (*func)(hx509_context, const char *, struct hx509_collector *,
313 const hx509_pem_header *, const void *, size_t,
314 const AlgorithmIdentifier *);
315 const AlgorithmIdentifier *(*ai)(void);
316 } formats[] = {
317 { "CERTIFICATE", parse_certificate, NULL },
318 { "PRIVATE KEY", parse_pkcs8_private_key, NULL },
319 { "RSA PRIVATE KEY", parse_pem_private_key, hx509_signature_rsa },
320 { "EC PRIVATE KEY", parse_pem_private_key, hx509_signature_ecPublicKey }
321 };
322
323
324 struct pem_ctx {
325 int flags;
326 struct hx509_collector *c;
327 };
328
329 static int
pem_func(hx509_context context,const char * type,const hx509_pem_header * header,const void * data,size_t len,void * ctx)330 pem_func(hx509_context context, const char *type,
331 const hx509_pem_header *header,
332 const void *data, size_t len, void *ctx)
333 {
334 struct pem_ctx *pem_ctx = (struct pem_ctx*)ctx;
335 int ret = 0;
336 size_t j;
337
338 for (j = 0; j < sizeof(formats)/sizeof(formats[0]); j++) {
339 const char *q = formats[j].name;
340 if (strcasecmp(type, q) == 0) {
341 const AlgorithmIdentifier *ai = NULL;
342 if (formats[j].ai != NULL)
343 ai = (*formats[j].ai)();
344
345 ret = (*formats[j].func)(context, NULL, pem_ctx->c,
346 header, data, len, ai);
347 if (ret && (pem_ctx->flags & HX509_CERTS_UNPROTECT_ALL)) {
348 hx509_set_error_string(context, HX509_ERROR_APPEND, ret,
349 "Failed parseing PEM format %s", type);
350 return ret;
351 }
352 break;
353 }
354 }
355 if (j == sizeof(formats)/sizeof(formats[0])) {
356 ret = HX509_UNSUPPORTED_OPERATION;
357 hx509_set_error_string(context, 0, ret,
358 "Found no matching PEM format for %s", type);
359 return ret;
360 }
361 return 0;
362 }
363
364 /*
365 *
366 */
367
368 static int
file_init_common(hx509_context context,hx509_certs certs,void ** data,int flags,const char * residue,hx509_lock lock,outformat format)369 file_init_common(hx509_context context,
370 hx509_certs certs, void **data, int flags,
371 const char *residue, hx509_lock lock, outformat format)
372 {
373 char *p, *pnext;
374 struct ks_file *ksf = NULL;
375 hx509_private_key *keys = NULL;
376 int ret;
377 struct pem_ctx pem_ctx;
378
379 pem_ctx.flags = flags;
380 pem_ctx.c = NULL;
381
382 *data = NULL;
383
384 if (lock == NULL)
385 lock = _hx509_empty_lock;
386
387 ksf = calloc(1, sizeof(*ksf));
388 if (ksf == NULL) {
389 hx509_clear_error_string(context);
390 return ENOMEM;
391 }
392 ksf->format = format;
393
394 ksf->fn = strdup(residue);
395 if (ksf->fn == NULL) {
396 hx509_clear_error_string(context);
397 ret = ENOMEM;
398 goto out;
399 }
400
401 /*
402 * XXX this is broken, the function should parse the file before
403 * overwriting it
404 */
405
406 if (flags & HX509_CERTS_CREATE) {
407 ret = hx509_certs_init(context, "MEMORY:ks-file-create",
408 0, lock, &ksf->certs);
409 if (ret)
410 goto out;
411 *data = ksf;
412 return 0;
413 }
414
415 ret = _hx509_collector_alloc(context, lock, &pem_ctx.c);
416 if (ret)
417 goto out;
418
419 for (p = ksf->fn; p != NULL; p = pnext) {
420 FILE *f;
421
422 pnext = strchr(p, ',');
423 if (pnext)
424 *pnext++ = '\0';
425
426
427 if ((f = fopen(p, "r")) == NULL) {
428 ret = ENOENT;
429 hx509_set_error_string(context, 0, ret,
430 "Failed to open PEM file \"%s\": %s",
431 p, strerror(errno));
432 goto out;
433 }
434 rk_cloexec_file(f);
435
436 ret = hx509_pem_read(context, f, pem_func, &pem_ctx);
437 fclose(f);
438 if (ret != 0 && ret != HX509_PARSING_KEY_FAILED)
439 goto out;
440 else if (ret == HX509_PARSING_KEY_FAILED) {
441 size_t length;
442 void *ptr;
443 size_t i;
444
445 ret = rk_undumpdata(p, &ptr, &length);
446 if (ret) {
447 hx509_clear_error_string(context);
448 goto out;
449 }
450
451 for (i = 0; i < sizeof(formats)/sizeof(formats[0]); i++) {
452 const AlgorithmIdentifier *ai = NULL;
453 if (formats[i].ai != NULL)
454 ai = (*formats[i].ai)();
455
456 ret = (*formats[i].func)(context, p, pem_ctx.c, NULL, ptr, length, ai);
457 if (ret == 0)
458 break;
459 }
460 rk_xfree(ptr);
461 if (ret) {
462 hx509_clear_error_string(context);
463 goto out;
464 }
465 }
466 }
467
468 ret = _hx509_collector_collect_certs(context, pem_ctx.c, &ksf->certs);
469 if (ret)
470 goto out;
471
472 ret = _hx509_collector_collect_private_keys(context, pem_ctx.c, &keys);
473 if (ret == 0) {
474 int i;
475
476 for (i = 0; keys[i]; i++)
477 _hx509_certs_keys_add(context, ksf->certs, keys[i]);
478 _hx509_certs_keys_free(context, keys);
479 }
480
481 out:
482 if (ret == 0)
483 *data = ksf;
484 else {
485 if (ksf->fn)
486 free(ksf->fn);
487 free(ksf);
488 }
489 if (pem_ctx.c)
490 _hx509_collector_free(pem_ctx.c);
491
492 return ret;
493 }
494
495 static int
file_init_pem(hx509_context context,hx509_certs certs,void ** data,int flags,const char * residue,hx509_lock lock)496 file_init_pem(hx509_context context,
497 hx509_certs certs, void **data, int flags,
498 const char *residue, hx509_lock lock)
499 {
500 return file_init_common(context, certs, data, flags, residue, lock, USE_PEM);
501 }
502
503 static int
file_init_der(hx509_context context,hx509_certs certs,void ** data,int flags,const char * residue,hx509_lock lock)504 file_init_der(hx509_context context,
505 hx509_certs certs, void **data, int flags,
506 const char *residue, hx509_lock lock)
507 {
508 return file_init_common(context, certs, data, flags, residue, lock, USE_DER);
509 }
510
511 static int
file_free(hx509_certs certs,void * data)512 file_free(hx509_certs certs, void *data)
513 {
514 struct ks_file *ksf = data;
515 hx509_certs_free(&ksf->certs);
516 free(ksf->fn);
517 free(ksf);
518 return 0;
519 }
520
521 struct store_ctx {
522 FILE *f;
523 outformat format;
524 };
525
526 static int
store_func(hx509_context context,void * ctx,hx509_cert c)527 store_func(hx509_context context, void *ctx, hx509_cert c)
528 {
529 struct store_ctx *sc = ctx;
530 heim_octet_string data;
531 int ret;
532
533 ret = hx509_cert_binary(context, c, &data);
534 if (ret)
535 return ret;
536
537 switch (sc->format) {
538 case USE_DER:
539 fwrite(data.data, data.length, 1, sc->f);
540 free(data.data);
541 break;
542 case USE_PEM:
543 hx509_pem_write(context, "CERTIFICATE", NULL, sc->f,
544 data.data, data.length);
545 free(data.data);
546 if (_hx509_cert_private_key_exportable(c)) {
547 hx509_private_key key = _hx509_cert_private_key(c);
548 ret = _hx509_private_key_export(context, key,
549 HX509_KEY_FORMAT_DER, &data);
550 if (ret)
551 break;
552 hx509_pem_write(context, _hx509_private_pem_name(key), NULL, sc->f,
553 data.data, data.length);
554 free(data.data);
555 }
556 break;
557 }
558
559 return 0;
560 }
561
562 static int
file_store(hx509_context context,hx509_certs certs,void * data,int flags,hx509_lock lock)563 file_store(hx509_context context,
564 hx509_certs certs, void *data, int flags, hx509_lock lock)
565 {
566 struct ks_file *ksf = data;
567 struct store_ctx sc;
568 int ret;
569
570 sc.f = fopen(ksf->fn, "w");
571 if (sc.f == NULL) {
572 hx509_set_error_string(context, 0, ENOENT,
573 "Failed to open file %s for writing");
574 return ENOENT;
575 }
576 rk_cloexec_file(sc.f);
577 sc.format = ksf->format;
578
579 ret = hx509_certs_iter_f(context, ksf->certs, store_func, &sc);
580 fclose(sc.f);
581 return ret;
582 }
583
584 static int
file_add(hx509_context context,hx509_certs certs,void * data,hx509_cert c)585 file_add(hx509_context context, hx509_certs certs, void *data, hx509_cert c)
586 {
587 struct ks_file *ksf = data;
588 return hx509_certs_add(context, ksf->certs, c);
589 }
590
591 static int
file_iter_start(hx509_context context,hx509_certs certs,void * data,void ** cursor)592 file_iter_start(hx509_context context,
593 hx509_certs certs, void *data, void **cursor)
594 {
595 struct ks_file *ksf = data;
596 return hx509_certs_start_seq(context, ksf->certs, cursor);
597 }
598
599 static int
file_iter(hx509_context context,hx509_certs certs,void * data,void * iter,hx509_cert * cert)600 file_iter(hx509_context context,
601 hx509_certs certs, void *data, void *iter, hx509_cert *cert)
602 {
603 struct ks_file *ksf = data;
604 return hx509_certs_next_cert(context, ksf->certs, iter, cert);
605 }
606
607 static int
file_iter_end(hx509_context context,hx509_certs certs,void * data,void * cursor)608 file_iter_end(hx509_context context,
609 hx509_certs certs,
610 void *data,
611 void *cursor)
612 {
613 struct ks_file *ksf = data;
614 return hx509_certs_end_seq(context, ksf->certs, cursor);
615 }
616
617 static int
file_getkeys(hx509_context context,hx509_certs certs,void * data,hx509_private_key ** keys)618 file_getkeys(hx509_context context,
619 hx509_certs certs,
620 void *data,
621 hx509_private_key **keys)
622 {
623 struct ks_file *ksf = data;
624 return _hx509_certs_keys_get(context, ksf->certs, keys);
625 }
626
627 static int
file_addkey(hx509_context context,hx509_certs certs,void * data,hx509_private_key key)628 file_addkey(hx509_context context,
629 hx509_certs certs,
630 void *data,
631 hx509_private_key key)
632 {
633 struct ks_file *ksf = data;
634 return _hx509_certs_keys_add(context, ksf->certs, key);
635 }
636
637 static struct hx509_keyset_ops keyset_file = {
638 "FILE",
639 0,
640 file_init_pem,
641 file_store,
642 file_free,
643 file_add,
644 NULL,
645 file_iter_start,
646 file_iter,
647 file_iter_end,
648 NULL,
649 file_getkeys,
650 file_addkey
651 };
652
653 static struct hx509_keyset_ops keyset_pemfile = {
654 "PEM-FILE",
655 0,
656 file_init_pem,
657 file_store,
658 file_free,
659 file_add,
660 NULL,
661 file_iter_start,
662 file_iter,
663 file_iter_end,
664 NULL,
665 file_getkeys,
666 file_addkey
667 };
668
669 static struct hx509_keyset_ops keyset_derfile = {
670 "DER-FILE",
671 0,
672 file_init_der,
673 file_store,
674 file_free,
675 file_add,
676 NULL,
677 file_iter_start,
678 file_iter,
679 file_iter_end,
680 NULL,
681 file_getkeys,
682 file_addkey
683 };
684
685
686 void
_hx509_ks_file_register(hx509_context context)687 _hx509_ks_file_register(hx509_context context)
688 {
689 _hx509_ks_register(context, &keyset_file);
690 _hx509_ks_register(context, &keyset_pemfile);
691 _hx509_ks_register(context, &keyset_derfile);
692 }
693