react-native-quick-crypto 0.7.11 → 1.0.0-beta.10

package/lib/commonjs/utils/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _conversion = require("./conversion");
+Object.keys(_conversion).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _conversion[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _conversion[key];
+    }
+  });
+});
+var _errors = require("./errors");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errors[key];
+    }
+  });
+});
+var _hashnames = require("./hashnames");
+Object.keys(_hashnames).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _hashnames[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _hashnames[key];
+    }
+  });
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var _validation = require("./validation");
+Object.keys(_validation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validation[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/lib/commonjs/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_conversion","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_errors","_hashnames","_types","_validation"],"sourceRoot":"../../../src","sources":["utils/index.ts"],"mappings":";;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,WAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,WAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,WAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,OAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,OAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,OAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,OAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,UAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,UAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,UAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,UAAA,CAAAN,GAAA;IAAA;EAAA;AAAA;AACA,IAAAO,MAAA,GAAAX,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAS,MAAA,EAAAR,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAO,MAAA,CAAAP,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAG,MAAA,CAAAP,GAAA;IAAA;EAAA;AAAA;AACA,IAAAQ,WAAA,GAAAZ,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAU,WAAA,EAAAT,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAQ,WAAA,CAAAR,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAI,WAAA,CAAAR,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/lib/commonjs/utils/types.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KeyVariant = exports.KeyType = exports.KeyEncoding = exports.KFormatType = void 0;
+// @types/node
+// On node this value is defined on the native side, for now I'm just creating it here in JS
+// TODO(osp) move this into native side to make sure they always match
+let KFormatType = exports.KFormatType = /*#__PURE__*/function (KFormatType) {
+  KFormatType[KFormatType["kKeyFormatDER"] = 0] = "kKeyFormatDER";
+  KFormatType[KFormatType["kKeyFormatPEM"] = 1] = "kKeyFormatPEM";
+  KFormatType[KFormatType["kKeyFormatJWK"] = 2] = "kKeyFormatJWK";
+  return KFormatType;
+}({}); // Same as KFormatType, this enum needs to be defined on the native side
+let KeyType = exports.KeyType = /*#__PURE__*/function (KeyType) {
+  KeyType[KeyType["Secret"] = 0] = "Secret";
+  KeyType[KeyType["Public"] = 1] = "Public";
+  KeyType[KeyType["Private"] = 2] = "Private";
+  return KeyType;
+}({});
+let KeyEncoding = exports.KeyEncoding = /*#__PURE__*/function (KeyEncoding) {
+  KeyEncoding[KeyEncoding["kKeyEncodingPKCS1"] = 0] = "kKeyEncodingPKCS1";
+  KeyEncoding[KeyEncoding["kKeyEncodingPKCS8"] = 1] = "kKeyEncodingPKCS8";
+  KeyEncoding[KeyEncoding["kKeyEncodingSPKI"] = 2] = "kKeyEncodingSPKI";
+  KeyEncoding[KeyEncoding["kKeyEncodingSEC1"] = 3] = "kKeyEncodingSEC1";
+  return KeyEncoding;
+}({}); // Note: removed CryptoKey class from this type (from 0.x) because Nitro doesn't
+//       handle custom JS objects.  We might need to make it a JS object.
+let KeyVariant = exports.KeyVariant = /*#__PURE__*/function (KeyVariant) {
+  KeyVariant[KeyVariant["RSA_SSA_PKCS1_v1_5"] = 0] = "RSA_SSA_PKCS1_v1_5";
+  KeyVariant[KeyVariant["RSA_PSS"] = 1] = "RSA_PSS";
+  KeyVariant[KeyVariant["RSA_OAEP"] = 2] = "RSA_OAEP";
+  KeyVariant[KeyVariant["DSA"] = 3] = "DSA";
+  KeyVariant[KeyVariant["EC"] = 4] = "EC";
+  KeyVariant[KeyVariant["NID"] = 5] = "NID";
+  KeyVariant[KeyVariant["DH"] = 6] = "DH";
+  return KeyVariant;
+}({});
+//# sourceMappingURL=types.js.map

package/lib/commonjs/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["KFormatType","exports","KeyType","KeyEncoding","KeyVariant"],"sourceRoot":"../../../src","sources":["utils/types.ts"],"mappings":";;;;;;AAEyC;AAiHzC;AACA;AAAA,IACYA,WAAW,GAAAC,OAAA,CAAAD,WAAA,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA,OAMvB;AAAA,IACYE,OAAO,GAAAD,OAAA,CAAAC,OAAA,0BAAPA,OAAO;EAAPA,OAAO,CAAPA,OAAO;EAAPA,OAAO,CAAPA,OAAO;EAAPA,OAAO,CAAPA,OAAO;EAAA,OAAPA,OAAO;AAAA;AAAA,IAMPC,WAAW,GAAAF,OAAA,CAAAE,WAAA,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA,OAwGvB;AACA;AAAA,IA2BYC,UAAU,GAAAH,OAAA,CAAAG,UAAA,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA","ignoreList":[]}

package/lib/commonjs/utils/validation.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isStringOrBuffer = isStringOrBuffer;
+exports.validateFunction = validateFunction;
+exports.validateObject = validateObject;
+function validateFunction(f) {
+  return f !== null && typeof f === 'function';
+}
+function isStringOrBuffer(val) {
+  return typeof val === 'string' || ArrayBuffer.isView(val) || val instanceof ArrayBuffer;
+}
+function validateObject(value, name, options) {
+  const useDefaultOptions = options == null;
+  const allowArray = useDefaultOptions ? false : options.allowArray;
+  const allowFunction = useDefaultOptions ? false : options.allowFunction;
+  const nullable = useDefaultOptions ? false : options.nullable;
+  if (!nullable && value === null || !allowArray && Array.isArray(value) || typeof value !== 'object' && (!allowFunction || typeof value !== 'function')) {
+    throw new Error(`${name} is not a valid object $${value}`);
+  }
+  return true;
+}
+//# sourceMappingURL=validation.js.map

package/lib/commonjs/utils/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["validateFunction","f","isStringOrBuffer","val","ArrayBuffer","isView","validateObject","value","name","options","useDefaultOptions","allowArray","allowFunction","nullable","Array","isArray","Error"],"sourceRoot":"../../../src","sources":["utils/validation.ts"],"mappings":";;;;;;;;AAAO,SAASA,gBAAgBA,CAACC,CAAU,EAAW;EACpD,OAAOA,CAAC,KAAK,IAAI,IAAI,OAAOA,CAAC,KAAK,UAAU;AAC9C;AAEO,SAASC,gBAAgBA,CAACC,GAAY,EAA+B;EAC1E,OACE,OAAOA,GAAG,KAAK,QAAQ,IACvBC,WAAW,CAACC,MAAM,CAACF,GAAG,CAAC,IACvBA,GAAG,YAAYC,WAAW;AAE9B;AAEO,SAASE,cAAcA,CAC5BC,KAAc,EACdC,IAAY,EACZC,OAIQ,EACI;EACZ,MAAMC,iBAAiB,GAAGD,OAAO,IAAI,IAAI;EACzC,MAAME,UAAU,GAAGD,iBAAiB,GAAG,KAAK,GAAGD,OAAO,CAACE,UAAU;EACjE,MAAMC,aAAa,GAAGF,iBAAiB,GAAG,KAAK,GAAGD,OAAO,CAACG,aAAa;EACvE,MAAMC,QAAQ,GAAGH,iBAAiB,GAAG,KAAK,GAAGD,OAAO,CAACI,QAAQ;EAC7D,IACG,CAACA,QAAQ,IAAIN,KAAK,KAAK,IAAI,IAC3B,CAACI,UAAU,IAAIG,KAAK,CAACC,OAAO,CAACR,KAAK,CAAE,IACpC,OAAOA,KAAK,KAAK,QAAQ,KACvB,CAACK,aAAa,IAAI,OAAOL,KAAK,KAAK,UAAU,CAAE,EAClD;IACA,MAAM,IAAIS,KAAK,CAAC,GAAGR,IAAI,2BAA2BD,KAAK,EAAE,CAAC;EAC5D;EACA,OAAO,IAAI;AACb","ignoreList":[]}

