STORE: Add a built-in 'file:' storemgmt implementation (loader)

This replaces the older 'file:' loader that is now an engine.

It's still possible to use the older 'file:' loader by explicitly
using the engine, and tests will remain for it as long as ENGINEs are
still supported (even through deprecated).

To support this storemgmt implementation, a few internal OSSL_DECODER
modifications are needed:

-   An internal function that implements most of
    OSSL_DECODER_CTX_new_by_EVP_PKEY(), but operates on an already
    existing OSSL_DECODER_CTX instead of allocating a new one.
-   Allow direct creation of a OSSL_DECODER from an OSSL_ALGORITHM.
    It isn't attached to any provider, and is only used internally, to
    simply catch any DER encoded object to be passed back to the
    object callback with no further checking.  This implementation
    becomes the last resort decoder, when all "normal"
    decodation attempts (i.e. those that are supposed to result
    in an OpenSSL object of some sort) have failed.

Because file_store_attach() uses BIO_tell(), we must also support
BIO_ctrl() as a libcrypto upcall.

Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/12587)

13 files changed, 1118 insertions, 4 deletions

diff --git a/providers/baseprov.c b/providers/baseprov.c
index dcea2ad93e..38d9090bb3 100644
--- a/providers/baseprov.c
+++ b/providers/baseprov.c
@@ -86,6 +86,15 @@ static const OSSL_ALGORITHM base_decoder[] = {
 };
 #undef DECODER
 
+static const OSSL_ALGORITHM base_store[] = {
+#define STORE(name, fips, func_table)                           \
+    { name, "provider=base,fips=" fips, (func_table) },
+
+#include "stores.inc"
+    { NULL, NULL, NULL }
+#undef STORE
+};
+
 static const OSSL_ALGORITHM *base_query(void *provctx, int operation_id,
                                          int *no_cache)
 {
@@ -95,6 +104,8 @@ static const OSSL_ALGORITHM *base_query(void *provctx, int operation_id,
         return base_encoder;
     case OSSL_OP_DECODER:
         return base_decoder;
+    case OSSL_OP_STORE:
+        return base_store;
     }
     return NULL;
 }
diff --git a/providers/common/bio_prov.c b/providers/common/bio_prov.c
index fc1f8b2b26..c049795cd1 100644
--- a/providers/common/bio_prov.c
+++ b/providers/common/bio_prov.c
@@ -18,6 +18,7 @@ static OSSL_FUNC_BIO_read_ex_fn *c_bio_read_ex = NULL;
 static OSSL_FUNC_BIO_write_ex_fn *c_bio_write_ex = NULL;
 static OSSL_FUNC_BIO_gets_fn *c_bio_gets = NULL;
 static OSSL_FUNC_BIO_puts_fn *c_bio_puts = NULL;
+static OSSL_FUNC_BIO_ctrl_fn *c_bio_ctrl = NULL;
 static OSSL_FUNC_BIO_free_fn *c_bio_free = NULL;
 static OSSL_FUNC_BIO_vprintf_fn *c_bio_vprintf = NULL;
 
@@ -49,6 +50,10 @@ int ossl_prov_bio_from_dispatch(const OSSL_DISPATCH *fns)
             if (c_bio_puts == NULL)
                 c_bio_puts = OSSL_FUNC_BIO_puts(fns);
             break;
+        case OSSL_FUNC_BIO_CTRL:
+            if (c_bio_ctrl == NULL)
+                c_bio_ctrl = OSSL_FUNC_BIO_ctrl(fns);
+            break;
         case OSSL_FUNC_BIO_FREE:
             if (c_bio_free == NULL)
                 c_bio_free = OSSL_FUNC_BIO_free(fns);
@@ -107,6 +112,13 @@ int ossl_prov_bio_puts(OSSL_CORE_BIO *bio, const char *str)
     return c_bio_puts(bio, str);
 }
 
