react-native-quick-crypto 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -0,0 +1,93 @@
+///
+/// KeyDetail.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#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
+
+
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * A struct which can be represented as a JavaScript object (KeyDetail).
+   */
+  struct KeyDetail {
+  public:
+    std::optional<double> length     SWIFT_PRIVATE;
+    std::optional<double> publicExponent     SWIFT_PRIVATE;
+    std::optional<double> modulusLength     SWIFT_PRIVATE;
+    std::optional<std::string> hashAlgorithm     SWIFT_PRIVATE;
+    std::optional<std::string> mgf1HashAlgorithm     SWIFT_PRIVATE;
+    std::optional<double> saltLength     SWIFT_PRIVATE;
+    std::optional<std::string> namedCurve     SWIFT_PRIVATE;
+
+  public:
+    explicit KeyDetail(std::optional<double> length, std::optional<double> publicExponent, std::optional<double> modulusLength, std::optional<std::string> hashAlgorithm, std::optional<std::string> mgf1HashAlgorithm, std::optional<double> saltLength, std::optional<std::string> namedCurve): length(length), publicExponent(publicExponent), modulusLength(modulusLength), hashAlgorithm(hashAlgorithm), mgf1HashAlgorithm(mgf1HashAlgorithm), saltLength(saltLength), namedCurve(namedCurve) {}
+  };
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::crypto;
+
+  // C++ KeyDetail <> JS KeyDetail (object)
+  template <>
+  struct JSIConverter<KeyDetail> {
+    static inline KeyDetail fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return KeyDetail(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "length")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "publicExponent")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "modulusLength")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "hashAlgorithm")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "mgf1HashAlgorithm")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "saltLength")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "namedCurve"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const KeyDetail& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "length", JSIConverter<std::optional<double>>::toJSI(runtime, arg.length));
+      obj.setProperty(runtime, "publicExponent", JSIConverter<std::optional<double>>::toJSI(runtime, arg.publicExponent));
+      obj.setProperty(runtime, "modulusLength", JSIConverter<std::optional<double>>::toJSI(runtime, arg.modulusLength));
+      obj.setProperty(runtime, "hashAlgorithm", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.hashAlgorithm));
+      obj.setProperty(runtime, "mgf1HashAlgorithm", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.mgf1HashAlgorithm));
+      obj.setProperty(runtime, "saltLength", JSIConverter<std::optional<double>>::toJSI(runtime, arg.saltLength));
+      obj.setProperty(runtime, "namedCurve", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.namedCurve));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "length"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "publicExponent"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "modulusLength"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "hashAlgorithm"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "mgf1HashAlgorithm"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "saltLength"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "namedCurve"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,66 @@
+///
+/// KeyEncoding.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <cmath>
+#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 enum (KeyEncoding).
+   */
+  enum class KeyEncoding {
+    KKEYENCODINGPKCS1      SWIFT_NAME(kkeyencodingpkcs1) = 0,
+    KKEYENCODINGPKCS8      SWIFT_NAME(kkeyencodingpkcs8) = 1,
+    KKEYENCODINGSPKI      SWIFT_NAME(kkeyencodingspki) = 2,
+    KKEYENCODINGSEC1      SWIFT_NAME(kkeyencodingsec1) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::crypto;
+
+  // C++ KeyEncoding <> JS KeyEncoding (enum)
+  template <>
+  struct JSIConverter<KeyEncoding> {
+    static inline KeyEncoding fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<KeyEncoding>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, KeyEncoding arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double integer;
+      double fraction = modf(value.getNumber(), &integer);
+      if (fraction != 0.0) {
+        // It is some kind of floating point number - our enums are ints.
+        return false;
+      }
+      // Check if we are within the bounds of the enum.
+      return integer >= 0 && integer <= 3;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,65 @@
+///
+/// KeyType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <cmath>
+#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 enum (KeyType).
+   */
+  enum class KeyType {
+    SECRET      SWIFT_NAME(secret) = 0,
+    PUBLIC      SWIFT_NAME(public) = 1,
+    PRIVATE      SWIFT_NAME(private) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::crypto;
+
+  // C++ KeyType <> JS KeyType (enum)
+  template <>
+  struct JSIConverter<KeyType> {
+    static inline KeyType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<KeyType>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, KeyType arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double integer;
+      double fraction = modf(value.getNumber(), &integer);
+      if (fraction != 0.0) {
+        // It is some kind of floating point number - our enums are ints.
+        return false;
+      }
+      // Check if we are within the bounds of the enum.
+      return integer >= 0 && integer <= 2;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,102 @@
+///
+/// KeyUsage.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 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 (KeyUsage).
+   */
+  enum class KeyUsage {
+    ENCRYPT      SWIFT_NAME(encrypt) = 0,
+    DECRYPT      SWIFT_NAME(decrypt) = 1,
+    SIGN      SWIFT_NAME(sign) = 2,
+    VERIFY      SWIFT_NAME(verify) = 3,
+    DERIVEKEY      SWIFT_NAME(derivekey) = 4,
+    DERIVEBITS      SWIFT_NAME(derivebits) = 5,
+    WRAPKEY      SWIFT_NAME(wrapkey) = 6,
+    UNWRAPKEY      SWIFT_NAME(unwrapkey) = 7,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::crypto;
+
+  // C++ KeyUsage <> JS KeyUsage (union)
+  template <>
+  struct JSIConverter<KeyUsage> {
+    static inline KeyUsage 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("encrypt"): return KeyUsage::ENCRYPT;
+        case hashString("decrypt"): return KeyUsage::DECRYPT;
+        case hashString("sign"): return KeyUsage::SIGN;
+        case hashString("verify"): return KeyUsage::VERIFY;
+        case hashString("deriveKey"): return KeyUsage::DERIVEKEY;
+        case hashString("deriveBits"): return KeyUsage::DERIVEBITS;
+        case hashString("wrapKey"): return KeyUsage::WRAPKEY;
+        case hashString("unwrapKey"): return KeyUsage::UNWRAPKEY;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum KeyUsage - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, KeyUsage arg) {
+      switch (arg) {
+        case KeyUsage::ENCRYPT: return JSIConverter<std::string>::toJSI(runtime, "encrypt");
+        case KeyUsage::DECRYPT: return JSIConverter<std::string>::toJSI(runtime, "decrypt");
+        case KeyUsage::SIGN: return JSIConverter<std::string>::toJSI(runtime, "sign");
+        case KeyUsage::VERIFY: return JSIConverter<std::string>::toJSI(runtime, "verify");
+        case KeyUsage::DERIVEKEY: return JSIConverter<std::string>::toJSI(runtime, "deriveKey");
+        case KeyUsage::DERIVEBITS: return JSIConverter<std::string>::toJSI(runtime, "deriveBits");
+        case KeyUsage::WRAPKEY: return JSIConverter<std::string>::toJSI(runtime, "wrapKey");
+        case KeyUsage::UNWRAPKEY: return JSIConverter<std::string>::toJSI(runtime, "unwrapKey");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert KeyUsage 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("encrypt"):
+        case hashString("decrypt"):
+        case hashString("sign"):
+        case hashString("verify"):
+        case hashString("deriveKey"):
+        case hashString("deriveBits"):
+        case hashString("wrapKey"):
+        case hashString("unwrapKey"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,82 @@
+///
+/// NamedCurve.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 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 (NamedCurve).
+   */
+  enum class NamedCurve {
+    P_256      SWIFT_NAME(p256) = 0,
+    P_384      SWIFT_NAME(p384) = 1,
+    P_521      SWIFT_NAME(p521) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::crypto;
+
+  // C++ NamedCurve <> JS NamedCurve (union)
+  template <>
+  struct JSIConverter<NamedCurve> {
+    static inline NamedCurve 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("P-256"): return NamedCurve::P_256;
+        case hashString("P-384"): return NamedCurve::P_384;
+        case hashString("P-521"): return NamedCurve::P_521;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NamedCurve - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, NamedCurve arg) {
+      switch (arg) {
+        case NamedCurve::P_256: return JSIConverter<std::string>::toJSI(runtime, "P-256");
+        case NamedCurve::P_384: return JSIConverter<std::string>::toJSI(runtime, "P-384");
+        case NamedCurve::P_521: return JSIConverter<std::string>::toJSI(runtime, "P-521");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert NamedCurve 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("P-256"):
+        case hashString("P-384"):
+        case hashString("P-521"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "type": "module",
   "main": "lib/commonjs/index",
@@ -17,6 +17,7 @@
     "android/src",
     "ios",
     "cpp",
+    "deps",
     "nitrogen",
     "react-native.config.js",
     "app.plugin.js",
@@ -27,15 +28,17 @@
     "!**/__mocks__"
   ],
   "scripts": {
-    "clean": "del-cli lib",
+    "clean": "del-cli android/build lib",
     "tsc": "tsc --noEmit",
     "typescript": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "lint-fix": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "lint:fix": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "format": "prettier --check \"**/*.{js,ts,tsx}\"",
+    "format:fix": "prettier --write \"**/*.{js,ts,tsx}\"",
     "prepare": "bun clean && bob build",
     "release-it": "bun prepare && release-it",
-    "test": "jest",
-    "postinstall": "bun tsc"
+    "specs": "nitro-codegen",
+    "test": "jest"
   },
   "keywords": [
     "react-native",
@@ -66,7 +69,7 @@
   "dependencies": {
     "@craftzdog/react-native-buffer": "6.0.5",
     "events": "3.3.0",
-    "react-native-nitro-modules": "0.4.0",
+    "react-native-nitro-modules": "0.14.0",
     "react-native-quick-base64": "2.1.2",
     "readable-stream": "4.5.2",
     "string_decoder": "1.3.0",
@@ -84,11 +87,9 @@
     "eslint": "9.9.0",
     "eslint-plugin-react-native": "^4.1.0",
     "jest": "29.7.0",
-    "nitro-codegen": "0.4.0",
-    "prettier": "3.2.5",
-    "react": "18.3.1",
-    "react-native": "0.74.5",
-    "react-native-builder-bob": "0.29.1",
+    "nitro-codegen": "0.14.0",
+    "prettier": "3.3.3",
+    "react-native-builder-bob": "0.30.0",
     "release-it": "17.6.0",
     "typescript": "5.1.6",
     "typescript-eslint": "^8.1.0"
@@ -121,5 +122,10 @@
         }
       ]
     ]
-  }
+  },
+  "trustedDependencies": [
+    "react-native-quick-crypto",
+    "nitro-codegen",
+    "react-native-nitro-modules"
+  ]
 }

package/src/index.ts

@@ -2,10 +2,11 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 
 // API imports
+import * as pbkdf2 from './pbkdf2';
 import * as random from './random';
 
 // utils import
-import { utils } from './utils';
+import * as utils from './utils';
 
 /**
  * Loosely matches Node.js {crypto} with some unimplemented functionality.
@@ -34,16 +35,17 @@ const QuickCrypto = {
   // createVerify,
   // subtle,
   // constants,
-  // ...pbkdf2,
+  ...pbkdf2,
   ...random,
   // getCiphers,
   // getHashes,
   // webcrypto,
-  utils,
+  ...utils,
 };
 
 /**
- * Optional. Patch global.crypto with quickcrypto and global.Buffer with react-native-buffer.
+ * Optional. Patch global.crypto with react-native-quick-crypto and
+ * global.Buffer with react-native-buffer.
  */
 export const install = () => {
   // @ts-expect-error copyBytesFrom and poolSizets are missing from react-native-buffer
@@ -56,7 +58,9 @@ export const install = () => {
 // random, cipher, hash use nextTick
 global.process.nextTick = setImmediate;
 
+// exports
 export default QuickCrypto;
+export * from './utils';
 
 // Additional exports for CommonJS compatibility
 module.exports = QuickCrypto;

package/src/keys/index.ts

@@ -0,0 +1,99 @@
+import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
+import type { EncodingOptions, KeyUsage, SubtleAlgorithm } from '../utils';
+
+export class CryptoKey {
+  keyObject: KeyObject;
+  keyAlgorithm: SubtleAlgorithm;
+  keyUsages: KeyUsage[];
+  keyExtractable: boolean;
+
+  constructor(
+    keyObject: KeyObject,
+    keyAlgorithm: SubtleAlgorithm,
+    keyUsages: KeyUsage[],
+    keyExtractable: boolean,
+  ) {
+    this.keyObject = keyObject;
+    this.keyAlgorithm = keyAlgorithm;
+    this.keyUsages = keyUsages;
+    this.keyExtractable = keyExtractable;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  inspect(_depth: number, _options: unknown): unknown {
+    throw new Error('CryptoKey.inspect is not implemented');
+    // if (depth < 0) return this;
+
+    // const opts = {
+    //   ...options,
+    //   depth: options.depth == null ? null : options.depth - 1,
+    // };
+
+    // return `CryptoKey ${inspect(
+    //   {
+    //     type: this.type,
+    //     extractable: this.extractable,
+    //     algorithm: this.algorithm,
+    //     usages: this.usages,
+    //   },
+    //   opts
+    // )}`;
+  }
+
+  get type() {
+    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');
+    return this.keyObject.type;
+  }
+
+  get extractable() {
+    return this.keyExtractable;
+  }
+
+  get algorithm() {
+    return this.keyAlgorithm;
+  }
+
+  get usages() {
+    return this.keyUsages;
+  }
+}
+
+class KeyObject {
+  handle: KeyObjectHandle;
+  type: 'public' | 'secret' | 'private' | 'unknown' = 'unknown';
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export(_options?: EncodingOptions): ArrayBuffer {
+    return new ArrayBuffer(0);
+  }
+
+  constructor(type: string, handle: KeyObjectHandle) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private')
+      throw new Error(`invalid KeyObject type: ${type}`);
+    this.handle = handle;
+    this.type = type;
+  }
+
+  // get type(): string {
+  //   return this.type;
+  // }
+
+  // static from(key) {
+  //   if (!isCryptoKey(key))
+  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
+  //   return key[kKeyObject];
+  // }
+
+  // equals(otherKeyObject) {
+  //   if (!isKeyObject(otherKeyObject)) {
+  //     throw new ERR_INVALID_ARG_TYPE(
+  //       'otherKeyObject',
+  //       'KeyObject',
+  //       otherKeyObject
+  //     );
+  //   }
+
+  //   return (
+  //     otherKeyObject.type === this.type &&
+  //     this[kHandle].equals(otherKeyObject[kHandle])
+  //   );
+  // }
+}