crypto: use provider EC group names

Pass group names through EC key generation and report provider names
in key details without requiring an OpenSSL NID. Preserve established
curve aliases and synchronous invalid-curve errors.

Filter built-in curves through EC parameter generation and refresh
getCurves() results when FIPS properties change.

Signed-off-by: Filip Skokan <panva.ip@gmail.com>
Assisted-by: Codex
PR-URL: #66108
Backport-PR-URL: #66233
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>

Author: panva

deps/ncrypto/ncrypto.cc

@@ -6381,10 +6381,15 @@ bool EVPKeyCtxPointer::setDsaParameters(uint32_t bits,
 }
 
 bool EVPKeyCtxPointer::setEcParameters(int curve, int encoding) {
-  if (!ctx_) return false;
+  return setEcParameters(OBJ_nid2sn(curve), encoding);
+}
+
+bool EVPKeyCtxPointer::setEcParameters(const char* group_name, int encoding) {
+  if (!ctx_ || group_name == nullptr) return false;
+  const int curve = Ec::GetCurveIdFromName(group_name);
 #if NCRYPTO_USE_OPENSSL3_PROVIDER
-  const char* group_name = OBJ_nid2sn(curve);
-  if (group_name == nullptr) return false;
+  // Keep the historical aliases while allowing names known only to providers.
+  if (curve != NID_undef) group_name = OBJ_nid2sn(curve);
 
   const char* encoding_name = nullptr;
   switch (encoding) {
@@ -6406,7 +6411,8 @@ bool EVPKeyCtxPointer::setEcParameters(int curve, int encoding) {
   };
   return EVP_PKEY_CTX_set_params(ctx_.get(), params) == 1;
 #else
-  return EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx_.get(), curve) == 1 &&
+  return curve != NID_undef &&
+         EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx_.get(), curve) == 1 &&
          EVP_PKEY_CTX_set_ec_param_enc(ctx_.get(), encoding) == 1;
 #endif
 }
@@ -7491,6 +7497,57 @@ int Ec::GetCurveId(const EVPKeyPointer& key) {
 #endif
 }
 
