@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/deps/simdutf/src/westmere/sse_convert_utf8_to_utf16.cpp

@@ -0,0 +1,197 @@
+// depends on "tables/utf8_to_utf16_tables.h"
+
+// Convert up to 12 bytes from utf8 to utf16 using a mask indicating the
+// end of the code points. Only the least significant 12 bits of the mask
+// are accessed.
+// It returns how many bytes were consumed (up to 12).
+template <endianness big_endian>
+size_t convert_masked_utf8_to_utf16(const char *input,
+                                    uint64_t utf8_end_of_code_point_mask,
+                                    char16_t *&utf16_output) {
+  // we use an approach where we try to process up to 12 input bytes.
+  // Why 12 input bytes and not 16? Because we are concerned with the size of
+  // the lookup tables. Also 12 is nicely divisible by two and three.
+  //
+  //
+  // Optimization note: our main path below is load-latency dependent. Thus it
+  // is maybe beneficial to have fast paths that depend on branch prediction but
+  // have less latency. This results in more instructions but, potentially, also
+  // higher speeds.
+  //
+  // We first try a few fast paths.
+  const __m128i swap =
+      _mm_setr_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+  const __m128i in = _mm_loadu_si128((__m128i *)input);
+  const uint16_t input_utf8_end_of_code_point_mask =
+      utf8_end_of_code_point_mask & 0xfff;
+  if (utf8_end_of_code_point_mask == 0xfff) {
+    // We process the data in chunks of 12 bytes.
+    // Note: using 16 bytes is unsafe, see issue_ossfuzz_71218
+    __m128i ascii_first = _mm_cvtepu8_epi16(in);
+    __m128i ascii_second = _mm_cvtepu8_epi16(_mm_srli_si128(in, 8));
+    if (big_endian) {
+      ascii_first = _mm_shuffle_epi8(ascii_first, swap);
+      ascii_second = _mm_shuffle_epi8(ascii_second, swap);
+    }
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf16_output), ascii_first);
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf16_output + 8),
+                     ascii_second);
+    utf16_output += 12; // We wrote 12 16-bit characters.
+    return 12;          // We consumed 12 bytes.
+  }
+  if (((utf8_end_of_code_point_mask & 0xFFFF) == 0xaaaa)) {
+    // We want to take 8 2-byte UTF-8 code units and turn them into 8 2-byte
+    // UTF-16 code units. There is probably a more efficient sequence, but the
+    // following might do.
+    const __m128i sh =
+        _mm_setr_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii = _mm_and_si128(perm, _mm_set1_epi16(0x7f));
+    const __m128i highbyte = _mm_and_si128(perm, _mm_set1_epi16(0x1f00));
+    __m128i composed = _mm_or_si128(ascii, _mm_srli_epi16(highbyte, 2));
+    if (big_endian)
+      composed = _mm_shuffle_epi8(composed, swap);
+    _mm_storeu_si128((__m128i *)utf16_output, composed);
+    utf16_output += 8; // We wrote 16 bytes, 8 code points.
+    return 16;
+  }
+  if (input_utf8_end_of_code_point_mask == 0x924) {
+    // We want to take 4 3-byte UTF-8 code units and turn them into 4 2-byte
+    // UTF-16 code units. There is probably a more efficient sequence, but the
+    // following might do.
+    const __m128i sh =
+        _mm_setr_epi8(2, 1, 0, -1, 5, 4, 3, -1, 8, 7, 6, -1, 11, 10, 9, -1);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii =
+        _mm_and_si128(perm, _mm_set1_epi32(0x7f)); // 7 or 6 bits
+    const __m128i middlebyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x3f00)); // 5 or 6 bits
+    const __m128i middlebyte_shifted = _mm_srli_epi32(middlebyte, 2);
+    const __m128i highbyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x0f0000)); // 4 bits
+    const __m128i highbyte_shifted = _mm_srli_epi32(highbyte, 4);
+    const __m128i composed =
+        _mm_or_si128(_mm_or_si128(ascii, middlebyte_shifted), highbyte_shifted);
+    __m128i composed_repacked = _mm_packus_epi32(composed, composed);
+    if (big_endian)
+      composed_repacked = _mm_shuffle_epi8(composed_repacked, swap);
+    _mm_storeu_si128((__m128i *)utf16_output, composed_repacked);
+    utf16_output += 4;
+    return 12;
+  }
+  /// We do not have a fast path available, so we fallback.
+
+  const uint8_t idx =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][0];
+  const uint8_t consumed =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][1];
+  if (idx < 64) {
+    // SIX (6) input code-code units
+    // this is a relatively easy scenario
+    // we process SIX (6) input code-code units. The max length in bytes of six
+    // code code units spanning between 1 and 2 bytes each is 12 bytes. On
+    // processors where pdep/pext is fast, we might be able to use a small
+    // lookup table.
+    const __m128i sh =
+        _mm_loadu_si128((const __m128i *)tables::utf8_to_utf16::shufutf8[idx]);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii = _mm_and_si128(perm, _mm_set1_epi16(0x7f));
+    const __m128i highbyte = _mm_and_si128(perm, _mm_set1_epi16(0x1f00));
+    __m128i composed = _mm_or_si128(ascii, _mm_srli_epi16(highbyte, 2));
+    if (big_endian)
+      composed = _mm_shuffle_epi8(composed, swap);
+    _mm_storeu_si128((__m128i *)utf16_output, composed);
+    utf16_output += 6; // We wrote 12 bytes, 6 code points.
+  } else if (idx < 145) {
+    // FOUR (4) input code-code units
+    const __m128i sh =
+        _mm_loadu_si128((const __m128i *)tables::utf8_to_utf16::shufutf8[idx]);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii =
+        _mm_and_si128(perm, _mm_set1_epi32(0x7f)); // 7 or 6 bits
+    const __m128i middlebyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x3f00)); // 5 or 6 bits
+    const __m128i middlebyte_shifted = _mm_srli_epi32(middlebyte, 2);
+    const __m128i highbyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x0f0000)); // 4 bits
+    const __m128i highbyte_shifted = _mm_srli_epi32(highbyte, 4);
+    const __m128i composed =
+        _mm_or_si128(_mm_or_si128(ascii, middlebyte_shifted), highbyte_shifted);
+    __m128i composed_repacked = _mm_packus_epi32(composed, composed);
+    if (big_endian)
+      composed_repacked = _mm_shuffle_epi8(composed_repacked, swap);
+    _mm_storeu_si128((__m128i *)utf16_output, composed_repacked);
+    utf16_output += 4;
+  } else if (idx < 209) {
+    // TWO (2) input code-code units
+    //////////////
+    // There might be garbage inputs where a leading byte mascarades as a
+    // four-byte leading byte (by being followed by 3 continuation byte), but is
+    // not greater than 0xf0. This could trigger a buffer overflow if we only
+    // counted leading bytes of the form 0xf0 as generating surrogate pairs,
+    // without further UTF-8 validation. Thus we must be careful to ensure that
+    // only leading bytes at least as large as 0xf0 generate surrogate pairs. We
+    // do as at the cost of an extra mask.
+    /////////////
+    const __m128i sh =
+        _mm_loadu_si128((const __m128i *)tables::utf8_to_utf16::shufutf8[idx]);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii = _mm_and_si128(perm, _mm_set1_epi32(0x7f));
+    const __m128i middlebyte = _mm_and_si128(perm, _mm_set1_epi32(0x3f00));
+    const __m128i middlebyte_shifted = _mm_srli_epi32(middlebyte, 2);
+    __m128i middlehighbyte = _mm_and_si128(perm, _mm_set1_epi32(0x3f0000));
+    // correct for spurious high bit
+    const __m128i correct =
+        _mm_srli_epi32(_mm_and_si128(perm, _mm_set1_epi32(0x400000)), 1);
+    middlehighbyte = _mm_xor_si128(correct, middlehighbyte);
+    const __m128i middlehighbyte_shifted = _mm_srli_epi32(middlehighbyte, 4);
+    // We deliberately carry the leading four bits in highbyte if they are
+    // present, we remove them later when computing hightenbits.
+    const __m128i highbyte = _mm_and_si128(perm, _mm_set1_epi32(0xff000000));
+    const __m128i highbyte_shifted = _mm_srli_epi32(highbyte, 6);
+    // When we need to generate a surrogate pair (leading byte > 0xF0), then
+    // the corresponding 32-bit value in 'composed'  will be greater than
+    // > (0xff00000>>6) or > 0x3c00000. This can be used later to identify the
+    // location of the surrogate pairs.
+    const __m128i composed =
+        _mm_or_si128(_mm_or_si128(ascii, middlebyte_shifted),
+                     _mm_or_si128(highbyte_shifted, middlehighbyte_shifted));
+    const __m128i composedminus =
+        _mm_sub_epi32(composed, _mm_set1_epi32(0x10000));
+    const __m128i lowtenbits =
+        _mm_and_si128(composedminus, _mm_set1_epi32(0x3ff));
+    // Notice the 0x3ff mask:
+    const __m128i hightenbits =
+        _mm_and_si128(_mm_srli_epi32(composedminus, 10), _mm_set1_epi32(0x3ff));
+    const __m128i lowtenbitsadd =
+        _mm_add_epi32(lowtenbits, _mm_set1_epi32(0xDC00));
+    const __m128i hightenbitsadd =
+        _mm_add_epi32(hightenbits, _mm_set1_epi32(0xD800));
+    const __m128i lowtenbitsaddshifted = _mm_slli_epi32(lowtenbitsadd, 16);
+    __m128i surrogates = _mm_or_si128(hightenbitsadd, lowtenbitsaddshifted);
+    uint32_t basic_buffer[4];
+    uint32_t basic_buffer_swap[4];
+    if (big_endian) {
+      _mm_storeu_si128((__m128i *)basic_buffer_swap,
+                       _mm_shuffle_epi8(composed, swap));
+      surrogates = _mm_shuffle_epi8(surrogates, swap);
+    }
+    _mm_storeu_si128((__m128i *)basic_buffer, composed);
+    uint32_t surrogate_buffer[4];
+    _mm_storeu_si128((__m128i *)surrogate_buffer, surrogates);
+    for (size_t i = 0; i < 3; i++) {
+      if (basic_buffer[i] > 0x3c00000) {
+        utf16_output[0] = uint16_t(surrogate_buffer[i] & 0xffff);
+        utf16_output[1] = uint16_t(surrogate_buffer[i] >> 16);
+        utf16_output += 2;
+      } else {
+        utf16_output[0] = big_endian ? uint16_t(basic_buffer_swap[i])
+                                     : uint16_t(basic_buffer[i]);
+        utf16_output++;
+      }
+    }
+  } else {
+    // here we know that there is an error but we do not handle errors
+  }
+  return consumed;
+}

