react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/tests/validate_utf8_brute_force_tests.cpp

@@ -0,0 +1,88 @@
+#include "simdutf.h"
+
+#include <tests/helpers/random_utf8.h>
+#include <tests/reference/validate_utf8.h>
+#include <tests/helpers/test.h>
+
+template <typename T>
+static void test_corrupt(T &implementation, uint32_t seed,
+                         simdutf::tests::helpers::random_utf8 gen_utf8) {
+  std::mt19937 gen(seed);
+  for (size_t i = 0; i < 10; i++) {
+    auto UTF8 = gen_utf8.generate(1000);
+    if (!implementation.validate_utf8((const char *)UTF8.data(), UTF8.size())) {
+      puts("bug");
+      ASSERT_TRUE(false);
+    }
+    std::uniform_int_distribution<size_t> distIdx{0, UTF8.size() - 1};
+    for (size_t j = 0; j < 1000; ++j) {
+      const size_t corrupt = distIdx(gen);
+      uint8_t restore = UTF8[corrupt];
+      UTF8[corrupt] = uint8_t(gen());
+      bool is_ok =
+          implementation.validate_utf8((const char *)UTF8.data(), UTF8.size());
+      bool is_ok_basic = simdutf::tests::reference::validate_utf8(
+          (const char *)UTF8.data(), UTF8.size());
+      if (is_ok != is_ok_basic) {
+        puts("bug");
+        ASSERT_TRUE(false);
+      }
+      UTF8[corrupt] = restore;
+    }
+  }
+}
+
+TEST(corrupt_1byte) {
+  uint32_t seed{1234};
+  test_corrupt(implementation, seed,
+               simdutf::tests::helpers::random_utf8(seed, 1, 0, 0, 0));
+}
+
+TEST(corrupt_2byte) {
+  uint32_t seed{1234};
+  test_corrupt(implementation, seed,
+               simdutf::tests::helpers::random_utf8(seed, 0, 1, 0, 0));
+  test_corrupt(implementation, seed,
+               simdutf::tests::helpers::random_utf8(seed, 1, 1, 0, 0));
+}
+
+TEST(corrupt_3byte) {
+  uint32_t seed{1234};
+  test_corrupt(implementation, seed,
+               simdutf::tests::helpers::random_utf8(seed, 0, 0, 1, 0));
+  test_corrupt(implementation, seed,
+               simdutf::tests::helpers::random_utf8(seed, 0, 1, 1, 0));
+  test_corrupt(implementation, seed,
+               simdutf::tests::helpers::random_utf8(seed, 1, 0, 1, 0));
+  test_corrupt(implementation, seed,
+               simdutf::tests::helpers::random_utf8(seed, 1, 1, 1, 0));
+}
+
+TEST(brute_force) {
+  uint32_t seed{1234};
+  simdutf::tests::helpers::random_utf8 gen_1_2_3_4(seed, 1, 1, 1, 1);
+  size_t total = 1000;
+  for (size_t i = 0; i < total; i++) {
+
+    auto UTF8 = gen_1_2_3_4.generate(rand() % 256);
+    if (!implementation.validate_utf8((const char *)UTF8.data(), UTF8.size())) {
+      puts("bug");
+      ASSERT_TRUE(false);
+    }
+    for (size_t flip = 0; flip < 1000; ++flip) {
+      // we are going to hack the string as long as it is UTF-8
+      const int bitflip{1 << (rand() % 8)};
+      UTF8[rand() % UTF8.size()] = uint8_t(bitflip); // we flip exactly one bit
+      bool is_ok =
+          implementation.validate_utf8((const char *)UTF8.data(), UTF8.size());
+      bool is_ok_basic = simdutf::tests::reference::validate_utf8(
+          (const char *)UTF8.data(), UTF8.size());
+      if (is_ok != is_ok_basic) {
+        puts("bug");
+        ASSERT_TRUE(false);
+      }
+    }
+  }
+}
+
+TEST_MAIN

package/deps/simdutf/tests/validate_utf8_puzzler_tests.cpp

