react-native-nitro-xlsx 0.2.5 → 0.2.6

package/thirdparty/miniz/tests/checksum_fuzzer.c

@@ -0,0 +1,26 @@
+/* Derived from zlib fuzzers at http://github.com/google/oss-fuzz/tree/master/projects/zlib,
+ * see ossfuzz.sh for full license text.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include "miniz.h"
+
+static const size_t kMaxSize = 1024 * 1024;
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataLen)
+{
+    /* Discard inputs larger than 1Mb. */
+    if (dataLen < 1 || dataLen > kMaxSize)
+        return 0;
+
+    uint32_t crc = crc32(0L, NULL, 0);
+    uint32_t adler = adler32(0L, NULL, 0);
+
+    crc = crc32(crc, data, (uint32_t)dataLen);
+    adler = adler32(adler, data, (uint32_t)dataLen);
+
+    return 0;
+}

package/thirdparty/miniz/tests/compress_fuzzer.c

@@ -0,0 +1,91 @@
+/* Derived from zlib fuzzers at http://github.com/google/oss-fuzz/tree/master/projects/zlib,
+ * see ossfuzz.sh for full license text.
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include "miniz.h"
+
+static const uint8_t *data;
+static size_t dataLen;
+
+static void check_compress_level(uint8_t *compr, size_t comprLen,
+                                 uint8_t *uncompr, size_t uncomprLen,
+                                 int level)
+{
+    compress2(compr, &comprLen, data, dataLen, level);
+    uncompress(uncompr, &uncomprLen, compr, comprLen);
+
+    /* Make sure compress + uncompress gives back the input data. */
+    assert(dataLen == uncomprLen);
+    assert(0 == memcmp(data, uncompr, dataLen));
+}
+
+#define put_byte(s, i, c)          \
+    {                              \
+        s[i] = (unsigned char)(c); \
+    }
+
+static void write_zlib_header(uint8_t *s)
+{
+    unsigned level_flags = 0; /* compression level (0..3) */
+    unsigned w_bits = 8;      /* window size log2(w_size)  (8..16) */
+    unsigned int header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
+    header |= (level_flags << 6);
+
+    header += 31 - (header % 31);
+
+    /* s is guaranteed to be longer than 2 bytes. */
+    put_byte(s, 0, (unsigned char)(header >> 8));
+    put_byte(s, 1, (unsigned char)(header & 0xff));
+}
+
+static void check_decompress(uint8_t *compr, size_t comprLen)
+{
+    /* We need to write a valid zlib header of size two bytes. Copy the input data
+        in a larger buffer. Do not modify the input data to avoid libFuzzer error:
+        fuzz target overwrites its const input. */
+    size_t copyLen = dataLen + 2;
+    uint8_t *copy = malloc(copyLen);
+    memcpy(copy + 2, data, dataLen);
+    write_zlib_header(copy);
+
+    uncompress(compr, &comprLen, copy, copyLen);
+    free(copy);
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size)
+{
+    /* compressBound does not provide enough space for low compression levels. */
+    size_t comprLen = 100 + 2 * compressBound(size);
+    size_t uncomprLen = size;
+    uint8_t *compr, *uncompr;
+
+    /* Discard inputs larger than 1Mb. */
+    static size_t kMaxSize = 1024 * 1024;
+
+    if (size < 1 || size > kMaxSize)
+        return 0;
+
+    data = d;
+    dataLen = size;
+    compr = calloc(1, comprLen);
+    uncompr = calloc(1, uncomprLen);
+
+    check_compress_level(compr, comprLen, uncompr, uncomprLen, 1);
+    check_compress_level(compr, comprLen, uncompr, uncomprLen, 3);
+    check_compress_level(compr, comprLen, uncompr, uncomprLen, 6);
+    check_compress_level(compr, comprLen, uncompr, uncomprLen, 7);
+
+    check_decompress(compr, comprLen);
+
+    free(compr);
+    free(uncompr);
+
+    return 0;
+}

package/thirdparty/miniz/tests/flush_fuzzer.c

