visaljs 0.0.1 → 0.0.3

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

@@ -0,0 +1,95 @@
+// Copyright 2016 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_POOL_INTERNAL_H
+#define OPENSSL_HEADER_CRYPTO_POOL_INTERNAL_H
+
+#include "../internal.h"
+#include "../lhash/internal.h"
+#include "../mem_internal.h"
+
+
+DECLARE_OPAQUE_STRUCT(crypto_buffer_st, CryptoBuffer)
+DECLARE_OPAQUE_STRUCT(crypto_buffer_pool_st, CryptoBufferPool)
+
+BSSL_NAMESPACE_BEGIN
+
+// A CryptoBufferPoolHandle is the portion of the pool that lasts as long as any
+// live buffer or pool. This allows buffers to outlive the pool. (The pool is
+// only needed as long as callers wish to create new buffers.)
+class CryptoBufferPoolHandle : public RefCounted<CryptoBufferPoolHandle> {
+ public:
+  explicit CryptoBufferPoolHandle(CryptoBufferPool *pool)
+      : RefCounted(CheckSubClass()), pool_(pool) {}
+
+  // pool_ is protected by lock_.
+  Mutex lock_;
+  CryptoBufferPool *pool_ = nullptr;
+
+ private:
+  friend RefCounted;
+  ~CryptoBufferPoolHandle() = default;
+};
+
+class CryptoBuffer : public crypto_buffer_st {
+ public:
+  CryptoBuffer() = default;
+  CryptoBuffer(const CryptoBuffer &) = delete;
+  CryptoBuffer &operator=(const CryptoBuffer &) = delete;
+
+  Span<const uint8_t> span() const { return Span(data_, len_); }
+
+  // Instead of subclassing RefCounted<T>, implement refcounting by hand.
+  // CryptoBuffer's refcounting must synchronize with CryptoBufferPool.
+  static constexpr bool kAllowRefCountedUniquePtr = true;
+  void UpRefInternal() const;
+  void DecRefInternal();
+
+  UniquePtr<CryptoBufferPoolHandle> pool_handle_;
+  uint8_t *data_ = nullptr;
+  size_t len_ = 0;
+  mutable CRYPTO_refcount_t references_ = 1;
+  bool data_is_static_ = false;
+
+ private:
+  ~CryptoBuffer();
+};
+
+DEFINE_LHASH_OF(CryptoBuffer)
+
+class CryptoBufferPool : public crypto_buffer_pool_st,
+                         public RefCounted<CryptoBufferPool> {
+ public:
+  CryptoBufferPool();
+
+  // Hash returns the hash of `data`.
+  uint32_t Hash(Span<const uint8_t> data) const;
+
+  // FindBufferLocked looks for a buffer with hash `hash` and contents `data`.
+  // It returns it if found and nullptr otherwise. `handle_->lock_` must be
+  // locked for reading or writing before calling this.
+  CryptoBuffer *FindBufferLocked(uint32_t hash, Span<const uint8_t> data);
+
+  UniquePtr<CryptoBufferPoolHandle> handle_;
+  LHASH_OF(CryptoBuffer) *bufs_ = nullptr;
+  uint64_t hash_key_[2];
+
+ private:
+  friend RefCounted;
+  ~CryptoBufferPool();
+};
+
+BSSL_NAMESPACE_END
+
+#endif  // OPENSSL_HEADER_CRYPTO_POOL_INTERNAL_H

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

