visaljs 0.0.1 → 0.0.3

package/runtime/third_party/boringssl/crypto/rand/getentropy.cc

@@ -0,0 +1,53 @@
+// Copyright 2023 The BoringSSL Authors
+//
+// 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.
+
+#if !defined(_DEFAULT_SOURCE)
+#define _DEFAULT_SOURCE  // Needed for getentropy on musl and glibc
+#endif
+
+#include <openssl/rand.h>
+
+#include "../bcm_support.h"
+#include "internal.h"
+
+#if defined(OPENSSL_RAND_GETENTROPY)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#if defined(OPENSSL_MACOS) || defined(OPENSSL_FUCHSIA)
+#include <sys/random.h>
+#endif
+
+using namespace bssl;
+
+void bssl::CRYPTO_init_sysrand() {}
+
+// CRYPTO_sysrand puts `requested` random bytes into `out`.
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
+  while (requested > 0) {
+    // `getentropy` can only request 256 bytes at a time.
+    size_t todo = requested <= 256 ? requested : 256;
+    if (getentropy(out, todo) != 0) {
+      perror("getentropy() failed");
+      abort();
+    }
+
+    out += todo;
+    requested -= todo;
+  }
+}
+
+#endif  // OPENSSL_RAND_GETENTROPY

package/runtime/third_party/boringssl/crypto/rand/internal.h

@@ -0,0 +1,67 @@
+// Copyright 2024 The BoringSSL Authors
+//
+// 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.
+
+#ifndef OPENSSL_HEADER_CRYPTO_RAND_INTERNAL_H
+#define OPENSSL_HEADER_CRYPTO_RAND_INTERNAL_H
+
+#include <openssl/base.h>
+
+
+#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
+#define OPENSSL_RAND_DETERMINISTIC
+#elif defined(OPENSSL_TRUSTY)
+#define OPENSSL_RAND_TRUSTY
+#elif defined(OPENSSL_WINDOWS)
+#define OPENSSL_RAND_WINDOWS
+#elif defined(OPENSSL_LINUX)
+#define OPENSSL_RAND_URANDOM
+#elif defined(OPENSSL_APPLE) && !defined(OPENSSL_MACOS)
+// Unlike macOS, iOS and similar hide away getentropy().
+#define OPENSSL_RAND_IOS
+#else
+// By default if you are integrating BoringSSL we expect you to
+// provide getentropy from the <unistd.h> header file.
+#define OPENSSL_RAND_GETENTROPY
+#endif
+
+#if defined(OPENSSL_LINUX) || defined(OPENSSL_FREEBSD) || \
+    defined(OPENSSL_OPENBSD)
+
+// On linux we use MADVISE instead of pthread_atfork(), due
+// to concerns about clone() being used for address space
+// duplication.
+#define OPENSSL_FORK_DETECTION
+#define OPENSSL_FORK_DETECTION_WIPEONFORK
+
+#elif defined(OPENSSL_MACOS) || defined(OPENSSL_IOS)
+
+// These platforms may detect address space duplication with pthread_atfork.
+// iOS doesn't normally allow fork in apps, but it's there.
+#define OPENSSL_FORK_DETECTION
+#define OPENSSL_FORK_DETECTION_PTHREAD_ATFORK
+
+#elif defined(OPENSSL_WINDOWS) || defined(OPENSSL_TRUSTY) || \
+    defined(__ZEPHYR__) || defined(CROS_EC)
+
+// These platforms do not fork.
+#define OPENSSL_DOES_NOT_FORK
+
+#else
+
+// Other platforms may fork, but BoringSSL cannot reliably detect it happening.
+// So instead, new entropy will be drawn on every RNG call.
+
+#endif
+
+#endif  // OPENSSL_HEADER_CRYPTO_RAND_INTERNAL_H

package/runtime/third_party/boringssl/crypto/rand/ios.cc

@@ -0,0 +1,35 @@
+// Copyright 2023 The BoringSSL Authors
+//
+// 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/rand.h>
+
+#include "../bcm_support.h"
+#include "internal.h"
+
+#if defined(OPENSSL_RAND_IOS)
+#include <stdlib.h>
+
+#include <CommonCrypto/CommonRandom.h>
+
+using namespace bssl;
+
+void bssl::CRYPTO_init_sysrand() {}
+
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
+  if (CCRandomGenerateBytes(out, requested) != kCCSuccess) {
+    abort();
+  }
+}
+
+#endif  // OPENSSL_RAND_IOS

package/runtime/third_party/boringssl/crypto/rand/rand.cc

