visaljs 0.0.2 → 0.0.3

package/runtime/third_party/boringssl/crypto/evp/pbkdf.cc

@@ -0,0 +1,105 @@
+// Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/evp.h>
+
+#include <string.h>
+
+#include <openssl/err.h>
+#include <openssl/hmac.h>
+
+#include "../internal.h"
+
+
+using namespace bssl;
+
+int PKCS5_PBKDF2_HMAC(const char *password, size_t password_len,
+                      const uint8_t *salt, size_t salt_len, uint32_t iterations,
+                      const EVP_MD *digest, size_t key_len, uint8_t *out_key) {
+  // See RFC 8018, section 5.2.
+  ScopedHMAC_CTX hctx;
+  if (!HMAC_Init_ex(hctx.get(), password, password_len, digest, nullptr)) {
+    return 0;
+  }
+
+  uint32_t i = 1;
+  size_t md_len = EVP_MD_size(digest);
+  if (key_len > ((uint64_t{1} << 32) - 1) * md_len) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_SECRET_LENGTH);
+    return 0;
+  }
+  while (key_len > 0) {
+    size_t todo = md_len;
+    if (todo > key_len) {
+      todo = key_len;
+    }
+
+    uint8_t i_buf[4];
+    i_buf[0] = (uint8_t)((i >> 24) & 0xff);
+    i_buf[1] = (uint8_t)((i >> 16) & 0xff);
+    i_buf[2] = (uint8_t)((i >> 8) & 0xff);
+    i_buf[3] = (uint8_t)(i & 0xff);
+
+    // Compute U_1.
+    uint8_t digest_tmp[EVP_MAX_MD_SIZE];
+    if (!HMAC_Init_ex(hctx.get(), nullptr, 0, nullptr, nullptr) ||
+        !HMAC_Update(hctx.get(), salt, salt_len) ||
+        !HMAC_Update(hctx.get(), i_buf, 4) ||
+        !HMAC_Final(hctx.get(), digest_tmp, nullptr)) {
+      return 0;
+    }
+
+    OPENSSL_memcpy(out_key, digest_tmp, todo);
+    for (uint32_t j = 1; j < iterations; j++) {
+      // Compute the remaining U_* values and XOR.
+      if (!HMAC_Init_ex(hctx.get(), nullptr, 0, nullptr, nullptr) ||
+          !HMAC_Update(hctx.get(), digest_tmp, md_len) ||
+          !HMAC_Final(hctx.get(), digest_tmp, nullptr)) {
+        return 0;
+      }
+      for (size_t k = 0; k < todo; k++) {
+        out_key[k] ^= digest_tmp[k];
+      }
+    }
+
+    key_len -= todo;
+    out_key += todo;
+    i++;
+  }
+
+  // RFC 8018 describes iterations (c) as being a "positive integer", so a
+  // value of 0 is an error.
+  //
+  // Unfortunately not all consumers of PKCS5_PBKDF2_HMAC() check their return
+  // value, expecting it to succeed and unconditionally using `out_key`.  As a
+  // precaution for such callsites in external code, the old behavior of
+  // iterations < 1 being treated as iterations == 1 is preserved, but
+  // additionally an error result is returned.
+  //
+  // TODO(eroman): Figure out how to remove this compatibility hack, or change
+  // the default to something more sensible like 2048.
+  if (iterations == 0) {
+    return 0;
+  }
+
+  return 1;
+}
+
+int PKCS5_PBKDF2_HMAC_SHA1(const char *password, size_t password_len,
+                           const uint8_t *salt, size_t salt_len,
+                           uint32_t iterations, size_t key_len,
+                           uint8_t *out_key) {
+  return PKCS5_PBKDF2_HMAC(password, password_len, salt, salt_len, iterations,
+                           EVP_sha1(), key_len, out_key);
+}

package/runtime/third_party/boringssl/crypto/evp/print.cc

