src: drop ByteSource::Builder in favor of ncrypto::DataPointer

Signed-off-by: James M Snell <[email protected]>

Author: jasnell

deps/ncrypto/ncrypto.h

@@ -384,7 +384,12 @@ class DataPointer final {
 
   inline bool operator==(std::nullptr_t) noexcept { return data_ == nullptr; }
   inline operator bool() const { return data_ != nullptr; }
-  inline void* get() const noexcept { return data_; }
+
+  template <typename T = void>
+  inline T* get() const noexcept {
+    return static_cast<T*>(data_);
+  }
+
   inline size_t size() const noexcept { return len_; }
   void reset(void* data = nullptr, size_t len = 0);
   void reset(const Buffer<void>& buffer);

src/crypto/README.md

@@ -106,10 +106,6 @@ an `ArrayBuffer` (`v8::BackingStore`), or allocated data.
 * If allocated data is used, then it must have been allocated using OpenSSL's
   allocator. It will be freed automatically when the `ByteSource` is destroyed.
 
-The `ByteSource::Builder` class can be used to allocate writable memory that can
-then be released as a `ByteSource`, making it read-only, or freed by destroying
-the `ByteSource::Builder` without releasing it as a `ByteSource`.
-
 ### `ArrayBufferOrViewContents`
 
 The `ArrayBufferOrViewContents` class is a helper utility that abstracts

src/crypto/crypto_ec.cc

@@ -483,15 +483,16 @@ bool ECDHBitsTraits::DeriveBits(Environment* env,
       const auto pub = ECKeyPointer::GetPublicKey(public_key);
       int field_size = EC_GROUP_get_degree(group);
       len = (field_size + 7) / 8;
-      ByteSource::Builder buf(len);
+      auto buf = DataPointer::Alloc(len);
       CHECK_NOT_NULL(pub);
       CHECK_NOT_NULL(private_key);
-      if (ECDH_compute_key(buf.data<char>(), len, pub, private_key, nullptr) <=
+      if (ECDH_compute_key(
+              static_cast<char*>(buf.get()), len, pub, private_key, nullptr) <=
           0) {
         return false;
       }
 
-      *out = std::move(buf).release();
+      *out = ByteSource::Allocated(buf.release());
     }
   }
 
@@ -605,14 +606,19 @@ WebCryptoKeyExportStatus EC_Raw_Export(const KeyObjectData& key_data,
     size_t len = EC_POINT_point2oct(group, point, form, nullptr, 0, nullptr);
     if (len == 0)
       return WebCryptoKeyExportStatus::FAILED;
-    ByteSource::Builder data(len);
-    size_t check_len = EC_POINT_point2oct(
-        group, point, form, data.data<unsigned char>(), len, nullptr);
+    auto data = DataPointer::Alloc(len);
+    size_t check_len =
+        EC_POINT_point2oct(group,
+                           point,
+                           form,
+                           static_cast<unsigned char*>(data.get()),
+                           len,
+                           nullptr);
     if (check_len == 0)
       return WebCryptoKeyExportStatus::FAILED;
 
     CHECK_EQ(len, check_len);
-    *out = std::move(data).release();
+    *out = ByteSource::Allocated(data.release());
   }
 
   return WebCryptoKeyExportStatus::OK;
@@ -660,15 +666,20 @@ WebCryptoKeyExportStatus ECKeyExportTraits::DoExport(
         const size_t need =
             EC_POINT_point2oct(group, point, form, nullptr, 0, nullptr);
         if (need == 0) return WebCryptoKeyExportStatus::FAILED;
-        ByteSource::Builder data(need);
-        const size_t have = EC_POINT_point2oct(
-            group, point, form, data.data<unsigned char>(), need, nullptr);
+        auto data = DataPointer::Alloc(need);
+        const size_t have =
+            EC_POINT_point2oct(group,
+                               point,
+                               form,
+                               static_cast<unsigned char*>(data.get()),
+                               need,
+                               nullptr);
         if (have == 0) return WebCryptoKeyExportStatus::FAILED;
         auto ec = ECKeyPointer::New(group);
         CHECK(ec);
         auto uncompressed = ECPointPointer::New(group);
         ncrypto::Buffer<const unsigned char> buffer{
-            .data = data.data<unsigned char>(),
+            .data = static_cast<unsigned char*>(data.get()),
             .len = data.size(),
         };
         CHECK(uncompressed.setFromBuffer(buffer, group));

src/crypto/crypto_keygen.cc

@@ -12,6 +12,7 @@
 
 namespace node {
 
+using ncrypto::DataPointer;
 using ncrypto::EVPKeyCtxPointer;
 using v8::FunctionCallbackInfo;
 using v8::Int32;
@@ -70,10 +71,11 @@ Maybe<void> SecretKeyGenTraits::AdditionalConfig(
 
 KeyGenJobStatus SecretKeyGenTraits::DoKeyGen(Environment* env,
                                              SecretKeyGenConfig* params) {
-  ByteSource::Builder bytes(params->length);
-  if (!ncrypto::CSPRNG(bytes.data<unsigned char>(), params->length))
+  auto bytes = DataPointer::Alloc(params->length);
+  if (!ncrypto::CSPRNG(static_cast<unsigned char*>(bytes.get()),
+                       params->length))
     return KeyGenJobStatus::FAILED;
-  params->out = std::move(bytes).release();
+  params->out = ByteSource::Allocated(bytes.release());
   return KeyGenJobStatus::OK;
 }
 

src/crypto/crypto_random.cc

@@ -13,6 +13,7 @@ namespace node {
 
 using ncrypto::BignumPointer;
 using ncrypto::ClearErrorOnReturn;
+using ncrypto::DataPointer;
 using v8::ArrayBuffer;
 using v8::Boolean;
 using v8::FunctionCallbackInfo;
@@ -196,9 +197,9 @@ bool CheckPrimeTraits::DeriveBits(
   int ret = params.candidate.isPrime(params.checks, getPrimeCheckCallback(env));
   if (ret < 0) [[unlikely]]
     return false;
-  ByteSource::Builder buf(1);
-  buf.data<char>()[0] = ret;
-  *out = std::move(buf).release();
+  auto buf = DataPointer::Alloc(1);
+  static_cast<char*>(buf.get())[0] = ret;
+  *out = ByteSource::Allocated(buf.release());
   return true;
 }
 

src/crypto/crypto_sig.cc

@@ -700,12 +700,12 @@ bool SignTraits::DeriveBits(
       break;
     }
     case SignConfiguration::Mode::Verify: {
-      ByteSource::Builder buf(1);
-      buf.data<char>()[0] = 0;
+      auto buf = DataPointer::Alloc(1);
+      static_cast<char*>(buf.get())[0] = 0;
       if (context.verify(params.data, params.signature)) {
-        buf.data<char>()[0] = 1;
+        static_cast<char*>(buf.get())[0] = 1;
       }
-      *out = std::move(buf).release();
+      *out = ByteSource::Allocated(buf.release());
     }
   }
 

src/crypto/crypto_util.cc

@@ -29,6 +29,7 @@ namespace node {
 using ncrypto::BignumPointer;
 using ncrypto::BIOPointer;
 using ncrypto::CryptoErrorList;
+using ncrypto::DataPointer;
 using ncrypto::EnginePointer;
 using ncrypto::EVPKeyCtxPointer;
 using v8::ArrayBuffer;
@@ -363,9 +364,9 @@ MaybeLocal<Uint8Array> ByteSource::ToBuffer(Environment* env) {
 ByteSource ByteSource::FromBIO(const BIOPointer& bio) {
   CHECK(bio);
   BUF_MEM* bptr = bio;
-  ByteSource::Builder out(bptr->length);
-  memcpy(out.data<void>(), bptr->data, bptr->length);
-  return std::move(out).release();
+  auto out = DataPointer::Alloc(bptr->length);
+  memcpy(out.get(), bptr->data, bptr->length);
+  return ByteSource::Allocated(out.release());
 }
 
 ByteSource ByteSource::FromEncodedString(Environment* env,
@@ -375,10 +376,10 @@ ByteSource ByteSource::FromEncodedString(Environment* env,
   ByteSource out;
 
   if (StringBytes::Size(env->isolate(), key, enc).To(&length) && length > 0) {
-    ByteSource::Builder buf(length);
-    size_t actual =
-        StringBytes::Write(env->isolate(), buf.data<char>(), length, key, enc);
-    out = std::move(buf).release(actual);
+    auto buf = DataPointer::Alloc(length);
+    size_t actual = StringBytes::Write(
+        env->isolate(), static_cast<char*>(buf.get()), length, key, enc);
+    out = ByteSource::Allocated(buf.resize(actual).release());
   }
 
   return out;
@@ -395,11 +396,12 @@ ByteSource ByteSource::FromString(Environment* env, Local<String> str,
   CHECK(str->IsString());
   size_t size = str->Utf8Length(env->isolate());
   size_t alloc_size = ntc ? size + 1 : size;
-  ByteSource::Builder out(alloc_size);
+  auto out = DataPointer::Alloc(alloc_size);
   int opts = String::NO_OPTIONS;
   if (!ntc) opts |= String::NO_NULL_TERMINATION;
-  str->WriteUtf8(env->isolate(), out.data<char>(), alloc_size, nullptr, opts);
-  return std::move(out).release();
+  str->WriteUtf8(
+      env->isolate(), static_cast<char*>(out.get()), alloc_size, nullptr, opts);
+  return ByteSource::Allocated(out.release());
 }
 
 ByteSource ByteSource::FromBuffer(Local<Value> buffer, bool ntc) {

src/crypto/crypto_util.h

@@ -166,53 +166,6 @@ T* MallocOpenSSL(size_t count) {
 // contents are zeroed.
 class ByteSource final {
  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();
@@ -651,18 +604,18 @@ class ArrayBufferOrViewContents final {
   }
 
   inline ByteSource ToCopy() const {
-    if (empty()) return ByteSource();
-    ByteSource::Builder buf(size());
-    memcpy(buf.data<void>(), data(), size());
-    return std::move(buf).release();
+    if (empty()) return {};
+    auto buf = ncrypto::DataPointer::Alloc(size());
+    memcpy(buf.get(), data(), size());
+    return ByteSource::Allocated(buf.release());
   }
 
   inline ByteSource ToNullTerminatedCopy() const {
-    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());
+    if (empty()) return {};
+    auto buf = ncrypto::DataPointer::Alloc(size() + 1);
+    memcpy(buf.get(), data(), size());
+    static_cast<char*>(buf.get())[size()] = 0;
+    return ByteSource::Allocated(buf.release());
   }
 
   inline ncrypto::DataPointer ToDataPointer() const {