react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/benchmarks/base64/libbase64_spaces.h

@@ -1,49 +0,0 @@
-
-// https://github.com/aklomp/base64/blob/b20a31a997e0b48274fa09e58b65ee9202531e4f/bin/base64.c#L392
-static inline size_t libbase64_find_space(const char *p, const size_t avail) {
-  for (size_t len = 0; len < avail; len++) {
-    if (p[len] == '\n' || p[len] == '\r' || p[len] == ' ' || p[len] == '\t') {
-      return len;
-    }
-  }
-
-  return avail;
-}
-
-// Inspired by
-// https://github.com/aklomp/base64/blob/b20a31a997e0b48274fa09e58b65ee9202531e4f/bin/base64.c#L405
-static bool libbase64_space_decode(const char *start, size_t avail,
-                                   char *outbuf, size_t *outlen) {
-  struct base64_state state;
-  *outlen = 0;
-
-  // Initialize the decoder's state structure.
-  base64_stream_decode_init(&state, 0);
-
-  while (avail > 0) {
-    size_t len = libbase64_find_space(start, avail);
-    if (len == 0) {
-      start++;
-      avail--;
-      continue;
-    }
-
-    // Decode the chunk into the raw buffer.
-    size_t outlen = 0;
-    if (base64_stream_decode(&state, start, len, outbuf, &outlen) == 0) {
-      // decoding error
-      return false;
-    }
-
-    // Update the output buffer pointer and total size.
-    outbuf += outlen;
-    outlen += outlen;
-    if (avail == len) {
-      break;
-    }
-
-    start += len + 1;
-    avail -= len + 1;
-  }
-  return true;
-}

package/deps/simdutf/benchmarks/base64/node_base64.h

