320c527a655c1bf1d8785ae31c477d2123adcf03
[openssl.git] / crypto / store / loader_file.c
1 /*
2  * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (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
8  */
9
10 #include "e_os.h"
11 #include <string.h>
12 #include <sys/stat.h>
13 #include <ctype.h>
14 #include <assert.h>
15
16 #include <openssl/bio.h>
17 #include <openssl/dsa.h>         /* For d2i_DSAPrivateKey */
18 #include <openssl/err.h>
19 #include <openssl/evp.h>
20 #include <openssl/pem.h>
21 #include "internal/pem_int.h"
22 #include <openssl/pkcs12.h>      /* For the PKCS8 stuff o.O */
23 #include <openssl/rsa.h>         /* For d2i_RSAPrivateKey */
24 #include <openssl/safestack.h>
25 #include <openssl/store.h>
26 #include <openssl/ui.h>
27 #include <openssl/x509.h>        /* For the PKCS8 stuff o.O */
28 #include "crypto/asn1.h"
29 #include "crypto/ctype.h"
30 #include "internal/o_dir.h"
31 #include "internal/cryptlib.h"
32 #include "crypto/store.h"
33 #include "crypto/evp.h"
34 #include "store_local.h"
35
36 DEFINE_STACK_OF(X509)
37
38 #ifdef _WIN32
39 # define stat    _stat
40 #endif
41
42 #ifndef S_ISDIR
43 # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
44 #endif
45
46 /*-
47  *  Password prompting
48  *  ------------------
49  */
50
51 static char *file_get_pass(const UI_METHOD *ui_method, char *pass,
52                            size_t maxsize, const char *desc, const char *info,
53                            void *data)
54 {
55     UI *ui = UI_new();
56     char *prompt = NULL;
57
58     if (ui == NULL) {
59         OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_MALLOC_FAILURE);
60         return NULL;
61     }
62
63     if (ui_method != NULL)
64         UI_set_method(ui, ui_method);
65     UI_add_user_data(ui, data);
66
67     if ((prompt = UI_construct_prompt(ui, desc, info)) == NULL) {
68         OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_MALLOC_FAILURE);
69         pass = NULL;
70     } else if (!UI_add_input_string(ui, prompt, UI_INPUT_FLAG_DEFAULT_PWD,
71                                     pass, 0, maxsize - 1)) {
72         OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_UI_LIB);
73         pass = NULL;
74     } else {
75         switch (UI_process(ui)) {
76         case -2:
77             OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS,
78                           OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED);
79             pass = NULL;
80             break;
81         case -1:
82             OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_UI_LIB);
83             pass = NULL;
84             break;
85         default:
86             break;
87         }
88     }
89
90     OPENSSL_free(prompt);
91     UI_free(ui);
92     return pass;
93 }
94
95 struct pem_pass_data {
96     const UI_METHOD *ui_method;
97     void *data;
98     const char *prompt_desc;
99     const char *prompt_info;
100 };
101
102 static int file_fill_pem_pass_data(struct pem_pass_data *pass_data,
103                                    const char *desc, const char *info,
104                                    const UI_METHOD *ui_method, void *ui_data)
105 {
106     if (pass_data == NULL)
107         return 0;
108     pass_data->ui_method = ui_method;
109     pass_data->data = ui_data;
110     pass_data->prompt_desc = desc;
111     pass_data->prompt_info = info;
112     return 1;
113 }
114
115 /* This is used anywhere a pem_password_cb is needed */
116 static int file_get_pem_pass(char *buf, int num, int w, void *data)
117 {
118     struct pem_pass_data *pass_data = data;
119     char *pass = file_get_pass(pass_data->ui_method, buf, num,
120                                pass_data->prompt_desc, pass_data->prompt_info,
121                                pass_data->data);
122
123     return pass == NULL ? 0 : strlen(pass);
124 }
125
126 /*-
127  *  The file scheme decoders
128  *  ------------------------
129  *
130  *  Each possible data type has its own decoder, which either operates
131  *  through a given PEM name, or attempts to decode to see if the blob
132  *  it's given is decodable for its data type.  The assumption is that
133  *  only the correct data type will match the content.
134  */
135
136 /*-
137  * The try_decode function is called to check if the blob of data can
138  * be used by this handler, and if it can, decodes it into a supported
139  * OpenSSL type and returns a OSSL_STORE_INFO with the decoded data.
140  * Input:
141  *    pem_name:     If this blob comes from a PEM file, this holds
142  *                  the PEM name.  If it comes from another type of
143  *                  file, this is NULL.
144  *    pem_header:   If this blob comes from a PEM file, this holds
145  *                  the PEM headers.  If it comes from another type of
146  *                  file, this is NULL.
147  *    blob:         The blob of data to match with what this handler
148  *                  can use.
149  *    len:          The length of the blob.
150  *    handler_ctx:  For a handler marked repeatable, this pointer can
151  *                  be used to create a context for the handler.  IT IS
152  *                  THE HANDLER'S RESPONSIBILITY TO CREATE AND DESTROY
153  *                  THIS CONTEXT APPROPRIATELY, i.e. create on first call
154  *                  and destroy when about to return NULL.
155  *    matchcount:   A pointer to an int to count matches for this data.
156  *                  Usually becomes 0 (no match) or 1 (match!), but may
157  *                  be higher in the (unlikely) event that the data matches
158  *                  more than one possibility.  The int will always be
159  *                  zero when the function is called.
160  *    ui_method:    Application UI method for getting a password, pin
161  *                  or any other interactive data.
162  *    ui_data:      Application data to be passed to ui_method when
163  *                  it's called.
164  *    libctx:       The library context to be used if applicable
165  *    propq:        The property query string for any algorithm fetches
166  * Output:
167  *    a OSSL_STORE_INFO
168  */
169 typedef OSSL_STORE_INFO *(*file_try_decode_fn)(const char *pem_name,
170                                                const char *pem_header,
171                                                const unsigned char *blob,
172                                                size_t len, void **handler_ctx,
173                                                int *matchcount,
174                                                const UI_METHOD *ui_method,
175                                                void *ui_data, const char *uri,
176                                                OPENSSL_CTX *libctx,
177                                                const char *propq);
178 /*
179  * The eof function should return 1 if there's no more data to be found
180  * with the handler_ctx, otherwise 0.  This is only used when the handler is
181  * marked repeatable.
182  */
183 typedef int (*file_eof_fn)(void *handler_ctx);
184 /*
185  * The destroy_ctx function is used to destroy the handler_ctx that was
186  * initiated by a repeatable try_decode function.  This is only used when
187  * the handler is marked repeatable.
188  */
189 typedef void (*file_destroy_ctx_fn)(void **handler_ctx);
190
191 typedef struct file_handler_st {
192     const char *name;
193     file_try_decode_fn try_decode;
194     file_eof_fn eof;
195     file_destroy_ctx_fn destroy_ctx;
196
197     /* flags */
198     int repeatable;
199 } FILE_HANDLER;
200
201 /*
202  * PKCS#12 decoder.  It operates by decoding all of the blob content,
203  * extracting all the interesting data from it and storing them internally,
204  * then serving them one piece at a time.
205  */
206 static OSSL_STORE_INFO *try_decode_PKCS12(const char *pem_name,
207                                           const char *pem_header,
208                                           const unsigned char *blob,
209                                           size_t len, void **pctx,
210                                           int *matchcount,
211                                           const UI_METHOD *ui_method,
212                                           void *ui_data, const char *uri,
213                                           OPENSSL_CTX *libctx,
214                                           const char *propq)
215 {
216     OSSL_STORE_INFO *store_info = NULL;
217     STACK_OF(OSSL_STORE_INFO) *ctx = *pctx;
218
219     if (ctx == NULL) {
220         /* Initial parsing */
221         PKCS12 *p12;
222         int ok = 0;
223
224         if (pem_name != NULL)
225             /* No match, there is no PEM PKCS12 tag */
226             return NULL;
227
228         if ((p12 = d2i_PKCS12(NULL, &blob, len)) != NULL) {
229             char *pass = NULL;
230             char tpass[PEM_BUFSIZE];
231             EVP_PKEY *pkey = NULL;
232             X509 *cert = NULL;
233             STACK_OF(X509) *chain = NULL;
234
235             *matchcount = 1;
236
237             if (PKCS12_verify_mac(p12, "", 0)
238                 || PKCS12_verify_mac(p12, NULL, 0)) {
239                 pass = "";
240             } else {
241                 if ((pass = file_get_pass(ui_method, tpass, PEM_BUFSIZE,
242                                           "PKCS12 import pass phrase", uri,
243                                           ui_data)) == NULL) {
244                     OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS12,
245                                   OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR);
246                     goto p12_end;
247                 }
248                 if (!PKCS12_verify_mac(p12, pass, strlen(pass))) {
249                     OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS12,
250                                   OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC);
251                     goto p12_end;
252                 }
253             }
254
255             if (PKCS12_parse(p12, pass, &pkey, &cert, &chain)) {
256                 OSSL_STORE_INFO *osi_pkey = NULL;
257                 OSSL_STORE_INFO *osi_cert = NULL;
258                 OSSL_STORE_INFO *osi_ca = NULL;
259
260                 if ((ctx = sk_OSSL_STORE_INFO_new_null()) != NULL
261                     && (osi_pkey = OSSL_STORE_INFO_new_PKEY(pkey)) != NULL
262                     && sk_OSSL_STORE_INFO_push(ctx, osi_pkey) != 0
263                     && (osi_cert = OSSL_STORE_INFO_new_CERT(cert)) != NULL
264                     && sk_OSSL_STORE_INFO_push(ctx, osi_cert) != 0) {
265                     ok = 1;
266                     osi_pkey = NULL;
267                     osi_cert = NULL;
268
269                     while(sk_X509_num(chain) > 0) {
270                         X509 *ca = sk_X509_value(chain, 0);
271
272                         if ((osi_ca = OSSL_STORE_INFO_new_CERT(ca)) == NULL
273                             || sk_OSSL_STORE_INFO_push(ctx, osi_ca) == 0) {
274                             ok = 0;
275                             break;
276                         }
277                         osi_ca = NULL;
278                         (void)sk_X509_shift(chain);
279                     }
280                 }
281                 sk_X509_free(chain);
282                 if (!ok) {
283                     OSSL_STORE_INFO_free(osi_ca);
284                     OSSL_STORE_INFO_free(osi_cert);
285                     OSSL_STORE_INFO_free(osi_pkey);
286                     sk_OSSL_STORE_INFO_pop_free(ctx, OSSL_STORE_INFO_free);
287                     EVP_PKEY_free(pkey);
288                     X509_free(cert);
289                     sk_X509_pop_free(chain, X509_free);
290                     ctx = NULL;
291                 }
292                 *pctx = ctx;
293             }
294         }
295      p12_end:
296         PKCS12_free(p12);
297         if (!ok)
298             return NULL;
299     }
300
301     if (ctx != NULL) {
302         *matchcount = 1;
303         store_info = sk_OSSL_STORE_INFO_shift(ctx);
304     }
305
306     return store_info;
307 }
308
309 static int eof_PKCS12(void *ctx_)
310 {
311     STACK_OF(OSSL_STORE_INFO) *ctx = ctx_;
312
313     return ctx == NULL || sk_OSSL_STORE_INFO_num(ctx) == 0;
314 }
315
316 static void destroy_ctx_PKCS12(void **pctx)
317 {
318     STACK_OF(OSSL_STORE_INFO) *ctx = *pctx;
319
320     sk_OSSL_STORE_INFO_pop_free(ctx, OSSL_STORE_INFO_free);
321     *pctx = NULL;
322 }
323
324 static FILE_HANDLER PKCS12_handler = {
325     "PKCS12",
326     try_decode_PKCS12,
327     eof_PKCS12,
328     destroy_ctx_PKCS12,
329     1                            /* repeatable */
330 };
331
332 /*
333  * Encrypted PKCS#8 decoder.  It operates by just decrypting the given blob
334  * into a new blob, which is returned as an EMBEDDED STORE_INFO.  The whole
335  * decoding process will then start over with the new blob.
336  */
337 static OSSL_STORE_INFO *try_decode_PKCS8Encrypted(const char *pem_name,
338                                                   const char *pem_header,
339                                                   const unsigned char *blob,
340                                                   size_t len, void **pctx,
341                                                   int *matchcount,
342                                                   const UI_METHOD *ui_method,
343                                                   void *ui_data,
344                                                   const char *uri,
345                                                   OPENSSL_CTX *libctx,
346                                                   const char *propq)
347 {
348     X509_SIG *p8 = NULL;
349     char kbuf[PEM_BUFSIZE];
350     char *pass = NULL;
351     const X509_ALGOR *dalg = NULL;
352     const ASN1_OCTET_STRING *doct = NULL;
353     OSSL_STORE_INFO *store_info = NULL;
354     BUF_MEM *mem = NULL;
355     unsigned char *new_data = NULL;
356     int new_data_len;
357
358     if (pem_name != NULL) {
359         if (strcmp(pem_name, PEM_STRING_PKCS8) != 0)
360             return NULL;
361         *matchcount = 1;
362     }
363
364     if ((p8 = d2i_X509_SIG(NULL, &blob, len)) == NULL)
365         return NULL;
366
367     *matchcount = 1;
368
369     if ((mem = BUF_MEM_new()) == NULL) {
370         OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED,
371                       ERR_R_MALLOC_FAILURE);
372         goto nop8;
373     }
374
375     if ((pass = file_get_pass(ui_method, kbuf, PEM_BUFSIZE,
376                               "PKCS8 decrypt pass phrase", uri,
377                               ui_data)) == NULL) {
378         OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED,
379                       OSSL_STORE_R_BAD_PASSWORD_READ);
380         goto nop8;
381     }
382
383     X509_SIG_get0(p8, &dalg, &doct);
384     if (!PKCS12_pbe_crypt(dalg, pass, strlen(pass), doct->data, doct->length,
385                           &new_data, &new_data_len, 0))
386         goto nop8;
387
388     mem->data = (char *)new_data;
389     mem->max = mem->length = (size_t)new_data_len;
390     X509_SIG_free(p8);
391
392     store_info = ossl_store_info_new_EMBEDDED(PEM_STRING_PKCS8INF, mem);
393     if (store_info == NULL) {
394         OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED,
395                       ERR_R_MALLOC_FAILURE);
396         goto nop8;
397     }
398
399     return store_info;
400  nop8:
401     X509_SIG_free(p8);
402     BUF_MEM_free(mem);
403     return NULL;
404 }
405
406 static FILE_HANDLER PKCS8Encrypted_handler = {
407     "PKCS8Encrypted",
408     try_decode_PKCS8Encrypted
409 };
410
411 /*
412  * Private key decoder.  Decodes all sorts of private keys, both PKCS#8
413  * encoded ones and old style PEM ones (with the key type is encoded into
414  * the PEM name).
415  */
416 int pem_check_suffix(const char *pem_str, const char *suffix);
417 static OSSL_STORE_INFO *try_decode_PrivateKey(const char *pem_name,
418                                               const char *pem_header,
419                                               const unsigned char *blob,
420                                               size_t len, void **pctx,
421                                               int *matchcount,
422                                               const UI_METHOD *ui_method,
423                                               void *ui_data, const char *uri,
424                                               OPENSSL_CTX *libctx,
425                                               const char *propq)
426 {
427     OSSL_STORE_INFO *store_info = NULL;
428     EVP_PKEY *pkey = NULL;
429     const EVP_PKEY_ASN1_METHOD *ameth = NULL;
430
431     if (pem_name != NULL) {
432         if (strcmp(pem_name, PEM_STRING_PKCS8INF) == 0) {
433             PKCS8_PRIV_KEY_INFO *p8inf =
434                 d2i_PKCS8_PRIV_KEY_INFO(NULL, &blob, len);
435
436             *matchcount = 1;
437             if (p8inf != NULL)
438                 pkey = evp_pkcs82pkey_int(p8inf, libctx, propq);
439             PKCS8_PRIV_KEY_INFO_free(p8inf);
440         } else {
441             int slen;
442
443             if ((slen = pem_check_suffix(pem_name, "PRIVATE KEY")) > 0
444                 && (ameth = EVP_PKEY_asn1_find_str(NULL, pem_name,
445                                                    slen)) != NULL) {
446                 *matchcount = 1;
447                 pkey = d2i_PrivateKey_ex(ameth->pkey_id, NULL, &blob, len,
448                                          libctx, propq);
449             }
450         }
451     } else {
452         int i;
453
454         for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
455             EVP_PKEY *tmp_pkey = NULL;
456             const unsigned char *tmp_blob = blob;
457
458             ameth = EVP_PKEY_asn1_get0(i);
459             if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
460                 continue;
461
462             tmp_pkey = d2i_PrivateKey_ex(ameth->pkey_id, NULL, &tmp_blob, len,
463                                          libctx, propq);
464             if (tmp_pkey != NULL) {
465                 if (pkey != NULL)
466                     EVP_PKEY_free(tmp_pkey);
467                 else
468                     pkey = tmp_pkey;
469                 (*matchcount)++;
470             }
471         }
472
473         if (*matchcount > 1) {
474             EVP_PKEY_free(pkey);
475             pkey = NULL;
476         }
477     }
478     if (pkey == NULL)
479         /* No match */
480         return NULL;
481
482     store_info = OSSL_STORE_INFO_new_PKEY(pkey);
483     if (store_info == NULL)
484         EVP_PKEY_free(pkey);
485
486     return store_info;
487 }
488
489 static FILE_HANDLER PrivateKey_handler = {
490     "PrivateKey",
491     try_decode_PrivateKey
492 };
493
494 /*
495  * Public key decoder.  Only supports SubjectPublicKeyInfo formatted keys.
496  */
497 static OSSL_STORE_INFO *try_decode_PUBKEY(const char *pem_name,
498                                           const char *pem_header,
499                                           const unsigned char *blob,
500                                           size_t len, void **pctx,
501                                           int *matchcount,
502                                           const UI_METHOD *ui_method,
503                                           void *ui_data, const char *uri,
504                                           OPENSSL_CTX *libctx,
505                                           const char *propq)
506 {
507     OSSL_STORE_INFO *store_info = NULL;
508     EVP_PKEY *pkey = NULL;
509
510     if (pem_name != NULL) {
511         if (strcmp(pem_name, PEM_STRING_PUBLIC) != 0)
512             /* No match */
513             return NULL;
514         *matchcount = 1;
515     }
516
517     if ((pkey = d2i_PUBKEY(NULL, &blob, len)) != NULL) {
518         *matchcount = 1;
519         store_info = OSSL_STORE_INFO_new_PKEY(pkey);
520     }
521
522     return store_info;
523 }
524
525 static FILE_HANDLER PUBKEY_handler = {
526     "PUBKEY",
527     try_decode_PUBKEY
528 };
529
530 /*
531  * Key parameter decoder.
532  */
533 static OSSL_STORE_INFO *try_decode_params(const char *pem_name,
534                                           const char *pem_header,
535                                           const unsigned char *blob,
536                                           size_t len, void **pctx,
537                                           int *matchcount,
538                                           const UI_METHOD *ui_method,
539                                           void *ui_data, const char *uri,
540                                           OPENSSL_CTX *libctx,
541                                           const char *propq)
542 {
543     OSSL_STORE_INFO *store_info = NULL;
544     int slen = 0;
545     EVP_PKEY *pkey = NULL;
546     const EVP_PKEY_ASN1_METHOD *ameth = NULL;
547     int ok = 0;
548
549     if (pem_name != NULL) {
550         if ((slen = pem_check_suffix(pem_name, "PARAMETERS")) == 0)
551             return NULL;
552         *matchcount = 1;
553     }
554
555     if (slen > 0) {
556         if ((pkey = EVP_PKEY_new()) == NULL) {
557             OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PARAMS, ERR_R_EVP_LIB);
558             return NULL;
559         }
560
561
562         if (EVP_PKEY_set_type_str(pkey, pem_name, slen)
563             && (ameth = EVP_PKEY_get0_asn1(pkey)) != NULL
564             && ameth->param_decode != NULL
565             && ameth->param_decode(pkey, &blob, len))
566             ok = 1;
567     } else {
568         int i;
569         EVP_PKEY *tmp_pkey = NULL;
570
571         for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {
572             const unsigned char *tmp_blob = blob;
573
574             if (tmp_pkey == NULL && (tmp_pkey = EVP_PKEY_new()) == NULL) {
575                 OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PARAMS, ERR_R_EVP_LIB);
576                 break;
577             }
578
579             ameth = EVP_PKEY_asn1_get0(i);
580             if (ameth->pkey_flags & ASN1_PKEY_ALIAS)
581                 continue;
582
583             if (EVP_PKEY_set_type(tmp_pkey, ameth->pkey_id)
584                 && (ameth = EVP_PKEY_get0_asn1(tmp_pkey)) != NULL
585                 && ameth->param_decode != NULL
586                 && ameth->param_decode(tmp_pkey, &tmp_blob, len)) {
587                 if (pkey != NULL)
588                     EVP_PKEY_free(tmp_pkey);
589                 else
590                     pkey = tmp_pkey;
591                 tmp_pkey = NULL;
592                 (*matchcount)++;
593             }
594         }
595
596         EVP_PKEY_free(tmp_pkey);
597         if (*matchcount == 1) {
598             ok = 1;
599         }
600     }
601
602     if (ok)
603         store_info = OSSL_STORE_INFO_new_PARAMS(pkey);
604     if (store_info == NULL)
605         EVP_PKEY_free(pkey);
606
607     return store_info;
608 }
609
610 static FILE_HANDLER params_handler = {
611     "params",
612     try_decode_params
613 };
614
615 /*
616  * X.509 certificate decoder.
617  */
618 static OSSL_STORE_INFO *try_decode_X509Certificate(const char *pem_name,
619                                                    const char *pem_header,
620                                                    const unsigned char *blob,
621                                                    size_t len, void **pctx,
622                                                    int *matchcount,
623                                                    const UI_METHOD *ui_method,
624                                                    void *ui_data,
625                                                    const char *uri,
626                                                    OPENSSL_CTX *libctx,
627                                                    const char *propq)
628 {
629     OSSL_STORE_INFO *store_info = NULL;
630     X509 *cert = NULL;
631
632     /*
633      * In most cases, we can try to interpret the serialized data as a trusted
634      * cert (X509 + X509_AUX) and fall back to reading it as a normal cert
635      * (just X509), but if the PEM name specifically declares it as a trusted
636      * cert, then no fallback should be engaged.  |ignore_trusted| tells if
637      * the fallback can be used (1) or not (0).
638      */
639     int ignore_trusted = 1;
640
641     if (pem_name != NULL) {
642         if (strcmp(pem_name, PEM_STRING_X509_TRUSTED) == 0)
643             ignore_trusted = 0;
644         else if (strcmp(pem_name, PEM_STRING_X509_OLD) != 0
645                  && strcmp(pem_name, PEM_STRING_X509) != 0)
646             /* No match */
647             return NULL;
648         *matchcount = 1;
649     }
650
651     if ((cert = d2i_X509_AUX(NULL, &blob, len)) != NULL
652         || (ignore_trusted && (cert = d2i_X509(NULL, &blob, len)) != NULL)) {
653         *matchcount = 1;
654         store_info = OSSL_STORE_INFO_new_CERT(cert);
655     }
656
657     if (store_info == NULL)
658         X509_free(cert);
659
660     return store_info;
661 }
662
663 static FILE_HANDLER X509Certificate_handler = {
664     "X509Certificate",
665     try_decode_X509Certificate
666 };
667
668 /*
669  * X.509 CRL decoder.
670  */
671 static OSSL_STORE_INFO *try_decode_X509CRL(const char *pem_name,
672                                            const char *pem_header,
673                                            const unsigned char *blob,
674                                            size_t len, void **pctx,
675                                            int *matchcount,
676                                            const UI_METHOD *ui_method,
677                                            void *ui_data, const char *uri,
678                                            OPENSSL_CTX *libctx,
679                                            const char *propq)
680 {
681     OSSL_STORE_INFO *store_info = NULL;
682     X509_CRL *crl = NULL;
683
684     if (pem_name != NULL) {
685         if (strcmp(pem_name, PEM_STRING_X509_CRL) != 0)
686             /* No match */
687             return NULL;
688         *matchcount = 1;
689     }
690
691     if ((crl = d2i_X509_CRL(NULL, &blob, len)) != NULL) {
692         *matchcount = 1;
693         store_info = OSSL_STORE_INFO_new_CRL(crl);
694     }
695
696     if (store_info == NULL)
697         X509_CRL_free(crl);
698
699     return store_info;
700 }
701
702 static FILE_HANDLER X509CRL_handler = {
703     "X509CRL",
704     try_decode_X509CRL
705 };
706
707 /*
708  * To finish it all off, we collect all the handlers.
709  */
710 static const FILE_HANDLER *file_handlers[] = {
711     &PKCS12_handler,
712     &PKCS8Encrypted_handler,
713     &X509Certificate_handler,
714     &X509CRL_handler,
715     &params_handler,
716     &PUBKEY_handler,
717     &PrivateKey_handler,
718 };
719
720
721 /*-
722  *  The loader itself
723  *  -----------------
724  */
725
726 struct ossl_store_loader_ctx_st {
727     char *uri;                   /* The URI we currently try to load */
728     enum {
729         is_raw = 0,
730         is_pem,
731         is_dir
732     } type;
733     int errcnt;
734 #define FILE_FLAG_SECMEM         (1<<0)
735 #define FILE_FLAG_ATTACHED       (1<<1)
736     unsigned int flags;
737     union {
738         struct {                 /* Used with is_raw and is_pem */
739             BIO *file;
740
741             /*
742              * The following are used when the handler is marked as
743              * repeatable
744              */
745             const FILE_HANDLER *last_handler;
746             void *last_handler_ctx;
747         } file;
748         struct {                 /* Used with is_dir */
749             OPENSSL_DIR_CTX *ctx;
750             int end_reached;
751
752             /*
753              * When a search expression is given, these are filled in.
754              * |search_name| contains the file basename to look for.
755              * The string is exactly 8 characters long.
756              */
757             char search_name[9];
758
759             /*
760              * The directory reading utility we have combines opening with
761              * reading the first name.  To make sure we can detect the end
762              * at the right time, we read early and cache the name.
763              */
764             const char *last_entry;
765             int last_errno;
766         } dir;
767     } _;
768
769     /* Expected object type.  May be unspecified */
770     int expected_type;
771
772     OPENSSL_CTX *libctx;
773     char *propq;
774 };
775
776 static void OSSL_STORE_LOADER_CTX_free(OSSL_STORE_LOADER_CTX *ctx)
777 {
778     if (ctx == NULL)
779         return;
780
781     OPENSSL_free(ctx->uri);
782     if (ctx->type != is_dir) {
783         if (ctx->_.file.last_handler != NULL) {
784             ctx->_.file.last_handler->destroy_ctx(&ctx->_.file.last_handler_ctx);
785             ctx->_.file.last_handler_ctx = NULL;
786             ctx->_.file.last_handler = NULL;
787         }
788     }
789     OPENSSL_free(ctx->propq);
790     OPENSSL_free(ctx);
791 }
792
793 static int file_find_type(OSSL_STORE_LOADER_CTX *ctx)
794 {
795     BIO *buff = NULL;
796     char peekbuf[4096] = { 0, };
797
798     if ((buff = BIO_new(BIO_f_buffer())) == NULL)
799         return 0;
800
801     ctx->_.file.file = BIO_push(buff, ctx->_.file.file);
802     if (BIO_buffer_peek(ctx->_.file.file, peekbuf, sizeof(peekbuf) - 1) > 0) {
803         peekbuf[sizeof(peekbuf) - 1] = '\0';
804         if (strstr(peekbuf, "-----BEGIN ") != NULL)
805             ctx->type = is_pem;
806     }
807     return 1;
808 }
809
810 static OSSL_STORE_LOADER_CTX *file_open(const OSSL_STORE_LOADER *loader,
811                                         const char *uri,
812                                         const UI_METHOD *ui_method,
813                                         void *ui_data)
814 {
815     OSSL_STORE_LOADER_CTX *ctx = NULL;
816     struct stat st;
817     struct {
818         const char *path;
819         unsigned int check_absolute:1;
820     } path_data[2];
821     size_t path_data_n = 0, i;
822     const char *path;
823
824     /*
825      * First step, just take the URI as is.
826      */
827     path_data[path_data_n].check_absolute = 0;
828     path_data[path_data_n++].path = uri;
829
830     /*
831      * Second step, if the URI appears to start with the 'file' scheme,
832      * extract the path and make that the second path to check.
833      * There's a special case if the URI also contains an authority, then
834      * the full URI shouldn't be used as a path anywhere.
835      */
836     if (strncasecmp(uri, "file:", 5) == 0) {
837         const char *p = &uri[5];
838
839         if (strncmp(&uri[5], "//", 2) == 0) {
840             path_data_n--;           /* Invalidate using the full URI */
841             if (strncasecmp(&uri[7], "localhost/", 10) == 0) {
842                 p = &uri[16];
843             } else if (uri[7] == '/') {
844                 p = &uri[7];
845             } else {
846                 OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN,
847                               OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED);
848                 return NULL;
849             }
850         }
851
852         path_data[path_data_n].check_absolute = 1;
853 #ifdef _WIN32
854         /* Windows file: URIs with a drive letter start with a / */
855         if (p[0] == '/' && p[2] == ':' && p[3] == '/') {
856             char c = ossl_tolower(p[1]);
857
858             if (c >= 'a' && c <= 'z') {
859                 p++;
860                 /* We know it's absolute, so no need to check */
861                 path_data[path_data_n].check_absolute = 0;
862             }
863         }
864 #endif
865         path_data[path_data_n++].path = p;
866     }
867
868
869     for (i = 0, path = NULL; path == NULL && i < path_data_n; i++) {
870         /*
871          * If the scheme "file" was an explicit part of the URI, the path must
872          * be absolute.  So says RFC 8089
873          */
874         if (path_data[i].check_absolute && path_data[i].path[0] != '/') {
875             OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN,
876                           OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE);
877             ERR_add_error_data(1, path_data[i].path);
878             return NULL;
879         }
880
881         if (stat(path_data[i].path, &st) < 0) {
882             ERR_raise_data(ERR_LIB_SYS, errno,
883                            "calling stat(%s)",
884                            path_data[i].path);
885         } else {
886             path = path_data[i].path;
887         }
888     }
889     if (path == NULL) {
890         return NULL;
891     }
892
893     /* Successfully found a working path, clear possible collected errors */
894     ERR_clear_error();
895
896     ctx = OPENSSL_zalloc(sizeof(*ctx));
897     if (ctx == NULL) {
898         OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN, ERR_R_MALLOC_FAILURE);
899         return NULL;
900     }
901     ctx->uri = OPENSSL_strdup(uri);
902     if (ctx->uri == NULL) {
903         OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN, ERR_R_MALLOC_FAILURE);
904         goto err;
905     }
906
907     if (S_ISDIR(st.st_mode)) {
908         ctx->type = is_dir;
909         ctx->_.dir.last_entry = OPENSSL_DIR_read(&ctx->_.dir.ctx, path);
910         ctx->_.dir.last_errno = errno;
911         if (ctx->_.dir.last_entry == NULL) {
912             if (ctx->_.dir.last_errno != 0) {
913                 char errbuf[256];
914                 OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN, ERR_R_SYS_LIB);
915                 errno = ctx->_.dir.last_errno;
916                 if (openssl_strerror_r(errno, errbuf, sizeof(errbuf)))
917                     ERR_add_error_data(1, errbuf);
918                 goto err;
919             }
920             ctx->_.dir.end_reached = 1;
921         }
922     } else if ((ctx->_.file.file = BIO_new_file(path, "rb")) == NULL
923                || !file_find_type(ctx)) {
924         BIO_free_all(ctx->_.file.file);
925         goto err;
926     }
927
928     return ctx;
929  err:
930     OSSL_STORE_LOADER_CTX_free(ctx);
931     return NULL;
932 }
933
934 static OSSL_STORE_LOADER_CTX *file_attach(const OSSL_STORE_LOADER *loader,
935                                           BIO *bp, OPENSSL_CTX *libctx,
936                                           const char *propq,
937                                           const UI_METHOD *ui_method,
938                                           void *ui_data)
939 {
940     OSSL_STORE_LOADER_CTX *ctx;
941
942     if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL
943         || (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL)) {
944         OSSL_STOREerr(OSSL_STORE_F_FILE_ATTACH, ERR_R_MALLOC_FAILURE);
945         OSSL_STORE_LOADER_CTX_free(ctx);
946         return NULL;
947     }
948
949     ctx->libctx = libctx;
950     ctx->flags |= FILE_FLAG_ATTACHED;
951     ctx->_.file.file = bp;
952     if (!file_find_type(ctx)) {
953         /* Safety measure */
954         ctx->_.file.file = NULL;
955         OSSL_STORE_LOADER_CTX_free(ctx);
956         ctx = NULL;
957     }
958
959     return ctx;
960 }
961
962 static int file_ctrl(OSSL_STORE_LOADER_CTX *ctx, int cmd, va_list args)
963 {
964     int ret = 1;
965
966     switch (cmd) {
967     case OSSL_STORE_C_USE_SECMEM:
968         {
969             int on = *(va_arg(args, int *));
970
971             switch (on) {
972             case 0:
973                 ctx->flags &= ~FILE_FLAG_SECMEM;
974                 break;
975             case 1:
976                 ctx->flags |= FILE_FLAG_SECMEM;
977                 break;
978             default:
979                 OSSL_STOREerr(OSSL_STORE_F_FILE_CTRL,
980                               ERR_R_PASSED_INVALID_ARGUMENT);
981                 ret = 0;
982                 break;
983             }
984         }
985         break;
986     default:
987         break;
988     }
989
990     return ret;
991 }
992
993 static int file_expect(OSSL_STORE_LOADER_CTX *ctx, int expected)
994 {
995     ctx->expected_type = expected;
996     return 1;
997 }
998
999 static int file_find(OSSL_STORE_LOADER_CTX *ctx,
1000                      const OSSL_STORE_SEARCH *search)
1001 {
1002     /*
1003      * If ctx == NULL, the library is looking to know if this loader supports
1004      * the given search type.
1005      */
1006
1007     if (OSSL_STORE_SEARCH_get_type(search) == OSSL_STORE_SEARCH_BY_NAME) {
1008         unsigned long hash = 0;
1009
1010         if (ctx == NULL)
1011             return 1;
1012
1013         if (ctx->type != is_dir) {
1014             OSSL_STOREerr(OSSL_STORE_F_FILE_FIND,
1015                           OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES);
1016             return 0;
1017         }
1018
1019         hash = X509_NAME_hash(OSSL_STORE_SEARCH_get0_name(search));
1020         BIO_snprintf(ctx->_.dir.search_name, sizeof(ctx->_.dir.search_name),
1021                      "%08lx", hash);
1022         return 1;
1023     }
1024
1025     if (ctx != NULL)
1026         OSSL_STOREerr(OSSL_STORE_F_FILE_FIND,
1027                       OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE);
1028     return 0;
1029 }
1030
1031 static OSSL_STORE_INFO *file_load_try_decode(OSSL_STORE_LOADER_CTX *ctx,
1032                                              const char *pem_name,
1033                                              const char *pem_header,
1034                                              unsigned char *data, size_t len,
1035                                              const UI_METHOD *ui_method,
1036                                              void *ui_data, int *matchcount)
1037 {
1038     OSSL_STORE_INFO *result = NULL;
1039     BUF_MEM *new_mem = NULL;
1040     char *new_pem_name = NULL;
1041     int t = 0;
1042
1043  again:
1044     {
1045         size_t i = 0;
1046         void *handler_ctx = NULL;
1047         const FILE_HANDLER **matching_handlers =
1048             OPENSSL_zalloc(sizeof(*matching_handlers)
1049                            * OSSL_NELEM(file_handlers));
1050
1051         if (matching_handlers == NULL) {
1052             OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD_TRY_DECODE,
1053                           ERR_R_MALLOC_FAILURE);
1054             goto err;
1055         }
1056
1057         *matchcount = 0;
1058         for (i = 0; i < OSSL_NELEM(file_handlers); i++) {
1059             const FILE_HANDLER *handler = file_handlers[i];
1060             int try_matchcount = 0;
1061             void *tmp_handler_ctx = NULL;
1062             OSSL_STORE_INFO *tmp_result =
1063                 handler->try_decode(pem_name, pem_header, data, len,
1064                                     &tmp_handler_ctx, &try_matchcount,
1065                                     ui_method, ui_data, ctx->uri,
1066                                     ctx->libctx, ctx->propq);
1067
1068             if (try_matchcount > 0) {
1069
1070                 matching_handlers[*matchcount] = handler;
1071
1072                 if (handler_ctx)
1073                     handler->destroy_ctx(&handler_ctx);
1074                 handler_ctx = tmp_handler_ctx;
1075
1076                 if ((*matchcount += try_matchcount) > 1) {
1077                     /* more than one match => ambiguous, kill any result */
1078                     OSSL_STORE_INFO_free(result);
1079                     OSSL_STORE_INFO_free(tmp_result);
1080                     if (handler->destroy_ctx != NULL)
1081                         handler->destroy_ctx(&handler_ctx);
1082                     handler_ctx = NULL;
1083                     tmp_result = NULL;
1084                     result = NULL;
1085                 }
1086                 if (result == NULL)
1087                     result = tmp_result;
1088             }
1089         }
1090
1091         if (*matchcount == 1 && matching_handlers[0]->repeatable) {
1092             ctx->_.file.last_handler = matching_handlers[0];
1093             ctx->_.file.last_handler_ctx = handler_ctx;
1094         }
1095
1096         OPENSSL_free(matching_handlers);
1097     }
1098
1099  err:
1100     OPENSSL_free(new_pem_name);
1101     BUF_MEM_free(new_mem);
1102
1103     if (result != NULL
1104         && (t = OSSL_STORE_INFO_get_type(result)) == OSSL_STORE_INFO_EMBEDDED) {
1105         pem_name = new_pem_name =
1106             ossl_store_info_get0_EMBEDDED_pem_name(result);
1107         new_mem = ossl_store_info_get0_EMBEDDED_buffer(result);
1108         data = (unsigned char *)new_mem->data;
1109         len = new_mem->length;
1110         OPENSSL_free(result);
1111         result = NULL;
1112         goto again;
1113     }
1114
1115     if (result != NULL)
1116         ERR_clear_error();
1117
1118     return result;
1119 }
1120
1121 static OSSL_STORE_INFO *file_load_try_repeat(OSSL_STORE_LOADER_CTX *ctx,
1122                                              const UI_METHOD *ui_method,
1123                                              void *ui_data)
1124 {
1125     OSSL_STORE_INFO *result = NULL;
1126     int try_matchcount = 0;
1127
1128     if (ctx->_.file.last_handler != NULL) {
1129         result =
1130             ctx->_.file.last_handler->try_decode(NULL, NULL, NULL, 0,
1131                                                  &ctx->_.file.last_handler_ctx,
1132                                                  &try_matchcount,
1133                                                  ui_method, ui_data, ctx->uri,
1134                                                  ctx->libctx, ctx->propq);
1135
1136         if (result == NULL) {
1137             ctx->_.file.last_handler->destroy_ctx(&ctx->_.file.last_handler_ctx);
1138             ctx->_.file.last_handler_ctx = NULL;
1139             ctx->_.file.last_handler = NULL;
1140         }
1141     }
1142     return result;
1143 }
1144
1145 static void pem_free_flag(void *pem_data, int secure, size_t num)
1146 {
1147     if (secure)
1148         OPENSSL_secure_clear_free(pem_data, num);
1149     else
1150         OPENSSL_free(pem_data);
1151 }
1152 static int file_read_pem(BIO *bp, char **pem_name, char **pem_header,
1153                          unsigned char **data, long *len,
1154                          const UI_METHOD *ui_method, void *ui_data,
1155                          const char *uri, int secure)
1156 {
1157     int i = secure
1158         ? PEM_read_bio_ex(bp, pem_name, pem_header, data, len,
1159                           PEM_FLAG_SECURE | PEM_FLAG_EAY_COMPATIBLE)
1160         : PEM_read_bio(bp, pem_name, pem_header, data, len);
1161
1162     if (i <= 0)
1163         return 0;
1164
1165     /*
1166      * 10 is the number of characters in "Proc-Type:", which
1167      * PEM_get_EVP_CIPHER_INFO() requires to be present.
1168      * If the PEM header has less characters than that, it's
1169      * not worth spending cycles on it.
1170      */
1171     if (strlen(*pem_header) > 10) {
1172         EVP_CIPHER_INFO cipher;
1173         struct pem_pass_data pass_data;
1174
1175         if (!PEM_get_EVP_CIPHER_INFO(*pem_header, &cipher)
1176             || !file_fill_pem_pass_data(&pass_data, "PEM pass phrase", uri,
1177                                         ui_method, ui_data)
1178             || !PEM_do_header(&cipher, *data, len, file_get_pem_pass,
1179                               &pass_data)) {
1180             return 0;
1181         }
1182     }
1183     return 1;
1184 }
1185
1186 static OSSL_STORE_INFO *file_try_read_msblob(BIO *bp, int *matchcount)
1187 {
1188 #ifdef OPENSSL_NO_DSA
1189     return NULL;
1190 #else
1191     OSSL_STORE_INFO *result = NULL;
1192     int ispub = -1;
1193
1194     {
1195         unsigned int magic = 0, bitlen = 0;
1196         int isdss = 0;
1197         unsigned char peekbuf[16] = { 0, };
1198         const unsigned char *p = peekbuf;
1199
1200         if (BIO_buffer_peek(bp, peekbuf, sizeof(peekbuf)) <= 0)
1201             return 0;
1202         if (!ossl_do_blob_header(&p, sizeof(peekbuf), &magic, &bitlen,
1203                                  &isdss, &ispub))
1204             return 0;
1205     }
1206
1207     (*matchcount)++;
1208
1209     {
1210         EVP_PKEY *tmp = ispub
1211             ? b2i_PublicKey_bio(bp)
1212             : b2i_PrivateKey_bio(bp);
1213
1214         if (tmp == NULL
1215             || (result = OSSL_STORE_INFO_new_PKEY(tmp)) == NULL) {
1216             EVP_PKEY_free(tmp);
1217             return 0;
1218         }
1219     }
1220
1221     return result;
1222 #endif
1223 }
1224
1225 static OSSL_STORE_INFO *file_try_read_PVK(BIO *bp, const UI_METHOD *ui_method,
1226                                           void *ui_data, const char *uri,
1227                                           int *matchcount)
1228 {
1229 #if defined(OPENSSL_NO_DSA) || defined(OPENSSL_NO_RC4)
1230     return NULL;
1231 #else
1232     OSSL_STORE_INFO *result = NULL;
1233
1234     {
1235         unsigned int saltlen = 0, keylen = 0;
1236         unsigned char peekbuf[24] = { 0, };
1237         const unsigned char *p = peekbuf;
1238
1239         if (BIO_buffer_peek(bp, peekbuf, sizeof(peekbuf)) <= 0)
1240             return 0;
1241         if (!ossl_do_PVK_header(&p, sizeof(peekbuf), 0, &saltlen, &keylen))
1242             return 0;
1243     }
1244
1245     (*matchcount)++;
1246
1247     {
1248         EVP_PKEY *tmp = NULL;
1249         struct pem_pass_data pass_data;
1250
1251         if (!file_fill_pem_pass_data(&pass_data, "PVK pass phrase", uri,
1252                                      ui_method, ui_data)
1253             || (tmp = b2i_PVK_bio(bp, file_get_pem_pass, &pass_data)) == NULL
1254             || (result = OSSL_STORE_INFO_new_PKEY(tmp)) == NULL) {
1255             EVP_PKEY_free(tmp);
1256             return 0;
1257         }
1258     }
1259
1260     return result;
1261 #endif
1262 }
1263
1264 static int file_read_asn1(BIO *bp, unsigned char **data, long *len)
1265 {
1266     BUF_MEM *mem = NULL;
1267
1268     if (asn1_d2i_read_bio(bp, &mem) < 0)
1269         return 0;
1270
1271     *data = (unsigned char *)mem->data;
1272     *len = (long)mem->length;
1273     OPENSSL_free(mem);
1274
1275     return 1;
1276 }
1277
1278 static int ends_with_dirsep(const char *uri)
1279 {
1280     if (*uri != '\0')
1281         uri += strlen(uri) - 1;
1282 #if defined __VMS
1283     if (*uri == ']' || *uri == '>' || *uri == ':')
1284         return 1;
1285 #elif defined _WIN32
1286     if (*uri == '\\')
1287         return 1;
1288 #endif
1289     return *uri == '/';
1290 }
1291
1292 static int file_name_to_uri(OSSL_STORE_LOADER_CTX *ctx, const char *name,
1293                             char **data)
1294 {
1295     assert(name != NULL);
1296     assert(data != NULL);
1297     {
1298         const char *pathsep = ends_with_dirsep(ctx->uri) ? "" : "/";
1299         long calculated_length = strlen(ctx->uri) + strlen(pathsep)
1300             + strlen(name) + 1 /* \0 */;
1301
1302         *data = OPENSSL_zalloc(calculated_length);
1303         if (*data == NULL) {
1304             OSSL_STOREerr(OSSL_STORE_F_FILE_NAME_TO_URI, ERR_R_MALLOC_FAILURE);
1305             return 0;
1306         }
1307
1308         OPENSSL_strlcat(*data, ctx->uri, calculated_length);
1309         OPENSSL_strlcat(*data, pathsep, calculated_length);
1310         OPENSSL_strlcat(*data, name, calculated_length);
1311     }
1312     return 1;
1313 }
1314
1315 static int file_name_check(OSSL_STORE_LOADER_CTX *ctx, const char *name)
1316 {
1317     const char *p = NULL;
1318
1319     /* If there are no search criteria, all names are accepted */
1320     if (ctx->_.dir.search_name[0] == '\0')
1321         return 1;
1322
1323     /* If the expected type isn't supported, no name is accepted */
1324     if (ctx->expected_type != 0
1325         && ctx->expected_type != OSSL_STORE_INFO_CERT
1326         && ctx->expected_type != OSSL_STORE_INFO_CRL)
1327         return 0;
1328
1329     /*
1330      * First, check the basename
1331      */
1332     if (strncasecmp(name, ctx->_.dir.search_name,
1333                     sizeof(ctx->_.dir.search_name) - 1) != 0
1334         || name[sizeof(ctx->_.dir.search_name) - 1] != '.')
1335         return 0;
1336     p = &name[sizeof(ctx->_.dir.search_name)];
1337
1338     /*
1339      * Then, if the expected type is a CRL, check that the extension starts
1340      * with 'r'
1341      */
1342     if (*p == 'r') {
1343         p++;
1344         if (ctx->expected_type != 0
1345             && ctx->expected_type != OSSL_STORE_INFO_CRL)
1346             return 0;
1347     } else if (ctx->expected_type == OSSL_STORE_INFO_CRL) {
1348         return 0;
1349     }
1350
1351     /*
1352      * Last, check that the rest of the extension is a decimal number, at
1353      * least one digit long.
1354      */
1355     if (!ossl_isdigit(*p))
1356         return 0;
1357     while (ossl_isdigit(*p))
1358         p++;
1359
1360 # ifdef __VMS
1361     /*
1362      * One extra step here, check for a possible generation number.
1363      */
1364     if (*p == ';')
1365         for (p++; *p != '\0'; p++)
1366             if (!ossl_isdigit(*p))
1367                 break;
1368 # endif
1369
1370     /*
1371      * If we've reached the end of the string at this point, we've successfully
1372      * found a fitting file name.
1373      */
1374     return *p == '\0';
1375 }
1376
1377 static int file_eof(OSSL_STORE_LOADER_CTX *ctx);
1378 static int file_error(OSSL_STORE_LOADER_CTX *ctx);
1379 static OSSL_STORE_INFO *file_load(OSSL_STORE_LOADER_CTX *ctx,
1380                                   const UI_METHOD *ui_method, void *ui_data)
1381 {
1382     OSSL_STORE_INFO *result = NULL;
1383
1384     ctx->errcnt = 0;
1385     ERR_clear_error();
1386
1387     if (ctx->type == is_dir) {
1388         do {
1389             char *newname = NULL;
1390
1391             if (ctx->_.dir.last_entry == NULL) {
1392                 if (!ctx->_.dir.end_reached) {
1393                     char errbuf[256];
1394                     assert(ctx->_.dir.last_errno != 0);
1395                     OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD, ERR_R_SYS_LIB);
1396                     errno = ctx->_.dir.last_errno;
1397                     ctx->errcnt++;
1398                     if (openssl_strerror_r(errno, errbuf, sizeof(errbuf)))
1399                         ERR_add_error_data(1, errbuf);
1400                 }
1401                 return NULL;
1402             }
1403
1404             if (ctx->_.dir.last_entry[0] != '.'
1405                 && file_name_check(ctx, ctx->_.dir.last_entry)
1406                 && !file_name_to_uri(ctx, ctx->_.dir.last_entry, &newname))
1407                 return NULL;
1408
1409             /*
1410              * On the first call (with a NULL context), OPENSSL_DIR_read()
1411              * cares about the second argument.  On the following calls, it
1412              * only cares that it isn't NULL.  Therefore, we can safely give
1413              * it our URI here.
1414              */
1415             ctx->_.dir.last_entry = OPENSSL_DIR_read(&ctx->_.dir.ctx, ctx->uri);
1416             ctx->_.dir.last_errno = errno;
1417             if (ctx->_.dir.last_entry == NULL && ctx->_.dir.last_errno == 0)
1418                 ctx->_.dir.end_reached = 1;
1419
1420             if (newname != NULL
1421                 && (result = OSSL_STORE_INFO_new_NAME(newname)) == NULL) {
1422                 OPENSSL_free(newname);
1423                 OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD, ERR_R_OSSL_STORE_LIB);
1424                 return NULL;
1425             }
1426         } while (result == NULL && !file_eof(ctx));
1427     } else {
1428         int matchcount = -1;
1429
1430      again:
1431         result = file_load_try_repeat(ctx, ui_method, ui_data);
1432         if (result != NULL)
1433             return result;
1434
1435         if (file_eof(ctx))
1436             return NULL;
1437
1438         do {
1439             char *pem_name = NULL;      /* PEM record name */
1440             char *pem_header = NULL;    /* PEM record header */
1441             unsigned char *data = NULL; /* DER encoded data */
1442             long len = 0;               /* DER encoded data length */
1443
1444             matchcount = -1;
1445             if (ctx->type == is_pem) {
1446                 if (!file_read_pem(ctx->_.file.file, &pem_name, &pem_header,
1447                                    &data, &len, ui_method, ui_data, ctx->uri,
1448                                    (ctx->flags & FILE_FLAG_SECMEM) != 0)) {
1449                     ctx->errcnt++;
1450                     goto endloop;
1451                 }
1452             } else {
1453                 if ((result = file_try_read_msblob(ctx->_.file.file,
1454                                                    &matchcount)) != NULL
1455                     || (result = file_try_read_PVK(ctx->_.file.file,
1456                                                    ui_method, ui_data, ctx->uri,
1457                                                    &matchcount)) != NULL)
1458                     goto endloop;
1459
1460                 if (!file_read_asn1(ctx->_.file.file, &data, &len)) {
1461                     ctx->errcnt++;
1462                     goto endloop;
1463                 }
1464             }
1465
1466             result = file_load_try_decode(ctx, pem_name, pem_header, data, len,
1467                                           ui_method, ui_data, &matchcount);
1468
1469             if (result != NULL)
1470                 goto endloop;
1471
1472             /*
1473              * If a PEM name matches more than one handler, the handlers are
1474              * badly coded.
1475              */
1476             if (!ossl_assert(pem_name == NULL || matchcount <= 1)) {
1477                 ctx->errcnt++;
1478                 goto endloop;
1479             }
1480
1481             if (matchcount > 1) {
1482                 OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD,
1483                               OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE);
1484             } else if (matchcount == 1) {
1485                 /*
1486                  * If there are other errors on the stack, they already show
1487                  * what the problem is.
1488                  */
1489                 if (ERR_peek_error() == 0) {
1490                     OSSL_STOREerr(OSSL_STORE_F_FILE_LOAD,
1491                                   OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE);
1492                     if (pem_name != NULL)
1493                         ERR_add_error_data(3, "PEM type is '", pem_name, "'");
1494                 }
1495             }
1496             if (matchcount > 0)
1497                 ctx->errcnt++;
1498
1499          endloop:
1500             pem_free_flag(pem_name, (ctx->flags & FILE_FLAG_SECMEM) != 0, 0);
1501             pem_free_flag(pem_header, (ctx->flags & FILE_FLAG_SECMEM) != 0, 0);
1502             pem_free_flag(data, (ctx->flags & FILE_FLAG_SECMEM) != 0, len);
1503         } while (matchcount == 0 && !file_eof(ctx) && !file_error(ctx));
1504
1505         /* We bail out on ambiguity */
1506         if (matchcount > 1)
1507             return NULL;
1508
1509         if (result != NULL
1510             && ctx->expected_type != 0
1511             && ctx->expected_type != OSSL_STORE_INFO_get_type(result)) {
1512             OSSL_STORE_INFO_free(result);
1513             goto again;
1514         }
1515     }
1516
1517     return result;
1518 }
1519
1520 static int file_error(OSSL_STORE_LOADER_CTX *ctx)
1521 {
1522     return ctx->errcnt > 0;
1523 }
1524
1525 static int file_eof(OSSL_STORE_LOADER_CTX *ctx)
1526 {
1527     if (ctx->type == is_dir)
1528         return ctx->_.dir.end_reached;
1529
1530     if (ctx->_.file.last_handler != NULL
1531         && !ctx->_.file.last_handler->eof(ctx->_.file.last_handler_ctx))
1532         return 0;
1533     return BIO_eof(ctx->_.file.file);
1534 }
1535
1536 static int file_close(OSSL_STORE_LOADER_CTX *ctx)
1537 {
1538     if ((ctx->flags & FILE_FLAG_ATTACHED) == 0) {
1539         if (ctx->type == is_dir)
1540             OPENSSL_DIR_end(&ctx->_.dir.ctx);
1541         else
1542             BIO_free_all(ctx->_.file.file);
1543     } else {
1544         /*
1545          * Because file_attach() called file_find_type(), we know that a
1546          * BIO_f_buffer() has been pushed on top of the regular BIO.
1547          */
1548         BIO *buff = ctx->_.file.file;
1549
1550         /* Detach buff */
1551         (void)BIO_pop(ctx->_.file.file);
1552         /* Safety measure */
1553         ctx->_.file.file = NULL;
1554
1555         BIO_free(buff);
1556     }
1557     OSSL_STORE_LOADER_CTX_free(ctx);
1558     return 1;
1559 }
1560
1561 static OSSL_STORE_LOADER file_loader =
1562     {
1563         "file",
1564         NULL,
1565         file_open,
1566         file_attach,
1567         file_ctrl,
1568         file_expect,
1569         file_find,
1570         file_load,
1571         file_eof,
1572         file_error,
1573         file_close
1574     };
1575
1576 static void store_file_loader_deinit(void)
1577 {
1578     ossl_store_unregister_loader_int(file_loader.scheme);
1579 }
1580
1581 int ossl_store_file_loader_init(void)
1582 {
1583     int ret = ossl_store_register_loader_int(&file_loader);
1584
1585     OPENSSL_atexit(store_file_loader_deinit);
1586     return ret;
1587 }