@@ -0,0 +1,79 @@
+// Copyright 2017 The BoringSSL Authors
+//
+// 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 <limits.h>
+
+#include <openssl/rand.h>
+
+#include "../bcm_support.h"
+#include "../fipsmodule/bcm_interface.h"
+
+
+using namespace bssl;
+
+int RAND_bytes(uint8_t *buf, size_t len) {
+  BCM_rand_bytes(buf, len);
+  return 1;
+}
+
+int RAND_pseudo_bytes(uint8_t *buf, size_t len) { return RAND_bytes(buf, len); }
+
+void RAND_seed(const void *buf, int num) {
+  // OpenSSH calls `RAND_seed` before jailing on the assumption that any needed
+  // file descriptors etc will be opened.
+  uint8_t unused;
+  RAND_bytes(&unused, sizeof(unused));
+}
+
+int RAND_load_file(const char *path, long num) {
+  if (num < 0) {  // read the "whole file"
+    return 1;
+  } else if (num <= INT_MAX) {
+    return (int)num;
+  } else {
+    return INT_MAX;
+  }
+}
+
+const char *RAND_file_name(char *buf, size_t num) { return nullptr; }
+
+void RAND_add(const void *buf, int num, double entropy) {}
+
+int RAND_egd(const char *path) { return 255; }
+
+int RAND_poll() { return 1; }
+
+int RAND_status() { return 1; }
+
+static const struct rand_meth_st kSSLeayMethod = {
+    RAND_seed, RAND_bytes,        RAND_cleanup,
+    RAND_add,  RAND_pseudo_bytes, RAND_status,
+};
+
+RAND_METHOD *RAND_SSLeay() { return (RAND_METHOD *)&kSSLeayMethod; }
+
+RAND_METHOD *RAND_OpenSSL() { return RAND_SSLeay(); }
+
+const RAND_METHOD *RAND_get_rand_method() { return RAND_SSLeay(); }
+
+int RAND_set_rand_method(const RAND_METHOD *method) { return 1; }
+
+void RAND_cleanup() {}
+
+void RAND_get_system_entropy_for_custom_prng(uint8_t *buf, size_t len) {
+  if (len > 256) {
+    abort();
+  }
+  CRYPTO_sysrand(buf, len);
+}

package/runtime/third_party/boringssl/crypto/rand/trusty.cc

@@ -0,0 +1,39 @@
+// Copyright 2023 The BoringSSL Authors
+//
+// 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/rand.h>
+
+#include "../bcm_support.h"
+#include "internal.h"
+
+#if defined(OPENSSL_RAND_TRUSTY)
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
+#include <uapi/err.h>
+
+#include <lib/rng/trusty_rng.h>
+
+using namespace bssl;
+
+void bssl::CRYPTO_init_sysrand() {}
+
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
+  if (trusty_rng_hw_rand(out, requested) != NO_ERROR) {
+    abort();
+  }
+}
+
+#endif  // OPENSSL_RAND_TRUSTY

package/runtime/third_party/boringssl/crypto/rand/urandom.cc