package/deps/simdutf/src/westmere/sse_convert_utf8_to_utf32.cpp

@@ -0,0 +1,141 @@
+// depends on "tables/utf8_to_utf16_tables.h"
+
+// Convert up to 12 bytes from utf8 to utf32 using a mask indicating the
+// end of the code points. Only the least significant 12 bits of the mask
+// are accessed.
+// It returns how many bytes were consumed (up to 12).
+size_t convert_masked_utf8_to_utf32(const char *input,
+                                    uint64_t utf8_end_of_code_point_mask,
+                                    char32_t *&utf32_output) {
+  // we use an approach where we try to process up to 12 input bytes.
+  // Why 12 input bytes and not 16? Because we are concerned with the size of
+  // the lookup tables. Also 12 is nicely divisible by two and three.
+  //
+  //
+  // Optimization note: our main path below is load-latency dependent. Thus it
+  // is maybe beneficial to have fast paths that depend on branch prediction but
+  // have less latency. This results in more instructions but, potentially, also
+  // higher speeds.
+  //
+  // We first try a few fast paths.
+  const __m128i in = _mm_loadu_si128((__m128i *)input);
+  const uint16_t input_utf8_end_of_code_point_mask =
+      utf8_end_of_code_point_mask & 0xfff;
+  if (utf8_end_of_code_point_mask == 0xfff) {
+    // We process the data in chunks of 12 bytes.
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output),
+                     _mm_cvtepu8_epi32(in));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output + 4),
+                     _mm_cvtepu8_epi32(_mm_srli_si128(in, 4)));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output + 8),
+                     _mm_cvtepu8_epi32(_mm_srli_si128(in, 8)));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output + 12),
+                     _mm_cvtepu8_epi32(_mm_srli_si128(in, 12)));
+    utf32_output += 12; // We wrote 12 32-bit characters.
+    return 12;          // We consumed 12 bytes.
+  }
+  if (((utf8_end_of_code_point_mask & 0xffff) == 0xaaaa)) {
+    // We want to take 8 2-byte UTF-8 code units and turn them into 8 4-byte
+    // UTF-32 code units. There is probably a more efficient sequence, but the
+    // following might do.
+    const __m128i sh =
+        _mm_setr_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii = _mm_and_si128(perm, _mm_set1_epi16(0x7f));
+    const __m128i highbyte = _mm_and_si128(perm, _mm_set1_epi16(0x1f00));
+    const __m128i composed = _mm_or_si128(ascii, _mm_srli_epi16(highbyte, 2));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output),
+                     _mm_cvtepu16_epi32(composed));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output + 4),
+                     _mm_cvtepu16_epi32(_mm_srli_si128(composed, 8)));
+    utf32_output += 8; // We wrote 32 bytes, 8 code points.
+    return 16;
+  }
+  if (input_utf8_end_of_code_point_mask == 0x924) {
+    // We want to take 4 3-byte UTF-8 code units and turn them into 4 4-byte
+    // UTF-32 code units. There is probably a more efficient sequence, but the
+    // following might do.
+    const __m128i sh =
+        _mm_setr_epi8(2, 1, 0, -1, 5, 4, 3, -1, 8, 7, 6, -1, 11, 10, 9, -1);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii =
+        _mm_and_si128(perm, _mm_set1_epi32(0x7f)); // 7 or 6 bits
+    const __m128i middlebyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x3f00)); // 5 or 6 bits
+    const __m128i middlebyte_shifted = _mm_srli_epi32(middlebyte, 2);
+    const __m128i highbyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x0f0000)); // 4 bits
+    const __m128i highbyte_shifted = _mm_srli_epi32(highbyte, 4);
+    const __m128i composed =
+        _mm_or_si128(_mm_or_si128(ascii, middlebyte_shifted), highbyte_shifted);
+    _mm_storeu_si128((__m128i *)utf32_output, composed);
+    utf32_output += 4;
+    return 12;
+  }
+  /// We do not have a fast path available, so we fallback.
+
+  const uint8_t idx =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][0];
+  const uint8_t consumed =
+      tables::utf8_to_utf16::utf8bigindex[input_utf8_end_of_code_point_mask][1];
+  if (idx < 64) {
+    // SIX (6) input code-code units
+    // this is a relatively easy scenario
+    // we process SIX (6) input code-code units. The max length in bytes of six
+    // code code units spanning between 1 and 2 bytes each is 12 bytes. On
+    // processors where pdep/pext is fast, we might be able to use a small
+    // lookup table.
+    const __m128i sh =
+        _mm_loadu_si128((const __m128i *)tables::utf8_to_utf16::shufutf8[idx]);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii = _mm_and_si128(perm, _mm_set1_epi16(0x7f));
+    const __m128i highbyte = _mm_and_si128(perm, _mm_set1_epi16(0x1f00));
+    const __m128i composed = _mm_or_si128(ascii, _mm_srli_epi16(highbyte, 2));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output),
+                     _mm_cvtepu16_epi32(composed));
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(utf32_output + 4),
+                     _mm_cvtepu16_epi32(_mm_srli_si128(composed, 8)));
+    utf32_output += 6; // We wrote 12 bytes, 6 code points.
+  } else if (idx < 145) {
+    // FOUR (4) input code-code units
+    const __m128i sh =
+        _mm_loadu_si128((const __m128i *)tables::utf8_to_utf16::shufutf8[idx]);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii =
+        _mm_and_si128(perm, _mm_set1_epi32(0x7f)); // 7 or 6 bits
+    const __m128i middlebyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x3f00)); // 5 or 6 bits
+    const __m128i middlebyte_shifted = _mm_srli_epi32(middlebyte, 2);
+    const __m128i highbyte =
+        _mm_and_si128(perm, _mm_set1_epi32(0x0f0000)); // 4 bits
+    const __m128i highbyte_shifted = _mm_srli_epi32(highbyte, 4);
+    const __m128i composed =
+        _mm_or_si128(_mm_or_si128(ascii, middlebyte_shifted), highbyte_shifted);
+    _mm_storeu_si128((__m128i *)utf32_output, composed);
+    utf32_output += 4;
+  } else if (idx < 209) {
+    // TWO (2) input code-code units
+    const __m128i sh =
+        _mm_loadu_si128((const __m128i *)tables::utf8_to_utf16::shufutf8[idx]);
+    const __m128i perm = _mm_shuffle_epi8(in, sh);
+    const __m128i ascii = _mm_and_si128(perm, _mm_set1_epi32(0x7f));
+    const __m128i middlebyte = _mm_and_si128(perm, _mm_set1_epi32(0x3f00));
+    const __m128i middlebyte_shifted = _mm_srli_epi32(middlebyte, 2);
+    __m128i middlehighbyte = _mm_and_si128(perm, _mm_set1_epi32(0x3f0000));
+    // correct for spurious high bit
+    const __m128i correct =
+        _mm_srli_epi32(_mm_and_si128(perm, _mm_set1_epi32(0x400000)), 1);
+    middlehighbyte = _mm_xor_si128(correct, middlehighbyte);
+    const __m128i middlehighbyte_shifted = _mm_srli_epi32(middlehighbyte, 4);
+    const __m128i highbyte = _mm_and_si128(perm, _mm_set1_epi32(0x07000000));
+    const __m128i highbyte_shifted = _mm_srli_epi32(highbyte, 6);
+    const __m128i composed =
+        _mm_or_si128(_mm_or_si128(ascii, middlebyte_shifted),
+                     _mm_or_si128(highbyte_shifted, middlehighbyte_shifted));
+    _mm_storeu_si128((__m128i *)utf32_output, composed);
+    utf32_output += 3;
+  } else {
+    // here we know that there is an error but we do not handle errors
+  }
+  return consumed;
+}

