/*

 * Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved.

 *

 * Licensed under the OpenSSL license (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"

#include <string.h>

#include <sys/stat.h>

#include <ctype.h>

#include <assert.h>

#include <openssl/bio.h>

#include <openssl/dsa.h>         /* For d2i_DSAPrivateKey */

#include <openssl/err.h>

#include <openssl/evp.h>

#include <openssl/pem.h>

#include <openssl/pkcs12.h>      /* For the PKCS8 stuff o.O */

#include <openssl/rsa.h>         /* For d2i_RSAPrivateKey */

#include <openssl/safestack.h>

#include <openssl/store.h>

#include <openssl/ui.h>

#include <openssl/x509.h>        /* For the PKCS8 stuff o.O */

#include "crypto/asn1.h"

#include "crypto/ctype.h"

#include "internal/o_dir.h"

#include "internal/cryptlib.h"

#include "crypto/store.h"

#include "store_local.h"

#ifdef _WIN32

# define stat    _stat

#endif

#ifndef S_ISDIR

# define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)

#endif

/*-

 *  Password prompting

 *  ------------------

 */

static char *file_get_pass(const UI_METHOD *ui_method, char *pass,

                           size_t maxsize, const char *prompt_info, void *data)

{

    UI *ui = UI_new();

    char *prompt = NULL;

    if (ui == NULL) {

        OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_MALLOC_FAILURE);

        return NULL;

    }

    if (ui_method != NULL)

        UI_set_method(ui, ui_method);

    UI_add_user_data(ui, data);

    if ((prompt = UI_construct_prompt(ui, "pass phrase",

                                      prompt_info)) == NULL) {

        OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_MALLOC_FAILURE);

        pass = NULL;

    } else if (!UI_add_input_string(ui, prompt, UI_INPUT_FLAG_DEFAULT_PWD,

                                    pass, 0, maxsize - 1)) {

        OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_UI_LIB);

        pass = NULL;

    } else {

        switch (UI_process(ui)) {

        case -2:

            OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS,

                          OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED);

            pass = NULL;

            break;

        case -1:

            OSSL_STOREerr(OSSL_STORE_F_FILE_GET_PASS, ERR_R_UI_LIB);

            pass = NULL;

            break;

        default:

            break;

        }

    }

    OPENSSL_free(prompt);

    UI_free(ui);

    return pass;

}

struct pem_pass_data {

    const UI_METHOD *ui_method;

    void *data;

    const char *prompt_info;

};

static int file_fill_pem_pass_data(struct pem_pass_data *pass_data,

                                   const char *prompt_info,

                                   const UI_METHOD *ui_method, void *ui_data)

{

    if (pass_data == NULL)

        return 0;

    pass_data->ui_method = ui_method;

    pass_data->data = ui_data;

    pass_data->prompt_info = prompt_info;

    return 1;

}

/* This is used anywhere a pem_password_cb is needed */

static int file_get_pem_pass(char *buf, int num, int w, void *data)

{

    struct pem_pass_data *pass_data = data;

    char *pass = file_get_pass(pass_data->ui_method, buf, num,

                               pass_data->prompt_info, pass_data->data);

    return pass == NULL ? 0 : strlen(pass);

}

/*-

 *  The file scheme decoders

 *  ------------------------

 *

 *  Each possible data type has its own decoder, which either operates

 *  through a given PEM name, or attempts to decode to see if the blob

 *  it's given is decodable for its data type.  The assumption is that

 *  only the correct data type will match the content.

 */

/*-

 * The try_decode function is called to check if the blob of data can

 * be used by this handler, and if it can, decodes it into a supported

 * OpenSSL type and returns a OSSL_STORE_INFO with the decoded data.

 * Input:

 *    pem_name:     If this blob comes from a PEM file, this holds

 *                  the PEM name.  If it comes from another type of

 *                  file, this is NULL.

 *    pem_header:   If this blob comes from a PEM file, this holds

 *                  the PEM headers.  If it comes from another type of

 *                  file, this is NULL.

 *    blob:         The blob of data to match with what this handler

 *                  can use.

 *    len:          The length of the blob.

 *    handler_ctx:  For a handler marked repeatable, this pointer can

 *                  be used to create a context for the handler.  IT IS

 *                  THE HANDLER'S RESPONSIBILITY TO CREATE AND DESTROY

 *                  THIS CONTEXT APPROPRIATELY, i.e. create on first call

 *                  and destroy when about to return NULL.

 *    matchcount:   A pointer to an int to count matches for this data.

 *                  Usually becomes 0 (no match) or 1 (match!), but may

 *                  be higher in the (unlikely) event that the data matches

 *                  more than one possibility.  The int will always be

 *                  zero when the function is called.

 *    ui_method:    Application UI method for getting a password, pin

 *                  or any other interactive data.

 *    ui_data:      Application data to be passed to ui_method when

 *                  it's called.

 * Output:

 *    a OSSL_STORE_INFO

 */

