sys/contrib/zstd/tests/fuzz/simple_round_trip.c

   1 /*
   2  * Copyright (c) 2016-present, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under both the BSD-style license (found in the
   6  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
   7  * in the COPYING file in the root directory of this source tree).
   8  */
   9
  10 /**
  11  * This fuzz target performs a zstd round-trip test (compress & decompress),
  12  * compares the result with the original, and calls abort() on corruption.
  13  */
  14
  15 #define ZSTD_STATIC_LINKING_ONLY
  16
  17 #include <stddef.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include "fuzz_helpers.h"
  22 #include "zstd_helpers.h"
  23
  24 static const int kMaxClevel = 19;
  25
  26 static ZSTD_CCtx *cctx = NULL;
  27 static ZSTD_DCtx *dctx = NULL;
  28 static void* cBuf = NULL;
  29 static void* rBuf = NULL;
  30 static size_t bufSize = 0;
  31 static uint32_t seed;
  32
  33 static size_t roundTripTest(void *result, size_t resultCapacity,
  34                             void *compressed, size_t compressedCapacity,
  35                             const void *src, size_t srcSize)
  36 {
  37     size_t cSize;
  38     if (FUZZ_rand(&seed) & 1) {
  39         ZSTD_inBuffer in = {src, srcSize, 0};
  40         ZSTD_outBuffer out = {compressed, compressedCapacity, 0};
  41         size_t err;
  42
  43         ZSTD_CCtx_reset(cctx);
  44         FUZZ_setRandomParameters(cctx, srcSize, &seed);
  45         err = ZSTD_compress_generic(cctx, &out, &in, ZSTD_e_end);
  46         FUZZ_ZASSERT(err);
  47         FUZZ_ASSERT(err == 0);
  48         cSize = out.pos;
  49     } else {
  50         int const cLevel = FUZZ_rand(&seed) % kMaxClevel;
  51         cSize = ZSTD_compressCCtx(
  52             cctx, compressed, compressedCapacity, src, srcSize, cLevel);
  53     }
  54     FUZZ_ZASSERT(cSize);
  55     return ZSTD_decompressDCtx(dctx, result, resultCapacity, compressed, cSize);
  56 }
  57
  58 int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
  59 {
  60     size_t neededBufSize;
  61
  62     seed = FUZZ_seed(&src, &size);
  63     neededBufSize = ZSTD_compressBound(size);
  64
  65     /* Allocate all buffers and contexts if not already allocated */
  66     if (neededBufSize > bufSize) {
  67         free(cBuf);
  68         free(rBuf);
  69         cBuf = malloc(neededBufSize);
  70         rBuf = malloc(neededBufSize);
  71         bufSize = neededBufSize;
  72         FUZZ_ASSERT(cBuf && rBuf);
  73     }
  74     if (!cctx) {
  75         cctx = ZSTD_createCCtx();
  76         FUZZ_ASSERT(cctx);
  77     }
  78     if (!dctx) {
  79         dctx = ZSTD_createDCtx();
  80         FUZZ_ASSERT(dctx);
  81     }
  82
  83     {
  84         size_t const result =
  85             roundTripTest(rBuf, neededBufSize, cBuf, neededBufSize, src, size);
  86         FUZZ_ZASSERT(result);
  87         FUZZ_ASSERT_MSG(result == size, "Incorrect regenerated size");
  88         FUZZ_ASSERT_MSG(!memcmp(src, rBuf, size), "Corruption!");
  89     }
  90 #ifndef STATEFUL_FUZZING
  91     ZSTD_freeCCtx(cctx); cctx = NULL;
  92     ZSTD_freeDCtx(dctx); dctx = NULL;
  93 #endif
  94     return 0;
  95 }