package/deps/simdutf/src/westmere/sse_utf16fix.cpp

@@ -0,0 +1,82 @@
+/*
+ * Process one block of 8 characters.  If in_place is false,
+ * copy the block from in to out.  If there is a sequencing
+ * error in the block, overwrite the illsequenced characters
+ * with the replacement character.  This function reads one
+ * character before the beginning of the buffer as a lookback.
+ * If that character is illsequenced, it too is overwritten.
+ */
+template <endianness big_endian, bool in_place>
+simdutf_really_inline void utf16fix_block_sse(char16_t *out,
+                                              const char16_t *in) {
+  auto swap_if_needed = [](uint16_t x) simdutf_constexpr -> uint16_t {
+    return scalar::utf16::swap_if_needed<big_endian>(x);
+  };
+  const char16_t replacement = scalar::utf16::replacement<big_endian>();
+
+  __m128i lookback, block, lb_masked, block_masked, lb_is_high, block_is_low;
+  __m128i illseq, lb_illseq, block_illseq;
+
+  lookback = _mm_loadu_si128((const __m128i *)(in - 1));
+  block = _mm_loadu_si128((const __m128i *)in);
+  lb_masked = _mm_and_si128(lookback, _mm_set1_epi16(swap_if_needed(0xfc00U)));
+  block_masked = _mm_and_si128(block, _mm_set1_epi16(swap_if_needed(0xfc00U)));
+  lb_is_high =
+      _mm_cmpeq_epi16(lb_masked, _mm_set1_epi16(swap_if_needed(0xd800U)));
+  block_is_low =
+      _mm_cmpeq_epi16(block_masked, _mm_set1_epi16(swap_if_needed(0xdc00U)));
+
+  illseq = _mm_xor_si128(lb_is_high, block_is_low);
+  if (_mm_movemask_epi8(illseq) != 0) {
+    int lb;
+
+    /* compute the cause of the illegal sequencing */
+    lb_illseq = _mm_andnot_si128(block_is_low, lb_is_high);
+    block_illseq = _mm_or_si128(_mm_andnot_si128(lb_is_high, block_is_low),
+                                _mm_bsrli_si128(lb_illseq, 2));
+
+    /* fix illegal sequencing in the lookback */
+    lb = _mm_cvtsi128_si32(lb_illseq);
+    lb = (lb & replacement) | (~lb & out[-1]);
+    out[-1] = char16_t(lb);
+    /* fix illegal sequencing in the main block */
+    block =
+        _mm_or_si128(_mm_andnot_si128(block_illseq, block),
+                     _mm_and_si128(block_illseq, _mm_set1_epi16(replacement)));
+    _mm_storeu_si128((__m128i *)out, block);
+  } else if (!in_place) {
+    _mm_storeu_si128((__m128i *)out, block);
+  }
+}
+
+template <endianness big_endian>
+void utf16fix_sse(const char16_t *in, size_t n, char16_t *out) {
+  const char16_t replacement = scalar::utf16::replacement<big_endian>();
+  size_t i;
+  if (n < 9) {
+    scalar::utf16::to_well_formed_utf16<big_endian>(in, n, out);
+    return;
+  }
+
+  out[0] =
+      scalar::utf16::is_low_surrogate<big_endian>(in[0]) ? replacement : in[0];
+
+  /* duplicate code to have the compiler specialise utf16fix_block() */
+  if (in == out) {
+    for (i = 1; i + 8 < n; i += 8) {
+      utf16fix_block_sse<big_endian, true>(out + i, in + i);
+    }
+
+    utf16fix_block_sse<big_endian, true>(out + n - 8, in + n - 8);
+  } else {
+    for (i = 1; i + 8 < n; i += 8) {
+      utf16fix_block_sse<big_endian, false>(out + i, in + i);
+    }
+
+    utf16fix_block_sse<big_endian, false>(out + n - 8, in + n - 8);
+  }
+
+  out[n - 1] = scalar::utf16::is_high_surrogate<big_endian>(out[n - 1])
+                   ? replacement
+                   : out[n - 1];
+}