@@ -0,0 +1,282 @@
+// Copyright 2016 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/pool.h>
+
+#include <assert.h>
+#include <string.h>
+
+#include <openssl/bytestring.h>
+#include <openssl/mem.h>
+#include <openssl/rand.h>
+#include <openssl/siphash.h>
+
+#include "../internal.h"
+#include "../mem_internal.h"
+#include "internal.h"
+
+
+using namespace bssl;
+
+static uint32_t CRYPTO_BUFFER_hash(const CryptoBuffer *buf) {
+  // This function must be called while there is a read or write lock on the
+  // pool, so it is safe to read `pool_`.
+  return buf->pool_handle_->pool_->Hash(buf->span());
+}
+
+static int CRYPTO_BUFFER_cmp(const CryptoBuffer *a, const CryptoBuffer *b) {
+  // Only `CRYPTO_BUFFER`s from the same pool have compatible hashes.
+  assert(a->pool_handle_ != nullptr);
+  assert(a->pool_handle_ == b->pool_handle_);
+  return a->span() == b->span() ? 0 : 1;
+}
+
+CryptoBufferPool::CryptoBufferPool() : RefCounted(CheckSubClass()) {
+  RAND_bytes(reinterpret_cast<uint8_t *>(&hash_key_), sizeof(hash_key_));
+}
+
+CryptoBufferPool::~CryptoBufferPool() {
+  if (handle_) {
+    MutexWriteLock lock(&handle_->lock_);
+    handle_->pool_ = nullptr;
+  }
+  lh_CryptoBuffer_free(bufs_);
+}
+
+uint32_t CryptoBufferPool::Hash(Span<const uint8_t> data) const {
+  return static_cast<uint32_t>(SIPHASH_24(hash_key_, data.data(), data.size()));
+}
+
+CryptoBuffer *CryptoBufferPool::FindBufferLocked(uint32_t hash,
+                                                 Span<const uint8_t> data) {
+  return lh_CryptoBuffer_retrieve_key(
+      bufs_, &data, hash,
+      [](const void *key_v, const CryptoBuffer *buf) -> int {
+        Span<const uint8_t> key =
+            *static_cast<const Span<const uint8_t> *>(key_v);
+        return key == buf->span() ? 0 : 1;
+      });
+}
+
+CRYPTO_BUFFER_POOL *CRYPTO_BUFFER_POOL_new() {
+  auto pool = MakeUnique<CryptoBufferPool>();
+  if (pool == nullptr) {
+    return nullptr;
+  }
+
+  pool->bufs_ = lh_CryptoBuffer_new(CRYPTO_BUFFER_hash, CRYPTO_BUFFER_cmp);
+  pool->handle_ = MakeUnique<CryptoBufferPoolHandle>(pool.get());
+  if (pool->bufs_ == nullptr || pool->handle_ == nullptr) {
+    return nullptr;
+  }
+
+  return pool.release();
+}
+
+void CRYPTO_BUFFER_POOL_free(CRYPTO_BUFFER_POOL *pool) {
+  if (pool != nullptr) {
+    FromOpaque(pool)->DecRefInternal();
+  }
+}
+
+int CRYPTO_BUFFER_POOL_up_ref(CRYPTO_BUFFER_POOL *pool) {
+  FromOpaque(pool)->UpRefInternal();
+  return 1;
+}
+
+void CryptoBuffer::UpRefInternal() const {
+  // This is safe in the case that `buf->pool` is NULL because it's just
+  // standard reference counting in that case.
+  //
+  // This is also safe if `buf->pool` is non-NULL because, if it were racing
+  // with `CRYPTO_BUFFER_free` then the two callers must have independent
+  // references already and so the reference count will never hit zero.
+  CRYPTO_refcount_inc(&references_);
+}
+
+void CryptoBuffer::DecRefInternal() {
+  // If there is a pool, decrementing the refcount must synchronize with it.
+  if (pool_handle_ == nullptr) {
+    if (!CRYPTO_refcount_dec_and_test_zero(&references_)) {
+      return;
+    }
+  } else {
+    MutexWriteLock lock(&pool_handle_->lock_);
+    if (!CRYPTO_refcount_dec_and_test_zero(&references_)) {
+      return;
+    }
+
+    // We have an exclusive lock on the pool handle, therefore no concurrent
+    // lookups can find this buffer and increment the reference count. Thus, if
+    // the count is zero there are and can never be any more references and thus
+    // we can free this buffer. It is possible the pool was already destroyed,
+    // but it cannot be destroyed concurrently.
+    //
+    // Note it is possible `buf` is no longer in the pool, if it was replaced by
+    // a static version. If that static version was since removed, it is even
+    // possible for `found` to be NULL.
+    if (CryptoBufferPool *pool = pool_handle_->pool_; pool != nullptr) {
+      CryptoBuffer *found = lh_CryptoBuffer_retrieve(pool->bufs_, this);
+      if (found == this) {
+        found = lh_CryptoBuffer_delete(pool->bufs_, this);
+        assert(found == this);
+        (void)found;
+      }
+    }
+  }
+
+  this->~CryptoBuffer();
+  OPENSSL_free(this);
+}
+
+CryptoBuffer::~CryptoBuffer() {
+  if (!data_is_static_) {
+    OPENSSL_free(data_);
+  }
+}
+
+static UniquePtr<CryptoBuffer> crypto_buffer_new(Span<const uint8_t> data,
+                                                 bool data_is_static) {
+  UniquePtr<CryptoBuffer> buf = MakeUnique<CryptoBuffer>();
+  if (buf == nullptr) {
+    return nullptr;
+  }
+
+  if (data_is_static) {
+    buf->data_ = const_cast<uint8_t *>(data.data());
+    buf->data_is_static_ = true;
+  } else {
+    buf->data_ =
+        static_cast<uint8_t *>(OPENSSL_memdup(data.data(), data.size()));
+    if (!data.empty() && buf->data_ == nullptr) {
+      return nullptr;
+    }
+  }
+
+  buf->len_ = data.size();
+  return buf;
+}
+
+static UniquePtr<CryptoBuffer> crypto_buffer_new_with_pool(
+    Span<const uint8_t> data, bool data_is_static, CryptoBufferPool *pool) {
+  if (pool == nullptr) {
+    return crypto_buffer_new(data, data_is_static);
+  }
+
+  const uint32_t hash = pool->Hash(data);
+  {
+    // Look for a matching buffer in the pool.
+    MutexReadLock lock(&pool->handle_->lock_);
+    CryptoBuffer *duplicate = pool->FindBufferLocked(hash, data);
+    if (data_is_static && duplicate != nullptr && !duplicate->data_is_static_) {
+      // If the new `CRYPTO_BUFFER` would have static data, but the duplicate
+      // does not, we replace the old one with the new static version.
+      duplicate = nullptr;
+    }
+    if (duplicate != nullptr) {
+      return UpRef(duplicate);
+    }
+  }
+
+  UniquePtr<CryptoBuffer> buf = crypto_buffer_new(data, data_is_static);
+  if (buf == nullptr) {
+    return nullptr;
+  }
+
+  MutexWriteLock lock(&pool->handle_->lock_);
+  CryptoBuffer *duplicate = pool->FindBufferLocked(hash, data);
+  if (data_is_static && duplicate != nullptr && !duplicate->data_is_static_) {
+    // If the new `CRYPTO_BUFFER` would have static data, but the duplicate does
+    // not, we replace the old one with the new static version.
+    duplicate = nullptr;
+  }
+  if (duplicate != nullptr) {
+    return UpRef(duplicate);
+  }
+
+  // Insert `buf` into the pool. Note `old` may be non-NULL if a match was found
+  // but ignored. `pool->bufs_` does not increment refcounts, so there is no
+  // need to clean up after the replacement.
+  buf->pool_handle_ = UpRef(pool->handle_);
+  CryptoBuffer *old = nullptr;
+  if (!lh_CryptoBuffer_insert(pool->bufs_, &old, buf.get())) {
+    buf->pool_handle_ = nullptr;  // No need to synchronize with the pool.
+    return nullptr;
+  }
+  return buf;
+}
+
+CRYPTO_BUFFER *CRYPTO_BUFFER_new(const uint8_t *data, size_t len,
+                                 CRYPTO_BUFFER_POOL *pool) {
+  return crypto_buffer_new_with_pool(Span(data, len), /*data_is_static=*/false,
+                                     FromOpaque(pool))
+      .release();
+}
+
+CRYPTO_BUFFER *CRYPTO_BUFFER_alloc(uint8_t **out_data, size_t len) {
+  auto buf = MakeUnique<CryptoBuffer>();
+  if (buf == nullptr) {
+    return nullptr;
+  }
+
+  buf->data_ = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
+  if (len != 0 && buf->data_ == nullptr) {
+    return nullptr;
+  }
+  buf->len_ = len;
+
+  *out_data = buf->data_;
+  return buf.release();
+}
+
+CRYPTO_BUFFER *CRYPTO_BUFFER_new_from_CBS(const CBS *cbs,
+                                          CRYPTO_BUFFER_POOL *pool) {
+  return CRYPTO_BUFFER_new(CBS_data(cbs), CBS_len(cbs), pool);
+}
+
+CRYPTO_BUFFER *CRYPTO_BUFFER_new_from_static_data_unsafe(
+    const uint8_t *data, size_t len, CRYPTO_BUFFER_POOL *pool) {
+  return crypto_buffer_new_with_pool(Span(data, len), /*data_is_static=*/true,
+                                     FromOpaque(pool))
+      .release();
+}
+
+void CRYPTO_BUFFER_free(CRYPTO_BUFFER *buf) {
+  if (buf != nullptr) {
+    FromOpaque(buf)->DecRefInternal();
+  }
+}
+
+int CRYPTO_BUFFER_up_ref(CRYPTO_BUFFER *buf) {
+  FromOpaque(buf)->UpRefInternal();
+  return 1;
+}
+
+CRYPTO_BUFFER *CRYPTO_BUFFER_dup_ref(const CRYPTO_BUFFER *buf) {
+  auto *buf_ = const_cast<CRYPTO_BUFFER *>(buf);
+  FromOpaque(buf_)->UpRefInternal();
+  return buf_;
+}
+
+const uint8_t *CRYPTO_BUFFER_data(const CRYPTO_BUFFER *buf) {
+  return FromOpaque(buf)->data_;
+}
+
+size_t CRYPTO_BUFFER_len(const CRYPTO_BUFFER *buf) {
+  return FromOpaque(buf)->len_;
+}
+
+void CRYPTO_BUFFER_init_CBS(const CRYPTO_BUFFER *buf, CBS *out) {
+  *out = FromOpaque(buf)->span();
+}

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

