react-native-nitro-xlsx 0.1.4 → 0.2.6

package/thirdparty/miniz/tests/miniz_zip_validate_fuzzer.cc

@@ -0,0 +1,71 @@
+// Copyright 2025 Google LLC
+// Fuzz target for miniz ZIP validation functions
+// Targets: mz_zip_validate_mem_archive (0% coverage, complexity 642)
+//          mz_zip_validate_file_archive (0% coverage, complexity 651)
+
+#include "miniz.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Fuzz target for ZIP archive validation
+// Tests both memory-based and file-based validation functions
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    if (size < 4) return 0; // Need at least a minimal ZIP header
+    
+    // Test mz_zip_validate_mem_archive - 0% coverage target
+    // This validates a ZIP archive in memory
+    mz_zip_error zip_error = MZ_ZIP_NO_ERROR;
+    mz_bool result = mz_zip_validate_mem_archive(
+        data, 
+        size, 
+        MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 
+        &zip_error
+    );
+    
+    // Try with different flags
+    zip_error = MZ_ZIP_NO_ERROR;
+    mz_zip_validate_mem_archive(data, size, 0, &zip_error);
+    
+    // Test with various buffer sizes to hit edge cases
+    if (size > 1024) {
+        zip_error = MZ_ZIP_NO_ERROR;
+        mz_zip_validate_mem_archive(data, 1024, 0, &zip_error);
+    }
+    
+    // Test mz_compress and mz_uncompress - 0% coverage targets
+    // These are the simple zlib-compatible API functions
+    if (size > 0 && size <= 1024 * 1024) { // Reasonable size limit
+        // Compress
+        mz_ulong compressed_size = compressBound(size);
+        unsigned char* compressed = (unsigned char*)malloc(compressed_size);
+        
+        if (compressed) {
+            int compress_result = mz_compress(
+                compressed, 
+                &compressed_size, 
+                data, 
+                size
+            );
+            
+            // If compression succeeded, try decompression
+            if (compress_result == MZ_OK && compressed_size > 0) {
+                mz_ulong uncompressed_size = size * 2; // Give some headroom
+                unsigned char* uncompressed = (unsigned char*)malloc(uncompressed_size);
+                
+                if (uncompressed) {
+                    mz_uncompress(uncompressed, &uncompressed_size, compressed, compressed_size);
+                    free(uncompressed);
+                }
+            }
+            
+            free(compressed);
+        }
+    }
+    
+    // Test mz_adler32 and mz_crc32 - checksum functions
+    mz_adler32(MZ_ADLER32_INIT, data, size);
+    mz_crc32(MZ_CRC32_INIT, data, size);
+    
+    return 0;
+}

package/thirdparty/miniz/tests/miniz_zip_writer_fuzzer.cc

@@ -0,0 +1,96 @@
+// Copyright 2025 Google LLC
+// Fuzz target for miniz ZIP writer functions
+// Targets: mz_zip_writer_add_mem (0% coverage, complexity 627)
+//          mz_zip_writer_add_mem_ex (0% coverage)
+//          mz_zip_writer_add_mem_ex_v2 (0% coverage)
+//          mz_zip_writer_finalize_archive (0% coverage)
+
+#include "miniz.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+// Fuzz target for ZIP archive creation and writing
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    if (size < 16) return 0; // Need enough data for meaningful test
+    
+    // Create a memory-backed ZIP archive
+    mz_zip_archive zip_archive;
+    memset(&zip_archive, 0, sizeof(zip_archive));
+    
+    // Initialize the archive with a growable memory buffer
+    size_t initial_capacity = size * 2;
+    if (!mz_zip_writer_init_heap(&zip_archive, initial_capacity, 0)) {
+        return 0;
+    }
+    
+    // Extract parameters from fuzz input
+    // First byte determines compression level
+    int compression_level = data[0] % 11; // 0-10 (10 = best compression)
+    
+    // Second byte determines flags
+    mz_uint flags = data[1];
+    
+    // Rest of data is content to add to ZIP
+    const char* filename = "fuzz_test.txt";
+    const uint8_t* content = data + 2;
+    size_t content_size = size - 2;
+    
+    // Test mz_zip_writer_add_mem - 0% coverage target
+    mz_bool add_result = mz_zip_writer_add_mem(
+        &zip_archive,
+        filename,
+        content,
+        content_size,
+        flags | (compression_level << MZ_ZIP_LDH_BIT_OFFS_SHL)
+    );
+    
+    // Add multiple entries with different strategies
+    if (content_size > 4) {
+        // Add raw (uncompressed) entry
+        mz_zip_writer_add_mem(&zip_archive, "raw.bin", content, content_size / 2, 0);
+        
+        // Add compressed entry with store-only flag
+        mz_zip_writer_add_mem(
+            &zip_archive, 
+            "stored.bin", 
+            content + content_size / 2, 
+            content_size / 2, 
+            MZ_ZIP_FLAG_STORE
+        );
+        
+        // Add with AES encryption flag (may fail without proper setup, but good for fuzzing)
+        if (content_size > 8) {
+            mz_zip_writer_add_mem(
+                &zip_archive,
+                "encrypted.bin",
+                content + 4,
+                content_size - 4,
+                MZ_ZIP_FLAG_ENCRYPTED
+            );
+        }
+    }
+    
+    // Test mz_zip_writer_finalize_archive - 0% coverage target
+    mz_zip_writer_finalize_archive(&zip_archive);
+    
+    // Get the final archive data
+    void* archive_data = NULL;
+    size_t archive_size = 0;
+    mz_zip_writer_finalize_heap_archive(&zip_archive, &archive_data, &archive_size);
+    
+    // If we successfully created an archive, try to validate it
+    if (archive_data && archive_size > 0) {
+        mz_zip_error zip_error = MZ_ZIP_NO_ERROR;
+        mz_zip_validate_mem_archive(archive_data, archive_size, 0, &zip_error);
+        
+        // Cleanup
+        free(archive_data);
+    }
+    
+    // Cleanup the writer
+    mz_zip_writer_end(&zip_archive);
+    
+    return 0;
+}