typedef OSSL_STORE_INFO *(*file_try_decode_fn)(const char *pem_name,

                                               const char *pem_header,

                                               const unsigned char *blob,

                                               size_t len, void **handler_ctx,

                                               int *matchcount,

                                               const UI_METHOD *ui_method,

                                               void *ui_data);

/*

 * The eof function should return 1 if there's no more data to be found

 * with the handler_ctx, otherwise 0.  This is only used when the handler is

 * marked repeatable.

 */

typedef int (*file_eof_fn)(void *handler_ctx);

/*

 * The destroy_ctx function is used to destroy the handler_ctx that was

 * initiated by a repeatable try_decode function.  This is only used when

 * the handler is marked repeatable.

 */

typedef void (*file_destroy_ctx_fn)(void **handler_ctx);

typedef struct file_handler_st {

    const char *name;

    file_try_decode_fn try_decode;

    file_eof_fn eof;

    file_destroy_ctx_fn destroy_ctx;

    /* flags */

    int repeatable;

} FILE_HANDLER;

/*

 * PKCS#12 decoder.  It operates by decoding all of the blob content,

 * extracting all the interesting data from it and storing them internally,

 * then serving them one piece at a time.

 */

static OSSL_STORE_INFO *try_decode_PKCS12(const char *pem_name,

                                          const char *pem_header,

                                          const unsigned char *blob,

                                          size_t len, void **pctx,

                                          int *matchcount,

                                          const UI_METHOD *ui_method,

                                          void *ui_data)

{

    OSSL_STORE_INFO *store_info = NULL;

    STACK_OF(OSSL_STORE_INFO) *ctx = *pctx;

    if (ctx == NULL) {

        /* Initial parsing */

        PKCS12 *p12;

        int ok = 0;

        if (pem_name != NULL)

            /* No match, there is no PEM PKCS12 tag */

            return NULL;

        if ((p12 = d2i_PKCS12(NULL, &blob, len)) != NULL) {

            char *pass = NULL;

            char tpass[PEM_BUFSIZE];

            EVP_PKEY *pkey = NULL;

            X509 *cert = NULL;

            STACK_OF(X509) *chain = NULL;

            *matchcount = 1;

            if (PKCS12_verify_mac(p12, "", 0)

                || PKCS12_verify_mac(p12, NULL, 0)) {

                pass = "";

            } else {

                if ((pass = file_get_pass(ui_method, tpass, PEM_BUFSIZE,

                                          "PKCS12 import password",

                                          ui_data)) == NULL) {

                    OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS12,

                                  OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR);

                    goto p12_end;

                }

                if (!PKCS12_verify_mac(p12, pass, strlen(pass))) {

                    OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS12,

                                  OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC);

                    goto p12_end;

                }

            }

            if (PKCS12_parse(p12, pass, &pkey, &cert, &chain)) {

                OSSL_STORE_INFO *osi_pkey = NULL;

                OSSL_STORE_INFO *osi_cert = NULL;

                OSSL_STORE_INFO *osi_ca = NULL;

                if ((ctx = sk_OSSL_STORE_INFO_new_null()) != NULL

                    && (osi_pkey = OSSL_STORE_INFO_new_PKEY(pkey)) != NULL

                    && sk_OSSL_STORE_INFO_push(ctx, osi_pkey) != 0

                    && (osi_cert = OSSL_STORE_INFO_new_CERT(cert)) != NULL

                    && sk_OSSL_STORE_INFO_push(ctx, osi_cert) != 0) {

                    ok = 1;

                    osi_pkey = NULL;

                    osi_cert = NULL;

                    while(sk_X509_num(chain) > 0) {

                        X509 *ca = sk_X509_value(chain, 0);

                        if ((osi_ca = OSSL_STORE_INFO_new_CERT(ca)) == NULL

                            || sk_OSSL_STORE_INFO_push(ctx, osi_ca) == 0) {

                            ok = 0;

                            break;

                        }

                        osi_ca = NULL;

                        (void)sk_X509_shift(chain);

                    }

                }

                if (!ok) {

                    OSSL_STORE_INFO_free(osi_ca);

                    OSSL_STORE_INFO_free(osi_cert);

                    OSSL_STORE_INFO_free(osi_pkey);

                    sk_OSSL_STORE_INFO_pop_free(ctx, OSSL_STORE_INFO_free);

                    EVP_PKEY_free(pkey);

                    X509_free(cert);

                    sk_X509_pop_free(chain, X509_free);

                    ctx = NULL;

                }

                *pctx = ctx;

            }

        }

     p12_end:

        PKCS12_free(p12);

        if (!ok)

            return NULL;

    }

    if (ctx != NULL) {

        *matchcount = 1;

        store_info = sk_OSSL_STORE_INFO_shift(ctx);

    }

    return store_info;

}

