@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/cleanup_queue.h

@@ -0,0 +1,79 @@
+#ifndef SRC_CLEANUP_QUEUE_H_
+#define SRC_CLEANUP_QUEUE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstddef>
+#include <cstdint>
+#include <unordered_set>
+#include <vector>
+
+#include "memory_tracker.h"
+
+namespace node {
+
+class CleanupQueue : public MemoryRetainer {
+ public:
+  typedef void (*Callback)(void*);
+
+  CleanupQueue() = default;
+
+  // Not copyable.
+  CleanupQueue(const CleanupQueue&) = delete;
+
+  SET_MEMORY_INFO_NAME(CleanupQueue)
+  SET_NO_MEMORY_INFO()
+  inline size_t SelfSize() const override;
+
+  inline bool empty() const;
+
+  inline void Add(Callback cb, void* arg);
+  inline void Remove(Callback cb, void* arg);
+  void Drain();
+
+ private:
+  class CleanupHookCallback {
+   public:
+    CleanupHookCallback(Callback fn,
+                        void* arg,
+                        uint64_t insertion_order_counter)
+        : fn_(fn),
+          arg_(arg),
+          insertion_order_counter_(insertion_order_counter) {}
+
+    // Only hashes `arg_`, since that is usually enough to identify the hook.
+    struct Hash {
+      size_t operator()(const CleanupHookCallback& cb) const;
+    };
+
+    // Compares by `fn_` and `arg_` being equal.
+    struct Equal {
+      bool operator()(const CleanupHookCallback& a,
+                      const CleanupHookCallback& b) const;
+    };
+
+   private:
+    friend class CleanupQueue;
+    Callback fn_;
+    void* arg_;
+
+    // We keep track of the insertion order for these objects, so that we can
+    // call the callbacks in reverse order when we are cleaning up.
+    uint64_t insertion_order_counter_;
+  };
+
+  std::vector<CleanupHookCallback> GetOrdered() const;
+
+  // Use an unordered_set, so that we have efficient insertion and removal.
+  std::unordered_set<CleanupHookCallback,
+                     CleanupHookCallback::Hash,
+                     CleanupHookCallback::Equal>
+      cleanup_hooks_;
+  uint64_t cleanup_hook_counter_ = 0;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CLEANUP_QUEUE_H_

package/src/headers/24/compile_cache.h

@@ -0,0 +1,113 @@
+#ifndef SRC_COMPILE_CACHE_H_
+#define SRC_COMPILE_CACHE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include "v8.h"
+
+namespace node {
+class Environment;
+
+#define CACHED_CODE_TYPES(V)                                                   \
+  V(kCommonJS, 0)                                                              \
+  V(kESM, 1)                                                                   \
+  V(kStrippedTypeScript, 2)                                                    \
+  V(kTransformedTypeScript, 3)                                                 \
+  V(kTransformedTypeScriptWithSourceMaps, 4)
+
+enum class CachedCodeType : uint8_t {
+#define V(type, value) type = value,
+  CACHED_CODE_TYPES(V)
+#undef V
+};
+
+struct CompileCacheEntry {
+  std::unique_ptr<v8::ScriptCompiler::CachedData> cache{nullptr};
+  uint32_t cache_key;
+  uint32_t code_hash;
+  uint32_t code_size;
+
+  std::string cache_filename;
+  std::string source_filename;
+  CachedCodeType type;
+  bool refreshed = false;
+  bool persisted = false;
+
+  // Copy the cache into a new store for V8 to consume. Caller takes
+  // ownership.
+  v8::ScriptCompiler::CachedData* CopyCache() const;
+  const char* type_name() const;
+};
+
+#define COMPILE_CACHE_STATUS(V)                                                \
+  V(FAILED)          /* Failed to enable the cache */                          \
+  V(ENABLED)         /* Was not enabled before, and now enabled. */            \
+  V(ALREADY_ENABLED) /* Was already enabled. */                                \
+  V(DISABLED)        /* Has been disabled by NODE_DISABLE_COMPILE_CACHE. */
+
+enum class CompileCacheEnableStatus : uint8_t {
+#define V(status) status,
+  COMPILE_CACHE_STATUS(V)
+#undef V
+};
+
+struct CompileCacheEnableResult {
+  CompileCacheEnableStatus status;
+  std::string cache_directory;
+  std::string message;  // Set in case of failure.
+};
+
+class CompileCacheHandler {
+ public:
+  explicit CompileCacheHandler(Environment* env);
+  CompileCacheEnableResult Enable(Environment* env, const std::string& dir);
+
+  void Persist();
+
+  CompileCacheEntry* GetOrInsert(v8::Local<v8::String> code,
+                                 v8::Local<v8::String> filename,
+                                 CachedCodeType type);
+  void MaybeSave(CompileCacheEntry* entry,
+                 v8::Local<v8::Function> func,
+                 bool rejected);
+  void MaybeSave(CompileCacheEntry* entry,
+                 v8::Local<v8::Module> mod,
+                 bool rejected);
+  void MaybeSave(CompileCacheEntry* entry, std::string_view transpiled);
+  std::string_view cache_dir() { return compile_cache_dir_; }
+
+ private:
+  void ReadCacheFile(CompileCacheEntry* entry);
+
+  template <typename T>
+  void MaybeSaveImpl(CompileCacheEntry* entry,
+                     v8::Local<T> func_or_mod,
+                     bool rejected);
+
+  template <typename... Args>
+  inline void Debug(const char* format, Args&&... args) const;
+
+  static constexpr size_t kMagicNumberOffset = 0;
+  static constexpr size_t kCodeSizeOffset = 1;
+  static constexpr size_t kCacheSizeOffset = 2;
+  static constexpr size_t kCodeHashOffset = 3;
+  static constexpr size_t kCacheHashOffset = 4;
+  static constexpr size_t kHeaderCount = 5;
+
+  v8::Isolate* isolate_ = nullptr;
+  bool is_debug_ = false;
+
+  std::string compile_cache_dir_;
+  std::unordered_map<uint32_t, std::unique_ptr<CompileCacheEntry>>
+      compiler_cache_store_;
+};
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_COMPILE_CACHE_H_

package/src/headers/24/cppgc_helpers-inl.h

@@ -0,0 +1,65 @@
+#ifndef SRC_CPPGC_HELPERS_INL_H_
+#define SRC_CPPGC_HELPERS_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "cppgc_helpers.h"
+#include "env-inl.h"
+
+namespace node {
+
+template <typename T>
+void CppgcMixin::Wrap(T* ptr, Realm* realm, v8::Local<v8::Object> obj) {
+  CHECK_GE(obj->InternalFieldCount(), T::kInternalFieldCount);
+  ptr->realm_ = realm;
+  v8::Isolate* isolate = realm->isolate();
+  ptr->traced_reference_ = v8::TracedReference<v8::Object>(isolate, obj);
+  // Note that ptr must be of concrete type T in Wrap.
+  v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(isolate, obj, ptr);
+  // Keep the layout consistent with BaseObjects.
+  obj->SetAlignedPointerInInternalField(
+      kEmbedderType, realm->isolate_data()->embedder_id_for_cppgc());
+  obj->SetAlignedPointerInInternalField(kSlot, ptr);
+  realm->TrackCppgcWrapper(ptr);
+}
+
+template <typename T>
+void CppgcMixin::Wrap(T* ptr, Environment* env, v8::Local<v8::Object> obj) {
+  Wrap(ptr, env->principal_realm(), obj);
+}
+
+template <typename T>
+T* CppgcMixin::Unwrap(v8::Local<v8::Object> obj) {
+  // We are not using v8::Object::Unwrap currently because that requires
+  // access to isolate which the ASSIGN_OR_RETURN_UNWRAP macro that we'll shim
+  // with ASSIGN_OR_RETURN_UNWRAP_GC doesn't take, and we also want a
+  // signature consistent with BaseObject::Unwrap() to avoid churn. Since
+  // cppgc-managed objects share the same layout as BaseObjects, just unwrap
+  // from the pointer in the internal field, which should be valid as long as
+  // the object is still alive.
+  if (obj->InternalFieldCount() != T::kInternalFieldCount) {
+    return nullptr;
+  }
+  T* ptr = static_cast<T*>(obj->GetAlignedPointerFromInternalField(T::kSlot));
+  return ptr;
+}
+
+v8::Local<v8::Object> CppgcMixin::object() const {
+  return traced_reference_.Get(realm_->isolate());
+}
+
+Environment* CppgcMixin::env() const {
+  return realm_->env();
+}
+
+CppgcMixin::~CppgcMixin() {
+  if (realm_ != nullptr) {
+    realm_->set_should_purge_empty_cppgc_wrappers(true);
+  }
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CPPGC_HELPERS_INL_H_

package/src/headers/24/cppgc_helpers.h

@@ -0,0 +1,162 @@
+#ifndef SRC_CPPGC_HELPERS_H_
+#define SRC_CPPGC_HELPERS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <type_traits>  // std::remove_reference
+#include "cppgc/garbage-collected.h"
+#include "cppgc/name-provider.h"
+#include "cppgc/persistent.h"
+#include "memory_tracker.h"
+#include "util.h"
+#include "v8-cppgc.h"
+#include "v8-sandbox.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+class Realm;
+class CppgcWrapperListNode;
+
+/**
+ * This is a helper mixin with a BaseObject-like interface to help
+ * implementing wrapper objects managed by V8's cppgc (Oilpan) library.
+ * cppgc-manged objects in Node.js internals should extend this mixin,
+ * while non-cppgc-managed objects typically extend BaseObject - the
+ * latter are being migrated to be cppgc-managed wherever it's beneficial
+ * and practical. Typically cppgc-managed objects are more efficient to
+ * keep track of (which lowers initialization cost) and work better
+ * with V8's GC scheduling.
+ *
+ * A cppgc-managed native wrapper should look something like this, note
+ * that per cppgc rules, CPPGC_MIXIN(MyWrap) must be at the left-most
+ * position in the hierarchy (which ensures cppgc::GarbageCollected
+ * is at the left-most position).
+ *
+ * class MyWrap final : CPPGC_MIXIN(MyWrap) {
+ *  public:
+ *   SET_CPPGC_NAME(MyWrap)  // Sets the heap snapshot name to "Node / MyWrap"
+ *   void Trace(cppgc::Visitor* visitor) const final {
+ *     CppgcMixin::Trace(visitor);
+ *     visitor->Trace(...);  // Trace any additional owned traceable data
+ *   }
+ * }
+ *
+ * If the wrapper needs to perform cleanups when it's destroyed and that
+ * cleanup relies on a living Node.js `Realm`, it should implement a
+ * pattern like this:
+ *
+ *   ~MyWrap() { this->Destroy(); }
+ *   void Clean(Realm* env) override {
+ *     // Do cleanup that relies on a living Environemnt.
+ *   }
+ */
+class CppgcMixin : public cppgc::GarbageCollectedMixin, public MemoryRetainer {
+ public:
+  // To help various callbacks access wrapper objects with different memory
+  // management, cppgc-managed objects share the same layout as BaseObjects.
+  enum InternalFields { kEmbedderType = 0, kSlot, kInternalFieldCount };
+
+  // The initialization cannot be done in the mixin constructor but has to be
+  // invoked from the child class constructor, per cppgc::GarbageCollectedMixin
+  // rules.
+  template <typename T>
+  static inline void Wrap(T* ptr, Realm* realm, v8::Local<v8::Object> obj);
+  template <typename T>
+  static inline void Wrap(T* ptr, Environment* env, v8::Local<v8::Object> obj);
+
+  inline v8::Local<v8::Object> object() const;
+  inline Environment* env() const;
+  inline Realm* realm() const { return realm_; }
+  inline v8::Local<v8::Object> object(v8::Isolate* isolate) const {
+    return traced_reference_.Get(isolate);
+  }
+
+  template <typename T>
+  static inline T* Unwrap(v8::Local<v8::Object> obj);
+
+  // Subclasses are expected to invoke CppgcMixin::Trace() in their own Trace()
+  // methods.
+  void Trace(cppgc::Visitor* visitor) const override {
+    visitor->Trace(traced_reference_);
+  }
+
+  // TODO(joyeecheung): use ObjectSizeTrait;
+  inline size_t SelfSize() const override { return sizeof(*this); }
+  inline bool IsCppgcWrapper() const override { return true; }
+
+  // This is run for all the remaining Cppgc wrappers tracked in the Realm
+  // during Realm shutdown. The destruction of the wrappers would happen later,
+  // when the final garbage collection is triggered when CppHeap is torn down as
+  // part of the Isolate teardown. If subclasses of CppgcMixin wish to perform
+  // cleanups that depend on the Realm during destruction, they should implment
+  // it in a Clean() override, and then call this->Finalize() from their
+  // destructor. Outside of Finalize(), subclasses should avoid calling
+  // into JavaScript or perform any operation that can trigger garbage
+  // collection during the destruction.
+  void Finalize() {
+    if (realm_ == nullptr) return;
+    this->Clean(realm_);
+    realm_ = nullptr;
+  }
+
+  // The default implementation of Clean() is a no-op. If subclasses wish
+  // to perform cleanup that require a living Realm, they should
+  // should put the cleanups in a Clean() override, and call this->Finalize()
+  // in the destructor, instead of doing those cleanups directly in the
+  // destructor.
+  virtual void Clean(Realm* realm) {}
+
+  inline ~CppgcMixin();
+
+  friend class CppgcWrapperListNode;
+
+ private:
+  Realm* realm_ = nullptr;
+  v8::TracedReference<v8::Object> traced_reference_;
+};
+
+// If the class doesn't have additional owned traceable data, use this macro to
+// save the implementation of a custom Trace() method.
+#define DEFAULT_CPPGC_TRACE()                                                  \
+  void Trace(cppgc::Visitor* visitor) const final {                            \
+    CppgcMixin::Trace(visitor);                                                \
+  }
+
+// This macro sets the node name in the heap snapshot with a "Node /" prefix.
+// Classes that use this macro must extend cppgc::NameProvider.
+#define SET_CPPGC_NAME(Klass)                                                  \
+  inline const char* GetHumanReadableName() const final {                      \
+    return "Node / " #Klass;                                                   \
+  }                                                                            \
+  inline const char* MemoryInfoName() const override { return #Klass; }
+
+/**
+ * Similar to ASSIGN_OR_RETURN_UNWRAP() but works on cppgc-managed types
+ * inheriting CppgcMixin.
+ */
+#define ASSIGN_OR_RETURN_UNWRAP_CPPGC(ptr, obj, ...)                           \
+  do {                                                                         \
+    *ptr = CppgcMixin::Unwrap<                                                 \
+        typename std::remove_reference<decltype(**ptr)>::type>(obj);           \
+    if (*ptr == nullptr) return __VA_ARGS__;                                   \
+  } while (0)
+}  // namespace node
+
+/**
+ * Helper macro the manage the cppgc-based wrapper hierarchy. This must
+ * be used at the left-most position - right after `:` in the class inheritance,
+ * like this:
+ * class Klass : CPPGC_MIXIN(Klass) ... {}
+ *
+ * This needs to disable linters because it will be at odds with
+ * clang-format.
+ */
+#define CPPGC_MIXIN(Klass)                                                     \
+  public /* NOLINT(whitespace/indent) */                                       \
+  cppgc::GarbageCollected<Klass>, public cppgc::NameProvider, public CppgcMixin
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_CPPGC_HELPERS_H_

package/src/headers/24/crypto/crypto_aes.h

@@ -0,0 +1,97 @@
+#ifndef SRC_CRYPTO_CRYPTO_AES_H_
+#define SRC_CRYPTO_CRYPTO_AES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "crypto/crypto_cipher.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
+#include "env.h"
+#include "v8.h"
+
+namespace node::crypto {
+constexpr unsigned kNoAuthTagLength = static_cast<unsigned>(-1);
+
+#define VARIANTS_COMMON(V)                                                     \
+  V(CTR_128, AES_CTR_Cipher, ncrypto::Cipher::AES_128_CTR)                     \
+  V(CTR_192, AES_CTR_Cipher, ncrypto::Cipher::AES_192_CTR)                     \
+  V(CTR_256, AES_CTR_Cipher, ncrypto::Cipher::AES_256_CTR)                     \
+  V(CBC_128, AES_Cipher, ncrypto::Cipher::AES_128_CBC)                         \
+  V(CBC_192, AES_Cipher, ncrypto::Cipher::AES_192_CBC)                         \
+  V(CBC_256, AES_Cipher, ncrypto::Cipher::AES_256_CBC)                         \
+  V(GCM_128, AES_Cipher, ncrypto::Cipher::AES_128_GCM)                         \
+  V(GCM_192, AES_Cipher, ncrypto::Cipher::AES_192_GCM)                         \
+  V(GCM_256, AES_Cipher, ncrypto::Cipher::AES_256_GCM)                         \
+  V(KW_128, AES_Cipher, ncrypto::Cipher::AES_128_KW)                           \
+  V(KW_192, AES_Cipher, ncrypto::Cipher::AES_192_KW)                           \
+  V(KW_256, AES_Cipher, ncrypto::Cipher::AES_256_KW)
+
+#if OPENSSL_VERSION_MAJOR >= 3
+#define VARIANTS_OCB(V)                                                        \
+  V(OCB_128, AES_Cipher, ncrypto::Cipher::AES_128_OCB)                         \
+  V(OCB_192, AES_Cipher, ncrypto::Cipher::AES_192_OCB)                         \
+  V(OCB_256, AES_Cipher, ncrypto::Cipher::AES_256_OCB)
+#else
+#define VARIANTS_OCB(V)
+#endif
+
+#define VARIANTS(V)                                                            \
+  VARIANTS_COMMON(V)                                                           \
+  VARIANTS_OCB(V)
+
+enum class AESKeyVariant {
+#define V(name, _, __) name,
+  VARIANTS(V)
+#undef V
+};
+
+struct AESCipherConfig final : public MemoryRetainer {
+  CryptoJobMode mode;
+  AESKeyVariant variant;
+  ncrypto::Cipher cipher;
+  size_t length;
+  ByteSource iv;  // Used for both iv or counter
+  ByteSource additional_data;
+  ByteSource tag;  // Used only for authenticated modes (GCM)
+
+  AESCipherConfig() = default;
+
+  AESCipherConfig(AESCipherConfig&& other) noexcept;
+
+  AESCipherConfig& operator=(AESCipherConfig&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(AESCipherConfig)
+  SET_SELF_SIZE(AESCipherConfig)
+};
+
+struct AESCipherTraits final {
+  static constexpr const char* JobName = "AESCipherJob";
+
+  using AdditionalParameters = AESCipherConfig;
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      WebCryptoCipherMode cipher_mode,
+      AESCipherConfig* config);
+
+  static WebCryptoCipherStatus DoCipher(Environment* env,
+                                        const KeyObjectData& key_data,
+                                        WebCryptoCipherMode cipher_mode,
+                                        const AESCipherConfig& params,
+                                        const ByteSource& in,
+                                        ByteSource* out);
+};
+
+using AESCryptoJob = CipherJob<AESCipherTraits>;
+
+namespace AES {
+void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+}  // namespace AES
+}  // namespace node::crypto
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_AES_H_

package/src/headers/24/crypto/crypto_argon2.h

@@ -0,0 +1,86 @@
+#ifndef SRC_CRYPTO_CRYPTO_ARGON2_H_
+#define SRC_CRYPTO_CRYPTO_ARGON2_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "crypto/crypto_util.h"
+
+namespace node::crypto {
+#if !defined(OPENSSL_NO_ARGON2) && OPENSSL_VERSION_NUMBER >= 0x30200000L
+
+// Argon2 is a password-based key derivation algorithm
+// defined in https://datatracker.ietf.org/doc/html/rfc9106
+
+// It takes as input a password, a salt value, and a
+// handful of additional parameters that control the
+// cost of the operation. In this case, the higher
+// the cost, the better the result. The length parameter
+// defines the number of bytes that are generated.
+
+// The salt must be as random as possible and should be
+// at least 16 bytes in length.
+
+struct Argon2Config final : public MemoryRetainer {
+  CryptoJobMode mode;
+  ByteSource pass;
+  ByteSource salt;
+  ByteSource secret;
+  ByteSource ad;
+  ncrypto::Argon2Type type;
+  uint32_t iter;
+  uint32_t lanes;
+  uint32_t memcost;
+  uint32_t version = 0x13;
+  uint32_t keylen;
+
+  Argon2Config() = default;
+
+  explicit Argon2Config(Argon2Config&& other) noexcept;
+
+  Argon2Config& operator=(Argon2Config&& other) noexcept;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Argon2Config)
+  SET_SELF_SIZE(Argon2Config)
+};
+
+struct Argon2Traits final {
+  using AdditionalParameters = Argon2Config;
+  static constexpr const char* JobName = "Argon2Job";
+  static constexpr AsyncWrap::ProviderType Provider =
+      AsyncWrap::PROVIDER_ARGON2REQUEST;
+
+  static v8::Maybe<void> AdditionalConfig(
+      CryptoJobMode mode,
+      const v8::FunctionCallbackInfo<v8::Value>& args,
+      unsigned int offset,
+      Argon2Config* config);
+
+  static bool DeriveBits(Environment* env,
+                         const Argon2Config& config,
+                         ByteSource* out,
+                         CryptoJobMode mode);
+
+  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
+                                                const Argon2Config& config,
+                                                ByteSource* out);
+};
+
+using Argon2Job = DeriveBitsJob<Argon2Traits>;
+
+namespace Argon2 {
+void Initialize(Environment* env, v8::Local<v8::Object> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+}  // namespace Argon2
+
+#else
+// If there is no Argon2 support, Argon2Job becomes a non-op
+struct Argon2Job {
+  static void Initialize(Environment* env, v8::Local<v8::Object> target) {}
+};
+#endif
+
+}  // namespace node::crypto
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_CRYPTO_CRYPTO_ARGON2_H_

package/src/headers/{16 → 24}/crypto/crypto_bio.h

@@ -43,12 +43,13 @@ class NodeBIO : public MemoryRetainer {
  public:
   ~NodeBIO() override;
 
-  static BIOPointer New(Environment* env = nullptr);
+  static ncrypto::BIOPointer New(Environment* env = nullptr);
 
   // NewFixed takes a copy of `len` bytes from `data` and returns a BIO that,
   // when read from, returns those bytes followed by EOF.
-  static BIOPointer NewFixed(const char* data, size_t len,
-                             Environment* env = nullptr);
+  static ncrypto::BIOPointer NewFixed(const char* data,
+                                      size_t len,
+                                      Environment* env = nullptr);
 
   // Move read head to next buffer if needed
   void TryMoveReadHead();
@@ -155,15 +156,15 @@ class NodeBIO : public MemoryRetainer {
                                            len_(len),
                                            next_(nullptr) {
       data_ = new char[len];
-      if (env_ != nullptr)
-        env_->isolate()->AdjustAmountOfExternalAllocatedMemory(len);
+      if (env_ != nullptr) {
+        env_->external_memory_accounter()->Increase(env_->isolate(), len);
+      }
     }
 
     ~Buffer() {
       delete[] data_;
       if (env_ != nullptr) {
-        const int64_t len = static_cast<int64_t>(len_);
-        env_->isolate()->AdjustAmountOfExternalAllocatedMemory(-len);
+        env_->external_memory_accounter()->Decrease(env_->isolate(), len_);
       }
     }
 
@@ -182,8 +183,6 @@ class NodeBIO : public MemoryRetainer {
   int eof_return_ = -1;
   Buffer* read_head_ = nullptr;
   Buffer* write_head_ = nullptr;
-
-  friend void node::crypto::InitCryptoOnce();
 };
 
 }  // namespace crypto