package/thirdparty/miniz/tests/ossfuzz.sh

@@ -0,0 +1,48 @@
+#!/bin/bash -eu
+# Copyright 2020 Google Inc.
+#
+# Licensed under the Apache License, Version 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
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# This script is meant to be run by
+# https://github.com/google/oss-fuzz/blob/master/projects/miniz/Dockerfile
+
+cat << "EOF" > miniz_export.h
+#ifndef MINIZ_EXPORT
+#define MINIZ_EXPORT
+#endif
+EOF
+
+mkdir build
+cd build
+cmake .. -DAMALGAMATE_SOURCES=ON -DBUILD_SHARED_LIBS=OFF -DBUILD_FUZZERS=ON -DBUILD_TESTS=OFF
+make -j$(nproc)
+cd ..
+
+zip $OUT/seed_corpus.zip *.*
+
+for f in $(find $SRC -name '*_fuzzer.c'); do
+    b=$(basename -s .c $f)
+    $CC $CFLAGS -Ibuild/amalgamation $f -c -o /tmp/$b.o
+    $CXX $CXXFLAGS -stdlib=libc++ -Ibuild/amalgamation /tmp/$b.o -o $OUT/$b $LIB_FUZZING_ENGINE ./build/libminiz.a
+    rm -f /tmp/$b.o
+    ln -sf $OUT/seed_corpus.zip $OUT/${b}_seed_corpus.zip
+done
+
+
+# Add .zip input file for the zip fuzzer
+rm -f $OUT/zip_fuzzer_seed_corpus.zip
+zip $OUT/zip_fuzzer_seed_corpus.zip $OUT/seed_corpus.zip
+
+cp tests/zip.dict $OUT/zip_fuzzer.dict

package/thirdparty/miniz/tests/small_fuzzer.c

@@ -0,0 +1,126 @@
+/* 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;
+
+/* Test deflate() with small buffers */
+void test_deflate(unsigned char *compr, size_t comprLen)
+{
+    z_stream c_stream; /* compression stream */
+    int err;
+    unsigned long 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;
+
+    while (c_stream.total_in != len && c_stream.total_out < comprLen)
+    {
+        c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
+        err = deflate(&c_stream, Z_NO_FLUSH);
+        CHECK_ERR(err, "deflate small 1");
+    }
+
+    /* Finish the stream, still forcing small buffers: */
+    for (;;)
+    {
+        c_stream.avail_out = 1;
+        err = deflate(&c_stream, Z_FINISH);
+        if (err == Z_STREAM_END)
+            break;
+        CHECK_ERR(err, "deflate small 2");
+    }
+
+    err = deflateEnd(&c_stream);
+    CHECK_ERR(err, "deflateEnd");
+}
+
+/* Test inflate() with small buffers */
+void test_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 = 0;
+    d_stream.next_out = uncompr;
+
+    err = inflateInit(&d_stream);
+    CHECK_ERR(err, "inflateInit");
+
+    while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
+    {
+        d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
+        err = inflate(&d_stream, Z_NO_FLUSH);
+        if (err == Z_STREAM_END)
+            break;
+        CHECK_ERR(err, "inflate");
+    }
+
+    err = inflateEnd(&d_stream);
+    CHECK_ERR(err, "inflateEnd");
+
+    if (memcmp(uncompr, data, dataLen))
+    {
+        fprintf(stderr, "bad inflate\n");
+        exit(1);
+    }
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size)
+{
+    size_t comprLen = 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);
+
+    test_deflate(compr, comprLen);
+    test_inflate(compr, comprLen, uncompr, uncomprLen);
+
+    free(compr);
+    free(uncompr);
+
+    return 0;
+}