+std::optional<std::string> Ec::GetCurveName(const EVPKeyPointer& key) {
+  if (!key) return std::nullopt;
+#if NCRYPTO_USE_OPENSSL3_PROVIDER
+  size_t length = 0;
+  if (EVP_PKEY_get_utf8_string_param(
+          key.get(), OSSL_PKEY_PARAM_GROUP_NAME, nullptr, 0, &length) != 1) {
+    return std::nullopt;
+  }
+  std::string name(length, '\0');
+  if (EVP_PKEY_get_utf8_string_param(key.get(),
+                                     OSSL_PKEY_PARAM_GROUP_NAME,
+                                     name.data(),
+                                     name.size() + 1,
+                                     &length) != 1) {
+    return std::nullopt;
+  }
+  name.resize(length);
+  // Preserve the public short names for the curves OpenSSL already knows.
+  const int nid = GetCurveIdFromName(name.c_str());
+  return nid == NID_undef ? name : std::string(OBJ_nid2sn(nid));
+#else
+  const int nid = GetCurveId(key);
+  if (nid == NID_undef) return std::nullopt;
+  return std::string(OBJ_nid2sn(nid));
+#endif
+}
+
+#if NCRYPTO_USE_OPENSSL3_PROVIDER
+namespace {
+bool IsAvailableEcGroup(const char* name) {
+  MarkPopErrorOnReturn mark;
+  auto ctx = EVPKeyCtxPointer::NewFromAlgorithm(KeyAlgorithm::EC);
+  return ctx.initForParamgen() &&
+         ctx.setEcParameters(name, OPENSSL_EC_NAMED_CURVE) && ctx.paramgen();
+}
+}  // namespace
+#endif
+
+bool Ec::CheckCurveName(const char* name) {
+  if (name == nullptr) return false;
+  if (GetCurveIdFromName(name) != NID_undef) return true;
+#if NCRYPTO_USE_OPENSSL3_PROVIDER
+  // Keep invalid names a synchronous argument error. Generation contexts can
+  // defer rejecting a group until parameter generation. Use the same parameter
+  // generation path as key generation without requiring parameter import.
+  return IsAvailableEcGroup(name);
+#else
+  return false;
+#endif
+}
+
 int Ec::GetCurveIdFromName(const char* name) {
   int nid = EC_curve_nist2nid(name);
   if (nid == NID_undef) {
@@ -7513,8 +7570,12 @@ bool Ec::GetCurves(Ec::GetCurveCallback callback) {
   if (EC_get_builtin_curves(curves.data(), count) != count) {
     return false;
   }
-  for (auto curve : curves) {
-    if (!callback(OBJ_nid2sn(curve.nid))) return false;
+  for (const auto& curve : curves) {
+    const char* name = OBJ_nid2sn(curve.nid);
+#if NCRYPTO_USE_OPENSSL3_PROVIDER
+    if (!IsAvailableEcGroup(name)) continue;
+#endif
+    if (!callback(name)) return false;
   }
   return true;
 }

deps/ncrypto/ncrypto.h

@@ -771,6 +771,8 @@ class Ec final {
 
   static int GetCurveIdFromName(const char* name);
   static int GetCurveId(const EVPKeyPointer& key);
+  static std::optional<std::string> GetCurveName(const EVPKeyPointer& key);
+  static bool CheckCurveName(const char* name);
   static DataPointer TryExportPublic(const EVPKeyPointer& key,
                                      point_conversion_form_t form);
   static DataPointer ExportPrivate(const EVPKeyPointer& key);
@@ -1150,6 +1152,7 @@ class EVPKeyCtxPointer final {
   bool setDhParameters(int prime_size, uint32_t generator);
   bool setDsaParameters(uint32_t bits, std::optional<int> q_bits);
   bool setEcParameters(int curve, int encoding);
+  bool setEcParameters(const char* group_name, int encoding);
 
   bool setRsaOaepMd(const Digest& md);
   bool setRsaMgf1Md(const Digest& md);

lib/internal/crypto/util.js

@@ -80,7 +80,6 @@ const {
 const { Buffer } = require('buffer');
 
 const {
-  cachedResult,
   emitExperimentalWarning,
   filterDuplicateStrings,
   lazyDOMException,
@@ -192,7 +191,8 @@ const getMacs = cachedArrayByFipsGeneration(
     _macCache = undefined;
   });
 
-const getCurves = cachedResult(() => filterDuplicateStrings(_getCurves()));
+const getCurves = cachedArrayByFipsGeneration(
+  () => filterDuplicateStrings(_getCurves()));
 
 function setEngine(id, flags) {
   validateString(id, 'id');

src/crypto/crypto_ec.cc

@@ -409,14 +409,18 @@ void ECDH::ConvertKey(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+void EcKeyPairParams::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("curve_name", curve_name);
+}
+
 EVPKeyCtxPointer EcKeyGenTraits::Setup(EcKeyPairGenConfig* params) {
   EVPKeyCtxPointer key_ctx;
   if (params->params.algorithm != nullptr) {
     key_ctx = EVPKeyCtxPointer::NewFromAlgorithm(*params->params.algorithm);
   } else {
     auto param_ctx = EVPKeyCtxPointer::NewFromAlgorithm(KeyAlgorithm::EC);
     if (!param_ctx.initForParamgen() ||
-        !param_ctx.setEcParameters(params->params.curve_nid,
+        !param_ctx.setEcParameters(params->params.curve_name.c_str(),
                                    params->params.param_encoding)) {
       return {};
     }
@@ -450,11 +454,11 @@ Maybe<void> EcKeyGenTraits::AdditionalConfig(
   Utf8Value curve_name(env->isolate(), args[*offset]);
   params->params.algorithm = ncrypto::Ec::GetNamedKeyAlgorithm(*curve_name);
   if (params->params.algorithm == nullptr) {
-    params->params.curve_nid = Ec::GetCurveIdFromName(*curve_name);
-    if (params->params.curve_nid == NID_undef) {
+    if (!Ec::CheckCurveName(*curve_name)) {
       THROW_ERR_CRYPTO_INVALID_CURVE(env);
       return Nothing<void>();
     }
+    params->params.curve_name = *curve_name;
   }
 
   // param encoding
@@ -762,13 +766,13 @@ bool GetEcKeyDetail(Environment* env,
   const auto& m_pkey = key.GetAsymmetricKey();
   DCHECK(m_pkey.isA(KeyAlgorithm::EC));
 
-  int nid = Ec::GetCurveId(m_pkey);
-  if (nid == NID_undef) return true;
+  const auto name = Ec::GetCurveName(m_pkey);
+  if (!name) return true;
 
   return target
       ->Set(env->context(),
             env->named_curve_string(),
-            OneByteString(env->isolate(), OBJ_nid2sn(nid)))
+            OneByteString(env->isolate(), name.value()))
       .IsJust();
 }
 

src/crypto/crypto_ec.h

@@ -13,6 +13,8 @@
 #include "node_internals.h"
 #include "v8.h"
 
+#include <string>
+
 namespace node {
 namespace crypto {
 
@@ -60,9 +62,9 @@ class ECDH final : public BaseObject {
 
 struct EcKeyPairParams final : public MemoryRetainer {
   const ncrypto::KeyAlgorithm* algorithm = nullptr;
-  int curve_nid = NID_undef;
+  std::string curve_name;
   int param_encoding;
-  SET_NO_MEMORY_INFO()
+  void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(EcKeyPairParams)
   SET_SELF_SIZE(EcKeyPairParams)
 };