/src/openssl41/fuzz/provider.c

Source
/*
 * Copyright 2023-2026 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 may obtain a copy of the License at
 * https://www.openssl.org/source/license.html
 * or in the file LICENSE in the source distribution.
 */
#include <string.h>
#include <openssl/types.h>
#include <openssl/crypto.h>
#include <openssl/core_names.h>
#include <openssl/kdf.h>
#include <openssl/evp.h>
#include <openssl/provider.h>
#include "fuzzer.h"

#define DEFINE_ALGORITHMS(name, evp)                                     \
    DEFINE_STACK_OF(evp)                                                 \
    static int cmp_##evp(const evp *const *a, const evp *const *b);      \
    static void collect_##evp(evp *obj, void *stack);                    \
    static void init_##name(OSSL_LIB_CTX *libctx);                       \
    static void cleanup_##name(void);                                    \
    static STACK_OF(evp) *name##_collection;                             \
    static int cmp_##evp(const evp *const *a, const evp *const *b)       \
    {                                                                    \
        return strcmp(OSSL_PROVIDER_get0_name(evp##_get0_provider(*a)),  \
            OSSL_PROVIDER_get0_name(evp##_get0_provider(*b)));           \
    }                                                                    \
    static void collect_##evp(evp *obj, void *stack)                     \
    {                                                                    \
        STACK_OF(evp) *obj_stack = stack;                                \
                                                                         \
        if (!evp##_up_ref(obj))                                          \
            return;                                                      \
                                                                         \
        if (sk_##evp##_push(obj_stack, obj) <= 0)                        \
            evp##_free(obj);                                             \
    }                                                                    \
    static void init_##name(OSSL_LIB_CTX *libctx)                        \
    {                                                                    \
        name##_collection = sk_##evp##_new(cmp_##evp);                   \
        evp##_do_all_provided(libctx, collect_##evp, name##_collection); \
    }                                                                    \
    static void cleanup_##name(void)                                     \
    {                                                                    \
        sk_##evp##_pop_free(name##_collection, evp##_free);              \
    }

DEFINE_ALGORITHMS(digests, EVP_MD)

DEFINE_ALGORITHMS(kdf, EVP_KDF)

DEFINE_ALGORITHMS(cipher, EVP_CIPHER)

DEFINE_ALGORITHMS(kem, EVP_KEM)

DEFINE_ALGORITHMS(keyexch, EVP_KEYEXCH)

DEFINE_ALGORITHMS(rand, EVP_RAND)

DEFINE_ALGORITHMS(mac, EVP_MAC)

DEFINE_ALGORITHMS(keymgmt, EVP_KEYMGMT)

DEFINE_ALGORITHMS(signature, EVP_SIGNATURE)

DEFINE_ALGORITHMS(asym_ciphers, EVP_ASYM_CIPHER)

static OSSL_LIB_CTX *libctx = NULL;

int FuzzerInitialize(int *argc, char ***argv)
{
    libctx = OSSL_LIB_CTX_new();
    if (libctx == NULL)
        return 0;

    init_digests(libctx);
    init_kdf(libctx);
    init_cipher(libctx);
    init_kem(libctx);
    init_keyexch(libctx);
    init_rand(libctx);
    init_mac(libctx);
    init_keymgmt(libctx);
    init_signature(libctx);
    init_asym_ciphers(libctx);
    return 1;
}

void FuzzerCleanup(void)
{
    cleanup_digests();
    cleanup_kdf();
    cleanup_cipher();
    cleanup_kem();
    cleanup_keyexch();
    cleanup_rand();
    cleanup_mac();
    cleanup_keymgmt();
    cleanup_signature();
    cleanup_asym_ciphers();

    OSSL_LIB_CTX_free(libctx);
}

static int read_uint(const uint8_t **buf, size_t *len, uint64_t **res)
{
    int r = 1;

    if (*len < sizeof(uint64_t)) {
        r = 0;
        goto end;
    }

    *res = OPENSSL_malloc(sizeof(uint64_t));
    if (*res == NULL) {
        r = 0;
        goto end;
    }
    **res = (uint64_t)**buf;

    *buf += sizeof(uint64_t);
    *len -= sizeof(uint64_t);
end:
    return r;
}

static int read_int(const uint8_t **buf, size_t *len, int64_t **res)
{
    int r = 1;

    if (*len < sizeof(int64_t)) {
        r = 0;
        goto end;
    }

    *res = OPENSSL_malloc(sizeof(int64_t));
    if (*res == NULL) {
        r = 0;
        goto end;
    }
    **res = (int64_t)**buf;

    *buf += sizeof(int64_t);
    *len -= sizeof(int64_t);
end:
    return r;
}

static int read_double(const uint8_t **buf, size_t *len, double **res)
{
    int r = 1;

    if (*len < sizeof(double)) {
        r = 0;
        goto end;
    }

    *res = OPENSSL_malloc(sizeof(double));
    if (*res == NULL) {
        r = 0;
        goto end;
    }
    **res = (double)**buf;

    *buf += sizeof(double);
    *len -= sizeof(double);
end:
    return r;
}

static int read_utf8_string(const uint8_t **buf, size_t *len, char **res)
{
    size_t found_len;
    int r;

    found_len = OPENSSL_strnlen((const char *)*buf, *len);

    if (found_len == *len) {
        r = -1;
        goto end;
    }

    found_len++; /* skip over the \0 byte */

    r = (int)found_len;

    *res = (char *)*buf;
    *len -= found_len;
    *buf = *buf + found_len; /* continue after the \0 byte */
end:
    return r;
}

static int read_utf8_ptr(const uint8_t **buf, size_t *len, char **res)
{
    if (*len > 0 && **buf == 0xFF) {
        /* represent NULL somehow */
        *res = NULL;
        *buf += 1;
        *len -= 1;
        return 0;
    }
    return read_utf8_string(buf, len, res);
}

static int read_octet_string(const uint8_t **buf, size_t *len, char **res)
{
    int r;
    size_t i;
    const uint8_t *ptr = *buf;
    int found = 0;

    for (i = 0; i < *len; ++i) {
        if (*ptr == 0xFF && (i + 1 < *len && *(ptr + 1) == 0xFF)) {
            ptr++;
            found = 1;
            break;
        }
        ptr++;
    }

    if (!found) {
        r = -1;
        goto end;
    }

    *res = (char *)*buf;

    r = (int)(ptr - *buf);
    *len -= r;
    *buf = ptr;

end:
    return r;
}

static int read_octet_ptr(const uint8_t **buf, size_t *len, char **res)
{
    /* TODO: This representation could need an improvement potentially. */
    if (*len > 1 && **buf == 0xFF && *(*buf + 1) == 0xFF) {
        /* represent NULL somehow */
        *res = NULL;
        *buf += 2;
        *len -= 2;
        return 0;
    }
    return read_octet_string(buf, len, res);
}

static char *DFLT_STR = "";
static char *DFLT_UTF8_PTR = NULL;
static char *DFLT_OCTET_STRING = "";
static char *DFLT_OCTET_PTR = NULL;

static int64_t ITERS = 1;
static uint64_t UITERS = 1;
static int64_t BLOCKSIZE = 8;
static uint64_t UBLOCKSIZE = 8;

static void free_params(OSSL_PARAM *param)
{
    for (; param != NULL && param->key != NULL; param++) {
        switch (param->data_type) {
        case OSSL_PARAM_INTEGER:
        case OSSL_PARAM_UNSIGNED_INTEGER:
        case OSSL_PARAM_REAL:
            if (param->data != NULL) {
                OPENSSL_free(param->data);
            }
            break;
        }
    }
}

static OSSL_PARAM *fuzz_params(OSSL_PARAM *param, const uint8_t **buf, size_t *len)
{
    OSSL_PARAM *p;
    OSSL_PARAM *fuzzed_parameters;
    int p_num = 0;

    for (p = param; p != NULL && p->key != NULL; p++)
        p_num++;

    fuzzed_parameters = OPENSSL_calloc(p_num + 1, sizeof(OSSL_PARAM));
    if (fuzzed_parameters == NULL)
        return NULL;
    p = fuzzed_parameters;

    for (; param != NULL && param->key != NULL; param++) {
        int64_t *use_param = NULL;
        int64_t *p_value_int = NULL;
        uint64_t *p_value_uint = NULL;
        double *p_value_double = NULL;
        char *p_value_utf8_str = DFLT_STR;
        char *p_value_octet_str = DFLT_OCTET_STRING;
        char *p_value_utf8_ptr = DFLT_UTF8_PTR;
        char *p_value_octet_ptr = DFLT_OCTET_PTR;

        int data_len = 0;

        if (!read_int(buf, len, &use_param)) {
            use_param = OPENSSL_malloc(sizeof(uint64_t));
            if (use_param == NULL) {
                free_params(fuzzed_parameters);
                OPENSSL_free(fuzzed_parameters);
                return NULL;
            }
            *use_param = 0;
        }

        switch (param->data_type) {
        case OSSL_PARAM_INTEGER:
            if (strcmp(param->key, OSSL_KDF_PARAM_ITER) == 0) {
                p_value_int = OPENSSL_malloc(sizeof(ITERS));
                if (p_value_int == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_int = ITERS;
            } else if (strcmp(param->key, OSSL_KDF_PARAM_SCRYPT_N) == 0) {
                p_value_int = OPENSSL_malloc(sizeof(ITERS));
                if (p_value_int == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_int = ITERS;
            } else if (strcmp(param->key, OSSL_KDF_PARAM_SCRYPT_R) == 0) {
                p_value_int = OPENSSL_malloc(sizeof(BLOCKSIZE));
                if (p_value_int == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_int = BLOCKSIZE;
            } else if (strcmp(param->key, OSSL_KDF_PARAM_SCRYPT_P) == 0) {
                p_value_int = OPENSSL_malloc(sizeof(BLOCKSIZE));
                if (p_value_int == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_int = BLOCKSIZE;
            } else if (!*use_param || !read_int(buf, len, &p_value_int)) {
                p_value_int = OPENSSL_malloc(sizeof(int64_t));
                if (p_value_int == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_int = 0;
            }

            *p = *param;
            p->data = p_value_int;
            p++;
            break;
        case OSSL_PARAM_UNSIGNED_INTEGER:
            if (strcmp(param->key, OSSL_KDF_PARAM_ITER) == 0) {
                p_value_uint = OPENSSL_malloc(sizeof(UITERS));
                if (p_value_uint == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_uint = UITERS;
            } else if (strcmp(param->key, OSSL_KDF_PARAM_SCRYPT_N) == 0) {
                p_value_uint = OPENSSL_malloc(sizeof(UITERS));
                if (p_value_uint == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_uint = UITERS;
            } else if (strcmp(param->key, OSSL_KDF_PARAM_SCRYPT_R) == 0) {
                p_value_uint = OPENSSL_malloc(sizeof(UBLOCKSIZE));
                if (p_value_uint == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_uint = UBLOCKSIZE;
            } else if (strcmp(param->key, OSSL_KDF_PARAM_SCRYPT_P) == 0) {
                p_value_uint = OPENSSL_malloc(sizeof(UBLOCKSIZE));
                if (p_value_uint == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_uint = UBLOCKSIZE;
            } else if (!*use_param || !read_uint(buf, len, &p_value_uint)) {
                p_value_uint = OPENSSL_malloc(sizeof(uint64_t));
                if (p_value_uint == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_uint = 0;
            }

            *p = *param;
            p->data = p_value_uint;
            p++;
            break;
        case OSSL_PARAM_REAL:
            if (!*use_param || !read_double(buf, len, &p_value_double)) {
                p_value_double = OPENSSL_malloc(sizeof(double));
                if (p_value_double == NULL) {
                    free_params(fuzzed_parameters);
                    OPENSSL_free(fuzzed_parameters);
                    OPENSSL_free(use_param);
                    return NULL;
                }
                *p_value_double = 0;
            }

            *p = *param;
            p->data = p_value_double;
            p++;
            break;
        case OSSL_PARAM_UTF8_STRING:
            if (*use_param && (data_len = read_utf8_string(buf, len, &p_value_utf8_str)) < 0)
                data_len = 0;
            *p = *param;
            p->data = p_value_utf8_str;
            p->data_size = data_len;
            p++;
            break;
        case OSSL_PARAM_OCTET_STRING:
            if (*use_param && (data_len = read_octet_string(buf, len, &p_value_octet_str)) < 0)
                data_len = 0;
            *p = *param;
            p->data = p_value_octet_str;
            p->data_size = data_len;
            p++;
            break;
        case OSSL_PARAM_UTF8_PTR:
            if (*use_param && (data_len = read_utf8_ptr(buf, len, &p_value_utf8_ptr)) < 0)
                data_len = 0;
            *p = *param;
            p->data = p_value_utf8_ptr;
            p->data_size = data_len;
            p++;
            break;
        case OSSL_PARAM_OCTET_PTR:
            if (*use_param && (data_len = read_octet_ptr(buf, len, &p_value_octet_ptr)) < 0)
                data_len = 0;
            *p = *param;
            p->data = p_value_octet_ptr;
            p->data_size = data_len;
            p++;
            break;
        default:
            break;
        }

        OPENSSL_free(use_param);
    }

    return fuzzed_parameters;
}

static int do_evp_cipher(const EVP_CIPHER *evp_cipher, const OSSL_PARAM param[])
{
    unsigned char outbuf[1024];
    int outlen, tmplen;
    int key_len = EVP_CIPHER_get_key_length(evp_cipher);
    int iv_len = EVP_CIPHER_get_iv_length(evp_cipher);
    unsigned char *key = NULL, *iv = NULL;
    const char intext[] = "text";
    EVP_CIPHER_CTX *ctx = NULL;
    int i;

    if (key_len <= 0)
        key_len = 16;
    if (iv_len <= 0)
        iv_len = 16;

    key = OPENSSL_zalloc(key_len);
    iv = OPENSSL_zalloc(iv_len);
    if (key == NULL || iv == NULL)
        goto err;
    for (i = 0; i < key_len; i++)
        key[i] = (unsigned char)i;
    for (i = 0; i < iv_len; i++)
        iv[i] = (unsigned char)(i + 1);

    ctx = EVP_CIPHER_CTX_new();
    if (ctx == NULL)
        goto err;

    if (!EVP_EncryptInit_ex2(ctx, evp_cipher, key, iv, NULL))
        goto err;

    if (!EVP_CIPHER_CTX_set_params(ctx, param))
        goto err;

    if (!EVP_EncryptUpdate(ctx, outbuf, &outlen, (const unsigned char *)intext,
            (int)strlen(intext)))
        goto err;
    /*
     * Buffer passed to EVP_EncryptFinal() must be after data just
     * encrypted to avoid overwriting it.
     */
    if (!EVP_EncryptFinal_ex(ctx, outbuf + outlen, &tmplen))
        goto err;
    outlen += tmplen;
    EVP_CIPHER_CTX_free(ctx);
    OPENSSL_free(key);
    OPENSSL_free(iv);
    return 1;

err:
    EVP_CIPHER_CTX_free(ctx);
    OPENSSL_free(key);
    OPENSSL_free(iv);
    return 0;
}

static int do_evp_kdf(EVP_KDF *evp_kdf, const OSSL_PARAM params[])
{
    int r = 1;
    EVP_KDF_CTX *kctx = NULL;
    unsigned char derived[32];

    kctx = EVP_KDF_CTX_new(evp_kdf);

    if (kctx == NULL) {
        r = 0;
        goto end;
    }

    if (EVP_KDF_CTX_set_params(kctx, params) <= 0) {
        r = 0;
        goto end;
    }

    if (EVP_KDF_derive(kctx, derived, sizeof(derived), NULL) <= 0) {
        r = 0;
        goto end;
    }

end:
    EVP_KDF_CTX_free(kctx);
    return r;
}

static int do_evp_mac(EVP_MAC *evp_mac, const OSSL_PARAM params[])
{
    int r = 1;
    const char *key = "mac_key";
    char text[] = "Some Crypto Text";
    EVP_MAC_CTX *ctx = NULL;
    unsigned char buf[4096];
    size_t final_l;

    if ((ctx = EVP_MAC_CTX_new(evp_mac)) == NULL
        || !EVP_MAC_init(ctx, (const unsigned char *)key, strlen(key),
            params)) {
        r = 0;
        goto end;
    }

    if (EVP_MAC_CTX_set_params(ctx, params) <= 0) {
        r = 0;
        goto end;
    }

    if (!EVP_MAC_update(ctx, (unsigned char *)text, sizeof(text))) {
        r = 0;
        goto end;
    }

    if (!EVP_MAC_final(ctx, buf, &final_l, sizeof(buf))) {
        r = 0;
        goto end;
    }

end:
    EVP_MAC_CTX_free(ctx);
    return r;
}

static int do_evp_rand(EVP_RAND *evp_rand, const OSSL_PARAM params[])
{
    int r = 1;
    EVP_RAND_CTX *ctx = NULL;
    unsigned char buf[4096];

    if (!(ctx = EVP_RAND_CTX_new(evp_rand, NULL))) {
        r = 0;
        goto end;
    }

    if (EVP_RAND_CTX_set_params(ctx, params) <= 0) {
        r = 0;
        goto end;
    }

    if (!EVP_RAND_generate(ctx, buf, sizeof(buf), 0, 0, NULL, 0)) {
        r = 0;
        goto end;
    }

    if (!EVP_RAND_reseed(ctx, 0, 0, 0, NULL, 0)) {
        r = 0;
        goto end;
    }

end:
    EVP_RAND_CTX_free(ctx);
    return r;
}

static int do_evp_sig(EVP_SIGNATURE *evp_sig, const OSSL_PARAM params[])
{
    return 0;
}

static int do_evp_asym_cipher(EVP_ASYM_CIPHER *evp_asym_cipher, const OSSL_PARAM params[])
{
    return 0;
}

static int do_evp_kem(EVP_KEM *evp_kem, const OSSL_PARAM params[])
{
    return 0;
}

static int do_evp_key_exch(EVP_KEYEXCH *evp_kdf, const OSSL_PARAM params[])
{
    return 0;
}

static int do_evp_md(EVP_MD *evp_md, const OSSL_PARAM params[])
{
    int r = 1;
    unsigned char md_value[EVP_MAX_MD_SIZE];
    unsigned int md_len;
    EVP_MD_CTX *mdctx = NULL;

    if (!(mdctx = EVP_MD_CTX_new())) {
        r = 0;
        goto end;
    }

    if (!EVP_DigestInit_ex2(mdctx, evp_md, NULL)) {
        r = 0;
        goto end;
    }

    if (!EVP_MD_CTX_set_params(mdctx, params)) {
        r = 0;
        goto end;
    }
    if (!EVP_DigestUpdate(mdctx, "Test", strlen("Test"))) {
        r = 0;
        goto end;
    }
    if (!EVP_DigestFinal_ex(mdctx, md_value, &md_len)) {
        r = 0;
        goto end;
    }

end:
    EVP_MD_CTX_free(mdctx);
    return r;
}

#define EVP_FUZZ(source, evp, f)                                                               \
    do {                                                                                       \
        evp *alg = sk_##evp##_value(source, *algorithm % sk_##evp##_num(source));              \
        OSSL_PARAM *fuzzed_params;                                                             \
                                                                                               \
        if (alg == NULL)                                                                       \
            break;                                                                             \
        fuzzed_params = fuzz_params((OSSL_PARAM *)evp##_settable_ctx_params(alg), &buf, &len); \
        if (fuzzed_params != NULL)                                                             \
            f(alg, fuzzed_params);                                                             \
        free_params(fuzzed_params);                                                            \
        OSSL_PARAM_free(fuzzed_params);                                                        \
    } while (0);

int FuzzerTestOneInput(const uint8_t *buf, size_t len)
{
    int r = 1;
    uint64_t *operation = NULL;
    int64_t *algorithm = NULL;

    if (!read_uint(&buf, &len, &operation)) {
        r = 0;
        goto end;
    }

    if (!read_int(&buf, &len, &algorithm)) {
        r = 0;
        goto end;
    }

    switch (*operation % 10) {
    case 0:
        EVP_FUZZ(digests_collection, EVP_MD, do_evp_md);
        break;
    case 1:
        EVP_FUZZ(cipher_collection, EVP_CIPHER, do_evp_cipher);
        break;
    case 2:
        EVP_FUZZ(kdf_collection, EVP_KDF, do_evp_kdf);
        break;
    case 3:
        EVP_FUZZ(mac_collection, EVP_MAC, do_evp_mac);
        break;
    case 4:
        EVP_FUZZ(kem_collection, EVP_KEM, do_evp_kem);
        break;
    case 5:
        EVP_FUZZ(rand_collection, EVP_RAND, do_evp_rand);
        break;
    case 6:
        EVP_FUZZ(asym_ciphers_collection, EVP_ASYM_CIPHER, do_evp_asym_cipher);
        break;
    case 7:
        EVP_FUZZ(signature_collection, EVP_SIGNATURE, do_evp_sig);
        break;
    case 8:
        EVP_FUZZ(keyexch_collection, EVP_KEYEXCH, do_evp_key_exch);
        break;
    case 9:
        /*
        Implement and call:
        static int do_evp_keymgmt(EVP_KEYMGMT *evp_kdf, const OSSL_PARAM params[])
        {
            return 0;
        }
        */
        /* not yet implemented */
        break;
    default:
        r = 0;
        goto end;
    }

end:
    OPENSSL_free(operation);
    OPENSSL_free(algorithm);
    return r;
}

Coverage Report

Created: 2026-10-28 06:28