providers/implementations/storemgmt/file_store.c

   1 /*
   2  * Copyright 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"                /* To get strncasecmp() on Windows */
  11 #include <string.h>
  12 #include <sys/stat.h>
  13 #include <ctype.h>
  14 #include <assert.h>
  15
  16 #include <openssl/core.h>
  17 #include <openssl/core_dispatch.h>
  18 #include <openssl/core_names.h>
  19 #include <openssl/core_object.h>
  20 #include <openssl/crypto.h>
  21 #include <openssl/bio.h>
  22 #include <openssl/err.h>
  23 #include <openssl/buffer.h>
  24 #include <openssl/params.h>
  25 #include <openssl/decoder.h>
  26 #include <openssl/store.h>       /* The OSSL_STORE_INFO type numbers */
  27 #include "internal/o_dir.h"
  28 #include "internal/pem.h"        /* For PVK and "blob" PEM headers */
  29 #include "crypto/decoder.h"
  30 #include "prov/implementations.h"
  31 #include "prov/bio.h"
  32 #include "prov/provider_ctx.h"
  33 #include "prov/providercommonerr.h"
  34 #include "file_store_local.h"
  35
  36 DEFINE_STACK_OF(X509)
  37 DEFINE_STACK_OF(OSSL_STORE_INFO)
  38
  39 #ifdef _WIN32
  40 # define stat _stat
  41 #endif
  42
  43 #ifndef S_ISDIR
  44 # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
  45 #endif
  46
  47 static OSSL_FUNC_store_open_fn file_open;
  48 static OSSL_FUNC_store_attach_fn file_attach;
  49 static OSSL_FUNC_store_settable_ctx_params_fn file_settable_ctx_params;
  50 static OSSL_FUNC_store_set_ctx_params_fn file_set_ctx_params;
  51 static OSSL_FUNC_store_load_fn file_load;
  52 static OSSL_FUNC_store_eof_fn file_eof;
  53 static OSSL_FUNC_store_close_fn file_close;
  54
  55 /*
  56  * This implementation makes full use of OSSL_DECODER, and then some.
  57  * It uses its own internal decoder implementation that reads DER and
  58  * passes that on to the data callback; this decoder is created with
  59  * internal OpenSSL functions, thereby bypassing the need for a surrounding
  60  * provider.  This is ok, since this is a local decoder, not meant for
  61  * public consumption.  It also uses the libcrypto internal decoder
  62  * setup function ossl_decoder_ctx_setup_for_EVP_PKEY(), to allow the
  63  * last resort decoder to be added first (and thereby be executed last).
  64  * Finally, it sets up its own construct and cleanup functions.
  65  *
  66  * Essentially, that makes this implementation a kind of glorified decoder.
  67  */
  68
  69 struct file_ctx_st {
  70     void *provctx;
  71     char *uri;                   /* The URI we currently try to load */
  72     enum {
  73         IS_FILE = 0,             /* Read file and pass results */
  74         IS_DIR                   /* Pass directory entry names */
  75     } type;
  76
  77     /* Flag bits */
  78     unsigned int flag_attached:1;
  79     unsigned int flag_buffered:1;
  80
  81     union {
  82         /* Used with |IS_FILE| */
  83         struct {
  84             BIO *file;
  85
  86             OSSL_DECODER_CTX *decoderctx;
  87             char *input_type;
  88             char *propq;    /* The properties we got as a parameter */
  89         } file;
  90
  91         /* Used with |IS_DIR| */
  92         struct {
  93             OPENSSL_DIR_CTX *ctx;
  94             int end_reached;
  95
  96             /*
  97              * When a search expression is given, these are filled in.
  98              * |search_name| contains the file basename to look for.
  99              * The string is exactly 8 characters long.
 100              */
 101             char search_name[9];
 102
 103             /*
 104              * The directory reading utility we have combines opening with
 105              * reading the first name.  To make sure we can detect the end
 106              * at the right time, we read early and cache the name.
 107              */
 108             const char *last_entry;
 109             int last_errno;
 110         } dir;
 111     } _;
 112
 113     /* Expected object type.  May be unspecified */
 114     int expected_type;
 115 };
 116
 117 static void free_file_ctx(struct file_ctx_st *ctx)
 118 {
 119     if (ctx == NULL)
 120         return;
 121
 122     OPENSSL_free(ctx->uri);
 123     if (ctx->type != IS_DIR) {
 124         OSSL_DECODER_CTX_free(ctx->_.file.decoderctx);
 125         OPENSSL_free(ctx->_.file.propq);
 126         OPENSSL_free(ctx->_.file.input_type);
 127     }
 128     OPENSSL_free(ctx);
 129 }
 130
 131 static struct file_ctx_st *new_file_ctx(int type, const char *uri,
 132                                         void *provctx)
 133 {
 134     struct file_ctx_st *ctx = NULL;
 135
 136     if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) != NULL
 137         && (uri == NULL || (ctx->uri = OPENSSL_strdup(uri)) != NULL)) {
 138         ctx->type = type;
 139         ctx->provctx = provctx;
 140         return ctx;
 141     }
 142     free_file_ctx(ctx);
 143     return NULL;
 144 }
 145
 146 static OSSL_DECODER_CONSTRUCT file_load_construct;
 147 static OSSL_DECODER_CLEANUP file_load_cleanup;
 148
 149 /*-
 150  *  Opening / attaching streams and directories
 151  *  -------------------------------------------
 152  */
 153
 154 /*
 155  * Function to service both file_open() and file_attach()
 156  *
 157  *
 158  */
 159 static struct file_ctx_st *file_open_stream(BIO *source, const char *uri,
 160                                             const char *input_type,
 161                                             void *provctx)
 162 {
 163     struct file_ctx_st *ctx;
 164
 165     if ((ctx = new_file_ctx(IS_FILE, uri, provctx)) == NULL
 166         || (input_type != NULL
 167             && (ctx->_.file.input_type =
 168                 OPENSSL_strdup(input_type)) == NULL)) {
 169         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 170         goto err;
 171     }
 172
 173     ctx->_.file.file = source;
 174
 175     return ctx;
 176  err:
 177     free_file_ctx(ctx);
 178     return NULL;
 179 }
 180
 181 static void *file_open_dir(const char *path, const char *uri, void *provctx)
 182 {
 183     struct file_ctx_st *ctx;
 184
 185     if ((ctx = new_file_ctx(IS_DIR, uri, provctx)) == NULL) {
 186         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 187         goto err;
 188     }
 189
 190     ctx->_.dir.last_entry = OPENSSL_DIR_read(&ctx->_.dir.ctx, path);
 191     ctx->_.dir.last_errno = errno;
 192     if (ctx->_.dir.last_entry == NULL) {
 193         if (ctx->_.dir.last_errno != 0) {
 194             ERR_raise_data(ERR_LIB_SYS, ctx->_.dir.last_errno,
 195                            "Calling OPENSSL_DIR_read(\"%s\")", path);
 196             goto err;
 197         }
 198         ctx->_.dir.end_reached = 1;
 199     }
 200     return ctx;
 201  err:
 202     file_close(ctx);
 203     return NULL;
 204 }
 205
 206 static void *file_open(void *provctx, const char *uri)
 207 {
 208     struct file_ctx_st *ctx = NULL;
 209     struct stat st;
 210     struct {
 211         const char *path;
 212         unsigned int check_absolute:1;
 213     } path_data[2];
 214     size_t path_data_n = 0, i;
 215     const char *path;
 216     BIO *bio;
 217
 218     ERR_set_mark();
 219
 220     /*
 221      * First step, just take the URI as is.
 222      */
 223     path_data[path_data_n].check_absolute = 0;
 224     path_data[path_data_n++].path = uri;
 225
 226     /*
 227      * Second step, if the URI appears to start with the 'file' scheme,
 228      * extract the path and make that the second path to check.
 229      * There's a special case if the URI also contains an authority, then
 230      * the full URI shouldn't be used as a path anywhere.
 231      */
 232     if (strncasecmp(uri, "file:", 5) == 0) {
 233         const char *p = &uri[5];
 234
 235         if (strncmp(&uri[5], "//", 2) == 0) {
 236             path_data_n--;           /* Invalidate using the full URI */
 237             if (strncasecmp(&uri[7], "localhost/", 10) == 0) {
 238                 p = &uri[16];
 239             } else if (uri[7] == '/') {
 240                 p = &uri[7];
 241             } else {
 242                 ERR_clear_last_mark();
 243                 ERR_raise(ERR_LIB_PROV, PROV_R_URI_AUTHORITY_UNSUPPORTED);
 244                 return NULL;
 245             }
 246         }
 247
 248         path_data[path_data_n].check_absolute = 1;
 249 #ifdef _WIN32
 250         /* Windows file: URIs with a drive letter start with a / */
 251         if (p[0] == '/' && p[2] == ':' && p[3] == '/') {
 252             char c = tolower(p[1]);
 253
 254             if (c >= 'a' && c <= 'z') {
 255                 p++;
 256                 /* We know it's absolute, so no need to check */
 257                 path_data[path_data_n].check_absolute = 0;
 258             }
 259         }
 260 #endif
 261         path_data[path_data_n++].path = p;
 262     }
 263
 264
 265     for (i = 0, path = NULL; path == NULL && i < path_data_n; i++) {
 266         /*
 267          * If the scheme "file" was an explicit part of the URI, the path must
 268          * be absolute.  So says RFC 8089
 269          */
 270         if (path_data[i].check_absolute && path_data[i].path[0] != '/') {
 271             ERR_clear_last_mark();
 272             ERR_raise_data(ERR_LIB_PROV, PROV_R_PATH_MUST_BE_ABSOLUTE,
 273                            "Given path=%s", path_data[i].path);
 274             return NULL;
 275         }
 276
 277         if (stat(path_data[i].path, &st) < 0) {
 278             ERR_raise_data(ERR_LIB_SYS, errno,
 279                            "calling stat(%s)",
 280                            path_data[i].path);
 281         } else {
 282             path = path_data[i].path;
 283         }
 284     }
 285     if (path == NULL) {
 286         ERR_clear_last_mark();
 287         return NULL;
 288     }
 289
 290     /* Successfully found a working path, clear possible collected errors */
 291     ERR_pop_to_mark();
 292
 293     if (S_ISDIR(st.st_mode))
 294         ctx = file_open_dir(path, uri, provctx);
 295     else if ((bio = BIO_new_file(path, "rb")) == NULL
 296              || (ctx = file_open_stream(bio, uri, NULL, provctx)) == NULL)
 297         BIO_free_all(bio);
 298
 299     return ctx;
 300 }
 301
 302 /*
 303  * Attached input streams must be treated very very carefully to avoid
 304  * nasty surprises.
 305  *
 306  * This implementation tries to support input streams that can't be reset,
 307  * such as standard input.  However, OSSL_DECODER assumes resettable streams,
 308  * and because the PEM decoder may read quite a bit of the input file to skip
 309  * past any non-PEM text that precedes the PEM block, we may need to detect
 310  * if the input stream is a PEM file early.
 311  *
 312  * If the input stream supports BIO_tell(), we assume that it also supports
 313  * BIO_seek(), making it a resettable stream and therefore safe to fully
 314  * unleash OSSL_DECODER.
 315  *
 316  * If the input stream doesn't support BIO_tell(), we must assume that we
 317  * have a non-resettable stream, and must tread carefully.  We do so by
 318  * trying to detect if the input is PEM, MSBLOB or PVK, and if not, we
 319  * assume that it's DER.
 320  *
 321  * To detect if an input stream is PEM, MSBLOB or PVK, we use the buffer BIO
 322  * filter, which allows us a 4KiB resettable read-ahead.  We *hope* that 4KiB
 323  * will be enough to find the start of the PEM block.
 324  *
 325  * It should be possible to use this same technique to detect other file
 326  * types as well.
 327  *
 328  * An alternative technique would be to have an endlessly caching BIO filter.
 329  * That would take away the need for all the detection here, and simply leave
 330  * it for OSSL_DECODER to find out on its own while supporting its demand for
 331  * resettable input streams.
 332  * That's a possible future development.
 333  */
 334
 335 # define INPUT_TYPE_ANY         NULL
 336 # define INPUT_TYPE_DER         "DER"
 337 # define INPUT_TYPE_PEM         "PEM"
 338 # define INPUT_TYPE_MSBLOB      "MSBLOB"
 339 # define INPUT_TYPE_PVK         "PVK"
 340
 341 void *file_attach(void *provctx, OSSL_CORE_BIO *cin)
 342 {
 343     BIO *new_bio = bio_new_from_core_bio(provctx, cin);
 344     BIO *new_bio_tmp = NULL;
 345     BIO *buff = NULL;
 346     char peekbuf[4096] = { 0, };
 347     int loc;
 348     const char *input_type = NULL;
 349     unsigned int flag_attached = 1;
 350     unsigned int flag_buffered = 0;
 351     struct file_ctx_st *ctx = NULL;
 352
 353     if (new_bio == NULL)
 354         return 0;
 355
 356     /* Try to get the current position */
 357     loc = BIO_tell(new_bio);
 358
 359     if ((buff = BIO_new(BIO_f_buffer())) == NULL
 360         || (new_bio_tmp = BIO_push(buff, new_bio)) == NULL)
 361         goto err;
 362
 363     /* Assumption, if we can't detect PEM */
 364     input_type = INPUT_TYPE_DER;
 365     flag_buffered = 1;
 366     new_bio = new_bio_tmp;
 367
 368     if (BIO_buffer_peek(new_bio, peekbuf, sizeof(peekbuf) - 1) > 0) {
 369 #ifndef OPENSSL_NO_DSA
 370         const unsigned char *p = NULL;
 371         unsigned int magic = 0, bitlen = 0;
 372         int isdss = 0, ispub = -1;
 373 # ifndef OPENSSL_NO_RC4
 374         unsigned int saltlen = 0, keylen = 0;
 375 # endif
 376 #endif
 377
 378         peekbuf[sizeof(peekbuf) - 1] = '\0';
 379         if (strstr(peekbuf, "-----BEGIN ") != NULL)
 380             input_type = INPUT_TYPE_PEM;
 381 #ifndef OPENSSL_NO_DSA
 382         else if (p = (unsigned char *)peekbuf,
 383                  ossl_do_blob_header(&p, sizeof(peekbuf), &magic, &bitlen,
 384                                      &isdss, &ispub))
 385             input_type = INPUT_TYPE_MSBLOB;
 386 # ifndef OPENSSL_NO_RC4
 387         else if (p = (unsigned char *)peekbuf,
 388                  ossl_do_PVK_header(&p, sizeof(peekbuf), 0, &saltlen, &keylen))
 389             input_type = INPUT_TYPE_PVK;
 390 # endif
 391 #endif
 392     }
 393
 394     /*
 395      * After peeking, we know that the underlying source BIO has moved ahead
 396      * from its earlier position and that if it supports BIO_tell(), that
 397      * should be a number that differs from |loc|.  Otherwise, we will get
 398      * the same value, which may one of:
 399      *
 400      * -   zero (the source BIO doesn't support BIO_tell() / BIO_seek() /
 401      *     BIO_reset())
 402      * -   -1 (the underlying operating system / C library routines do not
 403      *     support BIO_tell() / BIO_seek() / BIO_reset())
 404      *
 405      * If it turns out that the source BIO does support BIO_tell(), we pop
 406      * the buffer BIO filter and mark this input as |INPUT_TYPE_ANY|, which
 407      * fully unleashes OSSL_DECODER to do its thing.
 408      */
 409     if (BIO_tell(new_bio) != loc) {
 410         /* In this case, anything goes */
 411         input_type = INPUT_TYPE_ANY;
 412
 413         /* Restore the source BIO like it was when entering this function */
 414         new_bio = BIO_pop(buff);
 415         BIO_free(buff);
 416         (void)BIO_seek(new_bio, loc);
 417
 418         flag_buffered = 0;
 419     }
 420
 421     if ((ctx = file_open_stream(new_bio, NULL, input_type, provctx)) == NULL)
 422         goto err;
 423
 424     ctx->flag_attached = flag_attached;
 425     ctx->flag_buffered = flag_buffered;
 426
 427     return ctx;
 428  err:
 429     if (flag_buffered) {
 430         new_bio = BIO_pop(buff);
 431         BIO_free(buff);
 432     }
 433     BIO_free(new_bio);           /* Removes the provider BIO filter */
 434     return NULL;
 435 }
 436
 437 /*-
 438  *  Setting parameters
 439  *  ------------------
 440  */
 441
 442 static const OSSL_PARAM *file_settable_ctx_params(void *provctx)
 443 {
 444     static const OSSL_PARAM known_settable_ctx_params[] = {
 445         OSSL_PARAM_utf8_string(OSSL_STORE_PARAM_PROPERTIES, NULL, 0),
 446         OSSL_PARAM_int(OSSL_STORE_PARAM_EXPECT, NULL),
 447         OSSL_PARAM_octet_string(OSSL_STORE_PARAM_SUBJECT, NULL, 0),
 448         OSSL_PARAM_END
 449     };
 450     return known_settable_ctx_params;
 451 }
 452
 453 static int file_set_ctx_params(void *loaderctx, const OSSL_PARAM params[])
 454 {
 455     struct file_ctx_st *ctx = loaderctx;
 456     const OSSL_PARAM *p;
 457
 458     p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_PROPERTIES);
 459     if (p != NULL) {
 460         OPENSSL_free(ctx->_.file.propq);
 461         ctx->_.file.propq = NULL;
 462         if (!OSSL_PARAM_get_utf8_string(p, &ctx->_.file.propq, 0))
 463             return 0;
 464     }
 465     p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_EXPECT);
 466     if (p != NULL && !OSSL_PARAM_get_int(p, &ctx->expected_type))
 467         return 0;
 468     p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_SUBJECT);
 469     if (p != NULL) {
 470         const unsigned char *der = NULL;
 471         size_t der_len = 0;
 472         X509_NAME *x509_name;
 473         unsigned long hash;
 474
 475         if (ctx->type != IS_DIR) {
 476             ERR_raise(ERR_LIB_PROV,
 477                       PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES);
 478             return 0;
 479         }
 480
 481         if (!OSSL_PARAM_get_octet_string_ptr(p, (const void **)&der, &der_len)
 482             || (x509_name = d2i_X509_NAME(NULL, &der, der_len)) == NULL)
 483             return 0;
 484         hash = X509_NAME_hash(x509_name);
 485         BIO_snprintf(ctx->_.dir.search_name, sizeof(ctx->_.dir.search_name),
 486                      "%08lx", hash);
 487         X509_NAME_free(x509_name);
 488     }
 489     return 1;
 490 }
 491
 492 /*-
 493  *  Loading an object from a stream
 494  *  -------------------------------
 495  */
 496
 497 struct file_load_data_st {
 498     OSSL_CALLBACK *object_cb;
 499     void *object_cbarg;
 500 };
 501
 502 static int file_load_construct(OSSL_DECODER_INSTANCE *decoder_inst,
 503                                const OSSL_PARAM *params, void *construct_data)
 504 {
 505     struct file_load_data_st *data = construct_data;
 506
 507     /*
 508      * At some point, we may find it justifiable to recognise PKCS#12 and
 509      * handle it specially here, making |file_load()| return pass its
 510      * contents one piece at ta time, like |e_loader_attic.c| does.
 511      *
 512      * However, that currently means parsing them out, which converts the
 513      * DER encoded PKCS#12 into a bunch of EVP_PKEYs and X509s, just to
 514      * have to re-encode them into DER to create an object abstraction for
 515      * each of them.
 516      * It's much simpler (less churn) to pass on the object abstraction we
 517      * get to the load_result callback and leave it to that one to do the
 518      * work.  If that's libcrypto code, we know that it has much better
 519      * possibilities to handle the EVP_PKEYs and X509s without the extra
 520      * churn.
 521      */
 522
 523     return data->object_cb(params, data->object_cbarg);
 524 }
 525
 526 void file_load_cleanup(void *construct_data)
 527 {
 528     /* Nothing to do */
 529 }
 530
 531 static int file_setup_decoders(struct file_ctx_st *ctx)
 532 {
 533     EVP_PKEY *dummy; /* for OSSL_DECODER_CTX_new_by_EVP_PKEY() */
 534     OPENSSL_CTX *libctx = PROV_CTX_get0_library_context(ctx->provctx);
 535     OSSL_DECODER *to_obj = NULL; /* Last resort decoder */
 536     OSSL_DECODER_INSTANCE *to_obj_inst = NULL;
 537     OSSL_DECODER_CLEANUP *old_cleanup = NULL;
 538     void *old_construct_data = NULL;
 539     int ok = 0;
 540
 541     /* Setup for this session, so only if not already done */
 542     if (ctx->_.file.decoderctx == NULL) {
 543         if ((ctx->_.file.decoderctx = OSSL_DECODER_CTX_new()) == NULL) {
 544             ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 545             goto err;
 546         }
 547
 548         /* Make sure the input type is set */
 549         if (!OSSL_DECODER_CTX_set_input_type(ctx->_.file.decoderctx,
 550                                              ctx->_.file.input_type)) {
 551             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
 552             goto err;
 553         }
 554
 555         /*
 556          * Create the internal last resort decoder implementation together
 557          * with a "decoder instance".
 558          * The decoder doesn't need any identification or to be attached to
 559          * any provider, since it's only used locally.
 560          */
 561         to_obj = ossl_decoder_from_dispatch(0, &der_to_obj_algorithm, NULL);
 562         if (to_obj == NULL)
 563             goto err;
 564         to_obj_inst = ossl_decoder_instance_new(to_obj, ctx->provctx);
 565         if (to_obj_inst == NULL)
 566             goto err;
 567
 568         if (!ossl_decoder_ctx_add_decoder_inst(ctx->_.file.decoderctx,
 569                                                to_obj_inst)) {
 570             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
 571             goto err;
 572         }
 573
 574         /*
 575          * OSSL_DECODER_INSTANCE shouldn't be freed from this point on.
 576          * That's going to happen whenever the OSSL_DECODER_CTX is freed.
 577          */
 578         to_obj_inst = NULL;
 579
 580         /*
 581          * Add on the usual decoder context for keys, with a dummy object.
 582          * Since we're setting up our own constructor, we don't need to care
 583          * more than that...
 584          */
 585         if (!ossl_decoder_ctx_setup_for_EVP_PKEY(ctx->_.file.decoderctx, &dummy,
 586                                                  libctx, ctx->_.file.propq)
 587             || !OSSL_DECODER_CTX_add_extra(ctx->_.file.decoderctx,
 588                                            libctx, ctx->_.file.propq)) {
 589             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
 590             goto err;
 591         }
 592
 593         /*
 594          * Then we throw away the installed finalizer data, and install our
 595          * own instead.
 596          */
 597         old_cleanup = OSSL_DECODER_CTX_get_cleanup(ctx->_.file.decoderctx);
 598         old_construct_data =
 599             OSSL_DECODER_CTX_get_construct_data(ctx->_.file.decoderctx);
 600         if (old_cleanup != NULL)
 601             old_cleanup(old_construct_data);
 602
 603         /*
 604          * Set the hooks.
 605          */
 606         if (!OSSL_DECODER_CTX_set_construct(ctx->_.file.decoderctx,
 607                                             file_load_construct)
 608             || !OSSL_DECODER_CTX_set_cleanup(ctx->_.file.decoderctx,
 609                                              file_load_cleanup)) {
 610             ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
 611             goto err;
 612         }
 613     }
 614
 615     ok = 1;
 616  err:
 617     OSSL_DECODER_free(to_obj);
 618     return ok;
 619 }
 620
 621 static int file_load_file(struct file_ctx_st *ctx,
 622                           OSSL_CALLBACK *object_cb, void *object_cbarg,
 623                           OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
 624 {
 625     struct file_load_data_st data;
 626
 627     /* Setup the decoders (one time shot per session */
 628
 629     if (!file_setup_decoders(ctx))
 630         return 0;
 631
 632     /* Setup for this object */
 633
 634     data.object_cb = object_cb;
 635     data.object_cbarg = object_cbarg;
 636     OSSL_DECODER_CTX_set_construct_data(ctx->_.file.decoderctx, &data);
 637     OSSL_DECODER_CTX_set_passphrase_cb(ctx->_.file.decoderctx, pw_cb, pw_cbarg);
 638
 639     /* Launch */
 640
 641     return OSSL_DECODER_from_bio(ctx->_.file.decoderctx, ctx->_.file.file);
 642 }
 643
 644 /*-
 645  *  Loading a name object from a directory
 646  *  --------------------------------------
 647  */
 648
 649 static int ends_with_dirsep(const char *uri)
 650 {
 651     if (*uri != '\0')
 652         uri += strlen(uri) - 1;
 653 #if defined(__VMS)
 654     if (*uri == ']' || *uri == '>' || *uri == ':')
 655         return 1;
 656 #elif defined(_WIN32)
 657     if (*uri == '\\')
 658         return 1;
 659 #endif
 660     return *uri == '/';
 661 }
 662
 663 static char *file_name_to_uri(struct file_ctx_st *ctx, const char *name)
 664 {
 665     char *data = NULL;
 666
 667     assert(name != NULL);
 668     {
 669         const char *pathsep = ends_with_dirsep(ctx->uri) ? "" : "/";
 670         long calculated_length = strlen(ctx->uri) + strlen(pathsep)
 671             + strlen(name) + 1 /* \0 */;
 672
 673         data = OPENSSL_zalloc(calculated_length);
 674         if (data == NULL) {
 675             ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 676             return NULL;
 677         }
 678
 679         OPENSSL_strlcat(data, ctx->uri, calculated_length);
 680         OPENSSL_strlcat(data, pathsep, calculated_length);
 681         OPENSSL_strlcat(data, name, calculated_length);
 682     }
 683     return data;
 684 }
 685
 686 static int file_name_check(struct file_ctx_st *ctx, const char *name)
 687 {
 688     const char *p = NULL;
 689
 690     /* If there are no search criteria, all names are accepted */
 691     if (ctx->_.dir.search_name[0] == '\0')
 692         return 1;
 693
 694     /* If the expected type isn't supported, no name is accepted */
 695     if (ctx->expected_type != 0
 696         && ctx->expected_type != OSSL_STORE_INFO_CERT
 697         && ctx->expected_type != OSSL_STORE_INFO_CRL)
 698         return 0;
 699
 700     /*
 701      * First, check the basename
 702      */
 703     if (strncasecmp(name, ctx->_.dir.search_name,
 704                     sizeof(ctx->_.dir.search_name) - 1) != 0
 705         || name[sizeof(ctx->_.dir.search_name) - 1] != '.')
 706         return 0;
 707     p = &name[sizeof(ctx->_.dir.search_name)];
 708
 709     /*
 710      * Then, if the expected type is a CRL, check that the extension starts
 711      * with 'r'
 712      */
 713     if (*p == 'r') {
 714         p++;
 715         if (ctx->expected_type != 0
 716             && ctx->expected_type != OSSL_STORE_INFO_CRL)
 717             return 0;
 718     } else if (ctx->expected_type == OSSL_STORE_INFO_CRL) {
 719         return 0;
 720     }
 721
 722     /*
 723      * Last, check that the rest of the extension is a decimal number, at
 724      * least one digit long.
 725      */
 726     if (!isdigit(*p))
 727         return 0;
 728     while (isdigit(*p))
 729         p++;
 730
 731 #ifdef __VMS
 732     /*
 733      * One extra step here, check for a possible generation number.
 734      */
 735     if (*p == ';')
 736         for (p++; *p != '\0'; p++)
 737             if (!ossl_isdigit(*p))
 738                 break;
 739 #endif
 740
 741     /*
 742      * If we've reached the end of the string at this point, we've successfully
 743      * found a fitting file name.
 744      */
 745     return *p == '\0';
 746 }
 747
 748 static int file_load_dir_entry(struct file_ctx_st *ctx,
 749                                OSSL_CALLBACK *object_cb, void *object_cbarg,
 750                                OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
 751 {
 752     /* Prepare as much as possible in advance */
 753     static const int object_type = OSSL_OBJECT_NAME;
 754     OSSL_PARAM object[] = {
 755         OSSL_PARAM_int(OSSL_OBJECT_PARAM_TYPE, (int *)&object_type),
 756         OSSL_PARAM_utf8_string(OSSL_OBJECT_PARAM_DATA, NULL, 0),
 757         OSSL_PARAM_END
 758     };
 759     char *newname = NULL;
 760     int ok;
 761
 762     /* Loop until we get an error or until we have a suitable name */
 763     do {
 764         if (ctx->_.dir.last_entry == NULL) {
 765             if (!ctx->_.dir.end_reached) {
 766                 assert(ctx->_.dir.last_errno != 0);
 767                 ERR_raise(ERR_LIB_SYS, ctx->_.dir.last_errno);
 768             }
 769             /* file_eof() will tell if EOF was reached */
 770             return 0;
 771         }
 772
 773         /* flag acceptable names */
 774         if (ctx->_.dir.last_entry[0] != '.'
 775             && file_name_check(ctx, ctx->_.dir.last_entry)) {
 776
 777             /* If we can't allocate the new name, we fail */
 778             if ((newname =
 779                  file_name_to_uri(ctx, ctx->_.dir.last_entry)) == NULL)
 780                 return 0;
 781         }
 782
 783         /*
 784          * On the first call (with a NULL context), OPENSSL_DIR_read()
 785          * cares about the second argument.  On the following calls, it
 786          * only cares that it isn't NULL.  Therefore, we can safely give
 787          * it our URI here.
 788          */
 789         ctx->_.dir.last_entry = OPENSSL_DIR_read(&ctx->_.dir.ctx, ctx->uri);
 790         ctx->_.dir.last_errno = errno;
 791         if (ctx->_.dir.last_entry == NULL && ctx->_.dir.last_errno == 0)
 792             ctx->_.dir.end_reached = 1;
 793     } while (newname == NULL);
 794
 795     object[1].data = newname;
 796     object[1].data_size = strlen(newname);
 797     ok = object_cb(object, object_cbarg);
 798     OPENSSL_free(newname);
 799     return ok;
 800 }
 801
 802 /*-
 803  *  Loading, local dispatcher
 804  *  -------------------------
 805  */
 806
 807 static int file_load(void *loaderctx,
 808                      OSSL_CALLBACK *object_cb, void *object_cbarg,
 809                      OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
 810 {
 811     struct file_ctx_st *ctx = loaderctx;
 812
 813     switch (ctx->type) {
 814     case IS_FILE:
 815         return file_load_file(ctx, object_cb, object_cbarg, pw_cb, pw_cbarg);
 816     case IS_DIR:
 817         return
 818             file_load_dir_entry(ctx, object_cb, object_cbarg, pw_cb, pw_cbarg);
 819     default:
 820         break;
 821     }
 822
 823     /* ctx->type has an unexpected value */
 824     assert(0);
 825     return 0;
 826 }
 827
 828 /*-
 829  *  Eof detection and closing
 830  *  -------------------------
 831  */
 832
 833 static int file_eof(void *loaderctx)
 834 {
 835     struct file_ctx_st *ctx = loaderctx;
 836
 837     switch (ctx->type) {
 838     case IS_DIR:
 839         return ctx->_.dir.end_reached;
 840     case IS_FILE:
 841         /*
 842          * BIO_pending() checks any filter BIO.
 843          * BIO_eof() checks the source BIO.
 844          */
 845         return !BIO_pending(ctx->_.file.file)
 846             && BIO_eof(ctx->_.file.file);
 847     }
 848
 849     /* ctx->type has an unexpected value */
 850     assert(0);
 851     return 1;
 852 }
 853
 854 static int file_close_dir(struct file_ctx_st *ctx)
 855 {
 856     if (ctx->_.dir.ctx != NULL)
 857         OPENSSL_DIR_end(&ctx->_.dir.ctx);
 858     free_file_ctx(ctx);
 859     return 1;
 860 }
 861
 862 static int file_close_stream(struct file_ctx_st *ctx)
 863 {
 864     if (ctx->flag_buffered) {
 865         /*
 866          * file_attach() pushed a BIO_f_buffer() on top of the regular BIO.
 867          * Drop it.
 868          */
 869         BIO *buff = ctx->_.file.file;
 870
 871         /* Detach buff */
 872         ctx->_.file.file = BIO_pop(ctx->_.file.file);
 873
 874         BIO_free(buff);
 875     }
 876
 877     /*
 878      * If it was attached, we only free the top, as that's the provider BIO
 879      * filter.  Otherwise, it was entirely allocated by this implementation,
 880      * and can safely be completely freed.
 881      */
 882     if (ctx->flag_attached)
 883         BIO_free(ctx->_.file.file);
 884     else
 885         BIO_free_all(ctx->_.file.file);
 886
 887     /* To avoid double free */
 888     ctx->_.file.file = NULL;
 889
 890     free_file_ctx(ctx);
 891     return 1;
 892 }
 893
 894 static int file_close(void *loaderctx)
 895 {
 896     struct file_ctx_st *ctx = loaderctx;
 897
 898     switch (ctx->type) {
 899     case IS_DIR:
 900         return file_close_dir(ctx);
 901     case IS_FILE:
 902         return file_close_stream(ctx);
 903     }
 904
 905     /* ctx->type has an unexpected value */
 906     assert(0);
 907     return 1;
 908 }
 909
 910 const OSSL_DISPATCH file_store_functions[] = {
 911     { OSSL_FUNC_STORE_OPEN, (void (*)(void))file_open },
 912     { OSSL_FUNC_STORE_ATTACH, (void (*)(void))file_attach },
 913     { OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS,
 914       (void (*)(void))file_settable_ctx_params },
 915     { OSSL_FUNC_STORE_SET_CTX_PARAMS, (void (*)(void))file_set_ctx_params },
 916     { OSSL_FUNC_STORE_LOAD, (void (*)(void))file_load },
 917     { OSSL_FUNC_STORE_EOF, (void (*)(void))file_eof },
 918     { OSSL_FUNC_STORE_CLOSE, (void (*)(void))file_close },
 919     { 0, NULL },
 920 };