+int ossl_prov_bio_ctrl(OSSL_CORE_BIO *bio, int cmd, long num, void *ptr)
+{
+    if (c_bio_ctrl == NULL)
+        return -1;
+    return c_bio_ctrl(bio, cmd, num, ptr);
+}
+
 int ossl_prov_bio_free(OSSL_CORE_BIO *bio)
 {
     if (c_bio_free == NULL)
@@ -151,9 +163,7 @@ static int bio_core_write_ex(BIO *bio, const char *data, size_t data_len,
 
 static long bio_core_ctrl(BIO *bio, int cmd, long num, void *ptr)
 {
-    /* We don't support this */
-    assert(0);
-    return 0;
+    return ossl_prov_bio_ctrl(BIO_get_data(bio), cmd, num, ptr);
 }
 
 static int bio_core_gets(BIO *bio, char *buf, int size)
diff --git a/providers/common/include/prov/bio.h b/providers/common/include/prov/bio.h
index 3cef89ce18..9dd9f44bad 100644
--- a/providers/common/include/prov/bio.h
+++ b/providers/common/include/prov/bio.h
@@ -22,6 +22,7 @@ int ossl_prov_bio_write_ex(OSSL_CORE_BIO *bio, const void *data, size_t data_len
                            size_t *written);
 int ossl_prov_bio_gets(OSSL_CORE_BIO *bio, char *buf, int size);
 int ossl_prov_bio_puts(OSSL_CORE_BIO *bio, const char *str);
+int ossl_prov_bio_ctrl(OSSL_CORE_BIO *bio, int cmd, long num, void *ptr);
 int ossl_prov_bio_free(OSSL_CORE_BIO *bio);
 int ossl_prov_bio_vprintf(OSSL_CORE_BIO *bio, const char *format, va_list ap);
 int ossl_prov_bio_printf(OSSL_CORE_BIO *bio, const char *format, ...);
diff --git a/providers/common/include/prov/providercommonerr.h b/providers/common/include/prov/providercommonerr.h
index 4c356fc5c6..82eea21049 100644
--- a/providers/common/include/prov/providercommonerr.h
+++ b/providers/common/include/prov/providercommonerr.h
@@ -139,12 +139,14 @@ int ERR_load_PROV_strings(void);
 # define PROV_R_OUTPUT_BUFFER_TOO_SMALL                   106
 # define PROV_R_PARENT_LOCKING_NOT_ENABLED                182
 # define PROV_R_PARENT_STRENGTH_TOO_WEAK                  194
+# define PROV_R_PATH_MUST_BE_ABSOLUTE                     219
 # define PROV_R_PERSONALISATION_STRING_TOO_LONG           195
 # define PROV_R_PSS_SALTLEN_TOO_SMALL                     172
 # define PROV_R_READ_KEY                                  159
 # define PROV_R_REQUEST_TOO_LARGE_FOR_DRBG                196
 # define PROV_R_REQUIRE_CTR_MODE_CIPHER                   206
 # define PROV_R_RESEED_ERROR                              197
+# define PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES     222
 # define PROV_R_SELF_TEST_KAT_FAILURE                     215
 # define PROV_R_SELF_TEST_POST_FAILURE                    216
 # define PROV_R_TAG_NOTSET                                119
@@ -165,6 +167,7 @@ int ERR_load_PROV_strings(void);
 # define PROV_R_UNSUPPORTED_KEY_SIZE                      153
 # define PROV_R_UNSUPPORTED_MAC_TYPE                      137
 # define PROV_R_UNSUPPORTED_NUMBER_OF_ROUNDS              152
+# define PROV_R_URI_AUTHORITY_UNSUPPORTED                 223
 # define PROV_R_VALUE_ERROR                               138
 # define PROV_R_WRONG_FINAL_BLOCK_LENGTH                  107
 # define PROV_R_WRONG_OUTPUT_BUFFER_SIZE                  139
diff --git a/providers/common/provider_err.c b/providers/common/provider_err.c
index 3ea41f3c25..6d6a254dd6 100644
--- a/providers/common/provider_err.c
+++ b/providers/common/provider_err.c
@@ -149,6 +149,8 @@ static const ERR_STRING_DATA PROV_str_reasons[] = {
     "parent locking not enabled"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_PARENT_STRENGTH_TOO_WEAK),
     "parent strength too weak"},
+    {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_PATH_MUST_BE_ABSOLUTE),
+    "path must be absolute"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_PERSONALISATION_STRING_TOO_LONG),
     "personalisation string too long"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_PSS_SALTLEN_TOO_SMALL),
@@ -159,6 +161,8 @@ static const ERR_STRING_DATA PROV_str_reasons[] = {
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_REQUIRE_CTR_MODE_CIPHER),
     "require ctr mode cipher"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_RESEED_ERROR), "reseed error"},
+    {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES),
+    "search only supported for directories"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_SELF_TEST_KAT_FAILURE),
     "self test kat failure"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_SELF_TEST_POST_FAILURE),