static int eof_PKCS12(void *ctx_)

{

    STACK_OF(OSSL_STORE_INFO) *ctx = ctx_;

    return ctx == NULL || sk_OSSL_STORE_INFO_num(ctx) == 0;

}

static void destroy_ctx_PKCS12(void **pctx)

{

    STACK_OF(OSSL_STORE_INFO) *ctx = *pctx;

    sk_OSSL_STORE_INFO_pop_free(ctx, OSSL_STORE_INFO_free);

    *pctx = NULL;

}

static FILE_HANDLER PKCS12_handler = {

    "PKCS12",

    try_decode_PKCS12,

    eof_PKCS12,

    destroy_ctx_PKCS12,

    1                            /* repeatable */

};

/*

 * Encrypted PKCS#8 decoder.  It operates by just decrypting the given blob

 * into a new blob, which is returned as an EMBEDDED STORE_INFO.  The whole

 * decoding process will then start over with the new blob.

 */

static OSSL_STORE_INFO *try_decode_PKCS8Encrypted(const char *pem_name,

                                                  const char *pem_header,

                                                  const unsigned char *blob,

                                                  size_t len, void **pctx,

                                                  int *matchcount,

                                                  const UI_METHOD *ui_method,

                                                  void *ui_data)

{

    X509_SIG *p8 = NULL;

    char kbuf[PEM_BUFSIZE];

    char *pass = NULL;

    const X509_ALGOR *dalg = NULL;

    const ASN1_OCTET_STRING *doct = NULL;

    OSSL_STORE_INFO *store_info = NULL;

    BUF_MEM *mem = NULL;

    unsigned char *new_data = NULL;

    int new_data_len;

    if (pem_name != NULL) {

        if (strcmp(pem_name, PEM_STRING_PKCS8) != 0)

            return NULL;

        *matchcount = 1;

    }

    if ((p8 = d2i_X509_SIG(NULL, &blob, len)) == NULL)

        return NULL;

    *matchcount = 1;

    if ((mem = BUF_MEM_new()) == NULL) {

        OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED,

                      ERR_R_MALLOC_FAILURE);

        goto nop8;

    }

    if ((pass = file_get_pass(ui_method, kbuf, PEM_BUFSIZE,

                              "PKCS8 decrypt password", ui_data)) == NULL) {

        OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED,

                      OSSL_STORE_R_BAD_PASSWORD_READ);

        goto nop8;

    }

    X509_SIG_get0(p8, &dalg, &doct);

    if (!PKCS12_pbe_crypt(dalg, pass, strlen(pass), doct->data, doct->length,

                          &new_data, &new_data_len, 0))

        goto nop8;

    mem->data = (char *)new_data;

    mem->max = mem->length = (size_t)new_data_len;

    X509_SIG_free(p8);

    store_info = ossl_store_info_new_EMBEDDED(PEM_STRING_PKCS8INF, mem);

    if (store_info == NULL) {

        OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED,

                      ERR_R_MALLOC_FAILURE);

        goto nop8;

    }

    return store_info;

 nop8:

    X509_SIG_free(p8);

    BUF_MEM_free(mem);

    return NULL;

}

