react-native-quick-crypto 1.1.1 → 1.1.2

package/nitrogen/generated/shared/c++/HybridTurboShakeSpec.hpp

@@ -0,0 +1,70 @@
+///
+/// HybridTurboShakeSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `TurboShakeVariant` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class TurboShakeVariant; }
+// Forward declaration of `KangarooTwelveVariant` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class KangarooTwelveVariant; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include "TurboShakeVariant.hpp"
+#include "KangarooTwelveVariant.hpp"
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `TurboShake`
+   * Inherit this class to create instances of `HybridTurboShakeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTurboShake: public HybridTurboShakeSpec {
+   * public:
+   *   HybridTurboShake(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTurboShakeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTurboShakeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTurboShakeSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> turboShake(TurboShakeVariant variant, double domainSeparation, double outputLength, const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> kangarooTwelve(KangarooTwelveVariant variant, double outputLength, const std::shared_ptr<ArrayBuffer>& data, const std::optional<std::shared_ptr<ArrayBuffer>>& customization) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "TurboShake";
+  };
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/JWK.hpp

@@ -70,11 +70,13 @@ namespace margelo::nitro::crypto {
     std::optional<std::string> dp     SWIFT_PRIVATE;
     std::optional<std::string> dq     SWIFT_PRIVATE;
     std::optional<std::string> qi     SWIFT_PRIVATE;
+    std::optional<std::string> pub     SWIFT_PRIVATE;
+    std::optional<std::string> priv     SWIFT_PRIVATE;
     std::optional<bool> ext     SWIFT_PRIVATE;
 
   public:
     JWK() = default;
-    explicit JWK(std::optional<JWKkty> kty, std::optional<JWKuse> use, std::optional<std::vector<KeyUsage>> key_ops, std::optional<std::string> alg, std::optional<std::string> crv, std::optional<std::string> kid, std::optional<std::string> x5u, std::optional<std::vector<std::string>> x5c, std::optional<std::string> x5t, std::optional<std::string> x5t_256, std::optional<std::string> n, std::optional<std::string> e, std::optional<std::string> d, std::optional<std::string> p, std::optional<std::string> q, std::optional<std::string> x, std::optional<std::string> y, std::optional<std::string> k, std::optional<std::string> dp, std::optional<std::string> dq, std::optional<std::string> qi, std::optional<bool> ext): kty(kty), use(use), key_ops(key_ops), alg(alg), crv(crv), kid(kid), x5u(x5u), x5c(x5c), x5t(x5t), x5t_256(x5t_256), n(n), e(e), d(d), p(p), q(q), x(x), y(y), k(k), dp(dp), dq(dq), qi(qi), ext(ext) {}
+    explicit JWK(std::optional<JWKkty> kty, std::optional<JWKuse> use, std::optional<std::vector<KeyUsage>> key_ops, std::optional<std::string> alg, std::optional<std::string> crv, std::optional<std::string> kid, std::optional<std::string> x5u, std::optional<std::vector<std::string>> x5c, std::optional<std::string> x5t, std::optional<std::string> x5t_256, std::optional<std::string> n, std::optional<std::string> e, std::optional<std::string> d, std::optional<std::string> p, std::optional<std::string> q, std::optional<std::string> x, std::optional<std::string> y, std::optional<std::string> k, std::optional<std::string> dp, std::optional<std::string> dq, std::optional<std::string> qi, std::optional<std::string> pub, std::optional<std::string> priv, std::optional<bool> ext): kty(kty), use(use), key_ops(key_ops), alg(alg), crv(crv), kid(kid), x5u(x5u), x5c(x5c), x5t(x5t), x5t_256(x5t_256), n(n), e(e), d(d), p(p), q(q), x(x), y(y), k(k), dp(dp), dq(dq), qi(qi), pub(pub), priv(priv), ext(ext) {}
 
   public:
     friend bool operator==(const JWK& lhs, const JWK& rhs) = default;
@@ -111,6 +113,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dp"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dq"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "qi"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pub"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "priv"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ext")))
       );
     }
@@ -137,6 +141,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "dp"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.dp));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "dq"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.dq));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "qi"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.qi));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "pub"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.pub));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "priv"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.priv));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ext"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.ext));
       return obj;
     }
@@ -169,6 +175,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dp")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "dq")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "qi")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "pub")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "priv")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ext")))) return false;
       return true;
     }

package/nitrogen/generated/shared/c++/JWKkty.hpp

@@ -34,6 +34,7 @@ namespace margelo::nitro::crypto {
     EC      SWIFT_NAME(ec) = 2,
     OCT      SWIFT_NAME(oct) = 3,
     OKP      SWIFT_NAME(okp) = 4,
+    AKP      SWIFT_NAME(akp) = 5,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
@@ -51,6 +52,7 @@ namespace margelo::nitro {
         case hashString("EC"): return margelo::nitro::crypto::JWKkty::EC;
         case hashString("oct"): return margelo::nitro::crypto::JWKkty::OCT;
         case hashString("OKP"): return margelo::nitro::crypto::JWKkty::OKP;
+        case hashString("AKP"): return margelo::nitro::crypto::JWKkty::AKP;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum JWKkty - invalid value!");
       }
@@ -62,6 +64,7 @@ namespace margelo::nitro {
         case margelo::nitro::crypto::JWKkty::EC: return JSIConverter<std::string>::toJSI(runtime, "EC");
         case margelo::nitro::crypto::JWKkty::OCT: return JSIConverter<std::string>::toJSI(runtime, "oct");
         case margelo::nitro::crypto::JWKkty::OKP: return JSIConverter<std::string>::toJSI(runtime, "OKP");
+        case margelo::nitro::crypto::JWKkty::AKP: return JSIConverter<std::string>::toJSI(runtime, "AKP");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert JWKkty to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -78,6 +81,7 @@ namespace margelo::nitro {
         case hashString("EC"):
         case hashString("oct"):
         case hashString("OKP"):
+        case hashString("AKP"):
           return true;
         default:
           return false;

package/nitrogen/generated/shared/c++/KangarooTwelveVariant.hpp

@@ -0,0 +1,76 @@
+///
+/// KangarooTwelveVariant.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * An enum which can be represented as a JavaScript union (KangarooTwelveVariant).
+   */
+  enum class KangarooTwelveVariant {
+    KT128      SWIFT_NAME(kt128) = 0,
+    KT256      SWIFT_NAME(kt256) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ KangarooTwelveVariant <> JS KangarooTwelveVariant (union)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::KangarooTwelveVariant> final {
+    static inline margelo::nitro::crypto::KangarooTwelveVariant fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("KT128"): return margelo::nitro::crypto::KangarooTwelveVariant::KT128;
+        case hashString("KT256"): return margelo::nitro::crypto::KangarooTwelveVariant::KT256;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum KangarooTwelveVariant - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KangarooTwelveVariant arg) {
+      switch (arg) {
+        case margelo::nitro::crypto::KangarooTwelveVariant::KT128: return JSIConverter<std::string>::toJSI(runtime, "KT128");
+        case margelo::nitro::crypto::KangarooTwelveVariant::KT256: return JSIConverter<std::string>::toJSI(runtime, "KT256");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert KangarooTwelveVariant to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("KT128"):
+        case hashString("KT256"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/TurboShakeVariant.hpp

@@ -0,0 +1,76 @@
+///
+/// TurboShakeVariant.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * An enum which can be represented as a JavaScript union (TurboShakeVariant).
+   */
+  enum class TurboShakeVariant {
+    TURBOSHAKE128      SWIFT_NAME(turboshake128) = 0,
+    TURBOSHAKE256      SWIFT_NAME(turboshake256) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ TurboShakeVariant <> JS TurboShakeVariant (union)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::TurboShakeVariant> final {
+    static inline margelo::nitro::crypto::TurboShakeVariant fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("TurboSHAKE128"): return margelo::nitro::crypto::TurboShakeVariant::TURBOSHAKE128;
+        case hashString("TurboSHAKE256"): return margelo::nitro::crypto::TurboShakeVariant::TURBOSHAKE256;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum TurboShakeVariant - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::TurboShakeVariant arg) {
+      switch (arg) {
+        case margelo::nitro::crypto::TurboShakeVariant::TURBOSHAKE128: return JSIConverter<std::string>::toJSI(runtime, "TurboSHAKE128");
+        case margelo::nitro::crypto::TurboShakeVariant::TURBOSHAKE256: return JSIConverter<std::string>::toJSI(runtime, "TurboSHAKE256");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert TurboShakeVariant to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("TurboSHAKE128"):
+        case hashString("TurboSHAKE256"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -164,8 +164,7 @@
           {
             "file": "../../example/package.json",
             "path": [
-              "version",
-              "dependencies.react-native-quick-crypto"
+              "version"
             ]
           }
         ]

package/src/dhKeyPair.ts

@@ -97,6 +97,14 @@ function dh_formatKeyPairOutput(
   let publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
   let privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
 
+  if (
+    publicFormat === 'raw-public' ||
+    privateFormat === 'raw-private' ||
+    privateFormat === 'raw-seed'
+  ) {
+    throw new Error('Raw key formats are not supported for DH keys');
+  }
+
   if (publicFormat === -1) {
     publicKey = pub;
   } else {

package/src/dsa.ts

@@ -79,6 +79,14 @@ function dsa_formatKeyPairOutput(
   let publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
   let privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
 
+  if (
+    publicFormat === 'raw-public' ||
+    privateFormat === 'raw-private' ||
+    privateFormat === 'raw-seed'
+  ) {
+    throw new Error('Raw key formats are not supported for DSA keys');
+  }
+
   if (publicFormat === -1) {
     publicKey = pub;
   } else {

package/src/ec.ts

@@ -27,6 +27,7 @@ import {
   kNamedCurveAliases,
   lazyDOMException,
   normalizeHashName,
+  validateJwkStructure,
   HashContext,
   KeyEncoding,
   KFormatType,
@@ -93,36 +94,27 @@ export function ecImportKey(
     throw lazyDOMException('Unrecognized namedCurve', 'NotSupportedError');
   }
 
-  // Handle JWK format
   if (format === 'jwk') {
     const jwk = keyData as JWK;
 
-    // Validate JWK
+    if (!jwk || typeof jwk !== 'object') {
+      throw lazyDOMException('Invalid keyData', 'DataError');
+    }
     if (jwk.kty !== 'EC') {
       throw lazyDOMException('Invalid JWK "kty" Parameter', 'DataError');
     }
-
     if (jwk.crv !== namedCurve) {
       throw lazyDOMException(
         'JWK "crv" does not match the requested algorithm',
         'DataError',
       );
     }
+    const expectedUse = name === 'ECDH' ? 'enc' : 'sig';
+    validateJwkStructure(jwk, extractable, keyUsages, expectedUse);
 
-    // Check use parameter if present
-    if (jwk.use !== undefined) {
-      const expectedUse = name === 'ECDH' ? 'enc' : 'sig';
-      if (jwk.use !== expectedUse) {
-        throw lazyDOMException('Invalid JWK "use" Parameter', 'DataError');
-      }
-    }
-
-    // Check alg parameter if present
     if (jwk.alg !== undefined) {
       let expectedAlg: string | undefined;
-
       if (name === 'ECDSA') {
-        // Map namedCurve to expected ECDSA algorithm
         expectedAlg =
           namedCurve === 'P-256'
             ? 'ES256'
@@ -132,11 +124,9 @@ export function ecImportKey(
                 ? 'ES512'
                 : undefined;
       } else if (name === 'ECDH') {
-        // ECDH uses ECDH-ES algorithm
         expectedAlg = 'ECDH-ES';
       }
-
-      if (expectedAlg && jwk.alg !== undefined && jwk.alg !== expectedAlg) {
+      if (expectedAlg && jwk.alg !== expectedAlg) {
         throw lazyDOMException(
           'JWK "alg" does not match the requested algorithm',
           'DataError',
@@ -144,32 +134,49 @@ export function ecImportKey(
       }
     }
 
-    // Import using C++ layer
+    const isPublicJwk = jwk.d === undefined;
+    const validUsagesJwk: KeyUsage[] =
+      name === 'ECDSA'
+        ? isPublicJwk
+          ? ['verify']
+          : ['sign']
+        : isPublicJwk
+          ? []
+          : ['deriveKey', 'deriveBits'];
+    if (hasAnyNotIn(keyUsages, validUsagesJwk)) {
+      throw lazyDOMException(
+        `Unsupported key usage for a ${name} key`,
+        'SyntaxError',
+      );
+    }
+
     const handle =
       NitroModules.createHybridObject<KeyObjectHandle>('KeyObjectHandle');
-    const keyType = handle.initJwk(jwk, namedCurve as NamedCurve);
-
+    let keyType: number | undefined;
+    try {
+      keyType = handle.initJwk(jwk, namedCurve as NamedCurve);
+    } catch (err) {
+      throw lazyDOMException('Invalid keyData', {
+        name: 'DataError',
+        cause: err,
+      });
+    }
     if (keyType === undefined) {
-      throw lazyDOMException('Invalid JWK', 'DataError');
+      throw lazyDOMException('Invalid keyData', 'DataError');
     }
 
-    // Create the appropriate KeyObject based on type
     let keyObject: KeyObject;
     if (keyType === 1) {
       keyObject = new PublicKeyObject(handle);
     } else if (keyType === 2) {
       keyObject = new PrivateKeyObject(handle);
     } else {
-      throw lazyDOMException(
-        'Unexpected key type from JWK import',
-        'DataError',
-      );
+      throw lazyDOMException('Invalid keyData', 'DataError');
     }
 
     return new CryptoKey(keyObject, algorithm, keyUsages, extractable);
   }
 
-  // Handle binary formats (spki, pkcs8, raw)
   if (format !== 'spki' && format !== 'pkcs8' && format !== 'raw') {
     throw lazyDOMException(
       `Unsupported format: ${format}`,
@@ -177,11 +184,9 @@ export function ecImportKey(
     );
   }
 
-  // Determine expected key type based on format
   const expectedKeyType =
     format === 'spki' || format === 'raw' ? 'public' : 'private';
 
-  // Validate usages for the key type
   const isPublicKey = expectedKeyType === 'public';
   let validUsages: KeyUsage[];
 
@@ -225,6 +230,18 @@ export function ecImportKey(
       KFormatType.DER,
       format === 'spki' ? KeyEncoding.SPKI : KeyEncoding.PKCS8,
     );
+
+    // Validate the imported curve matches the requested algorithm.namedCurve.
+    const expectedAlias =
+      kNamedCurveAliases[namedCurve as keyof typeof kNamedCurveAliases];
+    if (keyObject.handle.keyDetail().namedCurve !== expectedAlias) {
+      throw lazyDOMException('Named curve mismatch', 'DataError');
+    }
+  }
+
+  // Verify the public/private point lies on the named curve.
+  if (!keyObject.handle.checkEcKeyData()) {
+    throw lazyDOMException('Invalid keyData', 'DataError');
   }
 
   return new CryptoKey(keyObject, algorithm, keyUsages, extractable);
@@ -433,6 +450,10 @@ function ec_formatKeyPairOutput(
 
   if (publicFormat === -1) {
     publicKey = pub;
+  } else if (publicFormat === 'raw-public') {
+    publicKey = Buffer.from(
+      pub.handle.exportECPublicRaw(publicType === 'compressed'),
+    );
   } else {
     const format =
       publicFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;
@@ -448,6 +469,8 @@ function ec_formatKeyPairOutput(
 
   if (privateFormat === -1) {
     privateKey = priv;
+  } else if (privateFormat === 'raw-private') {
+    privateKey = Buffer.from(priv.handle.exportECPrivateRaw());
   } else {
     const format =
       privateFormat === KFormatType.PEM ? KFormatType.PEM : KFormatType.DER;