@@ -0,0 +1,149 @@
+// Copyright 2014 The BoringSSL Authors
+//
+// 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.
+
+#if !defined(_GNU_SOURCE)
+#define _GNU_SOURCE  // needed for syscall() on Linux.
+#endif
+
+#include <openssl/rand.h>
+
+#include "../bcm_support.h"
+#include "internal.h"
+
+#if defined(OPENSSL_RAND_URANDOM)
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/random.h>
+#include <stdio.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include "../internal.h"
+
+
+using namespace bssl;
+
+#if defined(OPENSSL_MSAN)
+extern "C" {
+void __msan_unpoison(void *, size_t);
+}
+#endif
+
+static ssize_t boringssl_getrandom(void *buf, size_t buf_len, unsigned flags) {
+  ssize_t ret;
+  do {
+    ret = syscall(__NR_getrandom, buf, buf_len, flags);
+  } while (ret == -1 && errno == EINTR);
+
+#if defined(OPENSSL_MSAN)
+  if (ret > 0) {
+    // MSAN doesn't recognise `syscall` and thus doesn't notice that we have
+    // initialised the output buffer.
+    __msan_unpoison(buf, ret);
+  }
+#endif  // OPENSSL_MSAN
+
+  return ret;
+}
+
+// kHaveGetrandom in `urandom_fd` signals that `getrandom` or `getentropy` is
+// available and should be used instead.
+static const int kHaveGetrandom = -3;
+
+// urandom_fd is a file descriptor to /dev/urandom. It's protected by `once`.
+static int urandom_fd;
+
+static CRYPTO_once_t rand_once = CRYPTO_ONCE_INIT;
+
+// init_once initializes the state of this module to values previously
+// requested. This is the only function that modifies `urandom_fd`, which may be
+// read safely after calling the once.
+static void init_once() {
+  int have_getrandom;
+  uint8_t dummy;
+  ssize_t getrandom_ret =
+      boringssl_getrandom(&dummy, sizeof(dummy), GRND_NONBLOCK);
+  if (getrandom_ret == 1) {
+    have_getrandom = 1;
+  } else if (getrandom_ret == -1 && errno == EAGAIN) {
+    // We have getrandom, but the entropy pool has not been initialized yet.
+    have_getrandom = 1;
+  } else if (getrandom_ret == -1 && errno == ENOSYS) {
+    // Fallthrough to using /dev/urandom, below.
+    have_getrandom = 0;
+  } else {
+    // Other errors are fatal.
+    perror("getrandom");
+    abort();
+  }
+
+  if (have_getrandom) {
+    urandom_fd = kHaveGetrandom;
+    return;
+  }
+
+  // FIPS builds must support getrandom.
+#if defined(BORINGSSL_FIPS)
+  perror("getrandom not found");
+  abort();
+#endif
+
+  int fd;
+  do {
+    fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC);
+  } while (fd == -1 && errno == EINTR);
+
+  if (fd < 0) {
+    perror("failed to open /dev/urandom");
+    abort();
+  }
+
+  urandom_fd = fd;
+}
+
+void bssl::CRYPTO_init_sysrand() { CRYPTO_once(&rand_once, init_once); }
+
+// CRYPTO_sysrand writes `len` bytes of entropy into `out`.
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t len) {
+  if (len == 0) {
+    return;
+  }
+
+  CRYPTO_init_sysrand();
+
+  // Clear `errno` so it has defined value if `read` or `getrandom`
+  // "successfully" returns zero.
+  errno = 0;
+  while (len > 0) {
+    ssize_t r;
+
+    if (urandom_fd == kHaveGetrandom) {
+      r = boringssl_getrandom(out, len, 0);
+    } else {
+      do {
+        r = read(urandom_fd, out, len);
+      } while (r == -1 && errno == EINTR);
+    }
+
+    if (r <= 0) {
+      perror("entropy fill failed");
+      abort();
+    }
+    out += r;
+    len -= r;
+  }
+}
+
+#endif  // OPENSSL_RAND_URANDOM

package/runtime/third_party/boringssl/crypto/rand/windows.cc

@@ -0,0 +1,91 @@
+// Copyright 2014 The BoringSSL Authors
+//
+// 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/rand.h>
+
+#include "../bcm_support.h"
+#include "../internal.h"
+#include "internal.h"
+
+#if defined(OPENSSL_RAND_WINDOWS)
+
+#include <limits.h>
+#include <stdlib.h>
+
+#include <windows.h>
+
+using namespace bssl;
+
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
+    !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#include <bcrypt.h>
+OPENSSL_MSVC_PRAGMA(comment(lib, "bcrypt.lib"))
+#endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP
+
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
+    !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+
+void bssl::CRYPTO_init_sysrand() {}
+
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
+  while (requested > 0) {
+    ULONG output_bytes_this_pass = ULONG_MAX;
+    if (requested < output_bytes_this_pass) {
+      output_bytes_this_pass = (ULONG)requested;
+    }
+    if (!BCRYPT_SUCCESS(BCryptGenRandom(
+            /*hAlgorithm=*/nullptr, out, output_bytes_this_pass,
+            BCRYPT_USE_SYSTEM_PREFERRED_RNG))) {
+      abort();
+    }
+    requested -= output_bytes_this_pass;
+    out += output_bytes_this_pass;
+  }
+}
+
+#else
+
+// See: https://learn.microsoft.com/en-us/windows/win32/seccng/processprng
+typedef BOOL(WINAPI *ProcessPrngFunction)(PBYTE pbData, SIZE_T cbData);
+static ProcessPrngFunction g_processprng_fn = nullptr;
+
+static void init_processprng() {
+  HMODULE hmod = LoadLibraryW(L"bcryptprimitives");
+  if (hmod == nullptr) {
+    abort();
+  }
+  g_processprng_fn = (ProcessPrngFunction)GetProcAddress(hmod, "ProcessPrng");
+  if (g_processprng_fn == nullptr) {
+    abort();
+  }
+}
+
+void bssl::CRYPTO_init_sysrand() {
+  static CRYPTO_once_t once = CRYPTO_ONCE_INIT;
+  CRYPTO_once(&once, init_processprng);
+}
+
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
+  CRYPTO_init_sysrand();
+  // On non-UWP configurations, use ProcessPrng instead of BCryptGenRandom
+  // to avoid accessing resources that may be unavailable inside the
+  // Chromium sandbox. See https://crbug.com/74242
+  if (!g_processprng_fn(out, requested)) {
+    abort();
+  }
+}
+
+#endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP
+
+#endif  // OPENSSL_RAND_WINDOWS