package/lib/module/ed.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+import { binaryLikeToArrayBuffer as toAB } from './utils';
+export class Ed {
+  constructor(type, config) {
+    this.type = type;
+    this.config = config;
+    this.native = NitroModules.createHybridObject('EdKeyPair');
+    this.native.setCurve(type);
+  }
+  async generateKeyPair() {
+    this.native.generateKeyPair(this.config.publicFormat || -1, this.config.publicType || -1, this.config.privateFormat || -1, this.config.privateType || -1, this.config.cipher, this.config.passphrase);
+  }
+  generateKeyPairSync() {
+    this.native.generateKeyPairSync(this.config.publicFormat || -1, this.config.publicType || -1, this.config.privateFormat || -1, this.config.privateType || -1, this.config.cipher, this.config.passphrase);
+  }
+  getPublicKey() {
+    return this.native.getPublicKey();
+  }
+  getPrivateKey() {
+    return this.native.getPrivateKey();
+  }
+  async sign(message, key) {
+    return key ? this.native.sign(toAB(message), toAB(key)) : this.native.sign(toAB(message));
+  }
+  signSync(message, key) {
+    return key ? this.native.signSync(toAB(message), toAB(key)) : this.native.signSync(toAB(message));
+  }
+  async verify(signature, message, key) {
+    return key ? this.native.verify(toAB(signature), toAB(message), toAB(key)) : this.native.verify(toAB(signature), toAB(message));
+  }
+  verifySync(signature, message, key) {
+    return key ? this.native.verifySync(toAB(signature), toAB(message), toAB(key)) : this.native.verifySync(toAB(signature), toAB(message));
+  }
+}
+//# sourceMappingURL=ed.js.map