@@ -0,0 +1,58 @@
+// Copyright 2016 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_DETERMINISTIC)
+
+#include <string.h>
+
+#include <openssl/chacha.h>
+
+#include "../internal.h"
+
+
+using namespace bssl;
+
+// g_num_calls is the number of calls to `CRYPTO_sysrand` that have occurred.
+//
+// This is intentionally not thread-safe. If the fuzzer mode is ever used in a
+// multi-threaded program, replace this with a thread-local. (A mutex would not
+// be deterministic.)
+static uint64_t g_num_calls = 0;
+static StaticMutex g_num_calls_lock;
+
+void RAND_reset_for_fuzzing() { g_num_calls = 0; }
+
+void bssl::CRYPTO_init_sysrand() {}
+
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
+  static const uint8_t kZeroKey[32] = {0};
+
+  g_num_calls_lock.LockWrite();
+  uint64_t num_calls = g_num_calls++;
+  g_num_calls_lock.UnlockWrite();
+
+  uint8_t nonce[12];
+  OPENSSL_memset(nonce, 0, sizeof(nonce));
+  OPENSSL_memcpy(nonce, &num_calls, sizeof(num_calls));
+
+  OPENSSL_memset(out, 0, requested);
+  CRYPTO_chacha_20(out, out, requested, kZeroKey, nonce, 0);
+}
+
+#endif  // OPENSSL_RAND_DETERMINISTIC

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