@@ -0,0 +1,33 @@
+#include "simdutf.h"
+
+#include <tests/helpers/test.h>
+
+// This is an attempt at reproducing an issue with the utf8 fuzzer
+TEST(puzzler) {
+  const char *bad64 =
+      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00"
+      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00"
+      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+  size_t length = 64;
+  ASSERT_FALSE(implementation.validate_utf8(bad64, length));
+}
+
+TEST(puzzler2) {
+  // Interesting case where the error occurs in the first 64 bytes but is only
+  // detected in the next 64 bytes.
+  const char *bad102 =
+      "\x0a\x04\x00\x00\xdb\xa1\xdd\xa1\xf1\xa0\xb6\x95\xe4\xb5\x89\xe7\x8f\x95"
+      "\xe4\xa2\x83\xe7\x95\x89\xe7\x95\x91\xe7\x95\x89\x00\x01\x01\x1a\x20\x28"
+      "\x00\x00\x60\x00\x00\x23\x00\xf1\xa0\xb6\x95\xe4\xb5\x89\xe7\x8f\x95\xe4"
+      "\xa2\x83\xe7\x95\x89\xe7\x95\x91\xe7\x81\x00\x00\x01\x01\x1a\x20\x28\x00"
+      "\x00\x60\x00\x00\x23\x00\x2f\x00\x00\x00\x00\x07\x04\x75\xc2\xa0\x34\x2f"
+      "\x00\x00\x00\x00\x07\x04\x75\xc2\xa0\x33\x53\x2b";
+  size_t length = 102;
+  ASSERT_FALSE(implementation.validate_utf8(bad102, length));
+  auto r = implementation.validate_utf8_with_errors(bad102, length);
+  ASSERT_EQUAL(r.error, simdutf::TOO_SHORT);
+  ASSERT_EQUAL(r.count, 62);
+}
+
+TEST_MAIN

package/deps/simdutf/tests/validate_utf8_with_errors_tests.cpp