package/deps/simdutf/src/westmere/sse_validate_utf16.cpp

@@ -0,0 +1,17 @@
+template <endianness big_endian>
+simd8<uint8_t> utf16_gather_high_bytes(const simd16<uint16_t> in0,
+                                       const simd16<uint16_t> in1) {
+  if (big_endian) {
+    // we want lower bytes
+    const auto mask = simd16<uint16_t>(0x00ff);
+    const auto t0 = in0 & mask;
+    const auto t1 = in1 & mask;
+
+    return simd16<uint16_t>::pack(t0, t1);
+  } else {
+    const auto t0 = in0.shr<8>();
+    const auto t1 = in1.shr<8>();
+
+    return simd16<uint16_t>::pack(t0, t1);
+  }
+}

package/jest/index.js

@@ -0,0 +1,16 @@
+// Jest mock: forwards to node:crypto. See docs/content/docs/guides/testing-with-jest.mdx.
+const crypto = require('node:crypto');
+const { Buffer } = require('node:buffer');
+
+const QuickCrypto = {
+  ...crypto,
+  Buffer,
+  CryptoKey: globalThis.CryptoKey,
+  install: () => {},
+};
+
+module.exports = {
+  __esModule: true,
+  default: QuickCrypto,
+  ...QuickCrypto,
+};

