react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/SECURITY.md

@@ -0,0 +1,8 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please use the following contact information for reporting a vulnerability:
+
+- [Daniel Lemire](https://github.com/lemire) - daniel@lemire.me
+- [Paul Driek](https://github.com/pauldreik) -  firstname@thisdomainname where the domain is pauldreik.se, PGP key is 44EAE0EB.

package/deps/simdutf/benchmarks/CMakeLists.txt

@@ -0,0 +1,101 @@
+if (CMAKE_COMPILER_IS_GNUCXX)
+  add_compile_options("-fdiagnostics-color")
+  add_compile_options("-Wpedantic")
+  add_compile_options("-Wextra")
+  add_compile_options("-Wall")
+endif()
+
+
+if(MSVC)
+  add_compile_options("/Zi" "/EHsc" "/GR")
+endif()
+
+if(SIMDUTF_SANITIZE)
+  add_compile_options(-fsanitize=address  -fno-omit-frame-pointer -fno-sanitize-recover=all)
+  add_compile_definitions(ASAN_OPTIONS=detect_leaks=1)
+endif()
+
+
+add_executable(stream stream.cpp)
+target_link_libraries(stream PUBLIC simdutf)
+
+if(SIMDUTF_ICONV)
+find_package(Iconv)
+if(Iconv_FOUND)
+  target_compile_definitions(stream PRIVATE ICONV_AVAILABLE=1)
+  if(Iconv_IS_BUILT_IN)
+    message(STATUS "Iconv is part of the C library.")
+  else(Iconv_IS_BUILT_IN)
+    message(STATUS "Iconv is a separate library, headers at ${Iconv_INCLUDE_DIR}, binary at ${Iconv_LIBRARY}")
+    target_link_libraries(stream PUBLIC  ${Iconv_LIBRARY})
+    target_include_directories(stream PUBLIC ${Iconv_INCLUDE_DIR})
+  endif(Iconv_IS_BUILT_IN)
+else(Iconv_FOUND)
+  message(STATUS "Iconv was not found!")
+endif(Iconv_FOUND)
+else(SIMDUTF_ICONV)
+  message(STATUS "We are not seeking iconv.")
+endif(SIMDUTF_ICONV)
+
+add_subdirectory(src)
+
+add_executable(benchmark benchmark.cpp)
+target_link_libraries(benchmark PUBLIC simdutf::benchmarks::benchmark)
+
+set_property(TARGET benchmark PROPERTY CXX_STANDARD 17)
+set_property(TARGET benchmark PROPERTY CXX_STANDARD_REQUIRED ON)
+
+if(WIN32 AND BUILD_SHARED_LIBS)
+  # Copy the simdutf dll into the benchmark directory
+  add_custom_command(TARGET stream POST_BUILD        # Adds a post-build event
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different  # which executes "cmake -E copy_if_different..."
+        "$<TARGET_FILE:simdutf>"      # <--this is in-file
+        "$<TARGET_FILE_DIR:random_fuzzer>")                 # <--this is out-file path
+endif()
+
+
+set_property(TARGET stream PROPERTY CXX_STANDARD 17)
+set_property(TARGET stream PROPERTY CXX_STANDARD_REQUIRED ON)
+
+add_executable(alignment alignment.cpp)
+target_link_libraries(alignment PUBLIC simdutf)
+
+set_property(TARGET alignment PROPERTY CXX_STANDARD 17)
+set_property(TARGET alignment PROPERTY CXX_STANDARD_REQUIRED ON)
+
+
+
+find_package(Threads)
+
+if(Threads_FOUND)
+  add_executable(threaded threaded.cpp)
+  target_link_libraries(threaded PUBLIC simdutf)
+  target_link_libraries(threaded PUBLIC Threads::Threads)
+
+  set_property(TARGET threaded PROPERTY CXX_STANDARD 17)
+  set_property(TARGET threaded PROPERTY CXX_STANDARD_REQUIRED ON)
+endif(Threads_FOUND)
+
+option(SIMDUTF_BENCHMARK_BASE64 "Whether the base64 benchmarks are included as part of the CMake Build (requires C++17 or better)." ON)
+
+if(SIMDUTF_BENCHMARK_BASE64)
+  if(CMAKE_CXX_COMPILER_ID STREQUAL Clang AND "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
+    message(STATUS "Not building base64 benchmarks when using clang-cl due to build errors with the aklomp/base64 dependency.")
+  else()
+    add_subdirectory(base64)
+  endif()
+endif(SIMDUTF_BENCHMARK_BASE64)
+
+
+add_executable(benchmark_to_well_formed_utf16 benchmark_to_well_formed_utf16.cpp)
+target_link_libraries(benchmark_to_well_formed_utf16 PUBLIC simdutf)
+target_link_libraries(benchmark_to_well_formed_utf16 PUBLIC simdutf::benchmarks::benchmark)
+set_property(TARGET benchmark_to_well_formed_utf16 PROPERTY CXX_STANDARD 17)
+set_property(TARGET benchmark_to_well_formed_utf16 PROPERTY CXX_STANDARD_REQUIRED ON)
+
+
+add_executable(shortbench shortbench.cpp)
+target_link_libraries(shortbench PUBLIC simdutf::benchmarks::benchmark)
+target_compile_features(shortbench PRIVATE cxx_std_20)
+
+add_subdirectory(find)

package/deps/simdutf/benchmarks/alignment.cpp

@@ -0,0 +1,150 @@
+/**
+ * This simple program is meant to test the effect of alignment on the speed.
+ */
+
+#include <chrono>
+#include <cmath>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "simdutf.h"
+
+uint64_t nano() {
+  return std::chrono::duration_cast<::std::chrono::nanoseconds>(
+             std::chrono::steady_clock::now().time_since_epoch())
+      .count();
+}
+
+template <typename PROCEDURE>
+double bench(PROCEDURE f, uint64_t threshold = 200'000'000) {
+  uint64_t start = nano();
+  uint64_t finish = start;
+  size_t times{0};
+  for (; finish - start < threshold; times++) {
+    size_t output_size = f();
+    if (output_size == 0) {
+      throw std::runtime_error("bad input?");
+    }
+    finish = nano();
+  }
+  return double(finish - start) / times;
+}
+
+void run_from_utf8(const std::vector<char> &input_data) {
+  std::cout << "# aligning input" << std::endl;
+  std::cout << "# input size = " << input_data.size() << " bytes" << std::endl;
+  std::vector<char> tmp_buffer(input_data);
+  tmp_buffer.resize(tmp_buffer.size() + 512);
+  std::vector<char16_t> buffer(
+      simdutf::utf16_length_from_utf8(input_data.data(), input_data.size()));
+  size_t utf8count = simdutf::count_utf8(input_data.data(), input_data.size());
+  // Let us warm up:
+  bench(
+      [&tmp_buffer, &input_data, &buffer]() -> size_t {
+        return simdutf::convert_utf8_to_utf16le(
+            tmp_buffer.data(), input_data.size(), buffer.data());
+      },
+      2'000'000'000);
+  // warmed up
+  double best_speed = 0;
+  double worst_speed = 1e300;
+
+  for (size_t offset = 0; offset < 512; offset += 1) {
+    memcpy(tmp_buffer.data() + offset, input_data.data(), input_data.size());
+
+    std::cout << offset << ",\t";
+    auto size_procedure = [&tmp_buffer, &input_data, offset,
+                           &buffer]() -> size_t {
+      return simdutf::convert_utf8_to_utf16le(tmp_buffer.data() + offset,
+                                              input_data.size(), buffer.data());
+    };
+    double speed = utf8count / bench(size_procedure);
+    if (speed > best_speed) {
+      best_speed = speed;
+    }
+    if (speed < worst_speed) {
+      worst_speed = speed;
+    }
+
+    std::cout << speed << "\n";
+  }
+  std::cout << "# worst speed " << worst_speed << std::endl;
+  std::cout << "# best speed " << best_speed << std::endl;
+  std::cout << "# difference (percent) " << (best_speed / worst_speed - 1) * 100
+            << std::endl;
+}
+
+void run_from_utf8_output(const std::vector<char> &input_data) {
+  std::cout << "# aligning output" << std::endl;
+  std::cout << "# input size = " << input_data.size() << " bytes" << std::endl;
+
+  std::vector<char16_t> buffer(
+      simdutf::utf16_length_from_utf8(input_data.data(), input_data.size()) +
+      512);
+  size_t utf8count = simdutf::count_utf8(input_data.data(), input_data.size());
+  // Let us warm up:
+  bench(
+      [&input_data, &buffer]() -> size_t {
+        return simdutf::convert_utf8_to_utf16le(
+            input_data.data(), input_data.size(), buffer.data());
+      },
+      2'000'000'000);
+  // warmed up
+  double best_speed = 0;
+  double worst_speed = 1e300;
+
+  for (size_t offset = 0; offset < 512; offset += 1) {
+
+    std::cout << offset << ",\t";
+    auto size_procedure = [&input_data, offset, &buffer]() -> size_t {
+      return simdutf::convert_utf8_to_utf16le(
+          input_data.data(), input_data.size(), buffer.data() + offset);
+    };
+    double speed = utf8count / bench(size_procedure);
+    if (speed > best_speed) {
+      best_speed = speed;
+    }
+    if (speed < worst_speed) {
+      worst_speed = speed;
+    }
+
+    std::cout << speed << "\n";
+  }
+  std::cout << "# worst speed " << worst_speed << std::endl;
+  std::cout << "# best speed " << best_speed << std::endl;
+  std::cout << "# difference (percent) " << (best_speed / worst_speed - 1) * 100
+            << std::endl;
+}
+
+int main(int argc, char **argv) {
+  printf("# current system detected as %s.\n",
+         simdutf::get_active_implementation()->name().c_str());
+  if (argc < 2) {
+    std::cerr << "Please provide a file argument." << std::endl;
+    return EXIT_FAILURE;
+  }
+  const char *filename = argv[1];
+  printf("# loading file %s\n", filename);
+  std::filesystem::path path(filename);
+  std::ifstream file;
+  file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+  file.open(path);
+  std::vector<char> input_data;
+  input_data.assign(std::istreambuf_iterator<char>(file),
+                    std::istreambuf_iterator<char>());
+  auto detected_encoding =
+      simdutf::autodetect_encoding(input_data.data(), input_data.size());
+  printf("# input detected as %s.\n",
+         simdutf::to_string(detected_encoding).c_str());
+  if (detected_encoding == simdutf::encoding_type::UTF8) {
+    run_from_utf8_output(input_data);
+    std::cout << "----" << std::endl;
+
+    run_from_utf8(input_data);
+  } else {
+    printf("We only support UTF-8 inputs.\n");
+  }
+  return EXIT_SUCCESS;
+}

package/deps/simdutf/benchmarks/base64/CMakeLists.txt

@@ -0,0 +1,30 @@
+include(../../cmake/CPM.cmake)
+CPMAddPackage(
+  NAME base64
+  GITHUB_REPOSITORY aklomp/base64
+  VERSION 0.5.2
+  OPTIONS "BASE64_BUILD_CLI Off"
+)
+
+# Check if the compiler supports C++20
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag("/std:c++20" MSVC_CXX20_SUPPORTED) # For MSVC
+check_cxx_compiler_flag("-std=c++20" UNIX_CXX20_SUPPORTED) # For GCC/Clang
+
+if((CMAKE_CXX_COMPILER_ID MATCHES "MSVC" AND MSVC_CXX20_SUPPORTED) OR
+   (NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC" AND UNIX_CXX20_SUPPORTED))
+    message(STATUS "Compiler supports C++20")
+  add_executable(benchmark_base64 benchmark_base64.cpp)
+  set_property(TARGET benchmark_base64 PROPERTY CXX_STANDARD 20)
+  set_property(TARGET benchmark_base64 PROPERTY CXX_STANDARD_REQUIRED ON)
+
+  target_link_libraries(benchmark_base64 PUBLIC base64)
+  target_link_libraries(benchmark_base64 PUBLIC simdutf::benchmarks::benchmark)
+
+  # check if simdutf was built with c++ 20 - otherwise atomic base64 operations are not available
+  get_property(SIMDUTF_COMPILED_CXX_VERSION TARGET simdutf PROPERTY CXX_STANDARD)
+  message(VERBOSE "simdutf version is ${SIMDUTF_COMPILED_CXX_VERSION}")
+  target_compile_definitions(benchmark_base64 PRIVATE SIMDUTF_COMPILED_CXX_VERSION=${SIMDUTF_COMPILED_CXX_VERSION})
+else()
+  message(STATUS "Compiler does not support C++20. We not building the tool benchmark_base64.")
+endif()