1 files changed, 419 insertions, 0 deletions

diff --git a/fuzz/wrap.c b/fuzz/wrap.c
new file mode 100644
index 0000000..8ff7ee7
--- /dev/null
+++ b/fuzz/wrap.c
@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2019 Yubico AB. All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+#include <openssl/bn.h>
+#include <openssl/evp.h>
+#include <openssl/sha.h>
+
+#include <cbor.h>
+#include <fido.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "mutator_aux.h"
+
+/*
+ * Build wrappers around functions of interest, and have them fail
+ * in a pseudo-random manner.
+ */
+
+#define WRAP(type, name, args, retval, param, prob)     \
+extern type __wrap_##name args;                         \
+extern type __real_##name args;                         \
+type __wrap_##name args {                               \
+        if (uniform_random(400) < (prob)) {             \
+                return (retval);                        \
+        }                                               \
+                                                        \
+        return (__real_##name param);                   \
+}
+
+WRAP(void *,
+        malloc,
+        (size_t size),
+        NULL,
+        (size),
+        1
+)
+
+WRAP(void *,
+        calloc,
+        (size_t nmemb, size_t size),
+        NULL,
+        (nmemb, size),
+        1
+)
+
+WRAP(char *,
+        strdup,
+        (const char *s),
+        NULL,
+        (s),
+        1
+)
+
+WRAP(EVP_CIPHER_CTX *,
+        EVP_CIPHER_CTX_new,
+        (void),
+        NULL,
+        (),
+        1
+)
+
+WRAP(int, EVP_EncryptInit_ex,
+        (EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *impl,
+            const unsigned char *key, const unsigned char *iv),
+        0,
+        (ctx, type, impl, key, iv),
+        1
+)
+
+WRAP(int,
+        EVP_CIPHER_CTX_set_padding,
+        (EVP_CIPHER_CTX *x, int padding),
+        0,
+        (x, padding),
+        1
+)
+
+WRAP(int,
+        EVP_EncryptUpdate,
+        (EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
+            const unsigned char *in, int inl),
+        0,
+        (ctx, out, outl, in, inl),
+        1
+)
+
+WRAP(int,
+        EVP_DecryptInit_ex,
+        (EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *impl,
+            const unsigned char *key, const unsigned char *iv),
+        0,
+        (ctx, type, impl, key, iv),
+        1
+)
+
+WRAP(int,
+        EVP_DecryptUpdate,
+        (EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
+            const unsigned char *in, int inl),
+        0,
+        (ctx, out, outl, in, inl),
+        1
+)
+
+WRAP(int,
+        SHA256_Init,
+        (SHA256_CTX *c),
+        0,
+        (c),
+        1
+)
+
+WRAP(int,
+        SHA256_Update,
+        (SHA256_CTX *c, const void *data, size_t len),
+        0,
+        (c, data, len),
+        1
+)
+
+WRAP(int,
+        SHA256_Final,
+        (unsigned char *md, SHA256_CTX *c),
+        0,
+        (md, c),
+        1
+)
+
+WRAP(RSA *,
+        EVP_PKEY_get0_RSA,
+        (EVP_PKEY *pkey),
+        NULL,
+        (pkey),
+        1
+)
+
+WRAP(EVP_MD_CTX *,
+        EVP_MD_CTX_new,
+        (void),
+        NULL,
+        (),
+        1
+)
+
+WRAP(int,
+        EVP_DigestVerifyInit,
+        (EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type, ENGINE *e,
+            EVP_PKEY *pkey),
+        0,
+        (ctx, pctx, type, e, pkey),
+        1
+)
+
+WRAP(BIGNUM *,
+        BN_bin2bn,
+        (const unsigned char *s, int len, BIGNUM *ret),
+        NULL,
+        (s, len, ret),
+        1
+)
+
+WRAP(BIGNUM *,
+        BN_CTX_get,
+        (BN_CTX *ctx),
+        NULL,
+        (ctx),
+        1
+)
+
+WRAP(BN_CTX *,
+        BN_CTX_new,
+        (void),
+        NULL,
+        (),
+        1
+)
+
+WRAP(BIGNUM *,
+        BN_new,
+        (void),
+        NULL,
+        (),
+        1
+)
+
+WRAP(int,
+        RSA_set0_key,
+        (RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d),
+        0,
+        (r, n, e, d),
+        1
+)
+
+WRAP(EC_KEY *,
+        EC_KEY_new_by_curve_name,
+        (int nid),
+        NULL,
+        (nid),
+        1
+)
+
+WRAP(const EC_GROUP *,
+        EC_KEY_get0_group,
+        (const EC_KEY *key),
+        NULL,
+        (key),
+        1
+)
+
+WRAP(EC_POINT *,
+        EC_POINT_new,
+        (const EC_GROUP *group),
+        NULL,
+        (group),
+        1
+)
+
+WRAP(EVP_PKEY *,
+        EVP_PKEY_new,
+        (void),
+        NULL,
+        (),
+        1
+)
+
+WRAP(int,
+        EVP_PKEY_assign,
+        (EVP_PKEY *pkey, int type, void *key),
+        0,
+        (pkey, type, key),
+        1
+)
+
+WRAP(EVP_PKEY *,
+        EVP_PKEY_new_raw_public_key,
+        (int type, ENGINE *e, const unsigned char *key, size_t keylen),
+        NULL,
+        (type, e, key, keylen),
+        1
+)
+
+WRAP(EVP_PKEY_CTX *,
+        EVP_PKEY_CTX_new,
+        (EVP_PKEY *pkey, ENGINE *e),
+        NULL,
+        (pkey, e),
+        1
+)
+
+WRAP(int,
+        EVP_PKEY_derive_init,
+        (EVP_PKEY_CTX *ctx),
+        0,
+        (ctx),
+        1
+)
+
+WRAP(int,
+        EVP_PKEY_derive_set_peer,
+        (EVP_PKEY_CTX *ctx, EVP_PKEY *peer),
+        0,
+        (ctx, peer),
+        1
+)
+
+WRAP(const EVP_MD *,
+        EVP_sha256,
+        (void),
+        NULL,
+        (),
+        1
+)
+
+WRAP(unsigned char *,
+        HMAC,
+        (const EVP_MD *evp_md, const void *key, int key_len,
+            const unsigned char *d, int n, unsigned char *md,
+            unsigned int *md_len),
+        NULL,
+        (evp_md, key, key_len, d, n, md, md_len),
+        1
+)
+
+WRAP(HMAC_CTX *,
+        HMAC_CTX_new,
+        (void),
+        NULL,
+        (),
+        1
+)
+
+WRAP(int,
+        HMAC_Init_ex,
+        (HMAC_CTX *ctx, const void *key, int key_len, const EVP_MD *md,
+            ENGINE *impl),
+        0,
+        (ctx, key, key_len, md, impl),
+        1
+)
+
+WRAP(int,
+        HMAC_Update,
+        (HMAC_CTX *ctx, const unsigned char *data, int len),
+        0,
+        (ctx, data, len),
+        1
+)
+
+WRAP(int,
+        HMAC_Final,
+        (HMAC_CTX *ctx, unsigned char *md, unsigned int *len),
+        0,
+        (ctx, md, len),
+        1
+)
+
+WRAP(unsigned char *,
+        SHA256,
+        (const unsigned char *d, size_t n, unsigned char *md),
+        NULL,
+        (d, n, md),
+        1
+)
+
+WRAP(cbor_item_t *,
+        cbor_build_string,
+        (const char *val),
+        NULL,
+        (val),
+        1
+)
+
+WRAP(cbor_item_t *,
+        cbor_build_bytestring,
+        (cbor_data handle, size_t length),
+        NULL,
+        (handle, length),
+        1
+)
+
+WRAP(cbor_item_t *,
+        cbor_load,
+        (cbor_data source, size_t source_size, struct cbor_load_result *result),
+        NULL,
+        (source, source_size, result),
+        1
+)
+
+WRAP(cbor_item_t *,
+        cbor_build_uint8,
+        (uint8_t value),
+        NULL,
+        (value),
+        1
+)
+
+WRAP(struct cbor_pair *,
+        cbor_map_handle,
+        (const cbor_item_t *item),
+        NULL,
+        (item),
+        1
+)
+
+WRAP(cbor_item_t **,
+        cbor_array_handle,
+        (const cbor_item_t *item),
+        NULL,
+        (item),
+        1
+)
+
+WRAP(bool,
+        cbor_map_add,
+        (cbor_item_t *item, struct cbor_pair pair),
+        false,
+        (item, pair),
+        1
+)
+
+WRAP(cbor_item_t *,
+        cbor_new_definite_map,
+        (size_t size),
+        NULL,
+        (size),
+        1
+)
+
+WRAP(size_t,
+        cbor_serialize_alloc,
+        (const cbor_item_t *item, cbor_mutable_data *buffer,
+            size_t *buffer_size),
+        0,
+        (item, buffer, buffer_size),
+        1
+)
+
+WRAP(int,
+        fido_tx,
+        (fido_dev_t *d, uint8_t cmd, const void *buf, size_t count),
+        -1,
+        (d, cmd, buf, count),
+        1
+)
+
+WRAP(int,
+        usleep,
+        (unsigned int usec),
+        -1,
+        (usec),
+        1
+)