package/lib/commonjs/argon2.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.argon2 = argon2;
+exports.argon2Sync = argon2Sync;
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _reactNativeNitroModules = require("./nitro-node-shim");
+var _utils = require("./utils");
+let native;
+function getNative() {
+  if (native == null) {
+    native = _reactNativeNitroModules.NitroModules.createHybridObject('Argon2');
+  }
+  return native;
+}
+const ARGON2_VERSION = 0x13; // v1.3
+
+// RFC 9106 § 3.1: Argon2 input/parameter constraints.
+//   p (parallelism)   1   ≤ p ≤ 2^24 - 1
+//   T (tag length)    4   ≤ T ≤ 2^32 - 1
+//   m (memory in KiB) 8*p ≤ m ≤ 2^32 - 1
+//   t (passes)        1   ≤ t ≤ 2^32 - 1
+//   |salt| (nonce)    8   ≤ |s| ≤ 2^32 - 1
+//   v (version)       0x10 (v1.0) or 0x13 (v1.3)
+const ARGON2_MAX_U24 = 0xff_ffff;
+const ARGON2_MAX_U32 = 0xffff_ffff;
+function isUInt(value, max) {
+  return typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0 && value <= max;
+}
+function validateAlgorithm(algorithm) {
+  if (algorithm !== 'argon2d' && algorithm !== 'argon2i' && algorithm !== 'argon2id') {
+    throw new TypeError(`Unknown argon2 algorithm: ${algorithm}`);
+  }
+}
+
+// Returns the resolved nonce ArrayBuffer so the caller can pass it
+// straight to native without re-resolving `params.nonce`.
+function validateArgon2Params(params, version) {
+  if (!isUInt(params.parallelism, ARGON2_MAX_U24) || params.parallelism < 1) {
+    throw new RangeError(`Invalid Argon2 parallelism: ${params.parallelism} ` + `(RFC 9106: 1 ≤ p ≤ 2^24 - 1)`);
+  }
+  if (!isUInt(params.tagLength, ARGON2_MAX_U32) || params.tagLength < 4) {
+    throw new RangeError(`Invalid Argon2 tagLength: ${params.tagLength} ` + `(RFC 9106: 4 ≤ T ≤ 2^32 - 1)`);
+  }
+  const minMemory = 8 * params.parallelism;
+  if (!isUInt(params.memory, ARGON2_MAX_U32) || params.memory < minMemory) {
+    throw new RangeError(`Invalid Argon2 memory: ${params.memory} KiB ` + `(RFC 9106: 8 * p (= ${minMemory}) ≤ m ≤ 2^32 - 1)`);
+  }
+  if (!isUInt(params.passes, ARGON2_MAX_U32) || params.passes < 1) {
+    throw new RangeError(`Invalid Argon2 passes: ${params.passes} ` + `(RFC 9106: 1 ≤ t ≤ 2^32 - 1)`);
+  }
+  if (version !== 0x10 && version !== 0x13) {
+    throw new RangeError(`Invalid Argon2 version: 0x${version.toString(16)} ` + `(RFC 9106: 0x10 or 0x13)`);
+  }
+  // Salt (nonce) must be 8..2^32 - 1 bytes — measured against the resolved
+  // ArrayBuffer because BinaryLike accepts strings whose UTF-8 length is
+  // what actually reaches OpenSSL.
+  const nonceAB = (0, _utils.binaryLikeToArrayBuffer)(params.nonce);
+  if (nonceAB.byteLength < 8 || nonceAB.byteLength > ARGON2_MAX_U32) {
+    throw new RangeError(`Invalid Argon2 nonce length: ${nonceAB.byteLength} bytes ` + `(RFC 9106: 8 ≤ |s| ≤ 2^32 - 1)`);
+  }
+  return nonceAB;
+}
+function toAB(value) {
+  return (0, _utils.binaryLikeToArrayBuffer)(value);
+}
+function argon2Sync(algorithm, params) {
+  validateAlgorithm(algorithm);
+  const version = params.version ?? ARGON2_VERSION;
+  const nonceAB = validateArgon2Params(params, version);
+  const result = getNative().hashSync(algorithm, toAB(params.message), nonceAB, params.parallelism, params.tagLength, params.memory, params.passes, version, params.secret ? toAB(params.secret) : undefined, params.associatedData ? toAB(params.associatedData) : undefined);
+  return _reactNativeBuffer.Buffer.from(result);
+}
+function argon2(algorithm, params, callback) {
+  validateAlgorithm(algorithm);
+  const version = params.version ?? ARGON2_VERSION;
+  let nonceAB;
+  try {
+    nonceAB = validateArgon2Params(params, version);
+  } catch (err) {
+    callback(err, _reactNativeBuffer.Buffer.alloc(0));
+    return;
+  }
+  getNative().hash(algorithm, toAB(params.message), nonceAB, params.parallelism, params.tagLength, params.memory, params.passes, version, params.secret ? toAB(params.secret) : undefined, params.associatedData ? toAB(params.associatedData) : undefined).then(ab => callback(null, _reactNativeBuffer.Buffer.from(ab))).catch(err => callback(err, _reactNativeBuffer.Buffer.alloc(0)));
+}
+//# sourceMappingURL=argon2.js.map