@@ -196,6 +200,8 @@ static const ERR_STRING_DATA PROV_str_reasons[] = {
     "unsupported mac type"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_UNSUPPORTED_NUMBER_OF_ROUNDS),
     "unsupported number of rounds"},
+    {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_URI_AUTHORITY_UNSUPPORTED),
+    "uri authority unsupported"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_VALUE_ERROR), "value error"},
     {ERR_PACK(ERR_LIB_PROV, 0, PROV_R_WRONG_FINAL_BLOCK_LENGTH),
     "wrong final block length"},
diff --git a/providers/defltprov.c b/providers/defltprov.c
index 855497be06..beaf60bb1e 100644
--- a/providers/defltprov.c
+++ b/providers/defltprov.c
@@ -433,6 +433,15 @@ static const OSSL_ALGORITHM deflt_decoder[] = {
 };
 #undef DECODER
 
+static const OSSL_ALGORITHM deflt_store[] = {
+#define STORE(name, fips, func_table)                           \
+    { name, "provider=default,fips=" fips, (func_table) },
+
+#include "stores.inc"
+    { NULL, NULL, NULL }
+#undef STORE
+};
+
 static const OSSL_ALGORITHM *deflt_query(void *provctx, int operation_id,
                                          int *no_cache)
 {
@@ -461,6 +470,8 @@ static const OSSL_ALGORITHM *deflt_query(void *provctx, int operation_id,
         return deflt_encoder;
     case OSSL_OP_DECODER:
         return deflt_decoder;
+    case OSSL_OP_STORE:
+        return deflt_store;
     }
     return NULL;
 }
diff --git a/providers/implementations/build.info b/providers/implementations/build.info
index 54392cf68b..fe67e59401 100644
--- a/providers/implementations/build.info
+++ b/providers/implementations/build.info
@@ -1,2 +1,2 @@
 SUBDIRS=digests ciphers rands macs kdfs exchange keymgmt signature asymciphers \
-        encode_decode
+        encode_decode storemgmt
diff --git a/providers/implementations/include/prov/implementations.h b/providers/implementations/include/prov/implementations.h
index 1b8642415f..7060a4b839 100644
--- a/providers/implementations/include/prov/implementations.h
+++ b/providers/implementations/include/prov/implementations.h
@@ -385,3 +385,5 @@ extern const OSSL_DISPATCH der_to_rsapss_decoder_functions[];
 extern const OSSL_DISPATCH msblob_to_rsa_decoder_functions[];
 extern const OSSL_DISPATCH pvk_to_rsa_decoder_functions[];
 extern const OSSL_DISPATCH pem_to_der_decoder_functions[];