@@ -0,0 +1,88 @@
+/* Derived from zlib fuzzers at http://github.com/google/oss-fuzz/tree/master/projects/zlib,
+ * see ossfuzz.sh for full license text.
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <inttypes.h>
+
+#include "miniz.h"
+
+#define CHECK_ERR(err, msg)                              \
+    {                                                    \
+        if (err != Z_OK)                                 \
+        {                                                \
+            fprintf(stderr, "%s error: %d\n", msg, err); \
+            exit(1);                                     \
+        }                                                \
+    }
+
+static const uint8_t *data;
+static size_t dataLen;
+static alloc_func zalloc = NULL;
+static free_func zfree = NULL;
+
+void test_flush(unsigned char *compr, size_t *comprLen)
+{
+    z_stream c_stream; /* compression stream */
+    int err;
+    unsigned int len = dataLen;
+
+    c_stream.zalloc = zalloc;
+    c_stream.zfree = zfree;
+    c_stream.opaque = NULL;
+
+    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
+    CHECK_ERR(err, "deflateInit");
+
+    c_stream.next_in = (Bytef *)data;
+    c_stream.next_out = compr;
+    c_stream.avail_in = 3;
+    c_stream.avail_out = (unsigned int)*comprLen;
+    err = deflate(&c_stream, Z_FULL_FLUSH);
+    CHECK_ERR(err, "deflate flush 1");
+
+    compr[3]++; /* force an error in first compressed block */
+    c_stream.avail_in = len - 3;
+
+    err = deflate(&c_stream, Z_FINISH);
+
+    if (err != Z_STREAM_END)
+    {
+        CHECK_ERR(err, "deflate flush 2");
+    }
+
+    err = deflateEnd(&c_stream);
+    CHECK_ERR(err, "deflateEnd");
+
+    *comprLen = (size_t)c_stream.total_out;
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size)
+{
+    size_t comprLen = 100 + 2 * compressBound(size);
+    size_t uncomprLen = size;
+    uint8_t *compr, *uncompr;
+
+    /* Discard inputs larger than 1Mb. */
+    static const size_t kMaxSize = 1024 * 1024;
+
+    /* This test requires at least 3 bytes of input data. */
+    if (size <= 3 || size > kMaxSize)
+        return 0;
+
+    data = d;
+    dataLen = size;
+    compr = calloc(1, comprLen);
+    uncompr = calloc(1, uncomprLen);
+
+    test_flush(compr, &comprLen);
+
+    free(compr);
+    free(uncompr);
+
+    return 0;
+}

package/thirdparty/miniz/tests/fuzz_main.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/* Fuzz target entry point for building without libFuzzer */
+
+int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size);
+
+int main(int argc, char **argv)
+{
+    FILE *f;
+    char *buf = NULL;
+    long siz_buf;
+
+    if (argc < 2)
+    {
+        fprintf(stderr, "no input file\n");
+        goto err;
+    }
+
+    f = fopen(argv[1], "rb");
+    if (f == NULL)
+    {
+        fprintf(stderr, "error opening input file %s\n", argv[1]);
+        goto err;
+    }
+
+    fseek(f, 0, SEEK_END);
+
+    siz_buf = ftell(f);
+    rewind(f);
+
+    if (siz_buf < 1)
+        goto err;
+
+    buf = (char *)malloc(siz_buf);
+    if (buf == NULL)
+    {
+        fprintf(stderr, "malloc() failed\n");
+        goto err;
+    }
+
+    if (fread(buf, siz_buf, 1, f) != 1)
+    {
+        fprintf(stderr, "fread() failed\n");
+        goto err;
+    }
+
+    (void)LLVMFuzzerTestOneInput((uint8_t *)buf, siz_buf);
+
+err:
+    free(buf);
+
+    return 0;
+}

package/thirdparty/miniz/tests/large_fuzzer.c

