2 * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
12 #include <openssl/bio.h>
13 #include <openssl/dsa.h> /* For d2i_DSAPrivateKey */
14 #include <openssl/err.h>
15 #include <openssl/evp.h>
16 #include <openssl/pem.h>
17 #include <openssl/pkcs12.h> /* For the PKCS8 stuff o.O */
18 #include <openssl/rsa.h> /* For d2i_RSAPrivateKey */
19 #include <openssl/safestack.h>
20 #include <openssl/store.h>
21 #include <openssl/ui.h>
22 #include <openssl/x509.h> /* For the PKCS8 stuff o.O */
23 #include "internal/asn1_int.h"
24 #include "store_locl.h"
32 static char *file_get_pass(const UI_METHOD *ui_method, char *pass,
33 size_t maxsize, const char *prompt_info, void *data)
39 OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_MALLOC_FAILURE);
43 if (ui_method != NULL)
44 UI_set_method(ui, ui_method);
45 UI_add_user_data(ui, data);
47 if ((prompt = UI_construct_prompt(ui, "pass phrase",
48 prompt_info)) == NULL) {
49 OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_MALLOC_FAILURE);
51 } else if (!UI_add_input_string(ui, prompt, UI_INPUT_FLAG_DEFAULT_PWD,
52 pass, 0, maxsize - 1)) {
53 OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_UI_LIB);
56 switch (UI_process(ui)) {
58 OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS,
59 OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED);
63 OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_UI_LIB);
76 struct pem_pass_data {
77 const UI_METHOD *ui_method;
79 const char *prompt_info;
81 static int file_fill_pem_pass_data(struct pem_pass_data *pass_data,
82 const char *prompt_info,
83 const UI_METHOD *ui_method, void *ui_data)
85 if (pass_data == NULL)
87 pass_data->ui_method = ui_method;
88 pass_data->data = ui_data;
89 pass_data->prompt_info = prompt_info;
92 static int file_get_pem_pass(char *buf, int num, int w, void *data)
94 struct pem_pass_data *pass_data = data;
95 char *pass = file_get_pass(pass_data->ui_method, buf, num,
96 pass_data->prompt_info, pass_data->data);
98 return pass == NULL ? 0 : strlen(pass);
102 * The file scheme handlers
106 * The try_decode function is called to check if the blob of data can
107 * be used by this handler, and if it can, decodes it into a supported
108 * OpenSSL type and returns a OSSL_STORE_INFO with the decoded data.
110 * pem_name: If this blob comes from a PEM file, this holds
111 * the PEM name. If it comes from another type of
112 * file, this is NULL.
113 * pem_header: If this blob comes from a PEM file, this holds
114 * the PEM headers. If it comes from another type of
115 * file, this is NULL.
116 * blob: The blob of data to match with what this handler
118 * len: The length of the blob.
119 * handler_ctx: For a handler marked repeatable, this pointer can
120 * be used to create a context for the handler. IT IS
121 * THE HANDLER'S RESPONSIBILITY TO CREATE AND DESTROY
122 * THIS CONTEXT APPROPRIATELY, i.e. create on first call
123 * and destroy when about to return NULL.
124 * ui_method: Application UI method for getting a password, pin
125 * or any other interactive data.
126 * ui_data: Application data to be passed to ui_method when
131 typedef OSSL_STORE_INFO *(*file_try_decode_fn)(const char *pem_name,
132 const char *pem_header,
133 const unsigned char *blob,
134 size_t len, void **handler_ctx,
135 const UI_METHOD *ui_method,
138 * The eof function should return 1 if there's no more data to be found
139 * with the handler_ctx, otherwise 0. This is only used when the handler is
142 typedef int (*file_eof_fn)(void *handler_ctx);
144 * The destroy_ctx function is used to destroy the handler_ctx that was
145 * intiated by a repeatable try_decode fuction. This is only used when
146 * the handler is marked repeatable.
148 typedef void (*file_destroy_ctx_fn)(void **handler_ctx);
150 typedef struct file_handler_st {
152 file_try_decode_fn try_decode;
154 file_destroy_ctx_fn destroy_ctx;
160 static OSSL_STORE_INFO *try_decode_PKCS12(const char *pem_name,
161 const char *pem_header,
162 const unsigned char *blob,
163 size_t len, void **pctx,
164 const UI_METHOD *ui_method,
167 OSSL_STORE_INFO *store_info = NULL;
168 STACK_OF(OSSL_STORE_INFO) *ctx = *pctx;
171 /* Initial parsing */
175 if (pem_name != NULL)
176 /* No match, there is no PEM PKCS12 tag */
179 if ((p12 = d2i_PKCS12(NULL, &blob, len)) != NULL) {
181 char tpass[PEM_BUFSIZE];
182 EVP_PKEY *pkey = NULL;
184 STACK_OF(X509) *chain = NULL;
186 if (PKCS12_verify_mac(p12, "", 0)
187 || PKCS12_verify_mac(p12, NULL, 0)) {
190 if ((pass = file_get_pass(ui_method, tpass, PEM_BUFSIZE,
191 "PKCS12 import password",
193 OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS12,
194 OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR);
197 if (!PKCS12_verify_mac(p12, pass, strlen(pass))) {
198 OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS12,
199 OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC);
204 if (PKCS12_parse(p12, pass, &pkey, &cert, &chain)) {
205 OSSL_STORE_INFO *si_pkey = NULL;
206 OSSL_STORE_INFO *si_cert = NULL;
207 OSSL_STORE_INFO *si_ca = NULL;
209 if ((ctx = sk_OSSL_STORE_INFO_new_null()) != NULL
210 && (si_pkey = OSSL_STORE_INFO_new_PKEY(pkey)) != NULL
211 && sk_OSSL_STORE_INFO_push(ctx, si_pkey) != 0
212 && (si_cert = OSSL_STORE_INFO_new_CERT(cert)) != NULL
213 && sk_OSSL_STORE_INFO_push(ctx, si_cert) != 0) {
218 while(sk_X509_num(chain) > 0) {
219 X509 *ca = sk_X509_value(chain, 0);
221 if ((si_ca = OSSL_STORE_INFO_new_CERT(ca)) == NULL
222 || sk_OSSL_STORE_INFO_push(ctx, si_ca) == 0) {
227 (void)sk_X509_shift(chain);
231 OSSL_STORE_INFO_free(si_ca);
232 OSSL_STORE_INFO_free(si_cert);
233 OSSL_STORE_INFO_free(si_pkey);
234 sk_OSSL_STORE_INFO_pop_free(ctx, OSSL_STORE_INFO_free);
237 sk_X509_pop_free(chain, X509_free);
250 store_info = sk_OSSL_STORE_INFO_shift(ctx);
254 static int eof_PKCS12(void *ctx_)
256 STACK_OF(OSSL_STORE_INFO) *ctx = ctx_;
258 return ctx == NULL || sk_OSSL_STORE_INFO_num(ctx) == 0;
260 static void destroy_ctx_PKCS12(void **pctx)
262 STACK_OF(OSSL_STORE_INFO) *ctx = *pctx;
264 sk_OSSL_STORE_INFO_pop_free(ctx, OSSL_STORE_INFO_free);
267 static FILE_HANDLER PKCS12_handler = {
275 int pem_check_suffix(const char *pem_str, const char *suffix);
276 static OSSL_STORE_INFO *try_decode_PrivateKey(const char *pem_name,
277 const char *pem_header,
278 const unsigned char *blob,
279 size_t len, void **pctx,
280 const UI_METHOD *ui_method,
283 OSSL_STORE_INFO *store_info = NULL;
284 EVP_PKEY *pkey = NULL;
285 const EVP_PKEY_ASN1_METHOD *ameth = NULL;
287 if (pem_name != NULL) {
290 if ((slen = pem_check_suffix(pem_name, "PRIVATE KEY")) > 0
291 && (ameth = EVP_PKEY_asn1_find_str(NULL, pem_name, slen)) != NULL)
292 pkey = d2i_PrivateKey(ameth->pkey_id, NULL, &blob, len);
296 for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
297 ameth = EVP_PKEY_asn1_get0(i);
298 if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
300 pkey = d2i_PrivateKey(ameth->pkey_id, NULL, &blob, len);
309 store_info = OSSL_STORE_INFO_new_PKEY(pkey);
310 if (store_info == NULL)
315 static FILE_HANDLER PrivateKey_handler = {
317 try_decode_PrivateKey
320 static OSSL_STORE_INFO *try_decode_PUBKEY(const char *pem_name,
321 const char *pem_header,
322 const unsigned char *blob,
323 size_t len, void **pctx,
324 const UI_METHOD *ui_method,
327 OSSL_STORE_INFO *store_info = NULL;
328 EVP_PKEY *pkey = NULL;
330 if (pem_name != NULL && strcmp(pem_name, PEM_STRING_PUBLIC) != 0)
334 if ((pkey = d2i_PUBKEY(NULL, &blob, len)) != NULL)
335 store_info = OSSL_STORE_INFO_new_PKEY(pkey);
339 static FILE_HANDLER PUBKEY_handler = {
344 static OSSL_STORE_INFO *try_decode_params(const char *pem_name,
345 const char *pem_header,
346 const unsigned char *blob,
347 size_t len, void **pctx,
348 const UI_METHOD *ui_method,
351 OSSL_STORE_INFO *store_info = NULL;
352 EVP_PKEY *pkey = EVP_PKEY_new();
353 const EVP_PKEY_ASN1_METHOD *ameth = NULL;
357 OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PARAMS, ERR_R_EVP_LIB);
361 if (pem_name != NULL) {
364 if ((slen = pem_check_suffix(pem_name, "PARAMETERS")) > 0
365 && EVP_PKEY_set_type_str(pkey, pem_name, slen)
366 && (ameth = EVP_PKEY_get0_asn1(pkey)) != NULL
367 && ameth->param_decode != NULL
368 && ameth->param_decode(pkey, &blob, len))
373 for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
374 ameth = EVP_PKEY_asn1_get0(i);
375 if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
377 if (EVP_PKEY_set_type(pkey, ameth->pkey_id)
378 && (ameth = EVP_PKEY_get0_asn1(pkey)) != NULL
379 && ameth->param_decode != NULL
380 && ameth->param_decode(pkey, &blob, len)) {
388 store_info = OSSL_STORE_INFO_new_PARAMS(pkey);
389 if (store_info == NULL)
394 static FILE_HANDLER params_handler = {
399 static OSSL_STORE_INFO *try_decode_X509Certificate(const char *pem_name,
400 const char *pem_header,
401 const unsigned char *blob,
402 size_t len, void **pctx,
403 const UI_METHOD *ui_method,
406 OSSL_STORE_INFO *store_info = NULL;
410 * In most cases, we can try to interpret the serialized data as a trusted
411 * cert (X509 + X509_AUX) and fall back to reading it as a normal cert
412 * (just X509), but if the PEM name specifically declares it as a trusted
413 * cert, then no fallback should be engaged. |ignore_trusted| tells if
414 * the fallback can be used (1) or not (0).
416 int ignore_trusted = 1;
418 if (pem_name != NULL) {
419 if (strcmp(pem_name, PEM_STRING_X509_TRUSTED) == 0)
421 else if (strcmp(pem_name, PEM_STRING_X509_OLD) != 0
422 && strcmp(pem_name, PEM_STRING_X509) != 0)
427 if ((cert = d2i_X509_AUX(NULL, &blob, len)) != NULL
428 || (ignore_trusted && (cert = d2i_X509(NULL, &blob, len)) != NULL))
429 store_info = OSSL_STORE_INFO_new_CERT(cert);
431 if (store_info == NULL)
436 static FILE_HANDLER X509Certificate_handler = {
438 try_decode_X509Certificate
441 static OSSL_STORE_INFO *try_decode_X509CRL(const char *pem_name,
442 const char *pem_header,
443 const unsigned char *blob,
444 size_t len, void **pctx,
445 const UI_METHOD *ui_method,
448 OSSL_STORE_INFO *store_info = NULL;
449 X509_CRL *crl = NULL;
452 && strcmp(pem_name, PEM_STRING_X509_CRL) != 0)
456 if ((crl = d2i_X509_CRL(NULL, &blob, len)) != NULL)
457 store_info = OSSL_STORE_INFO_new_CRL(crl);
459 if (store_info == NULL)
464 static FILE_HANDLER X509CRL_handler = {
469 static const FILE_HANDLER *file_handlers[] = {
471 &X509Certificate_handler,
483 struct ossl_store_loader_ctx_st {
488 /* The following are used when the handler is marked as repeatable */
489 const FILE_HANDLER *last_handler;
490 void *last_handler_ctx;
493 static OSSL_STORE_LOADER_CTX *file_open(const OSSL_STORE_LOADER *loader,
495 const UI_METHOD *ui_method,
500 OSSL_STORE_LOADER_CTX *ctx = NULL;
501 const char *path = NULL;
503 if (strncasecmp(uri, "file:", 5) == 0) {
504 if (strncmp(&uri[5], "//localhost/", 12) == 0) {
506 } else if (strncmp(&uri[5], "///", 3) == 0) {
508 } else if (strncmp(&uri[5], "//", 2) != 0) {
511 OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN,
512 OSSL_STORE_R_URI_AUTHORITY_UNSUPPORED);
517 * If the scheme "file" was an explicit part of the URI, the path must
518 * be absolute. So says RFC 8089
520 if (path[0] != '/') {
521 OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN,
522 OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE);
527 /* Windows file: URIs with a drive letter start with a / */
528 if (path[0] == '/' && path[2] == ':' && path[3] == '/')
536 ctx = OPENSSL_zalloc(sizeof(*ctx));
538 OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN, ERR_R_MALLOC_FAILURE);
542 if ((buff = BIO_new(BIO_f_buffer())) == NULL)
544 if ((ctx->file = BIO_new_file(path, "rb")) == NULL) {
547 ctx->file = BIO_push(buff, ctx->file);
548 if (BIO_buffer_peek(ctx->file, peekbuf, sizeof(peekbuf)-1) > 0) {
549 peekbuf[sizeof(peekbuf)-1] = '\0';
550 if (strstr(peekbuf, "-----BEGIN ") != NULL)
562 static OSSL_STORE_INFO *file_load_try_decode(OSSL_STORE_LOADER_CTX *ctx,
563 const char *pem_name,
564 const char *pem_header,
565 unsigned char *data, size_t len,
566 const UI_METHOD *ui_method,
567 void *ui_data, int *matchcount)
569 OSSL_STORE_INFO *result = NULL;
570 BUF_MEM *new_mem = NULL;
571 char *new_pem_name = NULL;
577 void *handler_ctx = NULL;
578 const FILE_HANDLER **matching_handlers =
579 OPENSSL_zalloc(sizeof(*matching_handlers)
580 * OSSL_NELEM(file_handlers));
582 if (matching_handlers == NULL) {
583 OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD_TRY_DECODE,
584 ERR_R_MALLOC_FAILURE);
589 for (i = 0; i < OSSL_NELEM(file_handlers); i++) {
590 const FILE_HANDLER *handler = file_handlers[i];
591 void *tmp_handler_ctx = NULL;
592 OSSL_STORE_INFO *tmp_result =
593 handler->try_decode(pem_name, pem_header, data, len,
594 &tmp_handler_ctx, ui_method, ui_data);
596 if (tmp_result == NULL) {
597 OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD_TRY_DECODE,
598 OSSL_STORE_R_IS_NOT_A);
599 ERR_add_error_data(1, handler->name);
601 if (matching_handlers)
602 matching_handlers[*matchcount] = handler;
605 handler->destroy_ctx(&handler_ctx);
606 handler_ctx = tmp_handler_ctx;
608 if (++*matchcount == 1) {
612 /* more than one match => ambiguous, kill any result */
613 OSSL_STORE_INFO_free(result);
614 OSSL_STORE_INFO_free(tmp_result);
615 if (handler->destroy_ctx != NULL)
616 handler->destroy_ctx(&handler_ctx);
624 OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD_TRY_DECODE,
625 OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE);
626 if (*matchcount == 0)
627 OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD_TRY_DECODE,
628 OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE);
629 else if (matching_handlers[0]->repeatable) {
631 OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD_TRY_DECODE,
632 OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE);
633 OSSL_STORE_INFO_free(result);
636 ctx->last_handler = matching_handlers[0];
637 ctx->last_handler_ctx = handler_ctx;
641 OPENSSL_free(matching_handlers);
645 OPENSSL_free(new_pem_name);
646 BUF_MEM_free(new_mem);
649 && (t = OSSL_STORE_INFO_get_type(result)) == OSSL_STORE_INFO_EMBEDDED) {
650 pem_name = new_pem_name =
651 ossl_store_info_get0_EMBEDDED_pem_name(result);
652 new_mem = ossl_store_info_get0_EMBEDDED_buffer(result);
653 data = (unsigned char *)new_mem->data;
654 len = new_mem->length;
655 OPENSSL_free(result);
666 static OSSL_STORE_INFO *file_load_try_repeat(OSSL_STORE_LOADER_CTX *ctx,
667 const UI_METHOD *ui_method,
670 OSSL_STORE_INFO *result = NULL;
672 if (ctx->last_handler != NULL) {
673 result = ctx->last_handler->try_decode(NULL, NULL, NULL, 0,
674 &ctx->last_handler_ctx,
677 if (result == NULL) {
678 ctx->last_handler->destroy_ctx(&ctx->last_handler_ctx);
679 ctx->last_handler_ctx = NULL;
680 ctx->last_handler = NULL;
686 static int file_read_pem(BIO *bp, char **pem_name, char **pem_header,
687 unsigned char **data, long *len,
688 const UI_METHOD *ui_method,
691 int i = PEM_read_bio(bp, pem_name, pem_header, data, len);
697 * 10 is the number of characters in "Proc-Type:", which
698 * PEM_get_EVP_CIPHER_INFO() requires to be present.
699 * If the PEM header has less characters than that, it's
700 * not worth spending cycles on it.
702 if (strlen(*pem_header) > 10) {
703 EVP_CIPHER_INFO cipher;
704 struct pem_pass_data pass_data;
706 if (!PEM_get_EVP_CIPHER_INFO(*pem_header, &cipher)
707 || !file_fill_pem_pass_data(&pass_data, "PEM", ui_method, ui_data)
708 || !PEM_do_header(&cipher, *data, len, file_get_pem_pass,
716 static int file_read_asn1(BIO *bp, unsigned char **data, long *len)
720 if (asn1_d2i_read_bio(bp, &mem) < 0)
723 *data = (unsigned char *)mem->data;
724 *len = (long)mem->length;
730 static int file_eof(OSSL_STORE_LOADER_CTX *ctx);
731 static int file_error(OSSL_STORE_LOADER_CTX *ctx);
732 static OSSL_STORE_INFO *file_load(OSSL_STORE_LOADER_CTX *ctx,
733 const UI_METHOD *ui_method, void *ui_data)
735 OSSL_STORE_INFO *result = NULL;
738 result = file_load_try_repeat(ctx, ui_method, ui_data);
746 char *pem_name = NULL; /* PEM record name */
747 char *pem_header = NULL; /* PEM record header */
748 unsigned char *data = NULL; /* DER encoded data */
749 long len = 0; /* DER encoded data length */
752 if (!file_read_pem(ctx->file, &pem_name, &pem_header, &data, &len,
753 ui_method, ui_data)) {
759 if (!file_read_asn1(ctx->file, &data, &len)) {
767 result = file_load_try_decode(ctx, pem_name, pem_header, data, len,
768 ui_method, ui_data, &matchcount);
771 OPENSSL_free(pem_name);
772 OPENSSL_free(pem_header);
774 } while (matchcount == 0 && !file_eof(ctx) && !file_error(ctx));
776 /* We bail out on ambiguity */
783 static int file_error(OSSL_STORE_LOADER_CTX *ctx)
785 return ctx->errcnt > 0;
788 static int file_eof(OSSL_STORE_LOADER_CTX *ctx)
790 if (ctx->last_handler != NULL
791 && !ctx->last_handler->eof(ctx->last_handler_ctx))
793 return BIO_eof(ctx->file);
796 static int file_close(OSSL_STORE_LOADER_CTX *ctx)
798 if (ctx->last_handler != NULL) {
799 ctx->last_handler->destroy_ctx(&ctx->last_handler_ctx);
800 ctx->last_handler_ctx = NULL;
801 ctx->last_handler = NULL;
803 BIO_free_all(ctx->file);
808 static OSSL_STORE_LOADER file_loader =
819 static void store_file_loader_deinit(void)
821 ossl_store_unregister_loader_int(file_loader.scheme);
824 int ossl_store_file_loader_init(void)
826 int ret = ossl_store_register_loader_int(&file_loader);
828 OPENSSL_atexit(store_file_loader_deinit);