@@ -0,0 +1,287 @@
+// Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/evp.h>
+
+#include <openssl/bio.h>
+#include <openssl/bn.h>
+#include <openssl/dsa.h>
+#include <openssl/ec.h>
+#include <openssl/ec_key.h>
+#include <openssl/mem.h>
+#include <openssl/rsa.h>
+
+#include "../internal.h"
+
+
+using namespace bssl;
+
+static int print_hex(BIO *bp, const uint8_t *data, size_t len, int off) {
+  for (size_t i = 0; i < len; i++) {
+    if ((i % 15) == 0) {
+      if (BIO_puts(bp, "\n") <= 0 ||  //
+          !BIO_indent(bp, off + 4, 128)) {
+        return 0;
+      }
+    }
+    if (BIO_printf(bp, "%02x%s", data[i], (i + 1 == len) ? "" : ":") <= 0) {
+      return 0;
+    }
+  }
+  if (BIO_write(bp, "\n", 1) <= 0) {
+    return 0;
+  }
+  return 1;
+}
+
+static int bn_print(BIO *bp, const char *name, const BIGNUM *num, int off) {
+  if (num == nullptr) {
+    return 1;
+  }
+
+  if (!BIO_indent(bp, off, 128)) {
+    return 0;
+  }
+  if (BN_is_zero(num)) {
+    if (BIO_printf(bp, "%s 0\n", name) <= 0) {
+      return 0;
+    }
+    return 1;
+  }
+
+  uint64_t u64;
+  if (BN_get_u64(num, &u64)) {
+    const char *neg = BN_is_negative(num) ? "-" : "";
+    return BIO_printf(bp, "%s %s%" PRIu64 " (%s0x%" PRIx64 ")\n", name, neg,
+                      u64, neg, u64) > 0;
+  }
+
+  if (BIO_printf(bp, "%s%s", name,
+                 (BN_is_negative(num)) ? " (Negative)" : "") <= 0) {
+    return 0;
+  }
+
+  // Print `num` in hex, adding a leading zero, as in ASN.1, if the high bit
+  // is set.
+  //
+  // TODO(davidben): Do we need to do this? We already print "(Negative)" above
+  // and negative values are never valid in keys anyway.
+  size_t len = BN_num_bytes(num);
+  uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len + 1));
+  if (buf == nullptr) {
+    return 0;
+  }
+
+  buf[0] = 0;
+  BN_bn2bin(num, buf + 1);
+  int ret;
+  if (len > 0 && (buf[1] & 0x80) != 0) {
+    // Print the whole buffer.
+    ret = print_hex(bp, buf, len + 1, off);
+  } else {
+    // Skip the leading zero.
+    ret = print_hex(bp, buf + 1, len, off);
+  }
+  OPENSSL_free(buf);
+  return ret;
+}
+
+// RSA keys.
+
+static int do_rsa_print(BIO *out, const RSA *rsa, int off,
+                        int include_private) {
+  int mod_len = 0;
+  if (RSA_get0_n(rsa) != nullptr) {
+    mod_len = RSA_bits(rsa);
+  }
+
+  if (!BIO_indent(out, off, 128)) {
+    return 0;
+  }
+
+  const char *s, *str;
+  if (include_private && RSA_get0_d(rsa) != nullptr) {
+    if (BIO_printf(out, "Private-Key: (%d bit)\n", mod_len) <= 0) {
+      return 0;
+    }
+    str = "modulus:";
+    s = "publicExponent:";
+  } else {
+    if (BIO_printf(out, "Public-Key: (%d bit)\n", mod_len) <= 0) {
+      return 0;
+    }
+    str = "Modulus:";
+    s = "Exponent:";
+  }
+  if (!bn_print(out, str, RSA_get0_n(rsa), off) ||
+      !bn_print(out, s, RSA_get0_e(rsa), off)) {
+    return 0;
+  }
+
+  if (include_private) {
+    if (!bn_print(out, "privateExponent:", RSA_get0_d(rsa), off) ||
+        !bn_print(out, "prime1:", RSA_get0_p(rsa), off) ||
+        !bn_print(out, "prime2:", RSA_get0_q(rsa), off) ||
+        !bn_print(out, "exponent1:", RSA_get0_dmp1(rsa), off) ||
+        !bn_print(out, "exponent2:", RSA_get0_dmq1(rsa), off) ||
+        !bn_print(out, "coefficient:", RSA_get0_iqmp(rsa), off)) {
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent) {
+  return do_rsa_print(bp, EVP_PKEY_get0_RSA(pkey), indent, 0);
+}
+
+static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent) {
+  return do_rsa_print(bp, EVP_PKEY_get0_RSA(pkey), indent, 1);
+}
+
+
+// EC keys.
+
+static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, int ktype) {
+  const EC_GROUP *group;
+  if (x == nullptr || (group = EC_KEY_get0_group(x)) == nullptr) {
+    OPENSSL_PUT_ERROR(EVP, ERR_R_PASSED_NULL_PARAMETER);
+    return 0;
+  }
+
+  const char *ecstr;
+  if (ktype == 2) {
+    ecstr = "Private-Key";
+  } else if (ktype == 1) {
+    ecstr = "Public-Key";
+  } else {
+    ecstr = "ECDSA-Parameters";
+  }
+
+  if (!BIO_indent(bp, off, 128)) {
+    return 0;
+  }
+  int curve_name = EC_GROUP_get_curve_name(group);
+  if (BIO_printf(bp, "%s: (%s)\n", ecstr,
+                 curve_name == NID_undef
+                     ? "unknown curve"
+                     : EC_curve_nid2nist(curve_name)) <= 0) {
+    return 0;
+  }
+
+  if (ktype == 2) {
+    const BIGNUM *priv_key = EC_KEY_get0_private_key(x);
+    if (priv_key != nullptr &&  //
+        !bn_print(bp, "priv:", priv_key, off)) {
+      return 0;
+    }
+  }
+
+  if (ktype > 0 && EC_KEY_get0_public_key(x) != nullptr) {
+    uint8_t *pub = nullptr;
+    size_t pub_len = EC_KEY_key2buf(x, EC_KEY_get_conv_form(x), &pub, nullptr);
+    if (pub_len == 0) {
+      return 0;
+    }
+    int ret = BIO_indent(bp, off, 128) &&  //
+              BIO_puts(bp, "pub:") > 0 &&  //
+              print_hex(bp, pub, pub_len, off);
+    OPENSSL_free(pub);
+    if (!ret) {
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+static int eckey_param_print(BIO *bp, const EVP_PKEY *pkey, int indent) {
+  return do_EC_KEY_print(bp, EVP_PKEY_get0_EC_KEY(pkey), indent, 0);
+}
+
+static int eckey_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent) {
+  return do_EC_KEY_print(bp, EVP_PKEY_get0_EC_KEY(pkey), indent, 1);
+}
+
+
+static int eckey_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent) {
+  return do_EC_KEY_print(bp, EVP_PKEY_get0_EC_KEY(pkey), indent, 2);
+}
+
+
+typedef struct {
+  int type;
+  int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent);
+  int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent);
+  int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent);
+} EVP_PKEY_PRINT_METHOD;
+
+static const EVP_PKEY_PRINT_METHOD kPrintMethods[] = {
+    {
+        EVP_PKEY_RSA,
+        rsa_pub_print,
+        rsa_priv_print,
+        /*param_print=*/nullptr,
+    },
+    {
+        EVP_PKEY_EC,
+        eckey_pub_print,
+        eckey_priv_print,
+        eckey_param_print,
+    },
+};
+
+static const EVP_PKEY_PRINT_METHOD *find_method(int type) {
+  for (const auto &p : kPrintMethods) {
+    if (p.type == type) {
+      return &p;
+    }
+  }
+  return nullptr;
+}
+
+static int print_unsupported(BIO *out, const EVP_PKEY *pkey, int indent,
+                             const char *kstr) {
+  BIO_indent(out, indent, 128);
+  BIO_printf(out, "%s algorithm unsupported\n", kstr);
+  return 1;
+}
+
+int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, int indent,
+                          ASN1_PCTX *pctx) {
+  const EVP_PKEY_PRINT_METHOD *method = find_method(EVP_PKEY_id(pkey));
+  if (method != nullptr && method->pub_print != nullptr) {
+    return method->pub_print(out, pkey, indent);
+  }
+  return print_unsupported(out, pkey, indent, "Public Key");
+}
+
+int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, int indent,
+                           ASN1_PCTX *pctx) {
+  const EVP_PKEY_PRINT_METHOD *method = find_method(EVP_PKEY_id(pkey));
+  if (method != nullptr && method->priv_print != nullptr) {
+    return method->priv_print(out, pkey, indent);
+  }
+  return print_unsupported(out, pkey, indent, "Private Key");
+}
+
+int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, int indent,
+                          ASN1_PCTX *pctx) {
+  const EVP_PKEY_PRINT_METHOD *method = find_method(EVP_PKEY_id(pkey));
+  if (method != nullptr && method->param_print != nullptr) {
+    return method->param_print(out, pkey, indent);
+  }
+  return print_unsupported(out, pkey, indent, "Parameters");
+}