@@ -0,0 +1,133 @@
+/* Derived from zlib fuzzers at http://github.com/google/oss-fuzz/tree/master/projects/zlib,
+ * see ossfuzz.sh for full license text.
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <inttypes.h>
+
+#include "miniz.h"
+
+#define CHECK_ERR(err, msg)                              \
+    {                                                    \
+        if (err != Z_OK)                                 \
+        {                                                \
+            fprintf(stderr, "%s error: %d\n", msg, err); \
+            exit(1);                                     \
+        }                                                \
+    }
+
+static const uint8_t *data;
+static size_t dataLen;
+static alloc_func zalloc = NULL;
+static free_func zfree = NULL;
+static unsigned int diff;
+
+/* Test deflate() with large buffers and dynamic change of compression level */
+void test_large_deflate(unsigned char *compr, size_t comprLen,
+                        unsigned char *uncompr, size_t uncomprLen)
+{
+    z_stream c_stream; /* compression stream */
+    int err;
+
+    c_stream.zalloc = zalloc;
+    c_stream.zfree = zfree;
+    c_stream.opaque = NULL;
+
+    err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
+    CHECK_ERR(err, "deflateInit");
+
+    c_stream.next_out = compr;
+    c_stream.avail_out = (unsigned int)comprLen;
+
+    /* At this point, uncompr is still mostly zeroes, so it should compress
+     * very well:
+     */
+    c_stream.next_in = uncompr;
+    c_stream.avail_in = (unsigned int)uncomprLen;
+    err = deflate(&c_stream, Z_NO_FLUSH);
+    CHECK_ERR(err, "deflate large 1");
+
+    if (c_stream.avail_in != 0)
+    {
+        fprintf(stderr, "deflate not greedy\n");
+        exit(1);
+    }
+
+    /* Feed in already compressed data: */
+    c_stream.next_in = compr;
+    diff = (unsigned int)(c_stream.next_out - compr);
+    c_stream.avail_in = diff;
+
+    deflate(&c_stream, Z_NO_FLUSH);
+    err = deflate(&c_stream, Z_FINISH);
+
+    if (err != Z_STREAM_END)
+    {
+        fprintf(stderr, "deflate large should report Z_STREAM_END\n");
+        exit(1);
+    }
+    err = deflateEnd(&c_stream);
+    CHECK_ERR(err, "deflateEnd");
+}
+
+/* Test inflate() with large buffers */
+void test_large_inflate(unsigned char *compr, size_t comprLen,
+                        unsigned char *uncompr, size_t uncomprLen)
+{
+    int err;
+    z_stream d_stream; /* decompression stream */
+
+    d_stream.zalloc = zalloc;
+    d_stream.zfree = zfree;
+    d_stream.opaque = NULL;
+
+    d_stream.next_in = compr;
+    d_stream.avail_in = (unsigned int)comprLen;
+
+    err = inflateInit(&d_stream);
+    CHECK_ERR(err, "inflateInit");
+
+    for (;;)
+    {
+        d_stream.next_out = uncompr; /* discard the output */
+        d_stream.avail_out = (unsigned int)uncomprLen;
+        err = inflate(&d_stream, Z_NO_FLUSH);
+        if (err == Z_STREAM_END)
+            break;
+
+        CHECK_ERR(err, "large inflate");
+    }
+
+    err = inflateEnd(&d_stream);
+    CHECK_ERR(err, "inflateEnd");
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size)
+{
+    size_t comprLen = 100 + 3 * size;
+    size_t uncomprLen = comprLen;
+    uint8_t *compr, *uncompr;
+
+    /* Discard inputs larger than 512Kb. */
+    static size_t kMaxSize = 512 * 1024;
+
+    if (size < 1 || size > kMaxSize)
+        return 0;
+
+    data = d;
+    dataLen = size;
+    compr = calloc(1, comprLen);
+    uncompr = calloc(1, uncomprLen);
+
+    test_large_deflate(compr, comprLen, uncompr, uncomprLen);
+    test_large_inflate(compr, comprLen, uncompr, uncomprLen);
+
+    free(compr);
+    free(uncompr);
+
+    return 0;
+}

package/thirdparty/miniz/tests/main.cpp