static FILE_HANDLER PKCS8Encrypted_handler = {

    "PKCS8Encrypted",

    try_decode_PKCS8Encrypted

};

/*

 * Private key decoder.  Decodes all sorts of private keys, both PKCS#8

 * encoded ones and old style PEM ones (with the key type is encoded into

 * the PEM name).

 */

int pem_check_suffix(const char *pem_str, const char *suffix);

static OSSL_STORE_INFO *try_decode_PrivateKey(const char *pem_name,

                                              const char *pem_header,

                                              const unsigned char *blob,

                                              size_t len, void **pctx,

                                              int *matchcount,

                                              const UI_METHOD *ui_method,

                                              void *ui_data)

{

    OSSL_STORE_INFO *store_info = NULL;

    EVP_PKEY *pkey = NULL;

    const EVP_PKEY_ASN1_METHOD *ameth = NULL;

    if (pem_name != NULL) {

        if (strcmp(pem_name, PEM_STRING_PKCS8INF) == 0) {

            PKCS8_PRIV_KEY_INFO *p8inf =

                d2i_PKCS8_PRIV_KEY_INFO(NULL, &blob, len);

            *matchcount = 1;

            if (p8inf != NULL)

                pkey = EVP_PKCS82PKEY(p8inf);

            PKCS8_PRIV_KEY_INFO_free(p8inf);

        } else {

            int slen;

            if ((slen = pem_check_suffix(pem_name, "PRIVATE KEY")) > 0

                && (ameth = EVP_PKEY_asn1_find_str(NULL, pem_name,

                                                   slen)) != NULL) {

                *matchcount = 1;

                pkey = d2i_PrivateKey(ameth->pkey_id, NULL, &blob, len);

            }

        }

    } else {

        int i;

        for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {

            EVP_PKEY *tmp_pkey = NULL;

            const unsigned char *tmp_blob = blob;

            ameth = EVP_PKEY_asn1_get0(i);

            if (ameth->pkey_flags & ASN1_PKEY_ALIAS)

                continue;

            tmp_pkey = d2i_PrivateKey(ameth->pkey_id, NULL, &tmp_blob, len);

            if (tmp_pkey != NULL) {

                if (pkey != NULL)

                    EVP_PKEY_free(tmp_pkey);

                else

                    pkey = tmp_pkey;

                (*matchcount)++;

            }

        }

        if (*matchcount > 1) {

            EVP_PKEY_free(pkey);

            pkey = NULL;

        }

    }

    if (pkey == NULL)

        /* No match */

        return NULL;

    store_info = OSSL_STORE_INFO_new_PKEY(pkey);

    if (store_info == NULL)

        EVP_PKEY_free(pkey);

    return store_info;

}

static FILE_HANDLER PrivateKey_handler = {

    "PrivateKey",

    try_decode_PrivateKey

};

/*

 * Public key decoder.  Only supports SubjectPublicKeyInfo formatted keys.

 */

static OSSL_STORE_INFO *try_decode_PUBKEY(const char *pem_name,

                                          const char *pem_header,

                                          const unsigned char *blob,

                                          size_t len, void **pctx,

                                          int *matchcount,

                                          const UI_METHOD *ui_method,

                                          void *ui_data)

{

    OSSL_STORE_INFO *store_info = NULL;

    EVP_PKEY *pkey = NULL;

    if (pem_name != NULL) {

        if (strcmp(pem_name, PEM_STRING_PUBLIC) != 0)

            /* No match */

            return NULL;

        *matchcount = 1;

    }

    if ((pkey = d2i_PUBKEY(NULL, &blob, len)) != NULL) {

        *matchcount = 1;

        store_info = OSSL_STORE_INFO_new_PKEY(pkey);

    }

    return store_info;

}

static FILE_HANDLER PUBKEY_handler = {

    "PUBKEY",

    try_decode_PUBKEY

};

/*

 * Key parameter decoder.

 */

static OSSL_STORE_INFO *try_decode_params(const char *pem_name,

                                          const char *pem_header,

                                          const unsigned char *blob,

                                          size_t len, void **pctx,

                                          int *matchcount,

                                          const UI_METHOD *ui_method,

                                          void *ui_data)

