electrobun 0.0.1 → 0.0.2

package/src/bsdiff/zstd/tests/fuzz/huf_round_trip.c

@@ -1,137 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target performs a zstd round-trip test (compress & decompress),
- * compares the result with the original, and calls abort() on corruption.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "common/cpu.h"
-#include "compress/hist.h"
-#include "common/huf.h"
-#include "fuzz_helpers.h"
-#include "fuzz_data_producer.h"
-#include "common/bits.h"
-
-static size_t adjustTableLog(size_t tableLog, size_t maxSymbol)
-{
-    size_t const alphabetSize = maxSymbol + 1;
-    size_t minTableLog = ZSTD_highbit32(alphabetSize) + 1;
-    if ((alphabetSize & (alphabetSize - 1)) != 0) {
-        ++minTableLog;
-    }
-    assert(minTableLog <= 9);
-    if (tableLog < minTableLog)
-        return minTableLog;
-    else
-        return tableLog;
-}
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    /* Select random parameters: #streams, X1 or X2 decoding, bmi2 */
-    int const streams = FUZZ_dataProducer_int32Range(producer, 0, 1);
-    int const symbols = FUZZ_dataProducer_int32Range(producer, 0, 1);
-    int const flags = 0
-        | (ZSTD_cpuid_bmi2(ZSTD_cpuid()) && FUZZ_dataProducer_int32Range(producer, 0, 1) ? HUF_flags_bmi2 : 0)
-        | (FUZZ_dataProducer_int32Range(producer, 0, 1) ? HUF_flags_optimalDepth : 0)
-        | (FUZZ_dataProducer_int32Range(producer, 0, 1) ? HUF_flags_preferRepeat : 0)
-        | (FUZZ_dataProducer_int32Range(producer, 0, 1) ? HUF_flags_suspectUncompressible : 0)
-        | (FUZZ_dataProducer_int32Range(producer, 0, 1) ? HUF_flags_disableAsm : 0)
-        | (FUZZ_dataProducer_int32Range(producer, 0, 1) ? HUF_flags_disableFast : 0);
-    /* Select a random cBufSize - it may be too small */
-    size_t const cBufSize = FUZZ_dataProducer_uint32Range(producer, 0, 4 * size);
-    /* Select a random tableLog - we'll adjust it up later */
-    size_t tableLog = FUZZ_dataProducer_uint32Range(producer, 1, 12);
-    size_t const kMaxSize = 256 * 1024;
-    size = FUZZ_dataProducer_remainingBytes(producer);
-    if (size > kMaxSize)
-        size = kMaxSize;
-
-    if (size <= 1) {
-        FUZZ_dataProducer_free(producer);
-        return 0;
-    }
-
-    uint32_t maxSymbol = 255;
-
-    U32 count[256];
-    size_t const mostFrequent = HIST_count(count, &maxSymbol, src, size);
-    FUZZ_ZASSERT(mostFrequent);
-    if (mostFrequent == size) {
-        /* RLE */
-        FUZZ_dataProducer_free(producer);
-        return 0;
-
-    }
-    FUZZ_ASSERT(maxSymbol <= 255);
-    tableLog = adjustTableLog(tableLog, maxSymbol);
-
-    size_t const wkspSize = HUF_WORKSPACE_SIZE;
-    void* wksp = FUZZ_malloc(wkspSize);
-    void* rBuf = FUZZ_malloc(size);
-    void* cBuf = FUZZ_malloc(cBufSize);
-    HUF_CElt* ct = (HUF_CElt*)FUZZ_malloc(HUF_CTABLE_SIZE(maxSymbol));
-    HUF_DTable* dt = (HUF_DTable*)FUZZ_malloc(HUF_DTABLE_SIZE(tableLog) * sizeof(HUF_DTable));
-    dt[0] = tableLog * 0x01000001;
-
-    tableLog = HUF_optimalTableLog(tableLog, size, maxSymbol, wksp, wkspSize, ct, count, flags);
-    FUZZ_ASSERT(tableLog <= 12);
-    tableLog = HUF_buildCTable_wksp(ct, count, maxSymbol, tableLog, wksp, wkspSize);
-    FUZZ_ZASSERT(tableLog);
-    size_t const tableSize = HUF_writeCTable_wksp(cBuf, cBufSize, ct, maxSymbol, tableLog, wksp, wkspSize);
-    if (ERR_isError(tableSize)) {
-        /* Errors on uncompressible data or cBufSize too small */
-        goto _out;
-    }
-    FUZZ_ZASSERT(tableSize);
-    if (symbols == 0) {
-        FUZZ_ZASSERT(HUF_readDTableX1_wksp(dt, cBuf, tableSize, wksp, wkspSize, flags));
-    } else {
-        size_t const ret = HUF_readDTableX2_wksp(dt, cBuf, tableSize, wksp, wkspSize, flags);
-        if (ERR_getErrorCode(ret) == ZSTD_error_tableLog_tooLarge) {
-            FUZZ_ZASSERT(HUF_readDTableX1_wksp(dt, cBuf, tableSize, wksp, wkspSize, flags));
-        } else {
-            FUZZ_ZASSERT(ret);
-        }
-    }
-
-    size_t cSize;
-    size_t rSize;
-    if (streams == 0) {
-        cSize = HUF_compress1X_usingCTable(cBuf, cBufSize, src, size, ct, flags);
-        FUZZ_ZASSERT(cSize);
-        if (cSize != 0)
-            rSize = HUF_decompress1X_usingDTable(rBuf, size, cBuf, cSize, dt, flags);
-    } else {
-        cSize = HUF_compress4X_usingCTable(cBuf, cBufSize, src, size, ct, flags);
-        FUZZ_ZASSERT(cSize);
-        if (cSize != 0)
-            rSize = HUF_decompress4X_usingDTable(rBuf, size, cBuf, cSize, dt, flags);
-    }
-    if (cSize != 0) {
-        FUZZ_ZASSERT(rSize);
-        FUZZ_ASSERT_MSG(rSize == size, "Incorrect regenerated size");
-        FUZZ_ASSERT_MSG(!FUZZ_memcmp(src, rBuf, size), "Corruption!");
-    }
-_out:
-    free(rBuf);
-    free(cBuf);
-    free(ct);
-    free(dt);
-    free(wksp);
-    FUZZ_dataProducer_free(producer);
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/raw_dictionary_round_trip.c