@@ -0,0 +1,185 @@
+#include "catch_amalgamated.hpp"
+#include "../miniz.h"
+#include "miniz_zip.h"
+#include <assert.h>
+#include <string>
+
+#ifdef _WIN32
+#define unlink _unlink
+#else
+#include <unistd.h>
+#endif
+
+#ifndef MINIZ_NO_STDIO
+bool create_test_zip(const bool zip64)
+{
+    unlink("test.zip");
+    mz_zip_archive zip_archive = {};
+    auto b = mz_zip_writer_init_file_v2(&zip_archive, "test.zip", 0, zip64 ? MZ_ZIP_FLAG_WRITE_ZIP64 : 0);
+    if (!b)
+        return false;
+
+    b = mz_zip_writer_add_mem(&zip_archive, "test.txt", "foo", 3, MZ_DEFAULT_COMPRESSION);
+    if (!b)
+        return false;
+
+    b = mz_zip_writer_finalize_archive(&zip_archive);
+    if (!b)
+        return false;
+
+    b = mz_zip_writer_end(&zip_archive);
+    if (!b)
+        return false;
+
+    return true;
+}
+
+TEST_CASE("Zip writer tests")
+{
+    auto b = create_test_zip(false);
+    REQUIRE(b);
+
+    SECTION("Test test.txt content correct")
+    {
+        mz_zip_archive zip_archive = {};
+
+        auto b = mz_zip_reader_init_file(&zip_archive, "test.zip", 0);
+        REQUIRE(b);
+
+        size_t content_size;
+        auto content = mz_zip_reader_extract_file_to_heap(&zip_archive, "test.txt", &content_size, 0);
+
+        std::string_view content_view(reinterpret_cast<char *>(content), content_size);
+
+        REQUIRE(content_view == "foo");
+        REQUIRE(content_view.size() == 3);
+
+        free(content);
+
+        mz_zip_reader_end(&zip_archive);
+    }
+
+    SECTION("Test repeated file addition to zip")
+    {
+        mz_zip_archive zip_archive = {};
+        auto b = mz_zip_writer_init_file(&zip_archive, "test2.zip", 0);
+        REQUIRE(b);
+
+        b = mz_zip_writer_finalize_archive(&zip_archive);
+        REQUIRE(b);
+
+        b = mz_zip_writer_end(&zip_archive);
+        REQUIRE(b);
+
+        for (int i = 0; i < 50; i++)
+        {
+            const char *str = "hello world";
+            b = mz_zip_add_mem_to_archive_file_in_place(
+                std::string("test2.zip").c_str(), ("file1.txt" + std::to_string(i)).c_str(),
+                str, (mz_uint16)strlen(str),
+                NULL, 0,
+                MZ_BEST_COMPRESSION);
+            REQUIRE(b);
+        }
+    }
+}
+
+TEST_CASE("Zip reader tests")
+{
+    const auto b = create_test_zip(true);
+    REQUIRE(b);
+
+    SECTION("Test zip file reading")
+    {
+        mz_zip_archive zip_archive = {};
+
+        auto b = mz_zip_reader_init_file(&zip_archive, "test.zip", 0);
+        REQUIRE(b);
+
+        size_t num_files = mz_zip_reader_get_num_files(&zip_archive);
+        REQUIRE(num_files == 1);
+
+        mz_zip_archive_file_stat file_stat;
+        b = mz_zip_reader_file_stat(&zip_archive, 0, &file_stat);
+        REQUIRE(b);
+
+        REQUIRE(file_stat.m_file_index == 0);
+        REQUIRE(file_stat.m_uncomp_size == 3);
+        REQUIRE(file_stat.m_comp_size == 3);
+        REQUIRE(std::string_view(file_stat.m_filename) == "test.txt");
+
+        mz_zip_reader_end(&zip_archive);
+    }
+
+    SECTION("Test central dir overflow")
+    {
+        auto f = fopen("test.zip", "rb");
+        REQUIRE(f);
+        char buf[1000];
+        const auto read = fread(buf, 1, 1000, f);
+        fclose(f);
+
+        unsigned long long cdir_ofs = -1;
+        memcpy(buf + 159, &cdir_ofs, sizeof(cdir_ofs));
+
+        unlink("test.zip");
+        f = fopen("test.zip", "wb");
+        REQUIRE(f);
+        fwrite(buf, 1, read, f);
+        fclose(f);
+
+        mz_zip_archive zip_archive = {};
+
+        auto b = mz_zip_reader_init_file(&zip_archive, "test.zip", 0);
+        REQUIRE(!b);
+        REQUIRE(zip_archive.m_last_error == MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+    }
+}
+
+#endif
+
+TEST_CASE("Tinfl / tdefl tests")
+{
+    SECTION("simple_test1")
+    {
+        size_t cmp_len = 0;
+
+        const char *p = "This is a test.This is a test.This is a test.1234567This is a test.This is a test.123456";
+        size_t uncomp_len = strlen(p);
+
+        void *pComp_data = tdefl_compress_mem_to_heap(p, uncomp_len, &cmp_len, TDEFL_WRITE_ZLIB_HEADER);
+        REQUIRE(pComp_data);
+
+        size_t decomp_len = 0;
+        void *pDecomp_data = tinfl_decompress_mem_to_heap(pComp_data, cmp_len, &decomp_len, TINFL_FLAG_PARSE_ZLIB_HEADER);
+
+        REQUIRE(pDecomp_data);
+        REQUIRE(decomp_len == uncomp_len);
+        REQUIRE(memcmp(pDecomp_data, p, uncomp_len) == 0);
+
+        free(pComp_data);
+        free(pDecomp_data);
+    }
+
+    SECTION("simple_test2")
+    {
+        uint8_t cmp_buf[1024], decomp_buf[1024];
+        uLong cmp_len = sizeof(cmp_buf);
+
+        const char *p = "This is a test.This is a test.This is a test.1234567This is a test.This is a test.123456";
+        uLong uncomp_len = (uLong)strlen(p);
+
+        int status = compress(cmp_buf, &cmp_len, (const uint8_t *)p, uncomp_len);
+        REQUIRE(status == Z_OK);
+
+        REQUIRE(cmp_len <= compressBound(uncomp_len));
+
+        uLong decomp_len = sizeof(decomp_buf);
+        status = uncompress(decomp_buf, &decomp_len, cmp_buf, cmp_len);
+        ;
+
+        REQUIRE(status == Z_OK);
+        REQUIRE(decomp_len == uncomp_len);
+        REQUIRE(memcmp(decomp_buf, p, uncomp_len) == 0);
+    }
+}

package/thirdparty/miniz/tests/miniz_tdefl_fuzzer.cc

@@ -0,0 +1,115 @@
+// Copyright 2025 Google LLC
+// Fuzz target for miniz tdefl (tiny deflate) functions
+// Targets: tdefl_compress_mem_to_mem (0% coverage, complexity ~400)
+//          tdefl_compress_mem_to_heap (0% coverage)
+//          tdefl_write_image_to_png_file_in_memory (0% coverage, complexity 503)
+
+#include "miniz.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Fuzz target for tdefl compression functions
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    if (size < 1) return 0;
+    
+    // Determine compression level from input
+    tdefl_compress_level compression_level = (tdefl_compress_level)(data[0] % TDEFL_MAX_LEVELS);
+    const uint8_t* content = data + 1;
+    size_t content_size = size - 1;
+    
+    // Test tdefl_compress_mem_to_mem - 0% coverage target
+    if (content_size > 0 && content_size <= 10 * 1024 * 1024) { // Max 10MB
+        size_t max_compressed_size = content_size + 1024;
+        void* compressed = malloc(max_compressed_size);
+        
+        if (compressed) {
+            size_t actual_compressed_size = tdefl_compress_mem_to_mem(
+                compressed,
+                max_compressed_size,
+                content,
+                content_size,
+                compression_level
+            );
+            
+            // If compression succeeded, try decompression
+            if (actual_compressed_size > 0 && actual_compressed_size <= max_compressed_size) {
+                size_t max_uncompressed = content_size * 2;
+                void* uncompressed = malloc(max_uncompressed);
+                
+                if (uncompressed) {
+                    tinfl_decompress_mem_to_mem(
+                        uncompressed,
+                        max_uncompressed,
+                        compressed,
+                        actual_compressed_size,
+                        TINFL_FLAG_PARSE_ZLIB_HEADER
+                    );
+                    free(uncompressed);
+                }
+            }
+            
+            free(compressed);
+        }
+    }
+    
+    // Test tdefl_compress_mem_to_heap - 0% coverage target
+    if (content_size > 0 && content_size <= 10 * 1024 * 1024) {
+        size_t compressed_size = 0;
+        void* heap_compressed = tdefl_compress_mem_to_heap(
+            content,
+            content_size,
+            &compressed_size,
+            compression_level
+        );
+        
+        if (heap_compressed) {
+            // Decompress to verify
+            if (compressed_size > 0) {
+                size_t uncomp_size = content_size * 2;
+                void* uncomp = malloc(uncomp_size);
+                if (uncomp) {
+                    tinfl_decompress_mem_to_mem(
+                        uncomp,
+                        uncomp_size,
+                        heap_compressed,
+                        compressed_size,
+                        TINFL_FLAG_PARSE_ZLIB_HEADER
+                    );
+                    free(uncomp);
+                }
+            }
+            free(heap_compressed);
+        }
+    }
+    
+    // Test tdefl_write_image_to_png_file_in_memory - 0% coverage target (complexity 503)
+    // This function compresses a grayscale or RGB/RGBA image to PNG format
+    if (content_size >= 4) {
+        // Try to interpret input as a small image
+        // Extract dimensions from first bytes
+        int w = (data[0] % 64) + 1;  // 1-64 width
+        int h = (data[1] % 64) + 1;  // 1-64 height
+        int num_chans = (data[2] % 4) + 1;  // 1-4 channels (grayscale, RGB, RGBA)
+        
+        size_t expected_size = w * h * num_chans;
+        if (content_size - 3 >= expected_size && expected_size > 0) {
+            const void* image_data = data + 3;
+            
+            size_t png_size = 0;
+            void* png_data = tdefl_write_image_to_png_file_in_memory(
+                image_data,
+                w,
+                h,
+                num_chans,
+                &png_size
+            );
+            
+            if (png_data && png_size > 0) {
+                free(png_data);
+            }
+        }
+    }
+    
+    return 0;
+}