package/lib/commonjs/argon2.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeBuffer","require","_reactNativeNitroModules","_utils","native","getNative","NitroModules","createHybridObject","ARGON2_VERSION","ARGON2_MAX_U24","ARGON2_MAX_U32","isUInt","value","max","Number","isFinite","isInteger","validateAlgorithm","algorithm","TypeError","validateArgon2Params","params","version","parallelism","RangeError","tagLength","minMemory","memory","passes","toString","nonceAB","binaryLikeToArrayBuffer","nonce","byteLength","toAB","argon2Sync","result","hashSync","message","secret","undefined","associatedData","Buffer","from","argon2","callback","err","alloc","hash","then","ab","catch"],"sourceRoot":"../../src","sources":["argon2.ts"],"mappings":";;;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AACA,IAAAC,wBAAA,GAAAD,OAAA;AAEA,IAAAE,MAAA,GAAAF,OAAA;AAGA,IAAIG,MAAoB;AACxB,SAASC,SAASA,CAAA,EAAiB;EACjC,IAAID,MAAM,IAAI,IAAI,EAAE;IAClBA,MAAM,GAAGE,qCAAY,CAACC,kBAAkB,CAAe,QAAQ,CAAC;EAClE;EACA,OAAOH,MAAM;AACf;AAcA,MAAMI,cAAc,GAAG,IAAI,CAAC,CAAC;;AAE7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,cAAc,GAAG,SAAS;AAChC,MAAMC,cAAc,GAAG,WAAW;AAElC,SAASC,MAAMA,CAACC,KAAc,EAAEC,GAAW,EAAmB;EAC5D,OACE,OAAOD,KAAK,KAAK,QAAQ,IACzBE,MAAM,CAACC,QAAQ,CAACH,KAAK,CAAC,IACtBE,MAAM,CAACE,SAAS,CAACJ,KAAK,CAAC,IACvBA,KAAK,IAAI,CAAC,IACVA,KAAK,IAAIC,GAAG;AAEhB;AAEA,SAASI,iBAAiBA,CAACC,SAAiB,EAAQ;EAClD,IACEA,SAAS,KAAK,SAAS,IACvBA,SAAS,KAAK,SAAS,IACvBA,SAAS,KAAK,UAAU,EACxB;IACA,MAAM,IAAIC,SAAS,CAAC,6BAA6BD,SAAS,EAAE,CAAC;EAC/D;AACF;;AAEA;AACA;AACA,SAASE,oBAAoBA,CAC3BC,MAAoB,EACpBC,OAAe,EACF;EACb,IAAI,CAACX,MAAM,CAACU,MAAM,CAACE,WAAW,EAAEd,cAAc,CAAC,IAAIY,MAAM,CAACE,WAAW,GAAG,CAAC,EAAE;IACzE,MAAM,IAAIC,UAAU,CAClB,+BAA+BH,MAAM,CAACE,WAAW,GAAG,GAClD,8BACJ,CAAC;EACH;EACA,IAAI,CAACZ,MAAM,CAACU,MAAM,CAACI,SAAS,EAAEf,cAAc,CAAC,IAAIW,MAAM,CAACI,SAAS,GAAG,CAAC,EAAE;IACrE,MAAM,IAAID,UAAU,CAClB,6BAA6BH,MAAM,CAACI,SAAS,GAAG,GAC9C,8BACJ,CAAC;EACH;EACA,MAAMC,SAAS,GAAG,CAAC,GAAGL,MAAM,CAACE,WAAW;EACxC,IAAI,CAACZ,MAAM,CAACU,MAAM,CAACM,MAAM,EAAEjB,cAAc,CAAC,IAAIW,MAAM,CAACM,MAAM,GAAGD,SAAS,EAAE;IACvE,MAAM,IAAIF,UAAU,CAClB,0BAA0BH,MAAM,CAACM,MAAM,OAAO,GAC5C,uBAAuBD,SAAS,mBACpC,CAAC;EACH;EACA,IAAI,CAACf,MAAM,CAACU,MAAM,CAACO,MAAM,EAAElB,cAAc,CAAC,IAAIW,MAAM,CAACO,MAAM,GAAG,CAAC,EAAE;IAC/D,MAAM,IAAIJ,UAAU,CAClB,0BAA0BH,MAAM,CAACO,MAAM,GAAG,GACxC,8BACJ,CAAC;EACH;EACA,IAAIN,OAAO,KAAK,IAAI,IAAIA,OAAO,KAAK,IAAI,EAAE;IACxC,MAAM,IAAIE,UAAU,CAClB,6BAA6BF,OAAO,CAACO,QAAQ,CAAC,EAAE,CAAC,GAAG,GAClD,0BACJ,CAAC;EACH;EACA;EACA;EACA;EACA,MAAMC,OAAO,GAAG,IAAAC,8BAAuB,EAACV,MAAM,CAACW,KAAK,CAAC;EACrD,IAAIF,OAAO,CAACG,UAAU,GAAG,CAAC,IAAIH,OAAO,CAACG,UAAU,GAAGvB,cAAc,EAAE;IACjE,MAAM,IAAIc,UAAU,CAClB,gCAAgCM,OAAO,CAACG,UAAU,SAAS,GACzD,gCACJ,CAAC;EACH;EACA,OAAOH,OAAO;AAChB;AAEA,SAASI,IAAIA,CAACtB,KAAiB,EAAe;EAC5C,OAAO,IAAAmB,8BAAuB,EAACnB,KAAK,CAAC;AACvC;AAEO,SAASuB,UAAUA,CAACjB,SAAiB,EAAEG,MAAoB,EAAU;EAC1EJ,iBAAiB,CAACC,SAAS,CAAC;EAC5B,MAAMI,OAAO,GAAGD,MAAM,CAACC,OAAO,IAAId,cAAc;EAChD,MAAMsB,OAAO,GAAGV,oBAAoB,CAACC,MAAM,EAAEC,OAAO,CAAC;EACrD,MAAMc,MAAM,GAAG/B,SAAS,CAAC,CAAC,CAACgC,QAAQ,CACjCnB,SAAS,EACTgB,IAAI,CAACb,MAAM,CAACiB,OAAO,CAAC,EACpBR,OAAO,EACPT,MAAM,CAACE,WAAW,EAClBF,MAAM,CAACI,SAAS,EAChBJ,MAAM,CAACM,MAAM,EACbN,MAAM,CAACO,MAAM,EACbN,OAAO,EACPD,MAAM,CAACkB,MAAM,GAAGL,IAAI,CAACb,MAAM,CAACkB,MAAM,CAAC,GAAGC,SAAS,EAC/CnB,MAAM,CAACoB,cAAc,GAAGP,IAAI,CAACb,MAAM,CAACoB,cAAc,CAAC,GAAGD,SACxD,CAAC;EACD,OAAOE,yBAAM,CAACC,IAAI,CAACP,MAAM,CAAC;AAC5B;AAEO,SAASQ,MAAMA,CACpB1B,SAAiB,EACjBG,MAAoB,EACpBwB,QAAqD,EAC/C;EACN5B,iBAAiB,CAACC,SAAS,CAAC;EAC5B,MAAMI,OAAO,GAAGD,MAAM,CAACC,OAAO,IAAId,cAAc;EAChD,IAAIsB,OAAoB;EACxB,IAAI;IACFA,OAAO,GAAGV,oBAAoB,CAACC,MAAM,EAAEC,OAAO,CAAC;EACjD,CAAC,CAAC,OAAOwB,GAAG,EAAE;IACZD,QAAQ,CAACC,GAAG,EAAWJ,yBAAM,CAACK,KAAK,CAAC,CAAC,CAAC,CAAC;IACvC;EACF;EACA1C,SAAS,CAAC,CAAC,CACR2C,IAAI,CACH9B,SAAS,EACTgB,IAAI,CAACb,MAAM,CAACiB,OAAO,CAAC,EACpBR,OAAO,EACPT,MAAM,CAACE,WAAW,EAClBF,MAAM,CAACI,SAAS,EAChBJ,MAAM,CAACM,MAAM,EACbN,MAAM,CAACO,MAAM,EACbN,OAAO,EACPD,MAAM,CAACkB,MAAM,GAAGL,IAAI,CAACb,MAAM,CAACkB,MAAM,CAAC,GAAGC,SAAS,EAC/CnB,MAAM,CAACoB,cAAc,GAAGP,IAAI,CAACb,MAAM,CAACoB,cAAc,CAAC,GAAGD,SACxD,CAAC,CACAS,IAAI,CAACC,EAAE,IAAIL,QAAQ,CAAC,IAAI,EAAEH,yBAAM,CAACC,IAAI,CAACO,EAAE,CAAC,CAAC,CAAC,CAC3CC,KAAK,CAAEL,GAAU,IAAKD,QAAQ,CAACC,GAAG,EAAEJ,yBAAM,CAACK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1D","ignoreList":[]}