package/runtime/third_party/boringssl/crypto/evp/scrypt.cc

@@ -0,0 +1,218 @@
+// Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/evp.h>
+
+#include <assert.h>
+
+#include <openssl/err.h>
+#include <openssl/mem.h>
+
+#include "../internal.h"
+
+
+// This file implements scrypt, described in RFC 7914.
+//
+// Note scrypt refers to both "blocks" and a "block size" parameter, r. These
+// are two different notions of blocks. A Salsa20 block is 64 bytes long,
+// represented in this implementation by 16 `uint32_t`s. `r` determines the
+// number of 64-byte Salsa20 blocks in a scryptBlockMix block, which is 2 * `r`
+// Salsa20 blocks. This implementation refers to them as Salsa20 blocks and
+// scrypt blocks, respectively.
+
+using namespace bssl;
+
+// A block_t is a Salsa20 block.
+typedef struct {
+  uint32_t words[16];
+} block_t;
+
+static_assert(sizeof(block_t) == 64, "block_t has padding");
+
+// salsa208_word_specification implements the Salsa20/8 core function, also
+// described in RFC 7914, section 3. It modifies the block at `inout`
+// in-place.
+static void salsa208_word_specification(block_t *inout) {
+  block_t x;
+  OPENSSL_memcpy(&x, inout, sizeof(x));
+
+  for (int i = 8; i > 0; i -= 2) {
+    x.words[4] ^= CRYPTO_rotl_u32(x.words[0] + x.words[12], 7);
+    x.words[8] ^= CRYPTO_rotl_u32(x.words[4] + x.words[0], 9);
+    x.words[12] ^= CRYPTO_rotl_u32(x.words[8] + x.words[4], 13);
+    x.words[0] ^= CRYPTO_rotl_u32(x.words[12] + x.words[8], 18);
+    x.words[9] ^= CRYPTO_rotl_u32(x.words[5] + x.words[1], 7);
+    x.words[13] ^= CRYPTO_rotl_u32(x.words[9] + x.words[5], 9);
+    x.words[1] ^= CRYPTO_rotl_u32(x.words[13] + x.words[9], 13);
+    x.words[5] ^= CRYPTO_rotl_u32(x.words[1] + x.words[13], 18);
+    x.words[14] ^= CRYPTO_rotl_u32(x.words[10] + x.words[6], 7);
+    x.words[2] ^= CRYPTO_rotl_u32(x.words[14] + x.words[10], 9);
+    x.words[6] ^= CRYPTO_rotl_u32(x.words[2] + x.words[14], 13);
+    x.words[10] ^= CRYPTO_rotl_u32(x.words[6] + x.words[2], 18);
+    x.words[3] ^= CRYPTO_rotl_u32(x.words[15] + x.words[11], 7);
+    x.words[7] ^= CRYPTO_rotl_u32(x.words[3] + x.words[15], 9);
+    x.words[11] ^= CRYPTO_rotl_u32(x.words[7] + x.words[3], 13);
+    x.words[15] ^= CRYPTO_rotl_u32(x.words[11] + x.words[7], 18);
+    x.words[1] ^= CRYPTO_rotl_u32(x.words[0] + x.words[3], 7);
+    x.words[2] ^= CRYPTO_rotl_u32(x.words[1] + x.words[0], 9);
+    x.words[3] ^= CRYPTO_rotl_u32(x.words[2] + x.words[1], 13);
+    x.words[0] ^= CRYPTO_rotl_u32(x.words[3] + x.words[2], 18);
+    x.words[6] ^= CRYPTO_rotl_u32(x.words[5] + x.words[4], 7);
+    x.words[7] ^= CRYPTO_rotl_u32(x.words[6] + x.words[5], 9);
+    x.words[4] ^= CRYPTO_rotl_u32(x.words[7] + x.words[6], 13);
+    x.words[5] ^= CRYPTO_rotl_u32(x.words[4] + x.words[7], 18);
+    x.words[11] ^= CRYPTO_rotl_u32(x.words[10] + x.words[9], 7);
+    x.words[8] ^= CRYPTO_rotl_u32(x.words[11] + x.words[10], 9);
+    x.words[9] ^= CRYPTO_rotl_u32(x.words[8] + x.words[11], 13);
+    x.words[10] ^= CRYPTO_rotl_u32(x.words[9] + x.words[8], 18);
+    x.words[12] ^= CRYPTO_rotl_u32(x.words[15] + x.words[14], 7);
+    x.words[13] ^= CRYPTO_rotl_u32(x.words[12] + x.words[15], 9);
+    x.words[14] ^= CRYPTO_rotl_u32(x.words[13] + x.words[12], 13);
+    x.words[15] ^= CRYPTO_rotl_u32(x.words[14] + x.words[13], 18);
+  }
+
+  for (int i = 0; i < 16; ++i) {
+    inout->words[i] += x.words[i];
+  }
+}
+
+// xor_block sets `*out` to be `*a` XOR `*b`.
+static void xor_block(block_t *out, const block_t *a, const block_t *b) {
+  for (size_t i = 0; i < 16; i++) {
+    out->words[i] = a->words[i] ^ b->words[i];
+  }
+}
+
+// scryptBlockMix implements the function described in RFC 7914, section 4. B'
+// is written to `out`. `out` and `B` may not alias and must be each one scrypt
+// block (2 * `r` Salsa20 blocks) long.
+static void scryptBlockMix(block_t *out, const block_t *B, uint64_t r) {
+  assert(out != B);
+
+  block_t X;
+  OPENSSL_memcpy(&X, &B[r * 2 - 1], sizeof(X));
+  for (uint64_t i = 0; i < r * 2; i++) {
+    xor_block(&X, &X, &B[i]);
+    salsa208_word_specification(&X);
+
+    // This implements the permutation in step 3.
+    OPENSSL_memcpy(&out[i / 2 + (i & 1) * r], &X, sizeof(X));
+  }
+}
+
+// scryptROMix implements the function described in RFC 7914, section 5.  `B` is
+// an scrypt block (2 * `r` Salsa20 blocks) and is modified in-place. `T` and
+// `V` are scratch space allocated by the caller. `T` must have space for one
+// scrypt block (2 * `r` Salsa20 blocks). `V` must have space for `N` scrypt
+// blocks (2 * `r` * `N` Salsa20 blocks).
+static void scryptROMix(block_t *B, uint64_t r, uint64_t N, block_t *T,
+                        block_t *V) {
+  // Steps 1 and 2.
+  OPENSSL_memcpy(V, B, 2 * r * sizeof(block_t));
+  for (uint64_t i = 1; i < N; i++) {
+    scryptBlockMix(&V[2 * r * i /* scrypt block i */],
+                   &V[2 * r * (i - 1) /* scrypt block i-1 */], r);
+  }
+  scryptBlockMix(B, &V[2 * r * (N - 1) /* scrypt block N-1 */], r);
+
+  // Step 3.
+  for (uint64_t i = 0; i < N; i++) {
+    // Note this assumes `N` <= 2^32 and is a power of 2.
+    uint32_t j = B[2 * r - 1].words[0] & (N - 1);
+    for (size_t k = 0; k < 2 * r; k++) {
+      xor_block(&T[k], &B[k], &V[2 * r * j + k]);
+    }
+    scryptBlockMix(B, T, r);
+  }
+}
+
+// SCRYPT_PR_MAX is the maximum value of p * r. This is equivalent to the
+// bounds on p in section 6:
+//
+//   p <= ((2^32-1) * hLen) / MFLen iff
+//   p <= ((2^32-1) * 32) / (128 * r) iff
+//   p * r <= (2^30-1)
+#define SCRYPT_PR_MAX ((1 << 30) - 1)
+
+// SCRYPT_MAX_MEM is the default maximum memory that may be allocated by
+// `EVP_PBE_scrypt`.
+#define SCRYPT_MAX_MEM (1024 * 1024 * 65)
+
+int EVP_PBE_scrypt(const char *password, size_t password_len,
+                   const uint8_t *salt, size_t salt_len, uint64_t N, uint64_t r,
+                   uint64_t p, size_t max_mem, uint8_t *out_key,
+                   size_t key_len) {
+  if (r == 0 || p == 0 || p > SCRYPT_PR_MAX / r ||
+      // `N` must be a power of two.
+      N < 2 || (N & (N - 1)) ||
+      // We only support `N` <= 2^32 in `scryptROMix`.
+      N > UINT64_C(1) << 32 ||
+      // Check that `N` < 2^(128×r / 8).
+      (16 * r <= 63 && N >= UINT64_C(1) << (16 * r))) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PARAMETERS);
+    return 0;
+  }
+
+  // Determine the amount of memory needed. B, T, and V are `p`, 1, and `N`
+  // scrypt blocks, respectively. Each scrypt block is 2*`r` `block_t`s.
+  if (max_mem == 0) {
+    max_mem = SCRYPT_MAX_MEM;
+  }
+
+  size_t max_scrypt_blocks = max_mem / (2 * r * sizeof(block_t));
+  if (max_scrypt_blocks < p + 1 || max_scrypt_blocks - p - 1 < N) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_MEMORY_LIMIT_EXCEEDED);
+    return 0;
+  }
+
+  // Allocate and divide up the scratch space. `max_mem` fits in a size_t, which
+  // is no bigger than uint64_t, so none of these operations may overflow.
+  static_assert(UINT64_MAX >= SIZE_MAX, "size_t exceeds uint64_t");
+  size_t B_blocks = p * 2 * r;
+  size_t B_bytes = B_blocks * sizeof(block_t);
+  size_t T_blocks = 2 * r;
+  size_t V_blocks = N * 2 * r;
+  block_t *B = reinterpret_cast<block_t *>(
+      OPENSSL_calloc(B_blocks + T_blocks + V_blocks, sizeof(block_t)));
+  if (B == nullptr) {
+    return 0;
+  }
+
+  int ret = 0;
+  block_t *T = B + B_blocks;
+  block_t *V = T + T_blocks;
+
+  // NOTE: PKCS5_PBKDF2_HMAC can only fail due to allocation failure
+  // or `iterations` of 0 (we pass 1 here). This is consistent with
+  // the documented failure conditions of EVP_PBE_scrypt.
+  if (!PKCS5_PBKDF2_HMAC(password, password_len, salt, salt_len, 1,
+                         EVP_sha256(), B_bytes, (uint8_t *)B)) {
+    goto err;
+  }
+
+  for (uint64_t i = 0; i < p; i++) {
+    scryptROMix(B + 2 * r * i, r, N, T, V);
+  }
+
+  if (!PKCS5_PBKDF2_HMAC(password, password_len, (const uint8_t *)B, B_bytes, 1,
+                         EVP_sha256(), key_len, out_key)) {
+    goto err;
+  }
+
+  ret = 1;
+
+err:
+  OPENSSL_free(B);
+  return ret;
+}

