src: avoid redundant KEM encapsulation copies

KEM encapsulation produces separate ciphertext and shared-secret
allocations. The existing DeriveBitsJob path packs both values into an
intermediate buffer, then copies them again into separate buffers.
Instead, this uses a dedicated KEMEncapsulateJob to retain both outputs
across the worker boundary and convert each directly through ByteSource.
This removes the intermediate allocation and at least one complete round
of copies.
Signed-off-by: Filip Skokan <panva.ip@gmail.com>
PR-URL: #64553
Backport-PR-URL: #65087
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>

Author: panva

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);

src/crypto/crypto_kem.cc

@@ -8,21 +8,20 @@
 #include"crypto/crypto_util.h"
 #include"env-inl.h"
 #include"memory_tracker-inl.h"
-#include"node_buffer.h"
 #include"threadpoolwork-inl.h"
 #include"v8.h"
 
 namespacenode {
 
 using ncrypto::EVPKeyPointer;
 using v8::Array;
-using v8::ArrayBufferView;
 using v8::FunctionCallbackInfo;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::Uint8Array;
 using v8::Value;
 
 namespacecrypto {
@@ -49,51 +48,6 @@ void KEMConfiguration::MemoryInfo(MemoryTracker* tracker) const {
 
 namespace {
 
-boolDoKEMEncapsulate(Environment* env,
-const EVPKeyPointer& public_key,
- ByteSource* out,
- CryptoJobMode mode) {
-auto result = ncrypto::KEM::Encapsulate(public_key);
-if (!result) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to perform encapsulation");
- }
-returnfalse;
- }
-
-// Pack the result: [ciphertext_len][shared_key_len][ciphertext][shared_key]
-size_t ciphertext_len = result->ciphertext.size();
-size_t shared_key_len = result->shared_key.size();
-size_t total_len =
-sizeof(uint32_t) + sizeof(uint32_t) + ciphertext_len + shared_key_len;
-
-auto data = ncrypto::DataPointer::Alloc(total_len);
-if (!data) {
-if (mode == kCryptoJobSync) {
-THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-"Failed to allocate output buffer");
- }
-returnfalse;
- }
-
-unsignedchar* ptr = static_cast<unsignedchar*>(data.get());
-
-// Write size headers
- *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(ciphertext_len);
- *reinterpret_cast<uint32_t*>(ptr + sizeof(uint32_t)) =
-static_cast<uint32_t>(shared_key_len);
-
-// Write ciphertext and shared key data
-unsignedchar* ciphertext_ptr = ptr + 2 * sizeof(uint32_t);
-unsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
-std::memcpy(ciphertext_ptr, result->ciphertext.get(), ciphertext_len);
-std::memcpy(shared_key_ptr, result->shared_key.get(), shared_key_len);
-
- *out = ByteSource::Allocated(data.release());
-returntrue;
-}
-
 boolDoKEMDecapsulate(Environment* env,
 const EVPKeyPointer& private_key,
 const ByteSource& ciphertext,
@@ -135,71 +89,115 @@ Maybe<void> KEMEncapsulateTraits::AdditionalConfig(
 returnv8::JustVoid();
 }
 
-boolKEMEncapsulateTraits::DeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode) {
- Mutex::ScopedLock lock(params.key.mutex());
-constauto& public_key = params.key.GetAsymmetricKey();
+voidKEMEncapsulateJob::New(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+CHECK(args.IsConstructCall());
+
+ CryptoJobMode mode = GetCryptoJobMode(args[0]);
+ AdditionalParams params;
+if (KEMEncapsulateTraits::AdditionalConfig(mode, args, 1, &params)
+ .IsNothing()) {
+return;
+ }
 
-returnDoKEMEncapsulate(env, public_key, out, mode);
+newKEMEncapsulateJob(env, args.This(), mode, std::move(params));
 }
 
-MaybeLocal<Value> KEMEncapsulateTraits::EncodeOutput(
- Environment* env, const KEMConfiguration& params, ByteSource* out) {
-// The output contains:
-// [ciphertext_len][shared_key_len][ciphertext][shared_key]
-constunsignedchar* data = out->data<unsignedchar>();
-
-uint32_t ciphertext_len = *reinterpret_cast<constuint32_t*>(data);
-uint32_t shared_key_len =
- *reinterpret_cast<constuint32_t*>(data + sizeof(uint32_t));
-
-constunsignedchar* ciphertext_ptr = data + 2 * sizeof(uint32_t);
-constunsignedchar* shared_key_ptr = ciphertext_ptr + ciphertext_len;
-
- MaybeLocal<Object> ciphertext_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(ciphertext_ptr),
- ciphertext_len);
-
- MaybeLocal<Object> shared_key_buf =
-node::Buffer::Copy(env->isolate(),
-reinterpret_cast<constchar*>(shared_key_ptr),
- shared_key_len);
-
- Local<Object> ciphertext_obj;
- Local<Object> shared_key_obj;
-if (!ciphertext_buf.ToLocal(&ciphertext_obj) ||
- !shared_key_buf.ToLocal(&shared_key_obj)) {
-return MaybeLocal<Value>();
+voidKEMEncapsulateJob::Initialize(Environment* env, Local<Object> target) {
+ CryptoJob<KEMEncapsulateTraits>::Initialize(New, env, target);
+}
+
+voidKEMEncapsulateJob::RegisterExternalReferences(
+ ExternalReferenceRegistry* registry) {
+ CryptoJob<KEMEncapsulateTraits>::RegisterExternalReferences(New, registry);
+}
+
+KEMEncapsulateJob::KEMEncapsulateJob(Environment* env,
+ Local<Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params)
+ : CryptoJob<KEMEncapsulateTraits>(env,
+ object,
+ KEMEncapsulateTraits::Provider,
+ mode,
+std::move(params)) {}
+
+voidKEMEncapsulateJob::DoThreadPoolWork() {
+ ncrypto::ClearErrorOnReturn clear_error_on_return;
+ AdditionalParams* params = CryptoJob<KEMEncapsulateTraits>::params();
+ Mutex::ScopedLock lock(params->key.mutex());
+ out_ = ncrypto::KEM::Encapsulate(params->key.GetAsymmetricKey());
+if (!out_) {
+if (mode() == kCryptoJobSync) {
+THROW_ERR_CRYPTO_OPERATION_FAILED(AsyncWrap::env(),
+"Failed to perform encapsulation");
+ }
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+ errors->Capture();
+if (errors->Empty()) {
+ errors->Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+ }
  }
+}
 
-if (params.job_mode == kCryptoJobWebCrypto) {
- Local<Object> result = Object::New(env->isolate());
-if (!result
+Maybe<void> KEMEncapsulateJob::ToResult(Local<Value>* err,
+ Local<Value>* result) {
+ Environment* env = AsyncWrap::env();
+ CryptoErrorStore* errors = CryptoJob<KEMEncapsulateTraits>::errors();
+if (!out_) {
+if (errors->Empty()) errors->Capture();
+CHECK(!errors->Empty());
+ *result = v8::Undefined(env->isolate());
+if (!errors->ToException(env).ToLocal(err)) return Nothing<void>();
+returnv8::JustVoid();
+ }
+
+CHECK(errors->Empty());
+ *err = v8::Undefined(env->isolate());
+
+ ByteSource ciphertext = ByteSource::Allocated(out_->ciphertext.release());
+ ByteSource shared_key = ByteSource::Allocated(out_->shared_key.release());
+
+if (mode() == kCryptoJobWebCrypto) {
+ Local<Object> output = Object::New(env->isolate());
+if (!output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "sharedKey"),
-shared_key_obj.As<ArrayBufferView>()->Buffer())
+shared_key.ToArrayBuffer(env))
  .FromMaybe(false) ||
- !result
+ !output
  ->DefineOwnProperty(env->context(),
 OneByteString(env->isolate(), "ciphertext"),
-ciphertext_obj.As<ArrayBufferView>()->Buffer())
+ciphertext.ToArrayBuffer(env))
  .FromMaybe(false)) {
-returnMaybeLocal<Value>();
+returnNothing<void>();
  }
-return result;
+ *result = output;
+returnv8::JustVoid();
  }
 
-// Return an array [sharedKey, ciphertext].
- Local<Array> result = Array::New(env->isolate(), 2);
-if (result->Set(env->context(), 0, shared_key_obj).IsNothing() ||
-result->Set(env->context(), 1, ciphertext_obj).IsNothing()) {
-returnMaybeLocal<Value>();
+Local<Uint8Array> shared_key_buf;
+ Local<Uint8Array> ciphertext_buf;
+if (!shared_key.ToBuffer(env).ToLocal(&shared_key_buf) ||
+!ciphertext.ToBuffer(env).ToLocal(&ciphertext_buf)) {
+returnNothing<void>();
  }
 
-return result;
+ Local<Array> output = Array::New(env->isolate(), 2);
+if (output->Set(env->context(), 0, shared_key_buf).IsNothing() ||
+ output->Set(env->context(), 1, ciphertext_buf).IsNothing()) {
+return Nothing<void>();
+ }
+ *result = output;
+returnv8::JustVoid();
+}
+
+voidKEMEncapsulateJob::MemoryInfo(MemoryTracker* tracker) const {
+if (out_) {
+ tracker->TrackFieldWithSize("ciphertext", out_->ciphertext.size());
+ tracker->TrackFieldWithSize("shared_key", out_->shared_key.size());
+ }
+ CryptoJob<KEMEncapsulateTraits>::MemoryInfo(tracker);
 }
 
 // KEMDecapsulateTraits implementation

src/crypto/crypto_kem.h

@@ -44,15 +44,30 @@ struct KEMEncapsulateTraits final {
 const v8::FunctionCallbackInfo<v8::Value>& args,
 unsignedint offset,
  KEMConfiguration* params);
+};
 
-staticboolDeriveBits(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out,
- CryptoJobMode mode);
+classKEMEncapsulateJobfinal : public CryptoJob<KEMEncapsulateTraits> {
+public:
+using AdditionalParams = KEMEncapsulateTraits::AdditionalParameters;
 
-static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
-const KEMConfiguration& params,
- ByteSource* out);
+staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidInitialize(Environment* env, v8::Local<v8::Object> target);
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+KEMEncapsulateJob(Environment* env,
+ v8::Local<v8::Object> object,
+ CryptoJobMode mode,
+ AdditionalParams&& params);
+
+voidDoThreadPoolWork() override;
+ v8::Maybe<void> ToResult(v8::Local<v8::Value>* err,
+ v8::Local<v8::Value>* result) override;
+
+SET_SELF_SIZE(KEMEncapsulateJob)
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+
+private:
+ std::optional<ncrypto::KEM::EncapsulateResult> out_;
 };
 
 structKEMDecapsulateTraitsfinal {
@@ -78,7 +93,6 @@ struct KEMDecapsulateTraits final {
  ByteSource* out);
 };
 
-using KEMEncapsulateJob = DeriveBitsJob<KEMEncapsulateTraits>;
 using KEMDecapsulateJob = DeriveBitsJob<KEMDecapsulateTraits>;
 
 voidInitializeKEM(Environment* env, v8::Local<v8::Object> target);