{

    OSSL_STORE_INFO *store_info = NULL;

    int slen = 0;

    EVP_PKEY *pkey = NULL;

    const EVP_PKEY_ASN1_METHOD *ameth = NULL;

    int ok = 0;

    if (pem_name != NULL) {

        if ((slen = pem_check_suffix(pem_name, "PARAMETERS")) == 0)

            return NULL;

        *matchcount = 1;

    }

    if (slen > 0) {

        if ((pkey = EVP_PKEY_new()) == NULL) {

            OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PARAMS, ERR_R_EVP_LIB);

            return NULL;

        }

        if (EVP_PKEY_set_type_str(pkey, pem_name, slen)

            && (ameth = EVP_PKEY_get0_asn1(pkey)) != NULL

            && ameth->param_decode != NULL

            && ameth->param_decode(pkey, &blob, len))

            ok = 1;

    } else {

        int i;

        EVP_PKEY *tmp_pkey = NULL;

        for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) {

            const unsigned char *tmp_blob = blob;

            if (tmp_pkey == NULL && (tmp_pkey = EVP_PKEY_new()) == NULL) {

                OSSL_STOREerr(OSSL_STORE_F_TRY_DECODE_PARAMS, ERR_R_EVP_LIB);

                break;

            }

            ameth = EVP_PKEY_asn1_get0(i);

            if (ameth->pkey_flags & ASN1_PKEY_ALIAS)

                continue;

            if (EVP_PKEY_set_type(tmp_pkey, ameth->pkey_id)

                && (ameth = EVP_PKEY_get0_asn1(tmp_pkey)) != NULL

                && ameth->param_decode != NULL

                && ameth->param_decode(tmp_pkey, &tmp_blob, len)) {

                if (pkey != NULL)

                    EVP_PKEY_free(tmp_pkey);

                else

                    pkey = tmp_pkey;

                tmp_pkey = NULL;

                (*matchcount)++;

            }

        }

        EVP_PKEY_free(tmp_pkey);

        if (*matchcount == 1) {

            ok = 1;

        }

    }

    if (ok)

        store_info = OSSL_STORE_INFO_new_PARAMS(pkey);

    if (store_info == NULL)

        EVP_PKEY_free(pkey);

    return store_info;

}

static FILE_HANDLER params_handler = {

    "params",

    try_decode_params

};

/*

 * X.509 certificate decoder.

 */

static OSSL_STORE_INFO *try_decode_X509Certificate(const char *pem_name,

                                                   const char *pem_header,

                                                   const unsigned char *blob,

                                                   size_t len, void **pctx,

                                                   int *matchcount,

                                                   const UI_METHOD *ui_method,

                                                   void *ui_data)

{

    OSSL_STORE_INFO *store_info = NULL;

    X509 *cert = NULL;

    /*

     * In most cases, we can try to interpret the serialized data as a trusted

     * cert (X509 + X509_AUX) and fall back to reading it as a normal cert

     * (just X509), but if the PEM name specifically declares it as a trusted

     * cert, then no fallback should be engaged.  |ignore_trusted| tells if

     * the fallback can be used (1) or not (0).

     */

    int ignore_trusted = 1;

    if (pem_name != NULL) {

        if (strcmp(pem_name, PEM_STRING_X509_TRUSTED) == 0)

            ignore_trusted = 0;

        else if (strcmp(pem_name, PEM_STRING_X509_OLD) != 0

                 && strcmp(pem_name, PEM_STRING_X509) != 0)

            /* No match */

            return NULL;

        *matchcount = 1;

    }

    if ((cert = d2i_X509_AUX(NULL, &blob, len)) != NULL

        || (ignore_trusted && (cert = d2i_X509(NULL, &blob, len)) != NULL)) {

        *matchcount = 1;

        store_info = OSSL_STORE_INFO_new_CERT(cert);

    }

    if (store_info == NULL)

        X509_free(cert);

    return store_info;

}

static FILE_HANDLER X509Certificate_handler = {

    "X509Certificate",

    try_decode_X509Certificate

};

/*

 * X.509 CRL decoder.

 */

static OSSL_STORE_INFO *try_decode_X509CRL(const char *pem_name,

                                           const char *pem_header,

                                           const unsigned char *blob,

                                           size_t len, void **pctx,

                                           int *matchcount,

                                           const UI_METHOD *ui_method,

                                           void *ui_data)