@@ -1,227 +0,0 @@
-// Taken from Node.js, for benchmarking purposes.
-// See
-// https://github.com/nodejs/node/blob/dafe004703f4f0a878558090ab3dd8ef0624037d/src/base64.h#L15
-// and
-// https://github.com/nodejs/node/blob/dafe004703f4f0a878558090ab3dd8ef0624037d/src/base64-inl.h
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-namespace node {
-//// Base 64 ////
-
-enum class Base64Mode { NORMAL, URL };
-
-// Doesn't check for padding at the end.  Can be 1-2 bytes over.
-inline constexpr size_t base64_decoded_size_fast(size_t size) {
-  // 1-byte input cannot be decoded
-  return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
-}
-
-inline uint32_t ReadUint32BE(const unsigned char *p);
-
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName *src, size_t size);
-
-template <typename TypeName>
-size_t base64_decode(char *const dst, const size_t dstlen,
-                     const TypeName *const src, const size_t srclen);
-
-inline size_t base64_encode(const char *src, size_t slen, char *dst,
-                            size_t dlen, Base64Mode mode = Base64Mode::NORMAL);
-} // namespace node
-
-namespace node {
-
-/*extern const int8_t unbase64_table[256];*/
-
-// supports regular and URL-safe base64
-const int8_t unbase64_table[256] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
-    61, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
-    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1,
-    63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
-    43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1};
-
-inline int8_t unbase64(uint8_t x) { return unbase64_table[x]; }
-
-inline uint32_t ReadUint32BE(const unsigned char *p) {
-  return static_cast<uint32_t>(p[0] << 24U) |
-         static_cast<uint32_t>(p[1] << 16U) |
-         static_cast<uint32_t>(p[2] << 8U) | static_cast<uint32_t>(p[3]);
-}
-
-#ifdef _MSC_VER
-  #pragma warning(push)
-  // MSVC C4003: not enough actual parameters for macro 'identifier'
-  #pragma warning(disable : 4003)
-#endif
-template <typename TypeName>
-bool base64_decode_group_slow(char *const dst, const size_t dstlen,
-                              const TypeName *const src, const size_t srclen,
-                              size_t *const i, size_t *const k) {
-  uint8_t hi;
-  uint8_t lo;
-#define V(expr)                                                                \
-  for (;;) {                                                                   \
-    const uint8_t c = static_cast<uint8_t>(src[*i]);                           \
-    lo = uint8_t(unbase64(c));                                                 \
-    *i += 1;                                                                   \
-    if (lo < 64)                                                               \
-      break; /* Legal character. */                                            \
-    if (c == '=' || *i >= srclen)                                              \
-      return false; /* Stop decoding. */                                       \
-  }                                                                            \
-  expr;                                                                        \
-  if (*i >= srclen)                                                            \
-    return false;                                                              \
-  if (*k >= dstlen)                                                            \
-    return false;                                                              \
-  hi = lo;
-  V(/* Nothing. */);
-  V(dst[(*k)++] = char((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
-  V(dst[(*k)++] = char((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));
-  V(dst[(*k)++] = char((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));
-#undef V
-  return true; // Continue decoding.
-}
-
-#ifdef _MSC_VER
-  #pragma warning(pop)
-#endif
-
-template <typename TypeName>
-size_t base64_decode_fast(char *const dst, const size_t dstlen,
-                          const TypeName *const src, const size_t srclen,
-                          const size_t decoded_size) {
-  const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
-  const size_t max_k = available / 3 * 3;
-  size_t max_i = srclen / 4 * 4;
-  size_t i = 0;
-  size_t k = 0;
-  while (i < max_i && k < max_k) {
-    const unsigned char txt[] = {
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
-        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
-    };
-
-    const uint32_t v = ReadUint32BE(txt);
-    // If MSB is set, input contains whitespace or is not valid base64.
-    if (v & 0x80808080) {
-      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
-        return k;
-      max_i = i + (srclen - i) / 4 * 4; // Align max_i again.
-    } else {
-      dst[k + 0] = char(((v >> 22) & 0xFC) | ((v >> 20) & 0x03));
-      dst[k + 1] = char(((v >> 12) & 0xF0) | ((v >> 10) & 0x0F));
-      dst[k + 2] = char(((v >> 2) & 0xC0) | ((v >> 0) & 0x3F));
-      i += 4;
-      k += 3;
-    }
-  }
-  if (i < srclen && k < dstlen) {
-    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
-  }
-  return k;
-}
-
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName *src, size_t size) {
-  // 1-byte input cannot be decoded
-  if (size < 2)
-    return 0;
-
-  if (src[size - 1] == '=') {
-    size--;
-    if (src[size - 1] == '=')
-      size--;
-  }
-  return base64_decoded_size_fast(size);
-}
-
-template <typename TypeName>
-size_t base64_decode(char *const dst, const size_t dstlen,
-                     const TypeName *const src, const size_t srclen) {
-  const size_t decoded_size = base64_decoded_size(src, srclen);
-  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
-}
-
-template size_t base64_decode<char>(char *const dst, const size_t dstlen,
-                                    const char *const src, const size_t srclen);
-
-static inline constexpr size_t
-base64_encoded_size(size_t size, Base64Mode mode = Base64Mode::NORMAL) {
-  return mode == Base64Mode::NORMAL ? ((size + 2) / 3 * 4)
-                                    : static_cast<size_t>(std::ceil(
-                                          static_cast<double>(size * 4) / 3));
-}
-
-inline constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                           "abcdefghijklmnopqrstuvwxyz"
-                                           "0123456789-_";
-
-inline constexpr char base64_table_normal[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                              "abcdefghijklmnopqrstuvwxyz"
-                                              "0123456789+/";
-inline size_t base64_encode(const char *src, size_t slen, char *dst,
-                            size_t dlen, Base64Mode mode) {
-
-  dlen = base64_encoded_size(slen, mode);
-
-  unsigned a;
-  unsigned b;
-  unsigned c;
-  unsigned i;
-  unsigned k;
-  unsigned n;
-
-  const char *table =
-      (mode == Base64Mode::NORMAL) ? base64_table_normal : base64_table_url;
-
-  i = 0;
-  k = 0;
-  n = slen / 3 * 3;
-
-  while (i < n) {
-    a = src[i + 0] & 0xff;
-    b = src[i + 1] & 0xff;
-    c = src[i + 2] & 0xff;
-
-    dst[k + 0] = table[a >> 2];
-    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
-    dst[k + 3] = table[c & 0x3f];
-
-    i += 3;
-    k += 4;
-  }
-
-  switch (slen - n) {
-  case 1:
-    a = src[i + 0] & 0xff;
-    dst[k + 0] = table[a >> 2];
-    dst[k + 1] = table[(a & 3) << 4];
-    break;
-  case 2:
-    a = src[i + 0] & 0xff;
-    b = src[i + 1] & 0xff;
-    dst[k + 0] = table[a >> 2];
-    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-    dst[k + 2] = table[(b & 0x0f) << 2];
-    break;
-  }
-
-  return dlen;
-}
-
-} // namespace node

package/deps/simdutf/benchmarks/base64/openssl3_base64.h

@@ -1,334 +0,0 @@
-// Taken form OpenSSL 3.4-dev, for benchmarking purposes.
-// See
-// https://github.com/openssl/openssl/blob/0285160ffa3b8c2b5491222243042593808298c4/crypto/evp/encode.c#L303
-// and
-// https://github.com/openssl/openssl/blob/0285160ffa3b8c2b5491222243042593808298c4/include/openssl/evp.h#L871-L875
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-namespace openssl3 {
-struct evp_Encode_Ctx_st {
-  /* number saved in a partial encode/decode */
-  int num;
-  /*
-   * The length is either the output line length (in input bytes) or the
-   * shortest input line length that is ok.  Once decoding begins, the
-   * length is adjusted up each time a longer line is decoded
-   */
-  int length;
-  /* data to encode */
-  unsigned char enc_data[80];
-  /* number read on current line */
-  int line_num;
-  unsigned int flags;
-};
-typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX;
-
-struct buf_mem_st {
-  size_t length; /* current number of bytes */
-  char *data;
-  size_t max; /* size of buffer */
-  unsigned long flags;
-};
-typedef struct buf_mem_st BUF_MEM;
-
-static int evp_decodeblock_int(EVP_ENCODE_CTX *ctx, unsigned char *t,
-                               const unsigned char *f, int n);
-
-template <typename TypeName>
-size_t base64_decode(char *const dst, const size_t dstlen,
-                     const TypeName *const src, const size_t srclen);
-
-void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
-
-int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
-                     const unsigned char *in, int inl);
-
-int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
-} // namespace openssl3
-
-namespace openssl3 {
-//// Base 64 ////
-
-#define EVP_ENCODE_CTX_USE_SRP_ALPHABET 2
-
-#define B64_EOF 0xF2
-#define B64_WS 0xE0
-#define B64_ERROR 0xFF
-#define B64_NOT_BASE64(a) (((a) | 0x13) == 0xF3)
-#define B64_BASE64(a) (!B64_NOT_BASE64(a))
-
-static const unsigned char data_ascii2bin[128 * 2] = {
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0xF0, 0xFF,
-    0xFF, 0xF1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xF2, 0xFF, 0x3F,
-    0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF,
-    0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
-    0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
-    0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
-    0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF,
-};
-
-static const unsigned char srpdata_ascii2bin[128] = {
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0xF0, 0xFF,
-    0xFF, 0xF1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x3E, 0x3F,
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF,
-    0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
-    0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C,
-    0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E,
-    0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
-    0x3B, 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-};
-
-inline static unsigned char conv_ascii2bin(unsigned char a,
-                                           const unsigned char *table) {
-  if (a & 0x80)
-    return B64_ERROR;
-  return table[a];
-}
-
-void OPENSSL_die(const char *message, const char *file, int line) {
-  printf("%s:%d: OpenSSL internal error: %s\n", file, line, message);
-  abort();
-}
-
-#define OPENSSL_assert(e)                                                      \
-  (void)((e) ? 0                                                               \
-             : (OPENSSL_die("assertion failed: " #e, __FILE__, __LINE__), 1))
-
-void EVP_DecodeInit(EVP_ENCODE_CTX *ctx) {
-  /* Only ctx->num and ctx->flags are used during decoding. */
-  ctx->num = 0;
-  ctx->length = 0;
-  ctx->line_num = 0;
-  ctx->flags = 0;
-}
-
-/*-
- * -1 for error
- *  0 for last line
- *  1 for full line
- *
- * Note: even though EVP_DecodeUpdate attempts to detect and report end of
- * content, the context doesn't currently remember it and will accept more data
- * in the next call. Therefore, the caller is responsible for checking and
- * rejecting a 0 return value in the middle of content.
- *
- * Note: even though EVP_DecodeUpdate has historically tried to detect end of
- * content based on line length, this has never worked properly. Therefore,
- * we now return 0 when one of the following is true:
- *   - Padding or B64_EOF was detected and the last block is complete.
- *   - Input has zero-length.
- * -1 is returned if:
- *   - Invalid characters are detected.
- *   - There is extra trailing padding, or data after padding.
- *   - B64_EOF is detected after an incomplete base64 block.
- */
-int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
-                     const unsigned char *in, int inl) {
-  int seof = 0, eof = 0, rv = -1, ret = 0, i, v, tmp, n, decoded_len;
-  unsigned char *d;
-  const unsigned char *table;
-
-  n = ctx->num;
-  d = ctx->enc_data;
-
-  if (n > 0 && d[n - 1] == '=') {
-    eof++;
-    if (n > 1 && d[n - 2] == '=')
-      eof++;
-  }
-
-  /* Legacy behaviour: an empty input chunk signals end of input. */
-  if (inl == 0) {
-    rv = 0;
-    goto end;
-  }
-
-  if ((ctx->flags & EVP_ENCODE_CTX_USE_SRP_ALPHABET) != 0)
-    table = srpdata_ascii2bin;
-  else
-    table = data_ascii2bin;
-
-  for (i = 0; i < inl; i++) {
-    tmp = *(in++);
-    v = conv_ascii2bin(tmp, table);
-    if (v == B64_ERROR) {
-      rv = -1;
-      goto end;
-    }
-
-    if (tmp == '=') {
-      eof++;
-    } else if (eof > 0 && B64_BASE64(v)) {
-      /* More data after padding. */
-      rv = -1;
-      goto end;
-    }
-
-    if (eof > 2) {
-      rv = -1;
-      goto end;
-    }
-
-    if (v == B64_EOF) {
-      seof = 1;
-      goto tail;
-    }
-
-    /* Only save valid base64 characters. */
-    if (B64_BASE64(v)) {
-      if (n >= 64) {
-        /*
-         * We increment n once per loop, and empty the buffer as soon as
-         * we reach 64 characters, so this can only happen if someone's
-         * manually messed with the ctx. Refuse to write any more data.
-         */
-        rv = -1;
-        goto end;
-      }
-      OPENSSL_assert(n < (int)sizeof(ctx->enc_data));
-      d[n++] = tmp;
-    }
-
-    if (n == 64) {
-      decoded_len = evp_decodeblock_int(ctx, out, d, n);
-      n = 0;
-      if (decoded_len < 0 || eof > decoded_len) {
-        rv = -1;
-        goto end;
-      }
-      ret += decoded_len - eof;
-      out += decoded_len - eof;
-    }
-  }
-
-  /*
-   * Legacy behaviour: if the current line is a full base64-block (i.e., has
-   * 0 mod 4 base64 characters), it is processed immediately. We keep this
-   * behaviour as applications may not be calling EVP_DecodeFinal properly.
-   */
-tail:
-  if (n > 0) {
-    if ((n & 3) == 0) {
-      decoded_len = evp_decodeblock_int(ctx, out, d, n);
-      n = 0;
-      if (decoded_len < 0 || eof > decoded_len) {
-        rv = -1;
-        goto end;
-      }
-      ret += (decoded_len - eof);
-    } else if (seof) {
-      /* EOF in the middle of a base64 block. */
-      rv = -1;
-      goto end;
-    }
-  }
-
-  rv = seof || (n == 0 && eof) ? 0 : 1;
-end:
-  /* Legacy behaviour. This should probably rather be zeroed on error. */
-  *outl = ret;
-  ctx->num = n;
-  return rv;
-}
-
-// use mega SIMD fast base64 decode.
-static int evp_decodeblock_int(EVP_ENCODE_CTX *ctx, unsigned char *t,
-                               const unsigned char *f, int n) {
-  int i, ret = 0, a, b, c, d;
-  unsigned long l;
-  const unsigned char *table;
-
-  if (ctx != NULL && (ctx->flags & EVP_ENCODE_CTX_USE_SRP_ALPHABET) != 0)
-    table = srpdata_ascii2bin;
-  else
-    table = data_ascii2bin;
-
-  /* trim whitespace from the start of the line. */
-  while ((n > 0) && (conv_ascii2bin(*f, table) == B64_WS)) {
-    f++;
-    n--;
-  }
-
-  /*
-   * strip off stuff at the end of the line ascii2bin values B64_WS,
-   * B64_EOLN, B64_EOLN and B64_EOF
-   */
-  while ((n > 3) && (B64_NOT_BASE64(conv_ascii2bin(f[n - 1], table))))
-    n--;
-
-  if (n % 4 != 0)
-    return -1;
-
-  for (i = 0; i < n; i += 4) {
-    a = conv_ascii2bin(*(f++), table);
-    b = conv_ascii2bin(*(f++), table);
-    c = conv_ascii2bin(*(f++), table);
-    d = conv_ascii2bin(*(f++), table);
-    if ((a & 0x80) || (b & 0x80) || (c & 0x80) || (d & 0x80))
-      return -1;
-    l = ((((unsigned long)a) << 18L) | (((unsigned long)b) << 12L) |
-         (((unsigned long)c) << 6L) | (((unsigned long)d)));
-    *(t++) = (unsigned char)(l >> 16L) & 0xff;
-    *(t++) = (unsigned char)(l >> 8L) & 0xff;
-    *(t++) = (unsigned char)(l) & 0xff;
-    ret += 3;
-  }
-  return ret;
-}
-
-int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl) {
-  int i;
-
-  *outl = 0;
-  if (ctx->num != 0) {
-    i = evp_decodeblock_int(ctx, out, ctx->enc_data, ctx->num);
-    if (i < 0)
-      return -1;
-    ctx->num = 0;
-    *outl = i;
-    return 1;
-  } else
-    return 1;
-}
-
-template <typename TypeName>
-size_t base64_decode(char *const dst, const size_t dstlen,
-                     const TypeName *const src, const size_t srclen) {
-  EVP_ENCODE_CTX *ctx = new EVP_ENCODE_CTX();
-  int len = dstlen;
-  int taillen = 0;
-
-  EVP_DecodeInit(ctx);
-  if (EVP_DecodeUpdate(ctx, (unsigned char *)dst, &len, (unsigned char *)src,
-                       srclen) < 0 ||
-      EVP_DecodeFinal(ctx, (unsigned char *)&(dst[len]), &taillen) < 0) {
-    fprintf(stderr, "Invalid input for openssl base64 decode.\n");
-    exit(1);
-  }
-  delete ctx;
-
-  len += taillen;
-  return len;
-}
-
-} // namespace openssl3

package/deps/simdutf/benchmarks/benchmark.cpp

@@ -1,65 +0,0 @@
-#include "src/cmdline.h"
-#include "src/benchmark.h"
-
-#include <iostream>
-
-void info_message() {
-  std::cout
-      << "We define the number of bytes to be the number of *input* bytes.\n";
-  std::cout
-      << "We define a 'char' to be a code point (between 1 and 4 bytes).\n";
-#ifdef ICU_AVAILABLE
-  std::cout << "Using ICU version " << U_ICU_VERSION << std::endl;
-#endif
-#ifdef _LIBICONV_VERSION
-  std::cout << "Using iconv version " << _LIBICONV_VERSION << std::endl;
-#endif
-#if defined(__clang__)
-  std::cout << "Compiler: Clang " << __clang_major__ << "." << __clang_minor__
-            << "." << __clang_patchlevel__ << "\n";
-#elif defined(__GNUC__)
-  std::cout << "Compiler: GCC " << __GNUC__ << "." << __GNUC_MINOR__ << "."
-            << __GNUC_PATCHLEVEL__ << "\n";
-#elif defined(_MSC_VER)
-  std::cout << "Compiler: MSVC " << _MSC_VER << "\n";
-#endif
-  std::cout << "SIMDUTF version: " << SIMDUTF_VERSION << "\n";
-  std::cout << "System: " << simdutf::get_active_implementation()->name()
-            << "\n";
-  std::cout << "===========================\n";
-}
-
-int main(int argc, char *argv[]) {
-#ifdef INOUE2008
-  inoue2008::inoue_test(); // minimal testing
-#endif
-  using simdutf::benchmarks::CommandLine;
-  CommandLine cmdline;
-  try {
-    cmdline = CommandLine::parse_arguments(argc, argv);
-    if (cmdline.show_help) {
-      CommandLine::print_help();
-      return EXIT_SUCCESS;
-    }
-
-    if (cmdline.empty()) {
-      CommandLine::print_help();
-      return EXIT_FAILURE;
-    }
-  } catch (const std::exception &e) {
-    printf("%s\n", e.what());
-    return EXIT_FAILURE;
-  }
-
-  using simdutf::benchmarks::Benchmark;
-  using simdutf::benchmarks::ListingMode;
-
-  Benchmark benchmark{Benchmark::create(cmdline)};
-  if (cmdline.show_procedures != ListingMode::None) {
-    benchmark.list_procedures(cmdline.show_procedures);
-    return EXIT_SUCCESS;
-  }
-
-  info_message();
-  return benchmark.run() ? EXIT_SUCCESS : EXIT_FAILURE;
-}