@@ -1,119 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/**
- * This fuzz target performs a zstd round-trip test (compress & decompress) with
- * a raw content dictionary, compares the result with the original, and calls
- * abort() on corruption.
- */
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "fuzz_helpers.h"
-#include "zstd_helpers.h"
-#include "fuzz_data_producer.h"
-#include "fuzz_third_party_seq_prod.h"
-
-static ZSTD_CCtx *cctx = NULL;
-static ZSTD_DCtx *dctx = NULL;
-
-static size_t roundTripTest(void *result, size_t resultCapacity,
-                            void *compressed, size_t compressedCapacity,
-                            const void *src, size_t srcSize,
-                            const void *dict, size_t dictSize,
-                            FUZZ_dataProducer_t *producer)
-{
-    ZSTD_dictContentType_e const dictContentType = ZSTD_dct_rawContent;
-    int const refPrefix = FUZZ_dataProducer_uint32Range(producer, 0, 1) != 0;
-    size_t cSize;
-
-    FUZZ_setRandomParameters(cctx, srcSize, producer);
-    /* Disable checksum so we can use sizes smaller than compress bound. */
-    FUZZ_ZASSERT(ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 0));
-    if (refPrefix)
-        FUZZ_ZASSERT(ZSTD_CCtx_refPrefix_advanced(
-            cctx, dict, dictSize,
-            ZSTD_dct_rawContent));
-    else
-        FUZZ_ZASSERT(ZSTD_CCtx_loadDictionary_advanced(
-            cctx, dict, dictSize,
-            (ZSTD_dictLoadMethod_e)FUZZ_dataProducer_uint32Range(producer, 0, 1),
-            ZSTD_dct_rawContent));
-    cSize = ZSTD_compress2(cctx, compressed, compressedCapacity, src, srcSize);
-    FUZZ_ZASSERT(cSize);
-
-    if (refPrefix)
-        FUZZ_ZASSERT(ZSTD_DCtx_refPrefix_advanced(
-            dctx, dict, dictSize,
-            dictContentType));
-    else
-        FUZZ_ZASSERT(ZSTD_DCtx_loadDictionary_advanced(
-            dctx, dict, dictSize,
-            (ZSTD_dictLoadMethod_e)FUZZ_dataProducer_uint32Range(producer, 0, 1),
-            dictContentType));
-    {
-        size_t const ret = ZSTD_decompressDCtx(
-                dctx, result, resultCapacity, compressed, cSize);
-        return ret;
-    }
-}
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    FUZZ_SEQ_PROD_SETUP();
-
-    /* Give a random portion of src data to the producer, to use for
-    parameter generation. The rest will be used for (de)compression */
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    size = FUZZ_dataProducer_reserveDataPrefix(producer);
-
-    uint8_t const* const srcBuf = src;
-    size_t const srcSize = FUZZ_dataProducer_uint32Range(producer, 0, size);
-    uint8_t const* const dictBuf = srcBuf + srcSize;
-    size_t const dictSize = size - srcSize;
-    size_t const decompSize = srcSize;
-    void* const decompBuf = FUZZ_malloc(decompSize);
-    size_t compSize = ZSTD_compressBound(srcSize);
-    void* compBuf;
-    /* Half of the time fuzz with a 1 byte smaller output size.
-     * This will still succeed because we force the checksum to be disabled,
-     * giving us 4 bytes of overhead.
-     */
-    compSize -= FUZZ_dataProducer_uint32Range(producer, 0, 1);
-    compBuf = FUZZ_malloc(compSize);
-
-    if (!cctx) {
-        cctx = ZSTD_createCCtx();
-        FUZZ_ASSERT(cctx);
-    }
-    if (!dctx) {
-        dctx = ZSTD_createDCtx();
-        FUZZ_ASSERT(dctx);
-    }
-
-    {
-        size_t const result =
-            roundTripTest(decompBuf, decompSize, compBuf, compSize, srcBuf, srcSize, dictBuf, dictSize, producer);
-        FUZZ_ZASSERT(result);
-        FUZZ_ASSERT_MSG(result == srcSize, "Incorrect regenerated size");
-        FUZZ_ASSERT_MSG(!FUZZ_memcmp(src, decompBuf, srcSize), "Corruption!");
-    }
-    free(decompBuf);
-    free(compBuf);
-    FUZZ_dataProducer_free(producer);
-#ifndef STATEFUL_FUZZING
-    ZSTD_freeCCtx(cctx); cctx = NULL;
-    ZSTD_freeDCtx(dctx); dctx = NULL;
-#endif
-    FUZZ_SEQ_PROD_TEARDOWN();
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/regression_driver.c

