@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{18 → 22}/crypto/crypto_util.h

@@ -12,16 +12,17 @@
 #include "util.h"
 #include "v8.h"
 
+#include "ncrypto.h"
+
+#include <openssl/dsa.h>
+#include <openssl/ec.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
-#include <openssl/ec.h>
+#include <openssl/hmac.h>
 #include <openssl/kdf.h>
 #include <openssl/rsa.h>
-#include <openssl/dsa.h>
 #include <openssl/ssl.h>
-#ifndef OPENSSL_NO_ENGINE
-#  include <openssl/engine.h>
-#endif  // !OPENSSL_NO_ENGINE
+
 // The FIPS-related functions are only available
 // when the OpenSSL itself was compiled with FIPS support.
 #if defined(OPENSSL_FIPS) && OPENSSL_VERSION_MAJOR < 3
@@ -29,11 +30,12 @@
 #endif  // OPENSSL_FIPS
 
 #include <algorithm>
+#include <climits>
+#include <cstdio>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
-#include <climits>
-#include <cstdio>
 
 namespace node {
 namespace crypto {
@@ -52,39 +54,32 @@ constexpr size_t kSizeOf_EVP_PKEY_CTX = 80;
 constexpr size_t kSizeOf_HMAC_CTX = 32;
 
 // Define smart pointers for the most commonly used OpenSSL types:
-using X509Pointer = DeleteFnPtr<X509, X509_free>;
-using BIOPointer = DeleteFnPtr<BIO, BIO_free_all>;
-using SSLCtxPointer = DeleteFnPtr<SSL_CTX, SSL_CTX_free>;
-using SSLSessionPointer = DeleteFnPtr<SSL_SESSION, SSL_SESSION_free>;
-using SSLPointer = DeleteFnPtr<SSL, SSL_free>;
-using PKCS8Pointer = DeleteFnPtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>;
-using EVPKeyPointer = DeleteFnPtr<EVP_PKEY, EVP_PKEY_free>;
-using EVPKeyCtxPointer = DeleteFnPtr<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;
-using EVPMDPointer = DeleteFnPtr<EVP_MD_CTX, EVP_MD_CTX_free>;
-using RSAPointer = DeleteFnPtr<RSA, RSA_free>;
-using ECPointer = DeleteFnPtr<EC_KEY, EC_KEY_free>;
-using BignumPointer = DeleteFnPtr<BIGNUM, BN_free>;
-using BignumCtxPointer = DeleteFnPtr<BN_CTX, BN_CTX_free>;
-using NetscapeSPKIPointer = DeleteFnPtr<NETSCAPE_SPKI, NETSCAPE_SPKI_free>;
-using ECGroupPointer = DeleteFnPtr<EC_GROUP, EC_GROUP_free>;
-using ECPointPointer = DeleteFnPtr<EC_POINT, EC_POINT_free>;
-using ECKeyPointer = DeleteFnPtr<EC_KEY, EC_KEY_free>;
-using DHPointer = DeleteFnPtr<DH, DH_free>;
-using ECDSASigPointer = DeleteFnPtr<ECDSA_SIG, ECDSA_SIG_free>;
-using HMACCtxPointer = DeleteFnPtr<HMAC_CTX, HMAC_CTX_free>;
-using CipherCtxPointer = DeleteFnPtr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free>;
-using RsaPointer = DeleteFnPtr<RSA, RSA_free>;
-using DsaPointer = DeleteFnPtr<DSA, DSA_free>;
-using DsaSigPointer = DeleteFnPtr<DSA_SIG, DSA_SIG_free>;
-
-// Our custom implementation of the certificate verify callback
-// used when establishing a TLS handshake. Because we cannot perform
-// I/O quickly enough with X509_STORE_CTX_ APIs in this callback,
-// we ignore preverify_ok errors here and let the handshake continue.
-// In other words, this VerifyCallback is a non-op. It is imperative
-// that the user user Connection::VerifyError after the `secure`
-// callback has been made.
-extern int VerifyCallback(int preverify_ok, X509_STORE_CTX* ctx);
+using X509Pointer = ncrypto::X509Pointer;
+using BIOPointer = ncrypto::BIOPointer;
+using SSLCtxPointer = ncrypto::SSLCtxPointer;
+using SSLSessionPointer = ncrypto::SSLSessionPointer;
+using SSLPointer = ncrypto::SSLPointer;
+using PKCS8Pointer = ncrypto::PKCS8Pointer;
+using EVPKeyPointer = ncrypto::EVPKeyPointer;
+using EVPKeyCtxPointer = ncrypto::EVPKeyCtxPointer;
+using EVPMDCtxPointer = ncrypto::EVPMDCtxPointer;
+using RSAPointer = ncrypto::RSAPointer;
+using ECPointer = ncrypto::ECPointer;
+using BignumPointer = ncrypto::BignumPointer;
+using BignumCtxPointer = ncrypto::BignumCtxPointer;
+using NetscapeSPKIPointer = ncrypto::NetscapeSPKIPointer;
+using ECGroupPointer = ncrypto::ECGroupPointer;
+using ECPointPointer = ncrypto::ECPointPointer;
+using ECKeyPointer = ncrypto::ECKeyPointer;
+using DHPointer = ncrypto::DHPointer;
+using ECDSASigPointer = ncrypto::ECDSASigPointer;
+using HMACCtxPointer = ncrypto::HMACCtxPointer;
+using CipherCtxPointer = ncrypto::CipherCtxPointer;
+using DsaPointer = ncrypto::DSAPointer;
+using DsaSigPointer = ncrypto::DSASigPointer;
+
+using ClearErrorOnReturn = ncrypto::ClearErrorOnReturn;
+using MarkPopErrorOnReturn = ncrypto::MarkPopErrorOnReturn;
 
 bool ProcessFipsOptions();
 
@@ -95,47 +90,6 @@ void InitCrypto(v8::Local<v8::Object> target);
 
 extern void UseExtraCaCerts(const std::string& file);
 
-// Forcibly clear OpenSSL's error stack on return. This stops stale errors
-// from popping up later in the lifecycle of crypto operations where they
-// would cause spurious failures. It's a rather blunt method, though.
-// ERR_clear_error() isn't necessarily cheap either.
-struct ClearErrorOnReturn {
-  ~ClearErrorOnReturn() { ERR_clear_error(); }
-};
-
-// Pop errors from OpenSSL's error stack that were added
-// between when this was constructed and destructed.
-struct MarkPopErrorOnReturn {
-  MarkPopErrorOnReturn() { ERR_set_mark(); }
-  ~MarkPopErrorOnReturn() { ERR_pop_to_mark(); }
-};
-
-// Ensure that OpenSSL has enough entropy (at least 256 bits) for its PRNG.
-// The entropy pool starts out empty and needs to fill up before the PRNG
-// can be used securely.  Once the pool is filled, it never dries up again;
-// its contents is stirred and reused when necessary.
-//
-// OpenSSL normally fills the pool automatically but not when someone starts
-// generating random numbers before the pool is full: in that case OpenSSL
-// keeps lowering the entropy estimate to thwart attackers trying to guess
-// the initial state of the PRNG.
-//
-// When that happens, we will have to wait until enough entropy is available.
-// That should normally never take longer than a few milliseconds.
-//
-// OpenSSL draws from /dev/random and /dev/urandom.  While /dev/random may
-// block pending "true" randomness, /dev/urandom is a CSPRNG that doesn't
-// block under normal circumstances.
-//
-// The only time when /dev/urandom may conceivably block is right after boot,
-// when the whole system is still low on entropy.  That's not something we can
-// do anything about.
-void CheckEntropy();
-
-// Generate length bytes of random data. If this returns false, the data
-// may not be truly random but it's still generally good enough.
-bool EntropySource(unsigned char* buffer, size_t length);
-
 int PasswordCallback(char* buf, int size, int rwflag, void* u);
 
 int NoPasswordCallback(char* buf, int size, int rwflag, void* u);
@@ -147,7 +101,7 @@ void Decode(const v8::FunctionCallbackInfo<v8::Value>& args,
             void (*callback)(T*, const v8::FunctionCallbackInfo<v8::Value>&,
                              const char*, size_t)) {
   T* ctx;
-  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
 
   if (args[0]->IsString()) {
     StringBytes::InlineDecoder decoder;
@@ -176,6 +130,21 @@ enum class NodeCryptoError {
 #undef V
 };
 
+template <typename... Args>
+std::string getNodeCryptoErrorString(const NodeCryptoError error,
+                                     Args&&... args) {
+  const char* error_string = nullptr;
+  switch (error) {
+#define V(CODE, DESCRIPTION)                                                   \
+  case NodeCryptoError::CODE:                                                  \
+    error_string = DESCRIPTION;                                                \
+    break;
+    NODE_CRYPTO_ERROR_CODES_MAP(V)
+#undef V
+  }
+  return SPrintF(error_string, std::forward<Args>(args)...);
+}
+
 // Utility struct used to harvest error information from openssl's error stack
 struct CryptoErrorStore final : public MemoryRetainer {
  public:
@@ -211,6 +180,9 @@ void CryptoErrorStore::Insert(const NodeCryptoError error, Args&&... args) {
                                std::forward<Args>(args)...));
 }
 
+v8::MaybeLocal<v8::Value> cryptoErrorListToException(
+    Environment* env, const ncrypto::CryptoErrorList& errors);
+
 template <typename T>
 T* MallocOpenSSL(size_t count) {
   void* mem = OPENSSL_malloc(MultiplyWithOverflowCheck(count, sizeof(T)));
@@ -218,37 +190,79 @@ T* MallocOpenSSL(size_t count) {
   return static_cast<T*>(mem);
 }
 
-template <typename T>
-T* ReallocOpenSSL(T* buf, size_t count) {
-  void* mem = OPENSSL_realloc(buf, MultiplyWithOverflowCheck(count, sizeof(T)));
-  CHECK_IMPLIES(mem == nullptr, count == 0);
-  return static_cast<T*>(mem);
-}
-
 // A helper class representing a read-only byte array. When deallocated, its
 // contents are zeroed.
 class ByteSource {
  public:
+  class Builder {
+   public:
+    // Allocates memory using OpenSSL's memory allocator.
+    explicit Builder(size_t size)
+        : data_(MallocOpenSSL<char>(size)), size_(size) {}
+
+    Builder(Builder&& other) = delete;
+    Builder& operator=(Builder&& other) = delete;
+    Builder(const Builder&) = delete;
+    Builder& operator=(const Builder&) = delete;
+
+    ~Builder() { OPENSSL_clear_free(data_, size_); }
+
+    // Returns the underlying non-const pointer.
+    template <typename T>
+    T* data() {
+      return reinterpret_cast<T*>(data_);
+    }
+
+    // Returns the (allocated) size in bytes.
+    size_t size() const { return size_; }
+
+    // Returns if (allocated) size is zero.
+    bool empty() const { return size_ == 0; }
+
+    // Finalizes the Builder and returns a read-only view that is optionally
+    // truncated.
+    ByteSource release(std::optional<size_t> resize = std::nullopt) && {
+      if (resize) {
+        CHECK_LE(*resize, size_);
+        if (*resize == 0) {
+          OPENSSL_clear_free(data_, size_);
+          data_ = nullptr;
+        }
+        size_ = *resize;
+      }
+      ByteSource out = ByteSource::Allocated(data_, size_);
+      data_ = nullptr;
+      size_ = 0;
+      return out;
+    }
+
+   private:
+    void* data_;
+    size_t size_;
+  };
+
   ByteSource() = default;
   ByteSource(ByteSource&& other) noexcept;
   ~ByteSource();
 
   ByteSource& operator=(ByteSource&& other) noexcept;
 
-  const char* get() const;
+  ByteSource(const ByteSource&) = delete;
+  ByteSource& operator=(const ByteSource&) = delete;
+
+  template <typename T = void>
+  const T* data() const {
+    return reinterpret_cast<const T*>(data_);
+  }
 
-  template <typename T>
-  const T* data() const { return reinterpret_cast<const T*>(get()); }
+  size_t size() const { return size_; }
 
-  size_t size() const;
+  bool empty() const { return size_ == 0; }
 
   operator bool() const { return data_ != nullptr; }
 
   BignumPointer ToBN() const {
-    return BignumPointer(BN_bin2bn(
-        reinterpret_cast<const unsigned char*>(get()),
-        size(),
-        nullptr));
+    return BignumPointer(data<unsigned char>(), size());
   }
 
   // Creates a v8::BackingStore that takes over responsibility for
@@ -260,19 +274,14 @@ class ByteSource {
 
   v8::MaybeLocal<v8::Uint8Array> ToBuffer(Environment* env);
 
-  void reset();
+  static ByteSource Allocated(void* data, size_t size);
 
-  // Allows an Allocated ByteSource to be truncated.
-  void Resize(size_t newsize) {
-    CHECK_LE(newsize, size_);
-    CHECK_NOT_NULL(allocated_data_);
-    char* new_data_ = ReallocOpenSSL<char>(allocated_data_, newsize);
-    data_ = allocated_data_ = new_data_;
-    size_ = newsize;
+  template <typename T>
+  static ByteSource Allocated(const ncrypto::Buffer<T>& buffer) {
+    return Allocated(buffer.data, buffer.len);
   }
 
-  static ByteSource Allocated(char* data, size_t size);
-  static ByteSource Foreign(const char* data, size_t size);
+  static ByteSource Foreign(const void* data, size_t size);
 
   static ByteSource FromEncodedString(Environment* env,
                                       v8::Local<v8::String> value,
@@ -295,18 +304,16 @@ class ByteSource {
 
   static ByteSource FromSymmetricKeyObjectHandle(v8::Local<v8::Value> handle);
 
-  ByteSource(const ByteSource&) = delete;
-  ByteSource& operator=(const ByteSource&) = delete;
-
   static ByteSource FromSecretKeyBytes(
       Environment* env, v8::Local<v8::Value> value);
 
  private:
-  const char* data_ = nullptr;
-  char* allocated_data_ = nullptr;
+  const void* data_ = nullptr;
+  void* allocated_data_ = nullptr;
   size_t size_ = 0;
 
-  ByteSource(const char* data, char* allocated_data, size_t size);
+  ByteSource(const void* data, void* allocated_data, size_t size)
+      : data_(data), allocated_data_(allocated_data), size_(size) {}
 };
 
 enum CryptoJobMode {
@@ -321,14 +328,13 @@ class CryptoJob : public AsyncWrap, public ThreadPoolWork {
  public:
   using AdditionalParams = typename CryptoJobTraits::AdditionalParameters;
 
-  explicit CryptoJob(
-      Environment* env,
-      v8::Local<v8::Object> object,
-      AsyncWrap::ProviderType type,
-      CryptoJobMode mode,
-      AdditionalParams&& params)
+  explicit CryptoJob(Environment* env,
+                     v8::Local<v8::Object> object,
+                     AsyncWrap::ProviderType type,
+                     CryptoJobMode mode,
+                     AdditionalParams&& params)
       : AsyncWrap(env, object, type),
-        ThreadPoolWork(env),
+        ThreadPoolWork(env, "crypto"),
         mode_(mode),
         params_(std::move(params)) {
     // If the CryptoJob is async, then the instance will be
@@ -355,31 +361,31 @@ class CryptoJob : public AsyncWrap, public ThreadPoolWork {
     v8::HandleScope handle_scope(env->isolate());
     v8::Context::Scope context_scope(env->context());
 
-    // TODO(tniessen): Remove the exception handling logic here as soon as we
-    // can verify that no code path in ToResult will ever throw an exception.
     v8::Local<v8::Value> exception;
     v8::Local<v8::Value> args[2];
     {
       node::errors::TryCatchScope try_catch(env);
-      v8::Maybe<bool> ret = ptr->ToResult(&args[0], &args[1]);
-      if (!ret.IsJust()) {
+      // If ToResult returns Nothing, then an exception should have been
+      // thrown and we should have caught it. Otherwise, args[0] and args[1]
+      // both should have been set to a value, even if the value is undefined.
+      if (ptr->ToResult(&args[0], &args[1]).IsNothing()) {
         CHECK(try_catch.HasCaught());
+        CHECK(try_catch.CanContinue());
         exception = try_catch.Exception();
-      } else if (!ret.FromJust()) {
-        return;
       }
     }
 
-    if (exception.IsEmpty()) {
-      ptr->MakeCallback(env->ondone_string(), arraysize(args), args);
-    } else {
+    if (!exception.IsEmpty()) {
       ptr->MakeCallback(env->ondone_string(), 1, &exception);
+    } else {
+      CHECK(!args[0].IsEmpty());
+      CHECK(!args[1].IsEmpty());
+      ptr->MakeCallback(env->ondone_string(), arraysize(args), args);
     }
   }
 
-  virtual v8::Maybe<bool> ToResult(
-      v8::Local<v8::Value>* err,
-      v8::Local<v8::Value>* result) = 0;
+  virtual v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+                                   v8::Local<v8::Value>* result) = 0;
 
   CryptoJobMode mode() const { return mode_; }
 
@@ -387,7 +393,7 @@ class CryptoJob : public AsyncWrap, public ThreadPoolWork {
 
   AdditionalParams* params() { return &params_; }
 
-  std::string MemoryInfoName() const override {
+  const char* MemoryInfoName() const override {
     return CryptoJobTraits::JobName;
   }
 
@@ -400,15 +406,16 @@ class CryptoJob : public AsyncWrap, public ThreadPoolWork {
     Environment* env = Environment::GetCurrent(args);
 
     CryptoJob<CryptoJobTraits>* job;
-    ASSIGN_OR_RETURN_UNWRAP(&job, args.Holder());
+    ASSIGN_OR_RETURN_UNWRAP(&job, args.This());
     if (job->mode() == kCryptoJobAsync)
       return job->ScheduleWork();
 
     v8::Local<v8::Value> ret[2];
     env->PrintSyncTrace();
     job->DoThreadPoolWork();
-    v8::Maybe<bool> result = job->ToResult(&ret[0], &ret[1]);
-    if (result.IsJust() && result.FromJust()) {
+    if (job->ToResult(&ret[0], &ret[1]).IsJust()) {
+      CHECK(!ret[0].IsEmpty());
+      CHECK(!ret[1].IsEmpty());
       args.GetReturnValue().Set(
           v8::Array::New(env->isolate(), ret, arraysize(ret)));
     }
@@ -418,12 +425,15 @@ class CryptoJob : public AsyncWrap, public ThreadPoolWork {
       v8::FunctionCallback new_fn,
       Environment* env,
       v8::Local<v8::Object> target) {
-    v8::Local<v8::FunctionTemplate> job = env->NewFunctionTemplate(new_fn);
+    v8::Isolate* isolate = env->isolate();
+    v8::HandleScope scope(isolate);
+    v8::Local<v8::Context> context = env->context();
+    v8::Local<v8::FunctionTemplate> job = NewFunctionTemplate(isolate, new_fn);
     job->Inherit(AsyncWrap::GetConstructorTemplate(env));
     job->InstanceTemplate()->SetInternalFieldCount(
         AsyncWrap::kInternalFieldCount);
-    env->SetProtoMethod(job, "run", Run);
-    env->SetConstructorFunction(target, CryptoJobTraits::JobName, job);
+    SetProtoMethod(isolate, job, "run", Run);
+    SetConstructorFunction(context, target, CryptoJobTraits::JobName, job);
   }
 
   static void RegisterExternalReferences(v8::FunctionCallback new_fn,
@@ -495,26 +505,29 @@ class DeriveBitsJob final : public CryptoJob<DeriveBitsTraits> {
     success_ = true;
   }
 
-  v8::Maybe<bool> ToResult(
-      v8::Local<v8::Value>* err,
-      v8::Local<v8::Value>* result) override {
+  v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+                           v8::Local<v8::Value>* result) override {
     Environment* env = AsyncWrap::env();
     CryptoErrorStore* errors = CryptoJob<DeriveBitsTraits>::errors();
     if (success_) {
       CHECK(errors->Empty());
       *err = v8::Undefined(env->isolate());
-      return DeriveBitsTraits::EncodeOutput(
-          env,
-          *CryptoJob<DeriveBitsTraits>::params(),
-          &out_,
-          result);
+      if (!DeriveBitsTraits::EncodeOutput(
+               env, *CryptoJob<DeriveBitsTraits>::params(), &out_)
+               .ToLocal(result)) {
+        return v8::Nothing<void>();
+      }
+    } else {
+      if (errors->Empty()) errors->Capture();
+      CHECK(!errors->Empty());
+      *result = v8::Undefined(env->isolate());
+      if (!errors->ToException(env).ToLocal(err)) {
+        return v8::Nothing<void>();
+      }
     }
-
-    if (errors->Empty())
-      errors->Capture();
-    CHECK(!errors->Empty());
-    *result = v8::Undefined(env->isolate());
-    return v8::Just(errors->ToException(env).ToLocal(err));
+    CHECK(!result->IsEmpty());
+    CHECK(!err->IsEmpty());
+    return v8::JustVoid();
   }
 
   SET_SELF_SIZE(DeriveBitsJob)
@@ -532,72 +545,6 @@ void ThrowCryptoError(Environment* env,
                       unsigned long err,  // NOLINT(runtime/int)
                       const char* message = nullptr);
 
-#ifndef OPENSSL_NO_ENGINE
-struct EnginePointer {
-  ENGINE* engine = nullptr;
-  bool finish_on_exit = false;
-
-  inline EnginePointer() = default;
-
-  inline explicit EnginePointer(ENGINE* engine_, bool finish_on_exit_ = false)
-    : engine(engine_),
-      finish_on_exit(finish_on_exit_) {}
-
-  inline EnginePointer(EnginePointer&& other) noexcept
-      : engine(other.engine),
-        finish_on_exit(other.finish_on_exit) {
-    other.release();
-  }
-
-  inline ~EnginePointer() { reset(); }
-
-  inline EnginePointer& operator=(EnginePointer&& other) noexcept {
-    if (this == &other) return *this;
-    this->~EnginePointer();
-    return *new (this) EnginePointer(std::move(other));
-  }
-
-  inline operator bool() const { return engine != nullptr; }
-
-  inline ENGINE* get() { return engine; }
-
-  inline void reset(ENGINE* engine_ = nullptr, bool finish_on_exit_ = false) {
-    if (engine != nullptr) {
-      if (finish_on_exit) {
-        // This also does the equivalent of ENGINE_free.
-        CHECK_EQ(ENGINE_finish(engine), 1);
-      } else {
-        CHECK_EQ(ENGINE_free(engine), 1);
-      }
-    }
-    engine = engine_;
-    finish_on_exit = finish_on_exit_;
-  }
-
-  inline ENGINE* release() {
-    ENGINE* ret = engine;
-    engine = nullptr;
-    finish_on_exit = false;
-    return ret;
-  }
-};
-
-EnginePointer LoadEngineById(const char* id, CryptoErrorStore* errors);
-
-bool SetEngine(
-    const char* id,
-    uint32_t flags,
-    CryptoErrorStore* errors = nullptr);
-
-void SetEngine(const v8::FunctionCallbackInfo<v8::Value>& args);
-#endif  // !OPENSSL_NO_ENGINE
-
-void GetFipsCrypto(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-void SetFipsCrypto(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-void TestFipsCrypto(const v8::FunctionCallbackInfo<v8::Value>& args);
-
 class CipherPushContext {
  public:
   inline explicit CipherPushContext(Environment* env) : env_(env) {}
@@ -661,7 +608,8 @@ void array_push_back(const TypeName* evp_ref,
 }
 #endif
 
-inline bool IsAnyByteSource(v8::Local<v8::Value> arg) {
+// WebIDL AllowSharedBufferSource.
+inline bool IsAnyBufferSource(v8::Local<v8::Value> arg) {
   return arg->IsArrayBufferView() ||
          arg->IsArrayBuffer() ||
          arg->IsSharedArrayBuffer();
@@ -671,24 +619,30 @@ template <typename T>
 class ArrayBufferOrViewContents {
  public:
   ArrayBufferOrViewContents() = default;
+  ArrayBufferOrViewContents(const ArrayBufferOrViewContents&) = delete;
+  void operator=(const ArrayBufferOrViewContents&) = delete;
 
   inline explicit ArrayBufferOrViewContents(v8::Local<v8::Value> buf) {
-    CHECK(IsAnyByteSource(buf));
+    if (buf.IsEmpty()) {
+      return;
+    }
+
+    CHECK(IsAnyBufferSource(buf));
     if (buf->IsArrayBufferView()) {
       auto view = buf.As<v8::ArrayBufferView>();
       offset_ = view->ByteOffset();
       length_ = view->ByteLength();
-      store_ = view->Buffer()->GetBackingStore();
+      data_ = view->Buffer()->Data();
     } else if (buf->IsArrayBuffer()) {
       auto ab = buf.As<v8::ArrayBuffer>();
       offset_ = 0;
       length_ = ab->ByteLength();
-      store_ = ab->GetBackingStore();
+      data_ = ab->Data();
     } else {
       auto sab = buf.As<v8::SharedArrayBuffer>();
       offset_ = 0;
       length_ = sab->ByteLength();
-      store_ = sab->GetBackingStore();
+      data_ = sab->Data();
     }
   }
 
@@ -696,22 +650,22 @@ class ArrayBufferOrViewContents {
     // Ideally, these would return nullptr if IsEmpty() or length_ is zero,
     // but some of the openssl API react badly if given a nullptr even when
     // length is zero, so we have to return something.
-    if (size() == 0)
-      return &buf;
-    return reinterpret_cast<T*>(store_->Data()) + offset_;
+    if (empty()) return &buf;
+    return reinterpret_cast<T*>(data_) + offset_;
   }
 
   inline T* data() {
     // Ideally, these would return nullptr if IsEmpty() or length_ is zero,
     // but some of the openssl API react badly if given a nullptr even when
     // length is zero, so we have to return something.
-    if (size() == 0)
-      return &buf;
-    return reinterpret_cast<T*>(store_->Data()) + offset_;
+    if (empty()) return &buf;
+    return reinterpret_cast<T*>(data_) + offset_;
   }
 
   inline size_t size() const { return length_; }
 
+  inline bool empty() const { return length_ == 0; }
+
   // In most cases, input buffer sizes passed in to openssl need to
   // be limited to <= INT_MAX. This utility method helps us check.
   inline bool CheckSizeInt32() { return size() <= INT_MAX; }
@@ -721,63 +675,65 @@ class ArrayBufferOrViewContents {
   }
 
   inline ByteSource ToCopy() const {
-    if (size() == 0) return ByteSource();
-    char* buf = MallocOpenSSL<char>(size());
-    CHECK_NOT_NULL(buf);
-    memcpy(buf, data(), size());
-    return ByteSource::Allocated(buf, size());
+    if (empty()) return ByteSource();
+    ByteSource::Builder buf(size());
+    memcpy(buf.data<void>(), data(), size());
+    return std::move(buf).release();
   }
 
   inline ByteSource ToNullTerminatedCopy() const {
-    if (size() == 0) return ByteSource();
-    char* buf = MallocOpenSSL<char>(size() + 1);
-    CHECK_NOT_NULL(buf);
-    buf[size()] = 0;
-    memcpy(buf, data(), size());
-    return ByteSource::Allocated(buf, size());
+    if (empty()) return ByteSource();
+    ByteSource::Builder buf(size() + 1);
+    memcpy(buf.data<void>(), data(), size());
+    buf.data<char>()[size()] = 0;
+    return std::move(buf).release(size());
+  }
+
+  inline ncrypto::DataPointer ToDataPointer() const {
+    if (empty()) return {};
+    if (auto dp = ncrypto::DataPointer::Alloc(size())) {
+      memcpy(dp.get(), data(), size());
+      return dp;
+    }
+    return {};
   }
 
   template <typename M>
   void CopyTo(M* dest, size_t len) const {
     static_assert(sizeof(M) == 1, "sizeof(M) must equal 1");
     len = std::min(len, size());
-    if (len > 0 && data() != nullptr)
+    if (len > 0 && data() != nullptr) {
       memcpy(dest, data(), len);
+    }
   }
 
  private:
   T buf = 0;
   size_t offset_ = 0;
   size_t length_ = 0;
-  std::shared_ptr<v8::BackingStore> store_;
+  void* data_ = nullptr;
+
+  // Declaring operator new and delete as deleted is not spec compliant.
+  // Therefore declare them private instead to disable dynamic alloc
+  void* operator new(size_t);
+  void* operator new[](size_t);
+  void operator delete(void*);
+  void operator delete[](void*);
 };
 
-template <typename T>
-std::vector<T> CopyBuffer(const ArrayBufferOrViewContents<T>& buf) {
-  std::vector<T> vec;
-  vec->resize(buf.size());
-  if (vec->size() > 0 && buf.data() != nullptr)
-    memcpy(vec->data(), buf.data(), vec->size());
-  return vec;
-}
-
-template <typename T>
-std::vector<T> CopyBuffer(v8::Local<v8::Value> buf) {
-  return CopyBuffer(ArrayBufferOrViewContents<T>(buf));
-}
-
 v8::MaybeLocal<v8::Value> EncodeBignum(
     Environment* env,
     const BIGNUM* bn,
     int size,
     v8::Local<v8::Value>* error);
 
-v8::Maybe<bool> SetEncodedValue(
-    Environment* env,
-    v8::Local<v8::Object> target,
-    v8::Local<v8::String> name,
-    const BIGNUM* bn,
-    int size = 0);
+v8::Maybe<void> SetEncodedValue(Environment* env,
+                                v8::Local<v8::Object> target,
+                                v8::Local<v8::String> name,
+                                const BIGNUM* bn,
+                                int size = 0);
+
+bool SetRsaOaepLabel(const EVPKeyCtxPointer& rsa, const ByteSource& label);
 
 namespace Util {
 void Initialize(Environment* env, v8::Local<v8::Object> target);