{

    OSSL_STORE_INFO *store_info = NULL;

    X509_CRL *crl = NULL;

    if (pem_name != NULL) {

        if (strcmp(pem_name, PEM_STRING_X509_CRL) != 0)

            /* No match */

            return NULL;

        *matchcount = 1;

    }

    if ((crl = d2i_X509_CRL(NULL, &blob, len)) != NULL) {

        *matchcount = 1;

        store_info = OSSL_STORE_INFO_new_CRL(crl);

    }

    if (store_info == NULL)

        X509_CRL_free(crl);

    return store_info;

}

static FILE_HANDLER X509CRL_handler = {

    "X509CRL",

    try_decode_X509CRL

};

/*

 * To finish it all off, we collect all the handlers.

 */

static const FILE_HANDLER *file_handlers[] = {

    &PKCS12_handler,

    &PKCS8Encrypted_handler,

    &X509Certificate_handler,

    &X509CRL_handler,

    &params_handler,

    &PUBKEY_handler,

    &PrivateKey_handler,

};

/*-

 *  The loader itself

 *  -----------------

 */

struct ossl_store_loader_ctx_st {

    enum {

        is_raw = 0,

        is_pem,

        is_dir

    } type;

    int errcnt;

#define FILE_FLAG_SECMEM         (1<<0)

    unsigned int flags;

    union {

        struct {                 /* Used with is_raw and is_pem */

            BIO *file;

            /*

             * The following are used when the handler is marked as

             * repeatable

             */

            const FILE_HANDLER *last_handler;

            void *last_handler_ctx;

        } file;

        struct {                 /* Used with is_dir */

            OPENSSL_DIR_CTX *ctx;

            int end_reached;

            char *uri;

            /*

             * 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 OSSL_STORE_LOADER_CTX_free(OSSL_STORE_LOADER_CTX *ctx)

{

    if (ctx->type == is_dir) {

        OPENSSL_free(ctx->_.dir.uri);

    } else {

        if (ctx->_.file.last_handler != NULL) {

            ctx->_.file.last_handler->destroy_ctx(&ctx->_.file.last_handler_ctx);

            ctx->_.file.last_handler_ctx = NULL;

            ctx->_.file.last_handler = NULL;

        }

    }

    OPENSSL_free(ctx);

}

static OSSL_STORE_LOADER_CTX *file_open(const OSSL_STORE_LOADER *loader,

                                        const char *uri,

                                        const UI_METHOD *ui_method,

                                        void *ui_data)

{

    OSSL_STORE_LOADER_CTX *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;

    /*

     * 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 {

                OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN,

                              OSSL_STORE_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 = ossl_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] != '/') {

            OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN,

                          OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE);

            ERR_add_error_data(1, path_data[i].path);

            return NULL;

        }

        if (stat(path_data[i].path, &st) < 0) {

            SYSerr(SYS_F_STAT, errno);

            ERR_add_error_data(1, path_data[i].path);

        } else {

            path = path_data[i].path;

        }

    }

    if (path == NULL) {

        return NULL;

    }

    /* Successfully found a working path, clear possible collected errors */

    ERR_clear_error();

    ctx = OPENSSL_zalloc(sizeof(*ctx));

    if (ctx == NULL) {

        OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN, ERR_R_MALLOC_FAILURE);

        return NULL;

    }

    if (S_ISDIR(st.st_mode)) {

        /*

         * Try to copy everything, even if we know that some of them must be

         * NULL for the moment.  This prevents errors in the future, when more

         * components may be used.

         */

        ctx->_.dir.uri = OPENSSL_strdup(uri);

        ctx->type = is_dir;

        if (ctx->_.dir.uri == NULL)

            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) {

                char errbuf[256];

                OSSL_STOREerr(OSSL_STORE_F_FILE_OPEN, ERR_R_SYS_LIB);

                errno = ctx->_.dir.last_errno;

                if (openssl_strerror_r(errno, errbuf, sizeof(errbuf)))

                    ERR_add_error_data(1, errbuf);

                goto err;

            }

            ctx->_.dir.end_reached = 1;

        }

    } else {

        BIO *buff = NULL;

        char peekbuf[4096] = { 0, };

        if ((buff = BIO_new(BIO_f_buffer())) == NULL

            || (ctx->_.file.file = BIO_new_file(path, "rb")) == NULL) {

            BIO_free_all(buff);

            goto err;

        }