@@ -1,90 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "fuzz.h"
-#include "fuzz_helpers.h"
-#include "util.h"
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-int main(int argc, char const **argv) {
-  size_t const kMaxFileSize = (size_t)1 << 27;
-  int const kFollowLinks = 1;
-  FileNamesTable* files;
-  const char** const fnTable = argv + 1;
-  uint8_t *buffer = NULL;
-  size_t bufferSize = 0;
-  unsigned i;
-  unsigned numFilesTested = 0;
-  int ret = 0;
-
-  {
-    unsigned const numFiles = (unsigned)(argc - 1);
-#ifdef UTIL_HAS_CREATEFILELIST
-    files = UTIL_createExpandedFNT(fnTable, numFiles, kFollowLinks);
-#else
-    files = UTIL_createFNT_fromROTable(fnTable, numFiles);
-    assert(numFiles == files->tableSize);
-#endif
-  }
-  if (!files) {
-    fprintf(stderr, "ERROR: Failed to create file names table\n");
-    return 1;
-  }
-  if (files->tableSize == 0)
-    fprintf(stderr, "WARNING: No files passed to %s\n", argv[0]);
-  for (i = 0; i < files->tableSize; ++i) {
-    char const *fileName = files->fileNames[i];
-    size_t const fileSize = UTIL_getFileSize(fileName);
-    size_t readSize;
-    FILE *file;
-
-    DEBUGLOG(3, "Running %s", fileName);
-
-    /* Check that it is a regular file, and that the fileSize is valid.
-     * If it is not a regular file, then it may have been deleted since we
-     * constructed the list, so just skip it, but return an error exit code.
-     */
-    if (!UTIL_isRegularFile(fileName)) {
-      ret = 1;
-      continue;
-    }
-    FUZZ_ASSERT_MSG(fileSize <= kMaxFileSize, fileName);
-    /* Ensure we have a large enough buffer allocated */
-    if (fileSize > bufferSize) {
-      free(buffer);
-      buffer = (uint8_t *)malloc(fileSize);
-      FUZZ_ASSERT_MSG(buffer, fileName);
-      bufferSize = fileSize;
-    }
-    /* Open the file */
-    file = fopen(fileName, "rb");
-    FUZZ_ASSERT_MSG(file, fileName);
-    /* Read the file */
-    readSize = fread(buffer, 1, fileSize, file);
-    FUZZ_ASSERT_MSG(readSize == fileSize, fileName);
-    /* Close the file */
-    fclose(file);
-    /* Run the fuzz target */
-    LLVMFuzzerTestOneInput(buffer, fileSize);
-    ++numFilesTested;
-  }
-  fprintf(stderr, "Tested %u files: ", numFilesTested);
-  if (ret == 0) {
-    fprintf(stderr, "Success!\n");
-  } else {
-    fprintf(stderr, "Failure!\n");
-  }
-  free(buffer);
-  UTIL_freeFileNamesTable(files);
-  return ret;
-}