package/thirdparty/miniz/tests/timer.cpp

@@ -0,0 +1,152 @@
+// File: timer.cpp - Simple high-precision timer class. Supports Win32, X360, and POSIX/Linux
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <time.h>
+
+#include "timer.h"
+
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(_XBOX)
+#include <xtl.h>
+#endif
+
+unsigned long long timer::g_init_ticks;
+unsigned long long timer::g_freq;
+double timer::g_inv_freq;
+
+#if defined(WIN32) || defined(_XBOX)
+inline void query_counter(timer_ticks *pTicks)
+{
+   QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(pTicks));
+}
+inline void query_counter_frequency(timer_ticks *pTicks)
+{
+   QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(pTicks));
+}
+#elif defined(__GNUC__)
+#include <sys/timex.h>
+inline void query_counter(timer_ticks *pTicks)
+{
+   struct timeval cur_time;
+   gettimeofday(&cur_time, NULL);
+   *pTicks = static_cast<unsigned long long>(cur_time.tv_sec)*1000000ULL + static_cast<unsigned long long>(cur_time.tv_usec);
+}
+inline void query_counter_frequency(timer_ticks *pTicks)
+{
+   *pTicks = 1000000;
+}
+#endif
+
+timer::timer() :
+   m_start_time(0),
+   m_stop_time(0),
+   m_started(false),
+   m_stopped(false)
+{
+   if (!g_inv_freq)
+      init();
+}
+
+timer::timer(timer_ticks start_ticks)
+{
+   if (!g_inv_freq)
+      init();
+
+   m_start_time = start_ticks;
+
+   m_started = true;
+   m_stopped = false;
+}
+
+void timer::start(timer_ticks start_ticks)
+{
+   m_start_time = start_ticks;
+
+   m_started = true;
+   m_stopped = false;
+}
+
+void timer::start()
+{
+   query_counter(&m_start_time);
+
+   m_started = true;
+   m_stopped = false;
+}
+
+void timer::stop()
+{
+   assert(m_started);
+
+   query_counter(&m_stop_time);
+
+   m_stopped = true;
+}
+
+double timer::get_elapsed_secs() const
+{
+   assert(m_started);
+   if (!m_started)
+      return 0;
+
+   timer_ticks stop_time = m_stop_time;
+   if (!m_stopped)
+      query_counter(&stop_time);
+
+   timer_ticks delta = stop_time - m_start_time;
+   return delta * g_inv_freq;
+}
+
+timer_ticks timer::get_elapsed_us() const
+{
+   assert(m_started);
+   if (!m_started)
+      return 0;
+
+   timer_ticks stop_time = m_stop_time;
+   if (!m_stopped)
+      query_counter(&stop_time);
+
+   timer_ticks delta = stop_time - m_start_time;
+   return (delta * 1000000ULL + (g_freq >> 1U)) / g_freq;
+}
+
+void timer::init()
+{
+   if (!g_inv_freq)
+   {
+      query_counter_frequency(&g_freq);
+      g_inv_freq = 1.0f / g_freq;
+
+      query_counter(&g_init_ticks);
+   }
+}
+
+timer_ticks timer::get_init_ticks()
+{
+   if (!g_inv_freq)
+      init();
+
+   return g_init_ticks;
+}
+
+timer_ticks timer::get_ticks()
+{
+   if (!g_inv_freq)
+      init();
+
+   timer_ticks ticks;
+   query_counter(&ticks);
+   return ticks - g_init_ticks;
+}
+
+double timer::ticks_to_secs(timer_ticks ticks)
+{
+   if (!g_inv_freq)
+      init();
+
+   return ticks * g_inv_freq;
+}
+

package/thirdparty/miniz/tests/timer.h