@@ -0,0 +1,222 @@
+// Copyright 2020 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 madvise() and MAP_ANONYMOUS on Linux.
+#endif
+
+#include "../bcm_support.h"
+#include "../internal.h"
+#include "internal.h"
+
+#if defined(OPENSSL_FORK_DETECTION_WIPEONFORK)
+
+#if defined(OPENSSL_LINUX)
+
+#include <assert.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#if defined(MADV_WIPEONFORK)
+static_assert(MADV_WIPEONFORK == 18);
+#else
+#define MADV_WIPEONFORK 18
+#endif
+
+#else
+
+// Otherwise assume a BSD style API.
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#endif
+
+#elif defined(OPENSSL_FORK_DETECTION_PTHREAD_ATFORK)
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#endif  // OPENSSL_FORK_DETECTION_PTHREAD_ATFORK
+
+
+using namespace bssl;
+
+#if defined(OPENSSL_FORK_DETECTION_WIPEONFORK)
+
+static bool wipeonfork(void *addr, size_t page_size) {
+#if defined(OPENSSL_LINUX)
+  // Linux flavor, >=4.14.
+  // Some versions of qemu (up to at least 5.0.0-rc4, see linux-user/syscall.c)
+  // ignore `madvise` calls and just return zero (i.e. success). But we need to
+  // know whether MADV_WIPEONFORK actually took effect. Therefore try an invalid
+  // call to check that the implementation of `madvise` is actually rejecting
+  // unknown `advice` values.
+  return madvise(addr, page_size, -1) != 0 &&
+         madvise(addr, page_size, MADV_WIPEONFORK) == 0;
+#elif defined(MAP_INHERIT_ZERO)
+  // OpenBSD flavor, >=5.6.
+  return minherit(addr, page_size, MAP_INHERIT_ZERO) == 0;
+#else
+  // FreeBSD flavor, >=12.0.
+  return minherit(addr, page_size, INHERIT_ZERO) == 0;
+#endif
+}
+
+static int g_force_madv_wipeonfork;
+static int g_force_madv_wipeonfork_enabled;
+static CRYPTO_once_t g_fork_detect_once = CRYPTO_ONCE_INIT;
+static StaticMutex g_fork_detect_lock;
+static Atomic<uint32_t> *g_fork_detect_addr;
+static uint64_t g_fork_generation;
+
+static void init_fork_detect() {
+  if (g_force_madv_wipeonfork) {
+    return;
+  }
+
+  long page_size = sysconf(_SC_PAGESIZE);
+  if (page_size <= 0) {
+    return;
+  }
+
+  void *addr = mmap(nullptr, static_cast<size_t>(page_size),
+                    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (addr == MAP_FAILED) {
+    return;
+  }
+
+  if (!wipeonfork(addr, static_cast<size_t>(page_size))) {
+    munmap(addr, static_cast<size_t>(page_size));
+    return;
+  }
+
+  g_fork_detect_addr = new (addr) Atomic<uint32_t>(1);
+  g_fork_generation = 1;
+}
+
+uint64_t bssl::CRYPTO_get_fork_generation() {
+  CRYPTO_once(&g_fork_detect_once, init_fork_detect);
+
+  // In a single-threaded process, there are obviously no races because there's
+  // only a single mutator in the address space.
+  //
+  // In a multi-threaded environment, `CRYPTO_once` ensures that the flag byte
+  // is initialised atomically, even if multiple threads enter this function
+  // concurrently.
+  //
+  // Additionally, while the kernel will only clear WIPEONFORK at a point when a
+  // child process is single-threaded, the child may become multi-threaded
+  // before it observes this. Therefore, we must synchronize the logic below.
+
+  Atomic<uint32_t> *const flag_ptr = g_fork_detect_addr;
+  if (flag_ptr == nullptr) {
+    // Our kernel is too old to support `MADV_WIPEONFORK` or
+    // `g_force_madv_wipeonfork` is set.
+    if (g_force_madv_wipeonfork && g_force_madv_wipeonfork_enabled) {
+      // A constant generation number to simulate support, even if the kernel
+      // doesn't support it.
+      return 42;
+    }
+    // With Linux and clone(), we do not believe that pthread_atfork() is
+    // sufficient for detecting all forms of address space duplication. At this
+    // point we have a kernel that does not support MADV_WIPEONFORK. We could
+    // return the generation number from pthread_atfork() here and it would
+    // probably be safe in almost any situation, but to ensure safety we return
+    // 0 and force an entropy draw on every call.
+    return 0;
+  }
+
+  // In the common case, try to observe the flag without taking a lock. This
+  // avoids cacheline contention in the PRNG.
+  uint64_t *const generation_ptr = &g_fork_generation;
+  if (flag_ptr->load() != 0) {
+    // If we observe a non-zero flag, it is safe to read `generation_ptr`
+    // without a lock. The flag and generation number are fixed for this copy of
+    // the address space.
+    return *generation_ptr;
+  }
+
+  // The flag was zero. The generation number must be incremented, but other
+  // threads may have concurrently observed the zero, so take a lock before
+  // incrementing.
+  MutexWriteLock lock(&g_fork_detect_lock);
+  uint64_t current_generation = *generation_ptr;
+  if (flag_ptr->load() == 0) {
+    // A fork has occurred.
+    current_generation++;
+    if (current_generation == 0) {
+      // Zero means fork detection isn't supported, so skip that value.
+      current_generation = 1;
+    }
+
+    // We must update `generation_ptr` before `flag_ptr`. Other threads may
+    // observe `flag_ptr` without taking a lock.
+    *generation_ptr = current_generation;
+    flag_ptr->store(1);
+  }
+
+  return current_generation;
+}
+
+void bssl::CRYPTO_fork_detect_force_madv_wipeonfork_for_testing(int on) {
+  g_force_madv_wipeonfork = 1;
+  g_force_madv_wipeonfork_enabled = on;
+}
+
+#elif defined(OPENSSL_FORK_DETECTION_PTHREAD_ATFORK)
+
+static CRYPTO_once_t g_pthread_fork_detection_once = CRYPTO_ONCE_INIT;
+static uint64_t g_atfork_fork_generation;
+
+static void we_are_forked() {
+  // Immediately after a fork, the process must be single-threaded.
+  uint64_t value = g_atfork_fork_generation + 1;
+  if (value == 0) {
+    value = 1;
+  }
+  g_atfork_fork_generation = value;
+}
+
+static void init_pthread_fork_detection() {
+  if (pthread_atfork(nullptr, nullptr, we_are_forked) != 0) {
+    abort();
+  }
+  g_atfork_fork_generation = 1;
+}
+
+uint64_t bssl::CRYPTO_get_fork_generation() {
+  CRYPTO_once(&g_pthread_fork_detection_once, init_pthread_fork_detection);
+
+  return g_atfork_fork_generation;
+}
+
+#elif defined(OPENSSL_DOES_NOT_FORK)
+
+// These platforms are guaranteed not to fork, and therefore do not require
+// fork detection support. Returning a constant non zero value makes BoringSSL
+// assume address space duplication is not a concern and adding entropy to
+// every RAND_bytes call is not needed.
+uint64_t bssl::CRYPTO_get_fork_generation() { return 0xc0ffee; }
+
+#else
+
+// These platforms may fork, but we do not have a mitigation mechanism in
+// place.  Returning a constant zero value makes BoringSSL assume that address
+// space duplication could have occurred on any call entropy must be added to
+// every RAND_bytes call.
+uint64_t bssl::CRYPTO_get_fork_generation() { return 0; }
+
+#endif

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

@@ -0,0 +1,44 @@
+// 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 <openssl/rand.h>
+
+#include <stdlib.h>
+
+#include "../fipsmodule/rand/internal.h"
+#include "../internal.h"
+
+
+using namespace bssl;
+
+// g_buffering_enabled is one if fork-unsafe buffering has been enabled and zero
+// otherwise.
+static bssl::Atomic<uint32_t> g_buffering_enabled;
+
+#if !defined(OPENSSL_WINDOWS)
+void RAND_enable_fork_unsafe_buffering(int fd) {
+  // We no longer support setting the file-descriptor with this function.
+  if (fd != -1) {
+    abort();
+  }
+
+  g_buffering_enabled.store(1);
+}
+
+void RAND_disable_fork_unsafe_buffering() { g_buffering_enabled.store(0); }
+#endif
+
+int bssl::rand_fork_unsafe_buffering_enabled() {
+  return g_buffering_enabled.load() != 0;
+}