@@ -0,0 +1,228 @@
+#include "simdutf.h"
+
+#include <tests/helpers/fixed_string.h>
+#include <tests/helpers/random_utf8.h>
+#include <tests/helpers/test.h>
+
+TEST(validate_utf8_with_errors_cbf29ce4842223f0) {
+  const unsigned char data[] = {
+      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+      0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xff};
+  constexpr std::size_t data_len_bytes = sizeof(data);
+  constexpr std::size_t data_len = data_len_bytes / sizeof(char);
+  const auto validation1 =
+      implementation.validate_utf8_with_errors((const char *)data, data_len);
+  /*
+  got return [count=64, error=SUCCESS] from implementation icelake
+  got return [count=63, error=HEADER_BITS] from implementation haswell
+  got return [count=63, error=HEADER_BITS] from implementation westmere
+  got return [count=63, error=HEADER_BITS] from implementation fallback
+  */
+  ASSERT_EQUAL(validation1.count, 63);
+  ASSERT_EQUAL(validation1.error, simdutf::error_code::HEADER_BITS);
+}
+
+// https://github.com/nodejs/node/issues/48995
+TEST(node48995) {
+  const char bad[1] = {(char)0x80};
+  size_t length = 1;
+  simdutf::result res = implementation.validate_utf8_with_errors(bad, length);
+  ASSERT_TRUE(res.error);
+}
+
+TEST(copyright) {
+  const char good[2] = {'\xC2', '\xA9'};
+  size_t length = 2;
+  simdutf::result res = implementation.validate_utf8_with_errors(good, length);
+  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
+}
+
+TEST_LOOP(no_error) {
+  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
+  const auto utf8{generator.generate(512, seed)};
+  simdutf::result res = implementation.validate_utf8_with_errors(
+      reinterpret_cast<const char *>(utf8.data()), utf8.size());
+  ASSERT_EQUAL(res.error, simdutf::error_code::SUCCESS);
+  ASSERT_EQUAL(res.count, utf8.size());
+}
+
+TEST_LOOP(header_bits_error) {
+  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
+  auto utf8{generator.generate(512, seed)};
+
+  for (unsigned int i = 0; i < 512; i++) {
+    if ((utf8[i] & 0b11000000) != 0b10000000) { // Only process leading bytes
+      const unsigned char old = utf8[i];
+      utf8[i] = uint8_t(0b11111000);
+      simdutf::result res = implementation.validate_utf8_with_errors(
+          reinterpret_cast<const char *>(utf8.data()), utf8.size());
+      ASSERT_EQUAL(res.error, simdutf::error_code::HEADER_BITS);
+      ASSERT_EQUAL(res.count, i);
+      utf8[i] = old;
+    }
+  }
+}
+
+TEST_LOOP(too_short_error) {
+  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
+  auto utf8{generator.generate(512, seed)};
+  int leading_byte_pos = 0;
+  for (int i = 0; i < 512; i++) {
+    if ((utf8[i] & 0b11000000) ==
+        0b10000000) { // Only process continuation bytes by making them leading
+                      // bytes
+      const unsigned char old = utf8[i];
+      utf8[i] = uint8_t(0b11100000);
+      simdutf::result res = implementation.validate_utf8_with_errors(
+          reinterpret_cast<const char *>(utf8.data()), utf8.size());
+      ASSERT_EQUAL(res.error, simdutf::error_code::TOO_SHORT);
+      ASSERT_EQUAL(res.count, static_cast<unsigned>(leading_byte_pos));
+      utf8[i] = old;
+    } else {
+      leading_byte_pos = i;
+    }
+  }
+}
+
+TEST_LOOP(too_long_error) {
+  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
+  auto utf8{generator.generate(512, seed)};
+  for (unsigned int i = 1; i < 512; i++) {
+    if (((utf8[i] & 0b11000000) !=
+         0b10000000)) { // Only process leading bytes by making them
+                        // continuation bytes
+      const unsigned char old = utf8[i];
+      utf8[i] = uint8_t(0b10000000);
+      simdutf::result res = implementation.validate_utf8_with_errors(
+          reinterpret_cast<const char *>(utf8.data()), utf8.size());
+      ASSERT_EQUAL(res.error, simdutf::error_code::TOO_LONG);
+      ASSERT_EQUAL(res.count, i);
+      utf8[i] = old;
+    }
+  }
+}
+
+TEST_LOOP(overlong_error) {
+  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
+  auto utf8{generator.generate(512, seed)};
+  for (unsigned int i = 1; i < 512; i++) {
+    if (utf8[i] >= 0b11000000) { // Only non-ASCII leading bytes can be overlong
+      const unsigned char old = utf8[i];
+      const unsigned char second_old = utf8[i + 1];
+      if ((old & 0b11100000) == 0b11000000) { // two-bytes case, change to a
+                                              // value less or equal than 0x7f
+        utf8[i] = 0b11000000;
+      } else if ((old & 0b11110000) ==
+                 0b11100000) { // three-bytes case, change to a value less or
+                               // equal than 0x7ff
+        utf8[i] = 0b11100000;
+        utf8[i + 1] = utf8[i + 1] & 0b11011111;
+      } else { // four-bytes case, change to a value less or equal than 0xffff
+        utf8[i] = 0b11110000;
+        utf8[i + 1] = utf8[i + 1] & 0b11001111;
+      }
+      simdutf::result res = implementation.validate_utf8_with_errors(
+          reinterpret_cast<const char *>(utf8.data()), utf8.size());
+      ASSERT_EQUAL(res.error, simdutf::error_code::OVERLONG);
+      ASSERT_EQUAL(res.count, i);
+      utf8[i] = old;
+      utf8[i + 1] = second_old;
+    }
+  }
+}
+
+TEST_LOOP(too_large_error) {
+  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
+  auto utf8{generator.generate(512, seed)};
+  for (unsigned int i = 1; i < 512; i++) {
+    if ((utf8[i] & 0b11111000) ==
+        0b11110000) { // Can only have too large error in 4-bytes case
+      utf8[i] += ((utf8[i] & 0b100) == 0b100)
+                     ? 0b10
+                     : 0b100; // Make sure we get too large error and not header
+                              // bits error
+      simdutf::result res = implementation.validate_utf8_with_errors(
+          reinterpret_cast<const char *>(utf8.data()), utf8.size());
+      ASSERT_EQUAL(res.error, simdutf::error_code::TOO_LARGE);
+      ASSERT_EQUAL(res.count, i);
+      utf8[i] -= 0b100;
+    }
+  }
+}
+
+TEST_LOOP(surrogate_error) {
+  simdutf::tests::helpers::random_utf8 generator{seed, 1, 1, 1, 1};
+  auto utf8{generator.generate(512, seed)};
+  for (unsigned int i = 1; i < 512; i++) {
+    if ((utf8[i] & 0b11110000) ==
+        0b11100000) { // Can only have surrogate error in 3-bytes case
+      const unsigned char old = utf8[i];
+      const unsigned char second_old = utf8[i + 1];
+      utf8[i] = 0b11101101; // Leading byte is always the same
+      for (int s = 0x8; s < 0xf;
+           s++) { // Modify second byte to create a surrogate codepoint
+        utf8[i + 1] = (utf8[i + 1] & 0b11000011) | (s << 2);
+        simdutf::result res = implementation.validate_utf8_with_errors(
+            reinterpret_cast<const char *>(utf8.data()), utf8.size());
+        ASSERT_EQUAL(res.error, simdutf::error_code::SURROGATE);
+        ASSERT_EQUAL(res.count, i);
+      }
+      utf8[i] = old;
+      utf8[i + 1] = second_old;
+    }
+  }
+}
+
+#if SIMDUTF_CPLUSPLUS23
+
+void compile_time_test_of_good_data() {
+
+  using namespace simdutf::tests::helpers;
+  constexpr auto good = u8"köttbulle"_utf8;
+
+  static_assert(good.size() == 10);
+  static_assert(!simdutf::validate_utf8_with_errors(good).error);
+  static_assert(
+      !simdutf::validate_utf8_with_errors(good.as_array<signed char>()).error);
+  static_assert(
+      !simdutf::validate_utf8_with_errors(good.as_array<unsigned char>())
+           .error);
+  static_assert(
+      !simdutf::validate_utf8_with_errors(good.as_array<std::byte>()).error);
+}
+
+namespace {
+template <typename DestCharType, typename ArrayInput>
+constexpr auto convert_array(const ArrayInput &input) {
+  std::array<DestCharType, ArrayInput{}.size()> ret;
+  for (std::size_t i = 0; i < ArrayInput{}.size(); ++i) {
+    ret[i] = static_cast<DestCharType>(input[i]);
+  }
+  return ret;
+}
+} // namespace
+
+void compile_time_test_of_bad_data() {
+  constexpr std::array bad_utf8{'a', '\xFF'};
+  static_assert(simdutf::validate_utf8_with_errors(bad_utf8).error !=
+                simdutf::SUCCESS);
+  static_assert(simdutf::validate_utf8_with_errors(bad_utf8).count == 1);
+  static_assert(
+      simdutf::validate_utf8_with_errors(convert_array<char>(bad_utf8)).error);
+  static_assert(
+      simdutf::validate_utf8_with_errors(convert_array<signed char>(bad_utf8))
+          .error);
+  static_assert(
+      simdutf::validate_utf8_with_errors(convert_array<unsigned char>(bad_utf8))
+          .error);
+  static_assert(
+      simdutf::validate_utf8_with_errors(convert_array<std::byte>(bad_utf8))
+          .error);
+}
+#endif
+
+TEST_MAIN