package/runtime/third_party/boringssl/crypto/rc4/rc4.cc

@@ -0,0 +1,56 @@
+// 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/rc4.h>
+
+
+void RC4(RC4_KEY *key, size_t len, const uint8_t *in, uint8_t *out) {
+  uint32_t x = key->x;
+  uint32_t y = key->y;
+  uint32_t *d = key->data;
+
+  for (size_t i = 0; i < len; i++) {
+    x = (x + 1) & 0xff;
+    uint32_t tx = d[x];
+    y = (tx + y) & 0xff;
+    uint32_t ty = d[y];
+    d[x] = ty;
+    d[y] = tx;
+    out[i] = d[(tx + ty) & 0xff] ^ in[i];
+  }
+
+  key->x = x;
+  key->y = y;
+}
+
+void RC4_set_key(RC4_KEY *rc4key, unsigned len, const uint8_t *key) {
+  uint32_t *d = &rc4key->data[0];
+  rc4key->x = 0;
+  rc4key->y = 0;
+
+  for (unsigned i = 0; i < 256; i++) {
+    d[i] = i;
+  }
+
+  unsigned id1 = 0, id2 = 0;
+  for (unsigned i = 0; i < 256; i++) {
+    uint32_t tmp = d[i];
+    id2 = (key[id1] + tmp + id2) & 0xff;
+    if (++id1 == len) {
+      id1 = 0;
+    }
+    d[i] = d[id2];
+    d[id2] = tmp;
+  }
+}

package/runtime/third_party/boringssl/crypto/refcount.cc

@@ -0,0 +1,49 @@
+// Copyright 2015 The BoringSSL Authors
+//
+// 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 "internal.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+
+using namespace bssl;
+
+void bssl::CRYPTO_refcount_inc(CRYPTO_refcount_t *count) {
+  uint32_t expected = count->load();
+
+  while (expected != CRYPTO_REFCOUNT_MAX) {
+    uint32_t new_value = expected + 1;
+    if (count->compare_exchange_weak(expected, new_value)) {
+      break;
+    }
+  }
+}
+
+int bssl::CRYPTO_refcount_dec_and_test_zero(CRYPTO_refcount_t *count) {
+  uint32_t expected = count->load();
+
+  for (;;) {
+    if (expected == 0) {
+      abort();
+    } else if (expected == CRYPTO_REFCOUNT_MAX) {
+      return 0;
+    } else {
+      const uint32_t new_value = expected - 1;
+      if (count->compare_exchange_weak(expected, new_value)) {
+        return new_value == 0;
+      }
+    }
+  }
+}

package/runtime/third_party/boringssl/crypto/rsa/internal.h

@@ -0,0 +1,51 @@
+// 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.
+
+#ifndef OPENSSL_HEADER_CRYPTO_RSA_INTERNAL_H
+#define OPENSSL_HEADER_CRYPTO_RSA_INTERNAL_H
+
+#include <openssl/base.h>
+
+#include "../fipsmodule/rsa/internal.h"
+
+
+BSSL_NAMESPACE_BEGIN
+
+int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len,
+                                      size_t max_out, const uint8_t *from,
+                                      size_t from_len, const uint8_t *param,
+                                      size_t param_len, const EVP_MD *md,
+                                      const EVP_MD *mgf1md);
+
+// rsa_pss_params_get_md returns the hash function used with `params`. This also
+// specifies the MGF-1 hash and the salt length because we do not support other
+// configurations.
+const EVP_MD *rsa_pss_params_get_md(rsa_pss_params_t params);
+
+// rsa_marshal_pss_params marshals `params` as a DER-encoded RSASSA-PSS-params
+// (RFC 4055). It returns one on success and zero on error. If `params` is
+// `rsa_pss_params_none`, this function gives an error.
+int rsa_marshal_pss_params(CBB *cbb, rsa_pss_params_t params);
+
+// rsa_marshal_pss_params decodes a DER-encoded RSASSA-PSS-params
+// (RFC 4055). It returns one on success and zero on error. On success, it sets
+// `*out` to the result. If `allow_explicit_trailer` is non-zero, an explicit
+// encoding of the trailerField is allowed, although it is not valid DER. This
+// function never outputs `rsa_pss_params_none`.
+int rsa_parse_pss_params(CBS *cbs, rsa_pss_params_t *out,
+                         int allow_explicit_trailer);
+
+BSSL_NAMESPACE_END
+
+#endif  // OPENSSL_HEADER_CRYPTO_RSA_INTERNAL_H