package/src/bsdiff/zstd/tests/fuzz/seekable_roundtrip.c

@@ -1,88 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "zstd.h"
-#include "zstd_seekable.h"
-#include "fuzz_helpers.h"
-#include "fuzz_data_producer.h"
-
-static ZSTD_seekable *stream = NULL;
-static ZSTD_seekable_CStream *zscs = NULL;
-static const size_t kSeekableOverheadSize = ZSTD_seekTableFooterSize;
-
-int LLVMFuzzerTestOneInput(const uint8_t *src, size_t size)
-{
-    /* Give a random portion of src data to the producer, to use for
-    parameter generation. The rest will be used for (de)compression */
-    FUZZ_dataProducer_t *producer = FUZZ_dataProducer_create(src, size);
-    size = FUZZ_dataProducer_reserveDataPrefix(producer);
-    size_t const compressedBufferSize = ZSTD_compressBound(size) + kSeekableOverheadSize;
-    uint8_t* compressedBuffer = (uint8_t*)malloc(compressedBufferSize);
-    uint8_t* decompressedBuffer = (uint8_t*)malloc(size);
-
-    int const cLevel = FUZZ_dataProducer_int32Range(producer, ZSTD_minCLevel(), ZSTD_maxCLevel());
-    unsigned const checksumFlag = FUZZ_dataProducer_int32Range(producer, 0, 1);
-    size_t const uncompressedSize = FUZZ_dataProducer_uint32Range(producer, 0, size);
-    size_t const offset = FUZZ_dataProducer_uint32Range(producer, 0, size - uncompressedSize);
-    size_t seekSize;
-
-    if (!zscs) {
-        zscs = ZSTD_seekable_createCStream();
-        FUZZ_ASSERT(zscs);
-    }
-    if (!stream) {
-        stream = ZSTD_seekable_create();
-        FUZZ_ASSERT(stream);
-    }
-
-    {   /* Perform a compression */
-        size_t const initStatus = ZSTD_seekable_initCStream(zscs, cLevel, checksumFlag, size);
-        size_t endStatus;
-        ZSTD_outBuffer out = { .dst=compressedBuffer, .pos=0, .size=compressedBufferSize };
-        ZSTD_inBuffer  in  = { .src=src, .pos=0, .size=size };
-        FUZZ_ASSERT(!ZSTD_isError(initStatus));
-
-        do {
-            size_t cSize = ZSTD_seekable_compressStream(zscs, &out, &in);
-            FUZZ_ASSERT(!ZSTD_isError(cSize));
-        } while (in.pos != in.size);
-
-        FUZZ_ASSERT(in.pos == in.size);
-        endStatus = ZSTD_seekable_endStream(zscs, &out);
-        FUZZ_ASSERT(!ZSTD_isError(endStatus));
-        seekSize = out.pos;
-    }
-
-    {   /* Decompress at an offset */
-        size_t const initStatus = ZSTD_seekable_initBuff(stream, compressedBuffer, seekSize);
-        size_t decompressedBytesTotal = 0;
-        size_t dSize;
-
-        FUZZ_ZASSERT(initStatus);
-        do {
-            dSize = ZSTD_seekable_decompress(stream, decompressedBuffer, uncompressedSize, offset);
-            FUZZ_ASSERT(!ZSTD_isError(dSize));
-            decompressedBytesTotal += dSize;
-        } while (decompressedBytesTotal < uncompressedSize && dSize > 0);
-        FUZZ_ASSERT(decompressedBytesTotal == uncompressedSize);
-    }
-
-    FUZZ_ASSERT_MSG(!FUZZ_memcmp(src+offset, decompressedBuffer, uncompressedSize), "Corruption!");
-
-    free(decompressedBuffer);
-    free(compressedBuffer);
-    FUZZ_dataProducer_free(producer);
-
-#ifndef STATEFUL_FUZZING
-    ZSTD_seekable_free(stream); stream = NULL;
-    ZSTD_seekable_freeCStream(zscs); zscs = NULL;
-#endif
-    return 0;
-}