+
+extern const OSSL_DISPATCH file_store_functions[];
diff --git a/providers/implementations/storemgmt/build.info b/providers/implementations/storemgmt/build.info
new file mode 100644
index 0000000000..89939cce54
--- /dev/null
+++ b/providers/implementations/storemgmt/build.info
@@ -0,0 +1,6 @@
+# We make separate GOAL variables for each algorithm, to make it easy to
+# switch each to the Legacy provider when needed.
+
+$STORE_GOAL=../../libimplementations.a
+
+SOURCE[$STORE_GOAL]=file_store.c file_store_der2obj.c
diff --git a/providers/implementations/storemgmt/file_store.c b/providers/implementations/storemgmt/file_store.c
new file mode 100644
index 0000000000..70dbac600b
--- /dev/null
+++ b/providers/implementations/storemgmt/file_store.c
@@ -0,0 +1,920 @@
+/*
+ * Copyright 2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include "e_os.h"                /* To get strncasecmp() on Windows */
+#include <string.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include <openssl/core.h>
+#include <openssl/core_dispatch.h>
+#include <openssl/core_names.h>
+#include <openssl/core_object.h>
+#include <openssl/crypto.h>
+#include <openssl/bio.h>
+#include <openssl/err.h>
+#include <openssl/buffer.h>
+#include <openssl/params.h>
+#include <openssl/decoder.h>
+#include <openssl/store.h>       /* The OSSL_STORE_INFO type numbers */
+#include "internal/o_dir.h"
+#include "internal/pem.h"        /* For PVK and "blob" PEM headers */
+#include "crypto/decoder.h"
+#include "prov/implementations.h"
+#include "prov/bio.h"
+#include "prov/provider_ctx.h"
+#include "prov/providercommonerr.h"
+#include "file_store_local.h"
+
+DEFINE_STACK_OF(X509)
+DEFINE_STACK_OF(OSSL_STORE_INFO)
+
+#ifdef _WIN32
+# define stat _stat
+#endif
+
+#ifndef S_ISDIR
+# define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
+#endif
+
+static OSSL_FUNC_store_open_fn file_open;
+static OSSL_FUNC_store_attach_fn file_attach;
+static OSSL_FUNC_store_settable_ctx_params_fn file_settable_ctx_params;
+static OSSL_FUNC_store_set_ctx_params_fn file_set_ctx_params;
+static OSSL_FUNC_store_load_fn file_load;
+static OSSL_FUNC_store_eof_fn file_eof;
+static OSSL_FUNC_store_close_fn file_close;
+
+/*
+ * This implementation makes full use of OSSL_DECODER, and then some.
+ * It uses its own internal decoder implementation that reads DER and
+ * passes that on to the data callback; this decoder is created with
+ * internal OpenSSL functions, thereby bypassing the need for a surrounding
+ * provider.  This is ok, since this is a local decoder, not meant for
+ * public consumption.  It also uses the libcrypto internal decoder
+ * setup function ossl_decoder_ctx_setup_for_EVP_PKEY(), to allow the
+ * last resort decoder to be added first (and thereby be executed last).
+ * Finally, it sets up its own construct and cleanup functions.
+ *
+ * Essentially, that makes this implementation a kind of glorified decoder.
+ */
+
+struct file_ctx_st {
+    void *provctx;
+    char *uri;                   /* The URI we currently try to load */
+    enum {
+        IS_FILE = 0,             /* Read file and pass results */
+        IS_DIR                   /* Pass directory entry names */
+    } type;
+
+    /* Flag bits */
+    unsigned int flag_attached:1;
+    unsigned int flag_buffered:1;
+
+    union {
+        /* Used with |IS_FILE| */
+        struct {
+            BIO *file;
+
+            OSSL_DECODER_CTX *decoderctx;
+            char *input_type;
+            char *propq;    /* The properties we got as a parameter */
+        } file;
+
+        /* Used with |IS_DIR| */
+        struct {
+            OPENSSL_DIR_CTX *ctx;
+            int end_reached;
+
+            /*
+             * When a search expression is given, these are filled in.
+             * |search_name| contains the file basename to look for.
+             * The string is exactly 8 characters long.
+             */
+            char search_name[9];
+
+            /*
+             * The directory reading utility we have combines opening with
+             * reading the first name.  To make sure we can detect the end
+             * at the right time, we read early and cache the name.
+             */
+            const char *last_entry;
+            int last_errno;
+        } dir;
+    } _;
+
+    /* Expected object type.  May be unspecified */
+    int expected_type;
+};
+
+static void free_file_ctx(struct file_ctx_st *ctx)
+{
+    if (ctx == NULL)
+        return;
+
+    OPENSSL_free(ctx->uri);
+    if (ctx->type != IS_DIR) {
+        OSSL_DECODER_CTX_free(ctx->_.file.decoderctx);
+        OPENSSL_free(ctx->_.file.propq);
+        OPENSSL_free(ctx->_.file.input_type);
+    }
+    OPENSSL_free(ctx);
+}
+
+static struct file_ctx_st *new_file_ctx(int type, const char *uri,
+                                        void *provctx)
+{
+    struct file_ctx_st *ctx = NULL;
+
+    if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) != NULL
+        && (uri == NULL || (ctx->uri = OPENSSL_strdup(uri)) != NULL)) {
+        ctx->type = type;
+        ctx->provctx = provctx;
+        return ctx;
+    }
+    free_file_ctx(ctx);
+    return NULL;
+}
+
+static OSSL_DECODER_CONSTRUCT file_load_construct;
+static OSSL_DECODER_CLEANUP file_load_cleanup;
+
+/*-
+ *  Opening / attaching streams and directories
+ *  -------------------------------------------
+ */
+
+/*
+ * Function to service both file_open() and file_attach()
+ *
+ *
+ */
+static struct file_ctx_st *file_open_stream(BIO *source, const char *uri,
+                                            const char *input_type,
+                                            void *provctx)
+{
+    struct file_ctx_st *ctx;
+
+    if ((ctx = new_file_ctx(IS_FILE, uri, provctx)) == NULL
+        || (input_type != NULL
+            && (ctx->_.file.input_type =
+                OPENSSL_strdup(input_type)) == NULL)) {
+        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+        goto err;
+    }
+
+    ctx->_.file.file = source;
+
+    return ctx;
+ err:
+    free_file_ctx(ctx);
+    return NULL;
+}
+
+static void *file_open_dir(const char *path, const char *uri, void *provctx)
+{
+    struct file_ctx_st *ctx;
+
+    if ((ctx = new_file_ctx(IS_DIR, uri, provctx)) == NULL) {
+        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+        goto err;
+    }
+
+    ctx->_.dir.last_entry = OPENSSL_DIR_read(&ctx->_.dir.ctx, path);
+    ctx->_.dir.last_errno = errno;
+    if (ctx->_.dir.last_entry == NULL) {
+        if (ctx->_.dir.last_errno != 0) {
+            ERR_raise_data(ERR_LIB_SYS, ctx->_.dir.last_errno,
+                           "Calling OPENSSL_DIR_read(\"%s\")", path);
+            goto err;
+        }
+        ctx->_.dir.end_reached = 1;
+    }
+    return ctx;
+ err:
+    file_close(ctx);
+    return NULL;
+}
+
+static void *file_open(void *provctx, const char *uri)
+{
+    struct file_ctx_st *ctx = NULL;
+    struct stat st;
+    struct {
+        const char *path;
+        unsigned int check_absolute:1;
+    } path_data[2];
+    size_t path_data_n = 0, i;
+    const char *path;
+    BIO *bio;
+
+    ERR_set_mark();
+
+    /*
+     * First step, just take the URI as is.
+     */
+    path_data[path_data_n].check_absolute = 0;
+    path_data[path_data_n++].path = uri;
+
+    /*
+     * Second step, if the URI appears to start with the 'file' scheme,
+     * extract the path and make that the second path to check.
+     * There's a special case if the URI also contains an authority, then
+     * the full URI shouldn't be used as a path anywhere.
+     */
+    if (strncasecmp(uri, "file:", 5) == 0) {
+        const char *p = &uri[5];
+
+        if (strncmp(&uri[5], "//", 2) == 0) {
+            path_data_n--;           /* Invalidate using the full URI */
+            if (strncasecmp(&uri[7], "localhost/", 10) == 0) {
+                p = &uri[16];
+            } else if (uri[7] == '/') {
+                p = &uri[7];
+            } else {
+                ERR_clear_last_mark();
+                ERR_raise(ERR_LIB_PROV, PROV_R_URI_AUTHORITY_UNSUPPORTED);
+                return NULL;
+            }
+        }
+
+        path_data[path_data_n].check_absolute = 1;
+#ifdef _WIN32
+        /* Windows file: URIs with a drive letter start with a / */
+        if (p[0] == '/' && p[2] == ':' && p[3] == '/') {
+            char c = tolower(p[1]);
+
+            if (c >= 'a' && c <= 'z') {
+                p++;
+                /* We know it's absolute, so no need to check */
+                path_data[path_data_n].check_absolute = 0;
+            }
+        }
+#endif
+        path_data[path_data_n++].path = p;
+    }
+
+
+    for (i = 0, path = NULL; path == NULL && i < path_data_n; i++) {
+        /*
+         * If the scheme "file" was an explicit part of the URI, the path must
+         * be absolute.  So says RFC 8089
+         */
+        if (path_data[i].check_absolute && path_data[i].path[0] != '/') {
+            ERR_clear_last_mark();
+            ERR_raise_data(ERR_LIB_PROV, PROV_R_PATH_MUST_BE_ABSOLUTE,
+                           "Given path=%s", path_data[i].path);
+            return NULL;
+        }
+
+        if (stat(path_data[i].path, &st) < 0) {
+            ERR_raise_data(ERR_LIB_SYS, errno,
+                           "calling stat(%s)",
+                           path_data[i].path);
+        } else {
+            path = path_data[i].path;
+        }
+    }
+    if (path == NULL) {
+        ERR_clear_last_mark();
+        return NULL;
+    }
+
+    /* Successfully found a working path, clear possible collected errors */
+    ERR_pop_to_mark();
+
+    if (S_ISDIR(st.st_mode))
+        ctx = file_open_dir(path, uri, provctx);
+    else if ((bio = BIO_new_file(path, "rb")) == NULL
+             || (ctx = file_open_stream(bio, uri, NULL, provctx)) == NULL)
+        BIO_free_all(bio);
+
+    return ctx;
+}
+
+/*
+ * Attached input streams must be treated very very carefully to avoid
+ * nasty surprises.
+ *
+ * This implementation tries to support input streams that can't be reset,
+ * such as standard input.  However, OSSL_DECODER assumes resettable streams,
+ * and because the PEM decoder may read quite a bit of the input file to skip
+ * past any non-PEM text that precedes the PEM block, we may need to detect
+ * if the input stream is a PEM file early.
+ *
+ * If the input stream supports BIO_tell(), we assume that it also supports
+ * BIO_seek(), making it a resettable stream and therefore safe to fully
+ * unleash OSSL_DECODER.
+ *
+ * If the input stream doesn't support BIO_tell(), we must assume that we
+ * have a non-resettable stream, and must tread carefully.  We do so by
+ * trying to detect if the input is PEM, MSBLOB or PVK, and if not, we
+ * assume that it's DER.
+ *
+ * To detect if an input stream is PEM, MSBLOB or PVK, we use the buffer BIO
+ * filter, which allows us a 4KiB resettable read-ahead.  We *hope* that 4KiB
+ * will be enough to find the start of the PEM block.
+ *
+ * It should be possible to use this same technique to detect other file
+ * types as well.
+ *
+ * An alternative technique would be to have an endlessly caching BIO filter.
+ * That would take away the need for all the detection here, and simply leave
+ * it for OSSL_DECODER to find out on its own while supporting its demand for
+ * resettable input streams.
+ * That's a possible future development.
+ */
+
+# define INPUT_TYPE_ANY         NULL
+# define INPUT_TYPE_DER         "DER"
+# define INPUT_TYPE_PEM         "PEM"
+# define INPUT_TYPE_MSBLOB      "MSBLOB"
+# define INPUT_TYPE_PVK         "PVK"
+
+void *file_attach(void *provctx, OSSL_CORE_BIO *cin)
+{
+    BIO *new_bio = bio_new_from_core_bio(provctx, cin);
+    BIO *new_bio_tmp = NULL;
+    BIO *buff = NULL;
+    char peekbuf[4096] = { 0, };
+    int loc;
+    const char *input_type = NULL;
+    unsigned int flag_attached = 1;
+    unsigned int flag_buffered = 0;
+    struct file_ctx_st *ctx = NULL;
+
+    if (new_bio == NULL)
+        return 0;
+
+    /* Try to get the current position */
+    loc = BIO_tell(new_bio);
+
+    if ((buff = BIO_new(BIO_f_buffer())) == NULL
+        || (new_bio_tmp = BIO_push(buff, new_bio)) == NULL)
+        goto err;
+
+    /* Assumption, if we can't detect PEM */
+    input_type = INPUT_TYPE_DER;
+    flag_buffered = 1;
+    new_bio = new_bio_tmp;
+
+    if (BIO_buffer_peek(new_bio, peekbuf, sizeof(peekbuf) - 1) > 0) {
+#ifndef OPENSSL_NO_DSA
+        const unsigned char *p = NULL;
+        unsigned int magic = 0, bitlen = 0;
+        int isdss = 0, ispub = -1;
+# ifndef OPENSSL_NO_RC4
+        unsigned int saltlen = 0, keylen = 0;
+# endif
+#endif
+
+        peekbuf[sizeof(peekbuf) - 1] = '\0';
+        if (strstr(peekbuf, "-----BEGIN ") != NULL)
+            input_type = INPUT_TYPE_PEM;
+#ifndef OPENSSL_NO_DSA
+        else if (p = (unsigned char *)peekbuf,
+                 ossl_do_blob_header(&p, sizeof(peekbuf), &magic, &bitlen,
+                                     &isdss, &ispub))
+            input_type = INPUT_TYPE_MSBLOB;
+# ifndef OPENSSL_NO_RC4
+        else if (p = (unsigned char *)peekbuf,
+                 ossl_do_PVK_header(&p, sizeof(peekbuf), 0, &saltlen, &keylen))
+            input_type = INPUT_TYPE_PVK;
+# endif
+#endif
+    }
+
+    /*
+     * After peeking, we know that the underlying source BIO has moved ahead
+     * from its earlier position and that if it supports BIO_tell(), that
+     * should be a number that differs from |loc|.  Otherwise, we will get
+     * the same value, which may one of:
+     *
+     * -   zero (the source BIO doesn't support BIO_tell() / BIO_seek() /
+     *     BIO_reset())
+     * -   -1 (the underlying operating system / C library routines do not
+     *     support BIO_tell() / BIO_seek() / BIO_reset())
+     *
+     * If it turns out that the source BIO does support BIO_tell(), we pop
+     * the buffer BIO filter and mark this input as |INPUT_TYPE_ANY|, which
+     * fully unleashes OSSL_DECODER to do its thing.
+     */
+    if (BIO_tell(new_bio) != loc) {
+        /* In this case, anything goes */
+        input_type = INPUT_TYPE_ANY;
+
+        /* Restore the source BIO like it was when entering this function */
+        new_bio = BIO_pop(buff);
+        BIO_free(buff);
+        (void)BIO_seek(new_bio, loc);
+
+        flag_buffered = 0;
+    }
+
+    if ((ctx = file_open_stream(new_bio, NULL, input_type, provctx)) == NULL)
+        goto err;
+
+    ctx->flag_attached = flag_attached;
+    ctx->flag_buffered = flag_buffered;
+
+    return ctx;
+ err:
+    if (flag_buffered) {
+        new_bio = BIO_pop(buff);
+        BIO_free(buff);
+    }
+    BIO_free(new_bio);           /* Removes the provider BIO filter */
+    return NULL;
+}
+
+/*-
+ *  Setting parameters
+ *  ------------------
+ */
+
+static const OSSL_PARAM *file_settable_ctx_params(void *provctx)
+{
+    static const OSSL_PARAM known_settable_ctx_params[] = {
+        OSSL_PARAM_utf8_string(OSSL_STORE_PARAM_PROPERTIES, NULL, 0),
+        OSSL_PARAM_int(OSSL_STORE_PARAM_EXPECT, NULL),
+        OSSL_PARAM_octet_string(OSSL_STORE_PARAM_SUBJECT, NULL, 0),
+        OSSL_PARAM_END
+    };
+    return known_settable_ctx_params;
+}
+
+static int file_set_ctx_params(void *loaderctx, const OSSL_PARAM params[])
+{
+    struct file_ctx_st *ctx = loaderctx;
+    const OSSL_PARAM *p;
+
+    p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_PROPERTIES);
+    if (p != NULL) {
+        OPENSSL_free(ctx->_.file.propq);
+        ctx->_.file.propq = NULL;
+        if (!OSSL_PARAM_get_utf8_string(p, &ctx->_.file.propq, 0))
+            return 0;
+    }
+    p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_EXPECT);
+    if (p != NULL && !OSSL_PARAM_get_int(p, &ctx->expected_type))
+        return 0;
+    p = OSSL_PARAM_locate_const(params, OSSL_STORE_PARAM_SUBJECT);
+    if (p != NULL) {
+        const unsigned char *der = NULL;
+        size_t der_len = 0;
+        X509_NAME *x509_name;
+        unsigned long hash;
+
+        if (ctx->type != IS_DIR) {
+            ERR_raise(ERR_LIB_PROV,
+                      PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES);
+            return 0;
+        }
+
+        if (!OSSL_PARAM_get_octet_string_ptr(p, (const void **)&der, &der_len)
+            || (x509_name = d2i_X509_NAME(NULL, &der, der_len)) == NULL)
+            return 0;
+        hash = X509_NAME_hash(x509_name);
+        BIO_snprintf(ctx->_.dir.search_name, sizeof(ctx->_.dir.search_name),
+                     "%08lx", hash);
+        X509_NAME_free(x509_name);
+    }
+    return 1;
+}
+
+/*-
+ *  Loading an object from a stream
+ *  -------------------------------
+ */
+
+struct file_load_data_st {
+    OSSL_CALLBACK *object_cb;
+    void *object_cbarg;
+};
+
+static int file_load_construct(OSSL_DECODER_INSTANCE *decoder_inst,
+                               const OSSL_PARAM *params, void *construct_data)
+{
+    struct file_load_data_st *data = construct_data;
+
+    /*
+     * At some point, we may find it justifiable to recognise PKCS#12 and
+     * handle it specially here, making |file_load()| return pass its
+     * contents one piece at ta time, like |e_loader_attic.c| does.
+     *
+     * However, that currently means parsing them out, which converts the
+     * DER encoded PKCS#12 into a bunch of EVP_PKEYs and X509s, just to
+     * have to re-encode them into DER to create an object abstraction for
+     * each of them.
+     * It's much simpler (less churn) to pass on the object abstraction we
+     * get to the load_result callback and leave it to that one to do the
+     * work.  If that's libcrypto code, we know that it has much better
+     * possibilities to handle the EVP_PKEYs and X509s without the extra
+     * churn.
+     */
+
+    return data->object_cb(params, data->object_cbarg);
+}
+
+void file_load_cleanup(void *construct_data)
+{
+    /* Nothing to do */
+}
+
+static int file_setup_decoders(struct file_ctx_st *ctx)
+{
+    EVP_PKEY *dummy; /* for OSSL_DECODER_CTX_new_by_EVP_PKEY() */
+    OPENSSL_CTX *libctx = PROV_CTX_get0_library_context(ctx->provctx);
+    OSSL_DECODER *to_obj = NULL; /* Last resort decoder */
+    OSSL_DECODER_INSTANCE *to_obj_inst = NULL;
+    OSSL_DECODER_CLEANUP *old_cleanup = NULL;
+    void *old_construct_data = NULL;
+    int ok = 0;
+
+    /* Setup for this session, so only if not already done */
+    if (ctx->_.file.decoderctx == NULL) {
+        if ((ctx->_.file.decoderctx = OSSL_DECODER_CTX_new()) == NULL) {
+            ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+            goto err;
+        }
+
+        /* Make sure the input type is set */
+        if (!OSSL_DECODER_CTX_set_input_type(ctx->_.file.decoderctx,
+                                             ctx->_.file.input_type)) {
+            ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
+            goto err;
+        }
+
+        /*
+         * Create the internal last resort decoder implementation together
+         * with a "decoder instance".
+         * The decoder doesn't need any identification or to be attached to
+         * any provider, since it's only used locally.
+         */
+        to_obj = ossl_decoder_from_dispatch(0, &der_to_obj_algorithm, NULL);
+        if (to_obj == NULL)
+            goto err;
+        to_obj_inst = ossl_decoder_instance_new(to_obj, ctx->provctx);
+        if (to_obj_inst == NULL)
+            goto err;
+
+        if (!ossl_decoder_ctx_add_decoder_inst(ctx->_.file.decoderctx,
+                                               to_obj_inst)) {
+            ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
+            goto err;
+        }
+
+        /*
+         * OSSL_DECODER_INSTANCE shouldn't be freed from this point on.
+         * That's going to happen whenever the OSSL_DECODER_CTX is freed.
+         */
+        to_obj_inst = NULL;
+
+        /*
+         * Add on the usual decoder context for keys, with a dummy object.
+         * Since we're setting up our own constructor, we don't need to care
+         * more than that...
+         */
+        if (!ossl_decoder_ctx_setup_for_EVP_PKEY(ctx->_.file.decoderctx, &dummy,
+                                                 libctx, ctx->_.file.propq)
+            || !OSSL_DECODER_CTX_add_extra(ctx->_.file.decoderctx,
+                                           libctx, ctx->_.file.propq)) {
+            ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
+            goto err;
+        }
+
+        /*
+         * Then we throw away the installed finalizer data, and install our
+         * own instead.
+         */
+        old_cleanup = OSSL_DECODER_CTX_get_cleanup(ctx->_.file.decoderctx);
+        old_construct_data =
+            OSSL_DECODER_CTX_get_construct_data(ctx->_.file.decoderctx);
+        if (old_cleanup != NULL)
+            old_cleanup(old_construct_data);
+
+        /*
+         * Set the hooks.
+         */
+        if (!OSSL_DECODER_CTX_set_construct(ctx->_.file.decoderctx,
+                                            file_load_construct)
+            || !OSSL_DECODER_CTX_set_cleanup(ctx->_.file.decoderctx,
+                                             file_load_cleanup)) {
+            ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
+            goto err;
+        }
+    }
+
+    ok = 1;
+ err:
+    OSSL_DECODER_free(to_obj);
+    return ok;
+}
+
+static int file_load_file(struct file_ctx_st *ctx,
+                          OSSL_CALLBACK *object_cb, void *object_cbarg,
+                          OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
+{
+    struct file_load_data_st data;
+
+    /* Setup the decoders (one time shot per session */
+
+    if (!file_setup_decoders(ctx))
+        return 0;
+
+    /* Setup for this object */
+
+    data.object_cb = object_cb;
+    data.object_cbarg = object_cbarg;
+    OSSL_DECODER_CTX_set_construct_data(ctx->_.file.decoderctx, &data);
+    OSSL_DECODER_CTX_set_pass