@@ -0,0 +1,40 @@
+// File: timer.h
+#pragma once
+
+typedef unsigned long long timer_ticks;
+
+class timer
+{
+public:
+   timer();
+   timer(timer_ticks start_ticks);
+
+   void start();
+   void start(timer_ticks start_ticks);
+
+   void stop();
+
+   double get_elapsed_secs() const;
+   inline double get_elapsed_ms() const { return get_elapsed_secs() * 1000.0f; }
+   timer_ticks get_elapsed_us() const;
+
+   static void init();
+   static inline timer_ticks get_ticks_per_sec() { return g_freq; }
+   static timer_ticks get_init_ticks();
+   static timer_ticks get_ticks();
+   static double ticks_to_secs(timer_ticks ticks);
+   static inline double ticks_to_ms(timer_ticks ticks) { return ticks_to_secs(ticks) * 1000.0f; }
+   static inline double get_secs() { return ticks_to_secs(get_ticks()); }
+   static inline double get_ms() { return ticks_to_ms(get_ticks()); }
+
+private:
+   static timer_ticks g_init_ticks;
+   static timer_ticks g_freq;
+   static double g_inv_freq;
+
+   timer_ticks m_start_time;
+   timer_ticks m_stop_time;
+
+   bool m_started : 1;
+   bool m_stopped : 1;
+};

package/thirdparty/miniz/tests/uncompress2_fuzzer.c

@@ -0,0 +1,21 @@
+/* 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 <string.h>
+
+#include "miniz.h"
+
+static unsigned char buffer[256 * 1024] = { 0 };
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    unsigned long int buffer_length = sizeof(buffer);
+
+    if (Z_OK != uncompress2(buffer, &buffer_length, data, &size))
+        return 0;
+
+    return 0;
+}

package/thirdparty/miniz/tests/uncompress_fuzzer.c

@@ -0,0 +1,30 @@
+/* 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 <string.h>
+
+#include "miniz.h"
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    unsigned long int buffer_length = 1;
+    unsigned char *buffer = NULL;
+    int z_status = 0;
+
+    if (size > 0)
+        buffer_length *= data[0];
+    if (size > 1)
+        buffer_length *= data[1];
+
+    buffer = (unsigned char *)malloc(buffer_length);
+
+    z_status = uncompress(buffer, &buffer_length, data, size);
+    free(buffer);
+
+    if (Z_OK != z_status)
+        return 0;
+    return 0;
+}

package/thirdparty/miniz/tests/zip.dict

@@ -0,0 +1,9 @@
+# Fuzzing dictionary for .zip files
+
+header_lfh="\x50\x4b\x03\x04"
+header_cd="\x50\x4b\x01\x02"
+header_eocd="\x50\x4b\x05\x06"
+header_eocd64="\x50\x4b\x06\x06"
+data_descriptor="\x50\x4b\x07\x08"
+extra_data_sig="\x50\x4b\x06\x08"
+digital_sig="\x50\x4b\x05\x05"

package/thirdparty/miniz/tests/zip_fuzzer.c

@@ -0,0 +1,63 @@
+#include <stdint.h>
+#include <inttypes.h>
+
+#include "miniz.h"
+
+static char filename[260];
+static unsigned char read_buf[1024 * 256];
+
+static const size_t filename_max = sizeof(filename);
+static const size_t read_buf_size = sizeof(read_buf);
+static const size_t data_max = 1024 * 256;
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    if (size > data_max)
+        return 0;
+
+    int ret = 0;
+    mz_zip_archive zip;
+    mz_zip_zero_struct(&zip);
+
+    mz_uint flags = 0;
+
+    if (!mz_zip_reader_init_mem(&zip, data, size, flags))
+        return 0;
+
+    mz_uint i, files;
+
+    files = mz_zip_reader_get_num_files(&zip);
+
+    for (i = 0; i < files; i++)
+    {
+        mz_zip_clear_last_error(&zip);
+
+        if (mz_zip_reader_is_file_a_directory(&zip, i))
+            continue;
+
+        mz_zip_validate_file(&zip, i, MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY);
+
+        if (mz_zip_reader_is_file_encrypted(&zip, i))
+            continue;
+
+        mz_zip_clear_last_error(&zip);
+
+        mz_uint ret = mz_zip_reader_get_filename(&zip, i, filename, filename_max);
+
+        if (mz_zip_get_last_error(&zip))
+            continue;
+
+        mz_zip_archive_file_stat file_stat = { 0 };
+        mz_bool status = mz_zip_reader_file_stat(&zip, i, &file_stat) != 0;
+
+        if ((file_stat.m_method) && (file_stat.m_method != MZ_DEFLATED))
+            continue;
+
+        mz_zip_reader_extract_file_to_mem(&zip, file_stat.m_filename, read_buf, read_buf_size, 0);
+    }
+
+cleanup:
+    mz_zip_reader_end(&zip);
+
+    return ret;
+}

package/thirdparty/pugixml/.codecov.yml

@@ -0,0 +1,7 @@
+comment: false
+coverage:
+  status:
+    project:
+      default:
+        informational: true
+    patch: off

package/thirdparty/pugixml/.gitattributes

@@ -0,0 +1 @@
+tests/data/* -text