package/deps/simdutf/tools/CMakeLists.txt

@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.15)
+
+add_executable(sutf sutf.cpp)
+add_executable(fastbase64 fastbase64.cpp)
+
+if(SIMDUTF_ICONV)
+find_package(Iconv)
+if(Iconv_FOUND)
+  message(STATUS "Iconv was found!")
+  target_compile_definitions(sutf 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(sutf PUBLIC ${Iconv_LIBRARY})
+    target_include_directories(sutf 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)
+if(APPLE)
+  message(STATUS "This is an Apple platform " ${CMAKE_CXX_COMPILER_ID})
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    message(STATUS "Apple platform detected, using dead_strip and LTO")
+    target_link_options(sutf PRIVATE "-Wl,-dead_strip")
+    target_link_options(fastbase64 PRIVATE "-Wl,-dead_strip")
+    target_compile_options(sutf PRIVATE "-flto")
+    target_link_options(sutf PRIVATE "-flto")
+    target_compile_options(fastbase64 PRIVATE "-flto")
+    target_link_options(fastbase64 PRIVATE "-flto")
+  endif()
+endif()
+
+if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-libgcc-file-name OUTPUT_VARIABLE SIMDUTF_GCC_LIB)
+  get_filename_component(SIMDUTF_GCC_DIR "${SIMDUTF_GCC_LIB}" DIRECTORY)
+  message(STATUS "looking for static C++ library in " ${SIMDUTF_GCC_DIR})
+  find_library(LIBSTDCPP libstdc++.a PATHS "${SIMDUTF_GCC_DIR}")
+  if(LIBSTDCPP)
+    message(STATUS "libstdc++.a found")
+    target_link_options(sutf PRIVATE "-static-libstdc++")
+    target_link_options(fastbase64 PRIVATE "-static-libstdc++")
+  else()
+    message(STATUS "libstdc++.a not found")
+  endif()
+  if(NOT APPLE)
+    target_link_options(sutf PRIVATE "-Wl,--gc-sections")
+    target_link_options(fastbase64 PRIVATE "-Wl,--gc-sections")
+  endif()
+endif()
+message(STATUS "The tools require C++17. If your system does not support C++17, please set SIMDUTF_TOOLS to OFF.")
+set_property(TARGET sutf PROPERTY CXX_STANDARD 17)
+set_property(TARGET sutf PROPERTY CXX_STANDARD_REQUIRED ON)
+set_property(TARGET fastbase64 PROPERTY CXX_STANDARD 17)
+set_property(TARGET fastbase64 PROPERTY CXX_STANDARD_REQUIRED ON)
+
+target_link_libraries(sutf PUBLIC simdutf)
+target_link_libraries(fastbase64 PUBLIC simdutf)
+
+if(WIN32 AND BUILD_SHARED_LIBS)
+  # Copy the simdutf dll into the directory
+  add_custom_command(TARGET sutf 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:sutf>")                 # <--this is out-file path
+endif()
+install(
+   TARGETS
+    sutf
+   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+install(
+   TARGETS
+    fastbase64
+   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)

package/deps/simdutf/tools/fastbase64.cpp

@@ -0,0 +1,250 @@
+#include "simdutf.h"
+
+#include <array>
+#include <cerrno>
+#include <filesystem>
+#include <vector>
+
+class CommandLine {
+public:
+  std::FILE *current_file{NULL};
+  std::filesystem::path output_file;
+
+  CommandLine() = default;
+  static CommandLine parse_and_validate_arguments(int argc, char *argv[]);
+  bool run_procedure(std::FILE *fpout);
+  bool encode_to(std::FILE *fpout);
+  bool decode_to(std::FILE *fpout);
+  bool run();
+  std::pair<bool, size_t> load_chunk(char *input_data, size_t chunk_size,
+                                     size_t offset);
+  bool write_to_file_descriptor(std::FILE *fp, const char *data, size_t length);
+  static void show_help();
+  bool decode;
+};
+
+CommandLine CommandLine::parse_and_validate_arguments(int argc, char *argv[]) {
+  CommandLine cmdline;
+  std::vector<std::string> arguments;
+
+  for (int i = 1; i < argc; i++) {
+    std::string arg{argv[i]};
+    if ((arg == "-h") || (arg == "--help")) {
+      CommandLine::show_help();
+      return cmdline;
+    } else {
+      arguments.push_back(std::move(arg));
+    }
+  }
+  if (arguments.size() == 0) {
+    throw std::runtime_error("Too few arguments!");
+  }
+  cmdline.decode = false;
+  for (std::string &a : arguments) {
+    if (a == "-d") {
+      cmdline.decode = true;
+    } else if (a == "-e") {
+      cmdline.decode = false;
+    } else if (a[0] == '-') {
+      throw std::runtime_error("Unknown option: " + a);
+    } else {
+      if (cmdline.current_file == NULL) {
+        cmdline.current_file = std::fopen(a.c_str(), "rb");
+        if (cmdline.current_file == NULL) {
+          throw std::runtime_error("Could not open file: " + a + ":" +
+                                   std::string(strerror(errno)));
+        }
+      } else if (cmdline.output_file.empty()) {
+        cmdline.output_file = a;
+      } else {
+        throw std::runtime_error("Too many arguments!");
+      }
+    }
+  }
+  return cmdline;
+}
+
+bool CommandLine::run() {
+  if (current_file == NULL) {
+    throw std::runtime_error("No input file specified!");
+  }
+  if (output_file.empty()) {
+    return run_procedure(stdout);
+  } else {
+    SIMDUTF_PUSH_DISABLE_WARNINGS
+    SIMDUTF_DISABLE_DEPRECATED_WARNING
+    std::FILE *fp = std::fopen(output_file.string().c_str(), "wb");
+    SIMDUTF_POP_DISABLE_WARNINGS
+    if (fp == NULL) {
+      fprintf(stderr, "Could not open %s: %s\n", output_file.string().c_str(),
+              strerror(errno));
+      return false;
+    }
+    bool success = run_procedure(fp);
+    // Let us first try to close the file.
+    if (fclose(fp) != 0) {
+      fprintf(stderr, "Failed to close %s: %s\n", output_file.string().c_str(),
+              strerror(errno));
+      return false;
+    }
+    return success;
+  }
+}
+
+bool CommandLine::run_procedure(std::FILE *fpout) {
+  if (decode) {
+    return decode_to(fpout);
+  } else {
+    return encode_to(fpout);
+  }
+}
+
+// load_chunk returns a pair of a boolean and a size_t, the boolean is true
+// until we reach the end of the stream, the size_t is the number of bytes read.
+std::pair<bool, size_t>
+CommandLine::load_chunk(char *input_data, size_t chunk_size, size_t offset) {
+  size_t bytes_read =
+      std::fread(input_data + offset, 1, chunk_size - offset, current_file);
+  if (std::ferror(current_file)) {
+    std::fclose(current_file);
+    throw std::runtime_error("Error while reading:" +
+                             std::string(strerror(errno)));
+  }
+  if (std::feof(current_file)) { // Check if current_file is done
+    std::fclose(current_file);   // best effort
+    current_file = NULL;
+    return {false, bytes_read};
+  }
+  return {true, bytes_read};
+}
+
+bool CommandLine::write_to_file_descriptor(std::FILE *fp, const char *data,
+                                           size_t length) {
+  if (fp == NULL) {
+    return false;
+  }
+  size_t bytes_written = std::fwrite(data, 1, length, fp);
+  if (bytes_written != length) {
+    throw std::runtime_error("Failed to write:" + std::string(strerror(errno)));
+  }
+  return true;
+}
+
+bool CommandLine::decode_to(std::FILE *fpout) {
+  const size_t chunk_size = 65536;
+  std::array<char, chunk_size> input_data;
+  std::array<char, (chunk_size + 3) / 4 * 3> output_buffer;
+  size_t pos =
+      0; // the pos variable keeps track of the position in the input file.
+  // Its purpose is to provide a position for error messages.
+  size_t offset = 0;
+  // load_chunk returns a pair of a boolean and a size_t, the boolean is true
+  // until we reach the end of the stream, the size_t is the number of bytes
+  // read.
+  for (auto p = load_chunk(input_data.data(), chunk_size, offset); p.second > 0;
+       p = load_chunk(input_data.data(), chunk_size, offset)) {
+    // We convertto base64 the data we have read so far
+    simdutf::result r = simdutf::base64_to_binary(
+        input_data.data(), p.second + offset, output_buffer.data());
+    // If we have encountered an invalid character, we print an error message
+    // and return false.
+    if (r.error == simdutf::error_code::INVALID_BASE64_CHARACTER) {
+      fprintf(stderr, "Invalid base64 character at position %zu\n.",
+              pos + r.count);
+      return false;
+    }
+    // if p.first is false, we have reached the end of the file.
+    if (!p.first) {
+      // At the end of the file, if we are left with one base64 character
+      // leftover, it is a fatal error.
+      if (r.error == simdutf::error_code::BASE64_INPUT_REMAINDER) {
+        fprintf(stderr, "The base64 input contained an invalid number of "
+                        "characters or could not be read.");
+        return false;
+      }
+      // Otherwise, we write the output and return true.
+      write_to_file_descriptor(fpout, output_buffer.data(), r.count);
+      return true;
+    }
+    // We want to write the data in chunks of 3 bytes and read blocks of
+    // 4 bytes. We keep the last 0, 1, 3 or 4 base64 bytes in the input buffer.
+    // And we write the output in chunks of 3 bytes.
+    offset = 0;
+    if (r.error == simdutf::error_code::BASE64_INPUT_REMAINDER) {
+      offset = 1;
+    } else {
+      offset = (r.count % 3) == 0 ? 0 : (r.count % 3) + 1;
+    }
+    // Copy 0, 1, 2 or 3 non-space bytes to the input buffer.
+    size_t copied = 0;
+    for (size_t z = p.second - 1; copied < offset; z--) {
+      if (input_data[z] == ' ' || input_data[z] == '\n' ||
+          input_data[z] == '\r' || input_data[z] == '\t') {
+        continue;
+      }
+      copied++;
+      input_data[offset - copied] = input_data[z];
+    }
+    // We write a multiple of 3 bytes to the output buffer, discarding
+    // the last 0, 1 or 2 bytes.
+    r.count -= (r.count % 3);
+    write_to_file_descriptor(fpout, output_buffer.data(), r.count);
+    pos += p.second;
+  }
+  return true;
+}
+
+bool CommandLine::encode_to(std::FILE *fpout) {
+  const size_t chunk_size = 49152;
+  std::array<char, chunk_size> input_data;
+  std::array<char, (chunk_size + 2) / 3 * 4> output_buffer;
+  size_t pos = 0;
+  size_t offset = 0;
+  // load_chunk returns a pair of a boolean and a size_t, the boolean is true
+  // until we reach the end of the stream, the size_t is the number of bytes
+  // read.
+  for (auto p = load_chunk(input_data.data(), chunk_size, offset); p.second > 0;
+       p = load_chunk(input_data.data(), chunk_size, offset)) {
+    // We have read p.second bytes, and we have offset bytes left from the
+    // previous chunk.
+    size_t total_bytes = p.second + offset;
+    // If we have reached the end of the file, we write the output and return
+    // true.
+    if (!p.first) {
+      // We finish the file
+      size_t output_size = simdutf::binary_to_base64(
+          input_data.data(), total_bytes, output_buffer.data());
+      write_to_file_descriptor(fpout, output_buffer.data(), output_size);
+      return true;
+    }
+    // We want to write the data in chunks of 4 bytes and read blocks of
+    // 3 bytes. We keep the last 0, 1 or 2 bytes in the input buffer.
+    offset = total_bytes % 3;
+    total_bytes -= offset;
+    size_t output_size = simdutf::binary_to_base64(
+        input_data.data(), total_bytes, output_buffer.data());
+    write_to_file_descriptor(fpout, output_buffer.data(), output_size);
+    // Copy 0, 1 or 2 bytes to the start of the input buffer.
+    memcpy(input_data.data(), input_data.data() + total_bytes, offset);
+  }
+  return true;
+}
+
+void CommandLine::show_help() {
+  printf("Usage: fastbase64 [OPTIONS...] [INPUTFILE] [OUTPUTFILE]\n\n");
+  printf("  -d       decode base64\n"
+         "  -e       encode base64 (default)\n\n");
+  printf("If output is not specified, the output is redirected to standard "
+         "output.\n");
+}
+
+int main(int argc, char *argv[]) {
+  try {
+    CommandLine cmdline = CommandLine::parse_and_validate_arguments(argc, argv);
+    return cmdline.run() ? EXIT_SUCCESS : EXIT_FAILURE;
+  } catch (const std::exception &e) {
+    fprintf(stderr, "%s\n", e.what());
+    CommandLine::show_help();
+    return EXIT_FAILURE;
+  }
+}