package/runtime/third_party/boringssl/crypto/evp/sign.cc

@@ -0,0 +1,95 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/evp.h>
+
+#include <limits.h>
+
+#include <openssl/digest.h>
+#include <openssl/err.h>
+
+#include "internal.h"
+
+
+int EVP_SignInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl) {
+  return EVP_DigestInit_ex(ctx, type, impl);
+}
+
+int EVP_SignInit(EVP_MD_CTX *ctx, const EVP_MD *type) {
+  return EVP_DigestInit(ctx, type);
+}
+
+int EVP_SignUpdate(EVP_MD_CTX *ctx, const void *data, size_t len) {
+  return EVP_DigestUpdate(ctx, data, len);
+}
+
+int EVP_SignFinal(const EVP_MD_CTX *ctx, uint8_t *sig, unsigned *out_sig_len,
+                  EVP_PKEY *pkey) {
+  // Ensure the final result will fit in `unsigned`.
+  size_t sig_len = EVP_PKEY_size(pkey);
+  if (sig_len > UINT_MAX) {
+    sig_len = UINT_MAX;
+  }
+
+  *out_sig_len = 0;
+  uint8_t m[EVP_MAX_MD_SIZE];
+  unsigned m_len;
+  bssl::ScopedEVP_MD_CTX tmp_ctx;
+  if (!EVP_MD_CTX_copy_ex(tmp_ctx.get(), ctx) ||
+      !EVP_DigestFinal_ex(tmp_ctx.get(), m, &m_len)) {
+    return 0;
+  }
+
+  bssl::UniquePtr<EVP_PKEY_CTX> pkctx(EVP_PKEY_CTX_new(pkey, nullptr));
+  if (!pkctx ||  //
+      !EVP_PKEY_sign_init(pkctx.get()) ||
+      !EVP_PKEY_CTX_set_signature_md(pkctx.get(), ctx->digest) ||
+      !EVP_PKEY_sign(pkctx.get(), sig, &sig_len, m, m_len)) {
+    return 0;
+  }
+  *out_sig_len = static_cast<unsigned>(sig_len);
+  return 1;
+}
+
+int EVP_VerifyInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl) {
+  return EVP_DigestInit_ex(ctx, type, impl);
+}
+
+int EVP_VerifyInit(EVP_MD_CTX *ctx, const EVP_MD *type) {
+  return EVP_DigestInit(ctx, type);
+}
+
+int EVP_VerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t len) {
+  return EVP_DigestUpdate(ctx, data, len);
+}
+
+int EVP_VerifyFinal(EVP_MD_CTX *ctx, const uint8_t *sig, size_t sig_len,
+                    EVP_PKEY *pkey) {
+  uint8_t m[EVP_MAX_MD_SIZE];
+  unsigned m_len;
+  bssl::ScopedEVP_MD_CTX tmp_ctx;
+  if (!EVP_MD_CTX_copy_ex(tmp_ctx.get(), ctx) ||
+      !EVP_DigestFinal_ex(tmp_ctx.get(), m, &m_len)) {
+    return 0;
+  }
+
+  bssl::UniquePtr<EVP_PKEY_CTX> pkctx(EVP_PKEY_CTX_new(pkey, nullptr));
+  if (!pkctx ||
+      !EVP_PKEY_verify_init(pkctx.get()) ||
+      !EVP_PKEY_CTX_set_signature_md(pkctx.get(), ctx->digest)) {
+    return 0;
+  }
+  return EVP_PKEY_verify(pkctx.get(), sig, sig_len, m, m_len);
+}
+