#include "crypto/crypto_kmac.h"

#include "async_wrap-inl.h"

#include "node_internals.h"

#include "threadpoolwork-inl.h"

#if OPENSSL_VERSION_MAJOR >= 3

#include <openssl/core_names.h>

#include <openssl/params.h>

#include "crypto/crypto_keys.h"

#include "crypto/crypto_sig.h"

#include "ncrypto.h"

namespace node::crypto {

using ncrypto::EVPMacCtxPointer;

using ncrypto::EVPMacPointer;

using node::Utf8Value;

using v8::Boolean;

using v8::FunctionCallbackInfo;

using v8::JustVoid;

using v8::Local;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Nothing;

using v8::Object;

using v8::Uint32;

using v8::Value;

KmacConfig::KmacConfig(KmacConfig&& other) noexcept

: job_mode(other.job_mode),

mode(other.mode),

key(std::move(other.key)),

data(std::move(other.data)),

signature(std::move(other.signature)),

customization(std::move(other.customization)),

variant(other.variant),

length(other.length) {}

KmacConfig& KmacConfig::operator=(KmacConfig&& other) noexcept {

if (&other == this) return *this;

this->~KmacConfig();

return *new (this) KmacConfig(std::move(other));

}

void KmacConfig::MemoryInfo(MemoryTracker* tracker) const {

tracker->TrackField("key", key);

// If the job is sync, then the KmacConfig does not own the data.

if (job_mode == kCryptoJobAsync) {

tracker->TrackFieldWithSize("data", data.size());

tracker->TrackFieldWithSize("signature", signature.size());

tracker->TrackFieldWithSize("customization", customization.size());

}

}

Maybe<void> KmacTraits::AdditionalConfig(

CryptoJobMode mode,

const FunctionCallbackInfo<Value>& args,

unsigned int offset,

KmacConfig* params) {

Environment* env = Environment::GetCurrent(args);

params->job_mode = mode;

CHECK(args[offset]->IsUint32()); // SignConfiguration::Mode

params->mode =

static_cast<SignConfiguration::Mode>(args[offset].As<Uint32>()->Value());

CHECK(args[offset + 1]->IsObject()); // Key

KeyObjectHandle* key;

ASSIGN_OR_RETURN_UNWRAP(&key, args[offset + 1], Nothing<void>());

params->key = key->Data().addRef();

CHECK(args[offset + 2]->IsString()); // Algorithm name

Utf8Value algorithm_name(env->isolate(), args[offset + 2]);

std::string_view algorithm_str = algorithm_name.ToStringView();

// Convert string to enum and validate

if (algorithm_str == OSSL_MAC_NAME_KMAC128) {

params->variant = KmacVariant::KMAC128;

} else if (algorithm_str == OSSL_MAC_NAME_KMAC256) {

params->variant = KmacVariant::KMAC256;

} else {

UNREACHABLE();

}

// Customization string (may be empty or undefined).

if (!args[offset + 3]->IsUndefined()) {

ArrayBufferOrViewContents<char> customization(args[offset + 3]);

if (!customization.CheckSizeInt32()) [[unlikely]] {

THROW_ERR_OUT_OF_RANGE(env, "customization is too big");

return Nothing<void>();

}

params->customization = mode == kCryptoJobAsync

? customization.ToCopy()

: customization.ToByteSource();

}

// If undefined, params->customization remains uninitialized (size 0).

CHECK(args[offset + 4]->IsUint32()); // Length

params->length = args[offset + 4].As<Uint32>()->Value();

ArrayBufferOrViewContents<char> data(args[offset + 5]);

if (!data.CheckSizeInt32()) [[unlikely]] {

THROW_ERR_OUT_OF_RANGE(env, "data is too big");

return Nothing<void>();

}

params->data = mode == kCryptoJobAsync ? data.ToCopy() : data.ToByteSource();

if (!args[offset + 6]->IsUndefined()) {

ArrayBufferOrViewContents<char> signature(args[offset + 6]);

if (!signature.CheckSizeInt32()) [[unlikely]] {

THROW_ERR_OUT_OF_RANGE(env, "signature is too big");

return Nothing<void>();

}

params->signature =

mode == kCryptoJobAsync ? signature.ToCopy() : signature.ToByteSource();

}

return JustVoid();

}

bool KmacTraits::DeriveBits(Environment* env,

const KmacConfig& params,

ByteSource* out,

CryptoJobMode mode) {

if (params.length == 0) {

*out = ByteSource();

return true;

}

// Get the key data.

const void* key_data = params.key.GetSymmetricKey();

size_t key_size = params.key.GetSymmetricKeySize();

if (key_size == 0) {

return false;

}

// Fetch the KMAC algorithm

auto mac = EVPMacPointer::Fetch((params.variant == KmacVariant::KMAC128)

? OSSL_MAC_NAME_KMAC128

: OSSL_MAC_NAME_KMAC256);

if (!mac) {

return false;

}

// Create MAC context

auto mac_ctx = EVPMacCtxPointer::New(mac.get());

if (!mac_ctx) {

return false;

}

// Set up parameters.

OSSL_PARAM params_array[3]; // Max 3: size + customization + end

size_t params_count = 0;

// Set output length (always required for KMAC).

size_t outlen = params.length;

params_array[params_count++] =

OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_SIZE, &outlen);

// Set customization if provided.

if (params.customization.size() > 0) {

params_array[params_count++] = OSSL_PARAM_construct_octet_string(

OSSL_MAC_PARAM_CUSTOM,

const_cast<void*>(params.customization.data()),

params.customization.size());

}

params_array[params_count] = OSSL_PARAM_construct_end();

// Initialize the MAC context.

if (!mac_ctx.init(ncrypto::Buffer<const void>(key_data, key_size),

params_array)) {

return false;

}

// Update with data.

if (!mac_ctx.update(ncrypto::Buffer<const void>(params.data.data(),

params.data.size()))) {

return false;

}

// Finalize and get the result.

auto result = mac_ctx.final(params.length);

if (!result) {

return false;

}

auto buffer = result.release();

*out = ByteSource::Allocated(buffer.data, buffer.len);

return true;

}

MaybeLocal<Value> KmacTraits::EncodeOutput(Environment* env,

const KmacConfig& params,

ByteSource* out) {

switch (params.mode) {

case SignConfiguration::Mode::Sign:

return out->ToArrayBuffer(env);

case SignConfiguration::Mode::Verify:

return Boolean::New(

env->isolate(),

out->size() > 0 && out->size() == params.signature.size() &&

memcmp(out->data(), params.signature.data(), out->size()) == 0);

}

UNREACHABLE();

}

void Kmac::Initialize(Environment* env, Local<Object> target) {

KmacJob::Initialize(env, target);

}

void Kmac::RegisterExternalReferences(ExternalReferenceRegistry* registry) {

KmacJob::RegisterExternalReferences(registry);

}

} // namespace node::crypto

#endif