package/lib/commonjs/blake3.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Blake3 = void 0;
+exports.blake3 = blake3;
+exports.blake3Exports = void 0;
+exports.createBlake3 = createBlake3;
+var _reactNativeNitroModules = require("./nitro-node-shim");
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _utils = require("./utils");
+var _conversion = require("./utils/conversion");
+const BLAKE3_KEY_LEN = 32;
+const BLAKE3_OUT_LEN = 32;
+class Blake3 {
+  constructor(opts) {
+    this.native = _reactNativeNitroModules.NitroModules.createHybridObject('Blake3');
+    if (opts?.key && opts?.context) {
+      throw new Error('BLAKE3: cannot use both key and context options together');
+    }
+    if (opts?.key) {
+      if (opts.key.length !== BLAKE3_KEY_LEN) {
+        throw new Error(`BLAKE3: key must be exactly ${BLAKE3_KEY_LEN} bytes`);
+      }
+      this.mode = 'keyed';
+      this.keyData = opts.key;
+      this.native.initKeyed((0, _conversion.toArrayBuffer)(opts.key));
+    } else if (opts?.context !== undefined) {
+      if (typeof opts.context !== 'string' || opts.context.length === 0) {
+        throw new Error('BLAKE3: context must be a non-empty string');
+      }
+      this.mode = 'deriveKey';
+      this.contextData = opts.context;
+      this.native.initDeriveKey(opts.context);
+    } else {
+      this.mode = 'hash';
+      this.native.initHash();
+    }
+  }
+  update(data, inputEncoding) {
+    const buffer = (0, _utils.binaryLikeToArrayBuffer)(data, inputEncoding ?? 'utf8');
+    this.native.update(buffer);
+    return this;
+  }
+  digest(encodingOrLength) {
+    let length;
+    let encoding;
+    if (typeof encodingOrLength === 'number') {
+      length = encodingOrLength;
+    } else if (encodingOrLength) {
+      encoding = encodingOrLength;
+    }
+    const result = this.native.digest(length);
+    if (encoding && encoding !== 'buffer') {
+      return (0, _utils.ab2str)(result, encoding);
+    }
+    return _reactNativeBuffer.Buffer.from(result);
+  }
+  digestLength(length) {
+    return _reactNativeBuffer.Buffer.from(this.native.digest(length));
+  }
+  reset() {
+    this.native.reset();
+    return this;
+  }
+  copy() {
+    const copied = new Blake3();
+    // Replace the native with a copy
+    copied.native = this.native.copy();
+    copied.mode = this.mode;
+    copied.keyData = this.keyData;
+    copied.contextData = this.contextData;
+    return copied;
+  }
+  static getVersion() {
+    const native = _reactNativeNitroModules.NitroModules.createHybridObject('Blake3');
+    native.initHash();
+    return native.getVersion();
+  }
+}
+exports.Blake3 = Blake3;
+function createBlake3(opts) {
+  return new Blake3(opts);
+}
+function blake3(data, opts) {
+  const hasher = new Blake3(opts);
+  hasher.update(data);
+  const length = opts?.dkLen ?? BLAKE3_OUT_LEN;
+  const result = hasher.digestLength(length);
+  return new Uint8Array(result);
+}
+blake3.create = createBlake3;
+const blake3Exports = exports.blake3Exports = {
+  Blake3,
+  createBlake3,
+  blake3
+};
+//# sourceMappingURL=blake3.js.map

package/lib/commonjs/blake3.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeBuffer","_utils","_conversion","BLAKE3_KEY_LEN","BLAKE3_OUT_LEN","Blake3","constructor","opts","native","NitroModules","createHybridObject","key","context","Error","length","mode","keyData","initKeyed","toArrayBuffer","undefined","contextData","initDeriveKey","initHash","update","data","inputEncoding","buffer","binaryLikeToArrayBuffer","digest","encodingOrLength","encoding","result","ab2str","Buffer","from","digestLength","reset","copy","copied","getVersion","exports","createBlake3","blake3","hasher","dkLen","Uint8Array","create","blake3Exports"],"sourceRoot":"../../src","sources":["blake3.ts"],"mappings":"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","ignoreList":[]}