package/lib/module/ed.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","binaryLikeToArrayBuffer","toAB","Ed","constructor","type","config","native","createHybridObject","setCurve","generateKeyPair","publicFormat","publicType","privateFormat","privateType","cipher","passphrase","generateKeyPairSync","getPublicKey","getPrivateKey","sign","message","key","signSync","verify","signature","verifySync"],"sourceRoot":"../../src","sources":["ed.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/index.js

@@ -1,54 +1,52 @@
 "use strict";
 
+// polyfill imports
 import { Buffer } from '@craftzdog/react-native-buffer';
+
+// API imports
+import * as keys from './keys';
+import * as ed from './ed';
 import * as pbkdf2 from './pbkdf2';
 import * as random from './random';
-import { createCipher, createCipheriv, createDecipher, createDecipheriv, publicEncrypt, publicDecrypt, privateDecrypt, generateKeyPair, generateKeyPairSync } from './Cipher';
-import { generateKey, generateKeySync } from './keygen';
-import { createSign, createVerify } from './sig';
-import { createHmac } from './Hmac';
-import { createHash } from './Hash';
-import { constants } from './constants';
-import { subtle } from './subtle';
-import { getCiphers, getHashes } from './Utils';
-import webcrypto from './webcrypto';
-import { createPrivateKey, createPublicKey, createSecretKey } from './keys';
+
+// utils import
+import * as utils from './utils';
 
 /**
- * Loosely matches Node.js {crypto} with some unimplemented functionality
+ * Loosely matches Node.js {crypto} with some unimplemented functionality.
+ * See `docs/implementation-coverage.md` for status.
  */
 const QuickCrypto = {
-  createHmac,
-  Hmac: createHmac,
-  Hash: createHash,
-  createHash,
-  createCipher,
-  createCipheriv,
-  createDecipher,
-  createDecipheriv,
-  createPublicKey,
-  createPrivateKey,
-  createSecretKey,
-  publicEncrypt,
-  publicDecrypt,
-  privateDecrypt,
-  generateKey,
-  generateKeyPair,
-  generateKeyPairSync,
-  generateKeySync,
-  createSign,
-  createVerify,
-  subtle,
-  constants,
+  // createHmac,
+  // Hmac: createHmac,
+  // Hash: createHash,
+  // createHash,
+  // createCipher,
+  // createCipheriv,
+  // createDecipher,
+  // createDecipheriv,
+  // publicEncrypt,
+  // publicDecrypt,
+  // privateDecrypt,
+  // generateKey,
+  // generateKeySync,
+  // createSign,
+  // createVerify,
+  // subtle,
+  // constants,
+  ...keys,
+  ...ed,
   ...pbkdf2,
   ...random,
-  getCiphers,
-  getHashes,
-  webcrypto
+  // getCiphers,
+  // getHashes,
+  // webcrypto,
+  ...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
@@ -57,7 +55,16 @@ export const install = () => {
   // @ts-expect-error subtle isn't fully implemented and Cryptokey is missing
   global.crypto = QuickCrypto;
 };
+
+// random, cipher, hash use nextTick
+global.process.nextTick = setImmediate;
+
+// exports
 export default QuickCrypto;
+export * from './ed';
+export * from './pbkdf2';
+export * from './random';
+export * from './utils';
 
 // Additional exports for CommonJS compatibility
 module.exports = QuickCrypto;

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["Buffer","pbkdf2","random","createCipher","createCipheriv","createDecipher","createDecipheriv","publicEncrypt","publicDecrypt","privateDecrypt","generateKeyPair","generateKeyPairSync","generateKey","generateKeySync","createSign","createVerify","createHmac","createHash","constants","subtle","getCiphers","getHashes","webcrypto","createPrivateKey","createPublicKey","createSecretKey","QuickCrypto","Hmac","Hash","install","global","crypto","module","exports","default"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,MAAM,QAAQ,gCAAgC;AACvD,OAAO,KAAKC,MAAM,MAAM,UAAU;AAClC,OAAO,KAAKC,MAAM,MAAM,UAAU;AAClC,SACEC,YAAY,EACZC,cAAc,EACdC,cAAc,EACdC,gBAAgB,EAChBC,aAAa,EACbC,aAAa,EACbC,cAAc,EACdC,eAAe,EACfC,mBAAmB,QACd,UAAU;AACjB,SAASC,WAAW,EAAEC,eAAe,QAAQ,UAAU;AACvD,SAASC,UAAU,EAAEC,YAAY,QAAQ,OAAO;AAChD,SAASC,UAAU,QAAQ,QAAQ;AACnC,SAASC,UAAU,QAAQ,QAAQ;AACnC,SAASC,SAAS,QAAQ,aAAa;AACvC,SAASC,MAAM,QAAQ,UAAU;AACjC,SAASC,UAAU,EAAEC,SAAS,QAAQ,SAAS;AAC/C,OAAOC,SAAS,MAAM,aAAa;AACnC,SAASC,gBAAgB,EAAEC,eAAe,EAAEC,eAAe,QAAQ,QAAQ;;AAE3E;AACA;AACA;AACA,MAAMC,WAAW,GAAG;EAClBV,UAAU;EACVW,IAAI,EAAEX,UAAU;EAChBY,IAAI,EAAEX,UAAU;EAChBA,UAAU;EACVd,YAAY;EACZC,cAAc;EACdC,cAAc;EACdC,gBAAgB;EAChBkB,eAAe;EACfD,gBAAgB;EAChBE,eAAe;EACflB,aAAa;EACbC,aAAa;EACbC,cAAc;EACdG,WAAW;EACXF,eAAe;EACfC,mBAAmB;EACnBE,eAAe;EACfC,UAAU;EACVC,YAAY;EACZI,MAAM;EACND,SAAS;EACT,GAAGjB,MAAM;EACT,GAAGC,MAAM;EACTkB,UAAU;EACVC,SAAS;EACTC;AACF,CAAC;;AAED;AACA;AACA;AACA,OAAO,MAAMO,OAAO,GAAGA,CAAA,KAAM;EAC3B;EACAC,MAAM,CAAC9B,MAAM,GAAGA,MAAM;;EAEtB;EACA8B,MAAM,CAACC,MAAM,GAAGL,WAAW;AAC7B,CAAC;AAED,eAAeA,WAAW;;AAE1B;AACAM,MAAM,CAACC,OAAO,GAAGP,WAAW;AAC5BM,MAAM,CAACC,OAAO,CAACC,OAAO,GAAGR,WAAW;AACpCM,MAAM,CAACC,OAAO,CAACJ,OAAO,GAAGA,OAAO","ignoreList":[]}
+{"version":3,"names":["Buffer","keys","ed","pbkdf2","random","utils","QuickCrypto","install","global","crypto","process","nextTick","setImmediate","module","exports","default"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA;AACA,SAASA,MAAM,QAAQ,gCAAgC;;AAEvD;AACA,OAAO,KAAKC,IAAI,MAAM,QAAQ;AAC9B,OAAO,KAAKC,EAAE,MAAM,MAAM;AAC1B,OAAO,KAAKC,MAAM,MAAM,UAAU;AAClC,OAAO,KAAKC,MAAM,MAAM,UAAU;;AAElC;AACA,OAAO,KAAKC,KAAK,MAAM,SAAS;;AAEhC;AACA;AACA;AACA;AACA,MAAMC,WAAW,GAAG;EAClB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,GAAGL,IAAI;EACP,GAAGC,EAAE;EACL,GAAGC,MAAM;EACT,GAAGC,MAAM;EACT;EACA;EACA;EACA,GAAGC;AACL,CAAC;;AAED;AACA;AACA;AACA;AACA,OAAO,MAAME,OAAO,GAAGA,CAAA,KAAM;EAC3B;EACAC,MAAM,CAACR,MAAM,GAAGA,MAAM;;EAEtB;EACAQ,MAAM,CAACC,MAAM,GAAGH,WAAW;AAC7B,CAAC;;AAED;AACAE,MAAM,CAACE,OAAO,CAACC,QAAQ,GAAGC,YAAY;;AAEtC;AACA,eAAeN,WAAW;AAC1B,cAAc,MAAM;AACpB,cAAc,UAAU;AACxB,cAAc,UAAU;AACxB,cAAc,SAAS;;AAEvB;AACAO,MAAM,CAACC,OAAO,GAAGR,WAAW;AAC5BO,MAAM,CAACC,OAAO,CAACC,OAAO,GAAGT,WAAW;AACpCO,MAAM,CAACC,OAAO,CAACP,OAAO,GAAGA,OAAO","ignoreList":[]}

package/lib/module/keys/classes.js

@@ -0,0 +1,182 @@
+"use strict";
+
+import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+export class CryptoKey {
+  constructor(keyObject, keyAlgorithm, keyUsages, keyExtractable) {
+    this.keyObject = keyObject;
+    this.keyAlgorithm = keyAlgorithm;
+    this.keyUsages = keyUsages;
+    this.keyExtractable = keyExtractable;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  inspect(_depth, _options) {
+    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;
+  }
+}
+export class KeyObject {
+  type = 'unknown';
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export(_options) {
+    return new ArrayBuffer(0);
+  }
+  constructor(type, handle) {
+    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])
+  //   );
+  // }
+}
+export class SecretKeyObject extends KeyObject {
+  constructor(handle) {
+    super('secret', handle);
+  }
+
+  // get symmetricKeySize() {
+  //   return this[kHandle].getSymmetricKeySize();
+  // }
+
+  export(options) {
+    if (options !== undefined) {
+      if (options.format === 'jwk') {
+        throw new Error('SecretKey export for jwk is not implemented');
+        // return this.handle.exportJwk({}, false);
+      }
+    }
+    return this.handle.exportKey();
+  }
+}
+
+// const kAsymmetricKeyType = Symbol('kAsymmetricKeyType');
+// const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails');
+
+// function normalizeKeyDetails(details = {}) {
+//   if (details.publicExponent !== undefined) {
+//     return {
+//       ...details,
+//       publicExponent: bigIntArrayToUnsignedBigInt(
+//         new Uint8Array(details.publicExponent)
+//       ),
+//     };
+//   }
+//   return details;
+// }
+
+export class AsymmetricKeyObject extends KeyObject {
+  constructor(type, handle) {
+    super(type, handle);
+  }
+  get asymmetricKeyType() {
+    if (!this._asymmetricKeyType) {
+      this._asymmetricKeyType = this.handle.getAsymmetricKeyType();
+    }
+    return this._asymmetricKeyType;
+  }
+
+  // get asymmetricKeyDetails() {
+  //   switch (this._asymmetricKeyType) {
+  //     case 'rsa':
+  //     case 'rsa-pss':
+  //     case 'dsa':
+  //     case 'ec':
+  //       return (
+  //         this[kAsymmetricKeyDetails] ||
+  //         (this[kAsymmetricKeyDetails] = normalizeKeyDetails(
+  //           this[kHandle].keyDetail({})
+  //         ))
+  //       );
+  //     default:
+  //       return {};
+  //   }
+  // }
+}
+export class PublicKeyObject extends AsymmetricKeyObject {
+  constructor(handle) {
+    super('public', handle);
+  }
+  export(options) {
+    if (options?.format === 'jwk') {
+      throw new Error('PublicKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const {
+      format,
+      type
+    } = parsePublicKeyEncoding(options, this.asymmetricKeyType);
+    return this.handle.exportKey(format, type);
+  }
+}
+export class PrivateKeyObject extends AsymmetricKeyObject {
+  constructor(handle) {
+    super('private', handle);
+  }
+  export(options) {
+    if (options?.format === 'jwk') {
+      if (options.passphrase !== undefined) {
+        throw new Error('jwk does not support encryption');
+      }
+      throw new Error('PrivateKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const {
+      format,
+      type,
+      cipher,
+      passphrase
+    } = parsePrivateKeyEncoding(options, this.asymmetricKeyType);
+    return this.handle.exportKey(format, type, cipher, passphrase);
+  }
+}
+//# sourceMappingURL=classes.js.map

package/lib/module/keys/classes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["parsePrivateKeyEncoding","parsePublicKeyEncoding","CryptoKey","constructor","keyObject","keyAlgorithm","keyUsages","keyExtractable","inspect","_depth","_options","Error","type","extractable","algorithm","usages","KeyObject","export","ArrayBuffer","handle","SecretKeyObject","options","undefined","format","exportKey","AsymmetricKeyObject","asymmetricKeyType","_asymmetricKeyType","getAsymmetricKeyType","PublicKeyObject","PrivateKeyObject","passphrase","cipher"],"sourceRoot":"../../../src","sources":["keys/classes.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/keys/generateKeyPair.js

@@ -0,0 +1,148 @@
+// import { ed25519 } from '../ed25519';
+// import {
+//   kEmptyObject,
+//   validateFunction,
+//   type CryptoKeyPair,
+//   type GenerateKeyPairCallback,
+//   type GenerateKeyPairOptions,
+//   type GenerateKeyPairPromiseReturn,
+//   type GenerateKeyPairReturn,
+//   type KeyPairGenConfig,
+//   type KeyPairType,
+// } from '../utils';
+// import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+
+// export const generateKeyPair = (
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions,
+//   callback: GenerateKeyPairCallback,
+// ): void => {
+//   validateFunction(callback);
+//   internalGenerateKeyPair(true, type, options, callback);
+// };
+
+// // Promisify generateKeyPair
+// // (attempted to use util.promisify, to no avail)
+// export const generateKeyPairPromise = (
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions,
+// ): Promise<GenerateKeyPairPromiseReturn> => {
+//   return new Promise((resolve, reject) => {
+//     generateKeyPair(type, options, (err, publicKey, privateKey) => {
+//       if (err) {
+//         reject([err, undefined]);
+//       } else {
+//         resolve([undefined, { publicKey, privateKey }]);
+//       }
+//     });
+//   });
+// };
+
+// // generateKeyPairSync
+// export function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;
+// export function generateKeyPairSync(
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions,
+// ): CryptoKeyPair;
+// export function generateKeyPairSync(
+//   type: KeyPairType,
+//   options?: GenerateKeyPairOptions,
+// ): CryptoKeyPair {
+//   const [err, publicKey, privateKey] = internalGenerateKeyPair(
+//     false,
+//     type,
+//     options,
+//     undefined,
+//   )!;
+
+//   if (err) {
+//     throw err;
+//   }
+
+//   return {
+//     publicKey,
+//     privateKey,
+//   };
+// }
+
+// function parseKeyPairEncoding(
+//   keyType: string,
+//   options: GenerateKeyPairOptions = kEmptyObject,
+// ): KeyPairGenConfig {
+//   const { publicKeyEncoding, privateKeyEncoding } = options;
+
+//   let publicFormat, publicType;
+//   if (publicKeyEncoding == null) {
+//     publicFormat = publicType = -1;
+//   } else if (typeof publicKeyEncoding === 'object') {
+//     ({ format: publicFormat, type: publicType } = parsePublicKeyEncoding(
+//       publicKeyEncoding,
+//       keyType,
+//       'publicKeyEncoding',
+//     ));
+//   } else {
+//     throw new Error(
+//       'Invalid argument options.publicKeyEncoding',
+//       publicKeyEncoding,
+//     );
+//   }
+
+//   let privateFormat, privateType, cipher, passphrase;
+//   if (privateKeyEncoding == null) {
+//     privateFormat = privateType = -1;
+//   } else if (typeof privateKeyEncoding === 'object') {
+//     ({
+//       format: privateFormat,
+//       type: privateType,
+//       cipher,
+//       passphrase,
+//     } = parsePrivateKeyEncoding(
+//       privateKeyEncoding,
+//       keyType,
+//       'privateKeyEncoding',
+//     ));
+//   } else {
+//     throw new Error(
+//       'Invalid argument options.privateKeyEncoding',
+//       publicKeyEncoding as ErrorOptions,
+//     );
+//   }
+
+//   return {
+//     publicFormat,
+//     publicType,
+//     privateFormat,
+//     privateType,
+//     cipher,
+//     passphrase,
+//   };
+// }
+
+// function internalGenerateKeyPair(
+//   isAsync: boolean,
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions | undefined,
+//   callback: GenerateKeyPairCallback | undefined,
+// ): GenerateKeyPairReturn | void {
+//   const encoding = parseKeyPairEncoding(type, options);
+
+//   switch (type) {
+//     case 'ed25519':
+//     case 'ed448':
+//     case 'x25519':
+//     case 'x448': {
+//       return ed25519.utils.generateKeyPair(isAsync, type, encoding, callback);
+//     }
+//     default:
+//     // Fall through
+//   }
+
+//   const err = new Error(`
+//     Invalid Argument options: '${type}' scheme not supported for
+//     generateKeyPair(). Currently not all encryption methods are supported in
+//     this library.  Check docs/implementation_coverage.md for status.
+//   `);
+//   return [err, undefined, undefined];
+// }
+"use strict";
+//# sourceMappingURL=generateKeyPair.js.map

package/lib/module/keys/generateKeyPair.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["keys/generateKeyPair.ts"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA","ignoreList":[]}