package/src/bsdiff/zstd/tests/fuzz/seq_prod_fuzz_example/Makefile

@@ -1,16 +0,0 @@
-# Copyright (c) Yann Collet, Meta Platforms, Inc.
-# All rights reserved.
-#
-# This source code is licensed under both the BSD-style license (found in the
-# LICENSE file in the root directory of this source tree) and the GPLv2 (found
-# in the COPYING file in the root directory of this source tree).
-# You may select, at your option, one of the above-listed licenses.
-
-CC = clang
-CFLAGS = -g -fno-omit-frame-pointer -fsanitize=undefined,address,fuzzer -I../ -I../../../lib/
-
-.PHONY: default
-default: example_seq_prod.o
-
-example_seq_prod.o: example_seq_prod.c
-	$(CC) -c $(CFLAGS) $^ -o $@

package/src/bsdiff/zstd/tests/fuzz/seq_prod_fuzz_example/README.md

@@ -1,12 +0,0 @@
-# Fuzzing a Custom Sequence Producer Plugin
-This directory contains example code for using a custom sequence producer in the zstd fuzzers.
-
-You can build and run the code in this directory using these commands:
-```
-$ make corpora
-$ make -C seq_prod_fuzz_example/
-$ python3 ./fuzz.py build all --enable-fuzzer --enable-asan --enable-ubsan --cc clang --cxx clang++ --custom-seq-prod=seq_prod_fuzz_example/example_seq_prod.o
-$ python3 ./fuzz.py libfuzzer simple_round_trip
-```
-
-See `../fuzz_third_party_seq_prod.h` and `../README.md` for more information on zstd fuzzing.

package/src/bsdiff/zstd/tests/fuzz/seq_prod_fuzz_example/example_seq_prod.c

@@ -1,52 +0,0 @@
-/*
- * Copyright (c) Yann Collet, Meta Platforms, Inc.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "fuzz_third_party_seq_prod.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-_Thread_local size_t threadLocalState;
-
-size_t FUZZ_seqProdSetup(void) {
-    threadLocalState = 0;
-    return 0;
-}
-
-size_t FUZZ_seqProdTearDown(void) {
-    return 0;
-}
-
-void* FUZZ_createSeqProdState(void) {
-    return calloc(1, sizeof(size_t));
-}
-
-size_t FUZZ_freeSeqProdState(void* state) {
-    free(state);
-    return 0;
-}
-
-size_t FUZZ_thirdPartySeqProd(
-    void* sequenceProducerState,
-    ZSTD_Sequence* outSeqs, size_t outSeqsCapacity,
-    const void* src, size_t srcSize,
-    const void* dict, size_t dictSize,
-    int compressionLevel,
-    size_t windowSize
-) {
-    /* Try to catch unsafe use of the shared state */
-    size_t* const sharedStatePtr = (size_t*)sequenceProducerState;
-    assert(*sharedStatePtr == threadLocalState);
-    (*sharedStatePtr)++; threadLocalState++;
-
-    /* Check that fallback is enabled when FUZZ_THIRD_PARTY_SEQ_PROD is defined */
-    return ZSTD_SEQUENCE_PRODUCER_ERROR;
-}