react-native-quick-crypto 0.2.0 → 0.3.0

package/lib/module/Utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Utils.ts"],"names":["Buffer","defaultEncoding","setDefaultEncoding","encoding","getDefaultEncoding","isBuffer","buf","constructor","name","toArrayBuffer","buffer","slice","byteOffset","byteLength","ab","ArrayBuffer","length","view","Uint8Array","i","binaryLikeToArrayBuffer","input","from","ab2str","toString"],"mappings":"AAAA,SAASA,MAAT,QAAuB,gCAAvB;AAeA;AACA,IAAIC,eAA+B,GAAG,QAAtC;AAEA,OAAO,SAASC,kBAAT,CAA4BC,QAA5B,EAAsD;AAC3DF,EAAAA,eAAe,GAAGE,QAAlB;AACD;AAED,OAAO,SAASC,kBAAT,GAA8C;AACnD,SAAOH,eAAP;AACD,C,CAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;AAEA,OAAO,SAASI,QAAT,CAAkBC,GAAlB,EAA2C;AAAA;;AAChD,SAAOA,GAAG,YAAYN,MAAf,IAAyB,CAAAM,GAAG,SAAH,IAAAA,GAAG,WAAH,gCAAAA,GAAG,CAAEC,WAAL,sEAAkBC,IAAlB,MAA2B,QAA3D;AACD;AAED,OAAO,SAASC,aAAT,CAAuBH,GAAvB,EAAiD;AAAA;;AACtD,MAAIA,GAAJ,aAAIA,GAAJ,8BAAIA,GAAG,CAAEI,MAAT,wCAAI,YAAaC,KAAjB,EAAwB;AACtB,WAAOL,GAAG,CAACI,MAAJ,CAAWC,KAAX,CAAiBL,GAAG,CAACM,UAArB,EAAiCN,GAAG,CAACM,UAAJ,GAAiBN,GAAG,CAACO,UAAtD,CAAP;AACD;;AACD,QAAMC,EAAE,GAAG,IAAIC,WAAJ,CAAgBT,GAAG,CAACU,MAApB,CAAX;AACA,QAAMC,IAAI,GAAG,IAAIC,UAAJ,CAAeJ,EAAf,CAAb;;AACA,OAAK,IAAIK,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGb,GAAG,CAACU,MAAxB,EAAgC,EAAEG,CAAlC,EAAqC;AACnCF,IAAAA,IAAI,CAACE,CAAD,CAAJ,GAAUb,GAAG,CAACa,CAAD,CAAb;AACD;;AACD,SAAOL,EAAP;AACD;AAED,OAAO,SAASM,uBAAT,CACLC,KADK,EAGQ;AAAA,MADblB,QACa,uEADM,OACN;;AACb,MAAI,OAAOkB,KAAP,KAAiB,QAArB,EAA+B;AAC7B,UAAMX,MAAM,GAAGV,MAAM,CAACsB,IAAP,CAAYD,KAAZ,EAAmBlB,QAAnB,CAAf;AAEA,WAAOO,MAAM,CAACA,MAAP,CAAcC,KAAd,CACLD,MAAM,CAACE,UADF,EAELF,MAAM,CAACE,UAAP,GAAoBF,MAAM,CAACG,UAFtB,CAAP;AAID;;AAED,MAAIR,QAAQ,CAACgB,KAAD,CAAZ,EAAqB;AACnB,WAAOZ,aAAa,CAACY,KAAD,CAApB;AACD,GAZY,CAcb;;;AACA,MAAKA,KAAD,CAAeX,MAAnB,EAA2B;AACzB,WAAQW,KAAD,CAAeX,MAAtB;AACD;;AAED,MAAI,EAAEW,KAAK,YAAYN,WAAnB,CAAJ,EAAqC;AACnC,QAAI;AACF,YAAML,MAAM,GAAGV,MAAM,CAACsB,IAAP,CAAYD,KAAZ,CAAf;AACA,aAAOX,MAAM,CAACA,MAAP,CAAcC,KAAd,CACLD,MAAM,CAACE,UADF,EAELF,MAAM,CAACE,UAAP,GAAoBF,MAAM,CAACG,UAFtB,CAAP;AAID,KAND,CAME,MAAM;AACN,YAAM,OAAN;AACD;AACF;;AACD,SAAOQ,KAAP;AACD;AAED,OAAO,SAASE,MAAT,CAAgBjB,GAAhB,EAA4D;AAAA,MAA1BH,QAA0B,uEAAP,KAAO;AACjE,SAAOH,MAAM,CAACsB,IAAP,CAAYhB,GAAZ,EAAiBkB,QAAjB,CAA0BrB,QAA1B,CAAP;AACD","sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\n\nexport type BinaryLike = string | ArrayBuffer | Buffer;\n\nexport type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex' | 'binary';\nexport type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';\nexport type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';\nexport type Encoding =\n  | BinaryToTextEncoding\n  | CharacterEncoding\n  | LegacyCharacterEncoding;\n\n// TODO(osp) should buffer be part of the Encoding type?\nexport type CipherEncoding = Encoding | 'buffer';\n\n// Mimics node behavior for default global encoding\nlet defaultEncoding: CipherEncoding = 'buffer';\n\nexport function setDefaultEncoding(encoding: CipherEncoding) {\n  defaultEncoding = encoding;\n}\n\nexport function getDefaultEncoding(): CipherEncoding {\n  return defaultEncoding;\n}\n\n// function slowCases(enc: string) {\n//   switch (enc.length) {\n//     case 4:\n//       if (enc === 'UTF8') return 'utf8';\n//       if (enc === 'ucs2' || enc === 'UCS2') return 'utf16le';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'utf8') return 'utf8';\n//       if (enc === 'ucs2') return 'utf16le';\n//       break;\n//     case 3:\n//       if (enc === 'hex' || enc === 'HEX' || `${enc}`.toLowerCase() === 'hex')\n//         return 'hex';\n//       break;\n//     case 5:\n//       if (enc === 'ascii') return 'ascii';\n//       if (enc === 'ucs-2') return 'utf16le';\n//       if (enc === 'UTF-8') return 'utf8';\n//       if (enc === 'ASCII') return 'ascii';\n//       if (enc === 'UCS-2') return 'utf16le';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'utf-8') return 'utf8';\n//       if (enc === 'ascii') return 'ascii';\n//       if (enc === 'ucs-2') return 'utf16le';\n//       break;\n//     case 6:\n//       if (enc === 'base64') return 'base64';\n//       if (enc === 'latin1' || enc === 'binary') return 'latin1';\n//       if (enc === 'BASE64') return 'base64';\n//       if (enc === 'LATIN1' || enc === 'BINARY') return 'latin1';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'base64') return 'base64';\n//       if (enc === 'latin1' || enc === 'binary') return 'latin1';\n//       break;\n//     case 7:\n//       if (\n//         enc === 'utf16le' ||\n//         enc === 'UTF16LE' ||\n//         `${enc}`.toLowerCase() === 'utf16le'\n//       )\n//         return 'utf16le';\n//       break;\n//     case 8:\n//       if (\n//         enc === 'utf-16le' ||\n//         enc === 'UTF-16LE' ||\n//         `${enc}`.toLowerCase() === 'utf-16le'\n//       )\n//         return 'utf16le';\n//       break;\n//     case 9:\n//       if (\n//         enc === 'base64url' ||\n//         enc === 'BASE64URL' ||\n//         `${enc}`.toLowerCase() === 'base64url'\n//       )\n//         return 'base64url';\n//       break;\n//     default:\n//       if (enc === '') return 'utf8';\n//   }\n// }\n\n// // Return undefined if there is no match.\n// // Move the \"slow cases\" to a separate function to make sure this function gets\n// // inlined properly. That prioritizes the common case.\n// export function normalizeEncoding(enc?: string) {\n//   if (enc == null || enc === 'utf8' || enc === 'utf-8') return 'utf8';\n//   return slowCases(enc);\n// }\n\nexport function isBuffer(buf: any): buf is Buffer {\n  return buf instanceof Buffer || buf?.constructor?.name === 'Buffer';\n}\n\nexport function toArrayBuffer(buf: Buffer): ArrayBuffer {\n  if (buf?.buffer?.slice) {\n    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);\n  }\n  const ab = new ArrayBuffer(buf.length);\n  const view = new Uint8Array(ab);\n  for (let i = 0; i < buf.length; ++i) {\n    view[i] = buf[i];\n  }\n  return ab;\n}\n\nexport function binaryLikeToArrayBuffer(\n  input: BinaryLike,\n  encoding: string = 'utf-8'\n): ArrayBuffer {\n  if (typeof input === 'string') {\n    const buffer = Buffer.from(input, encoding);\n\n    return buffer.buffer.slice(\n      buffer.byteOffset,\n      buffer.byteOffset + buffer.byteLength\n    );\n  }\n\n  if (isBuffer(input)) {\n    return toArrayBuffer(input);\n  }\n\n  // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property\n  if ((input as any).buffer) {\n    return (input as any).buffer;\n  }\n\n  if (!(input instanceof ArrayBuffer)) {\n    try {\n      const buffer = Buffer.from(input);\n      return buffer.buffer.slice(\n        buffer.byteOffset,\n        buffer.byteOffset + buffer.byteLength\n      );\n    } catch {\n      throw 'error';\n    }\n  }\n  return input;\n}\n\nexport function ab2str(buf: ArrayBuffer, encoding: string = 'hex') {\n  return Buffer.from(buf).toString(encoding);\n}\n"]}
+{"version":3,"sources":["Utils.ts"],"names":["Buffer","defaultEncoding","setDefaultEncoding","encoding","getDefaultEncoding","kEmptyObject","Object","freeze","create","isBuffer","buf","constructor","name","toArrayBuffer","buffer","slice","byteOffset","byteLength","ab","ArrayBuffer","length","view","Uint8Array","i","binaryLikeToArrayBuffer","input","from","ab2str","toString","validateString","str","isString","Error","validateFunction","f","isStringOrBuffer","val","isView","validateObject","value","options","useDefaultOptions","allowArray","allowFunction","nullable","Array","isArray","validateInt32","min","max","Number","isInteger","validateUint32","positive"],"mappings":"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","sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\n\nexport type BinaryLike = string | ArrayBuffer | Buffer;\n\nexport type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex' | 'binary';\nexport type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';\nexport type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';\nexport type Encoding =\n  | BinaryToTextEncoding\n  | CharacterEncoding\n  | LegacyCharacterEncoding;\n\n// TODO(osp) should buffer be part of the Encoding type?\nexport type CipherEncoding = Encoding | 'buffer';\n\n// Mimics node behavior for default global encoding\nlet defaultEncoding: CipherEncoding = 'buffer';\n\nexport function setDefaultEncoding(encoding: CipherEncoding) {\n  defaultEncoding = encoding;\n}\n\nexport function getDefaultEncoding(): CipherEncoding {\n  return defaultEncoding;\n}\n\nexport const kEmptyObject = Object.freeze(Object.create(null));\n\n// Should be used by Cipher (or any other module that requires valid encodings)\n// function slowCases(enc: string) {\n//   switch (enc.length) {\n//     case 4:\n//       if (enc === 'UTF8') return 'utf8';\n//       if (enc === 'ucs2' || enc === 'UCS2') return 'utf16le';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'utf8') return 'utf8';\n//       if (enc === 'ucs2') return 'utf16le';\n//       break;\n//     case 3:\n//       if (enc === 'hex' || enc === 'HEX' || `${enc}`.toLowerCase() === 'hex')\n//         return 'hex';\n//       break;\n//     case 5:\n//       if (enc === 'ascii') return 'ascii';\n//       if (enc === 'ucs-2') return 'utf16le';\n//       if (enc === 'UTF-8') return 'utf8';\n//       if (enc === 'ASCII') return 'ascii';\n//       if (enc === 'UCS-2') return 'utf16le';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'utf-8') return 'utf8';\n//       if (enc === 'ascii') return 'ascii';\n//       if (enc === 'ucs-2') return 'utf16le';\n//       break;\n//     case 6:\n//       if (enc === 'base64') return 'base64';\n//       if (enc === 'latin1' || enc === 'binary') return 'latin1';\n//       if (enc === 'BASE64') return 'base64';\n//       if (enc === 'LATIN1' || enc === 'BINARY') return 'latin1';\n//       enc = `${enc}`.toLowerCase();\n//       if (enc === 'base64') return 'base64';\n//       if (enc === 'latin1' || enc === 'binary') return 'latin1';\n//       break;\n//     case 7:\n//       if (\n//         enc === 'utf16le' ||\n//         enc === 'UTF16LE' ||\n//         `${enc}`.toLowerCase() === 'utf16le'\n//       )\n//         return 'utf16le';\n//       break;\n//     case 8:\n//       if (\n//         enc === 'utf-16le' ||\n//         enc === 'UTF-16LE' ||\n//         `${enc}`.toLowerCase() === 'utf-16le'\n//       )\n//         return 'utf16le';\n//       break;\n//     case 9:\n//       if (\n//         enc === 'base64url' ||\n//         enc === 'BASE64URL' ||\n//         `${enc}`.toLowerCase() === 'base64url'\n//       )\n//         return 'base64url';\n//       break;\n//     default:\n//       if (enc === '') return 'utf8';\n//   }\n// }\n\n// // Return undefined if there is no match.\n// // Move the \"slow cases\" to a separate function to make sure this function gets\n// // inlined properly. That prioritizes the common case.\n// export function normalizeEncoding(enc?: string) {\n//   if (enc == null || enc === 'utf8' || enc === 'utf-8') return 'utf8';\n//   return slowCases(enc);\n// }\n\nexport function isBuffer(buf: any): buf is Buffer {\n  return buf instanceof Buffer || buf?.constructor?.name === 'Buffer';\n}\n\nexport function toArrayBuffer(buf: Buffer): ArrayBuffer {\n  if (buf?.buffer?.slice) {\n    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);\n  }\n  const ab = new ArrayBuffer(buf.length);\n  const view = new Uint8Array(ab);\n  for (let i = 0; i < buf.length; ++i) {\n    view[i] = buf[i];\n  }\n  return ab;\n}\n\nexport function binaryLikeToArrayBuffer(\n  input: BinaryLike,\n  encoding: string = 'utf-8'\n): ArrayBuffer {\n  if (typeof input === 'string') {\n    const buffer = Buffer.from(input, encoding);\n\n    return buffer.buffer.slice(\n      buffer.byteOffset,\n      buffer.byteOffset + buffer.byteLength\n    );\n  }\n\n  if (isBuffer(input)) {\n    return toArrayBuffer(input);\n  }\n\n  // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property\n  if ((input as any).buffer) {\n    return (input as any).buffer;\n  }\n\n  if (!(input instanceof ArrayBuffer)) {\n    try {\n      const buffer = Buffer.from(input);\n      return buffer.buffer.slice(\n        buffer.byteOffset,\n        buffer.byteOffset + buffer.byteLength\n      );\n    } catch {\n      throw 'error';\n    }\n  }\n  return input;\n}\n\nexport function ab2str(buf: ArrayBuffer, encoding: string = 'hex') {\n  return Buffer.from(buf).toString(encoding);\n}\n\nexport function validateString(str: any, name?: string): str is string {\n  const isString = typeof str === 'string';\n  if (isString) {\n    throw new Error(`${name} is not a string`);\n  }\n  return isString;\n}\n\nexport function validateFunction(f: any): f is Function {\n  return f != null && typeof f === 'function';\n}\n\nexport function isStringOrBuffer(val: any): val is string | ArrayBuffer {\n  return typeof val === 'string' || ArrayBuffer.isView(val);\n}\n\nexport function validateObject<T>(\n  value: any,\n  name: string,\n  options?: {\n    allowArray: boolean;\n    allowFunction: boolean;\n    nullable: boolean;\n  } | null\n): value is T {\n  const useDefaultOptions = options == null;\n  const allowArray = useDefaultOptions ? false : options.allowArray;\n  const allowFunction = useDefaultOptions ? false : options.allowFunction;\n  const nullable = useDefaultOptions ? false : options.nullable;\n  if (\n    (!nullable && value === null) ||\n    (!allowArray && Array.isArray(value)) ||\n    (typeof value !== 'object' &&\n      (!allowFunction || typeof value !== 'function'))\n  ) {\n    throw new Error(`${name} is not a valid object $${value}`);\n  }\n  return true;\n}\n\nexport function validateInt32(\n  value: any,\n  name: string,\n  min = -2147483648,\n  max = 2147483647\n) {\n  // The defaults for min and max correspond to the limits of 32-bit integers.\n  if (typeof value !== 'number') {\n    throw new Error(`Invalid argument - ${name} is not a number: ${value}`);\n  }\n  if (!Number.isInteger(value)) {\n    throw new Error(\n      `Argument out of range - ${name} out of integer range: ${value}`\n    );\n  }\n  if (value < min || value > max) {\n    throw new Error(\n      `Invalid argument - ${name} out of range >= ${min} && <= ${max}: ${value}`\n    );\n  }\n}\n\nexport function validateUint32(\n  value: number,\n  name: string,\n  positive?: boolean\n) {\n  if (typeof value !== 'number') {\n    // throw new ERR_INVALID_ARG_TYPE(name, 'number', value);\n    throw new Error(`Invalid argument - ${name} is not a number: ${value}`);\n  }\n  if (!Number.isInteger(value)) {\n    // throw new ERR_OUT_OF_RANGE(name, 'an integer', value);\n    throw new Error(\n      `Argument out of range - ${name} out of integer range: ${value}`\n    );\n  }\n  const min = positive ? 1 : 0;\n  // 2 ** 32 === 4294967296\n  const max = 4_294_967_295;\n  if (value < min || value > max) {\n    // throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);\n    throw new Error(\n      `Invalid argument - ${name} out of range >= ${min} && <= ${max}: ${value}`\n    );\n  }\n}\n"]}

package/lib/module/constants.js

@@ -0,0 +1,79 @@
+// Taken by printing node.crypto.constants
+// Node declares them as enums on v8 directly
+// Whenever the API gets updated (or some dependency like OpenSSL) I guess we will have to revisit these
+export const constants = {
+  OPENSSL_VERSION_NUMBER: 269488367,
+  SSL_OP_ALL: 2147485780,
+  SSL_OP_ALLOW_NO_DHE_KEX: 1024,
+  SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144,
+  SSL_OP_CIPHER_SERVER_PREFERENCE: 4194304,
+  SSL_OP_CISCO_ANYCONNECT: 32768,
+  SSL_OP_COOKIE_EXCHANGE: 8192,
+  SSL_OP_CRYPTOPRO_TLSEXT_BUG: 2147483648,
+  SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: 2048,
+  SSL_OP_EPHEMERAL_RSA: 0,
+  SSL_OP_LEGACY_SERVER_CONNECT: 4,
+  SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: 0,
+  SSL_OP_MICROSOFT_SESS_ID_BUG: 0,
+  SSL_OP_MSIE_SSLV2_RSA_PADDING: 0,
+  SSL_OP_NETSCAPE_CA_DN_BUG: 0,
+  SSL_OP_NETSCAPE_CHALLENGE_BUG: 0,
+  SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: 0,
+  SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: 0,
+  SSL_OP_NO_COMPRESSION: 131072,
+  SSL_OP_NO_ENCRYPT_THEN_MAC: 524288,
+  SSL_OP_NO_QUERY_MTU: 4096,
+  SSL_OP_NO_RENEGOTIATION: 1073741824,
+  SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: 65536,
+  SSL_OP_NO_SSLv2: 0,
+  SSL_OP_NO_SSLv3: 33554432,
+  SSL_OP_NO_TICKET: 16384,
+  SSL_OP_NO_TLSv1: 67108864,
+  SSL_OP_NO_TLSv1_1: 268435456,
+  SSL_OP_NO_TLSv1_2: 134217728,
+  SSL_OP_NO_TLSv1_3: 536870912,
+  SSL_OP_PKCS1_CHECK_1: 0,
+  SSL_OP_PKCS1_CHECK_2: 0,
+  SSL_OP_PRIORITIZE_CHACHA: 2097152,
+  SSL_OP_SINGLE_DH_USE: 0,
+  SSL_OP_SINGLE_ECDH_USE: 0,
+  SSL_OP_SSLEAY_080_CLIENT_DH_BUG: 0,
+  SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: 0,
+  SSL_OP_TLS_BLOCK_PADDING_BUG: 0,
+  SSL_OP_TLS_D5_BUG: 0,
+  SSL_OP_TLS_ROLLBACK_BUG: 8388608,
+  ENGINE_METHOD_RSA: 1,
+  ENGINE_METHOD_DSA: 2,
+  ENGINE_METHOD_DH: 4,
+  ENGINE_METHOD_RAND: 8,
+  ENGINE_METHOD_EC: 2048,
+  ENGINE_METHOD_CIPHERS: 64,
+  ENGINE_METHOD_DIGESTS: 128,
+  ENGINE_METHOD_PKEY_METHS: 512,
+  ENGINE_METHOD_PKEY_ASN1_METHS: 1024,
+  ENGINE_METHOD_ALL: 65535,
+  ENGINE_METHOD_NONE: 0,
+  DH_CHECK_P_NOT_SAFE_PRIME: 2,
+  DH_CHECK_P_NOT_PRIME: 1,
+  DH_UNABLE_TO_CHECK_GENERATOR: 4,
+  DH_NOT_SUITABLE_GENERATOR: 8,
+  ALPN_ENABLED: 1,
+  RSA_PKCS1_PADDING: 1,
+  RSA_SSLV23_PADDING: 2,
+  RSA_NO_PADDING: 3,
+  RSA_PKCS1_OAEP_PADDING: 4,
+  RSA_X931_PADDING: 5,
+  RSA_PKCS1_PSS_PADDING: 6,
+  RSA_PSS_SALTLEN_DIGEST: -1,
+  RSA_PSS_SALTLEN_MAX_SIGN: -2,
+  RSA_PSS_SALTLEN_AUTO: -2,
+  defaultCoreCipherList: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',
+  TLS1_VERSION: 769,
+  TLS1_1_VERSION: 770,
+  TLS1_2_VERSION: 771,
+  TLS1_3_VERSION: 772,
+  POINT_CONVERSION_COMPRESSED: 2,
+  POINT_CONVERSION_UNCOMPRESSED: 4,
+  POINT_CONVERSION_HYBRID: 6
+};
+//# sourceMappingURL=constants.js.map

package/lib/module/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["constants.ts"],"names":["constants","OPENSSL_VERSION_NUMBER","SSL_OP_ALL","SSL_OP_ALLOW_NO_DHE_KEX","SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION","SSL_OP_CIPHER_SERVER_PREFERENCE","SSL_OP_CISCO_ANYCONNECT","SSL_OP_COOKIE_EXCHANGE","SSL_OP_CRYPTOPRO_TLSEXT_BUG","SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS","SSL_OP_EPHEMERAL_RSA","SSL_OP_LEGACY_SERVER_CONNECT","SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER","SSL_OP_MICROSOFT_SESS_ID_BUG","SSL_OP_MSIE_SSLV2_RSA_PADDING","SSL_OP_NETSCAPE_CA_DN_BUG","SSL_OP_NETSCAPE_CHALLENGE_BUG","SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG","SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG","SSL_OP_NO_COMPRESSION","SSL_OP_NO_ENCRYPT_THEN_MAC","SSL_OP_NO_QUERY_MTU","SSL_OP_NO_RENEGOTIATION","SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION","SSL_OP_NO_SSLv2","SSL_OP_NO_SSLv3","SSL_OP_NO_TICKET","SSL_OP_NO_TLSv1","SSL_OP_NO_TLSv1_1","SSL_OP_NO_TLSv1_2","SSL_OP_NO_TLSv1_3","SSL_OP_PKCS1_CHECK_1","SSL_OP_PKCS1_CHECK_2","SSL_OP_PRIORITIZE_CHACHA","SSL_OP_SINGLE_DH_USE","SSL_OP_SINGLE_ECDH_USE","SSL_OP_SSLEAY_080_CLIENT_DH_BUG","SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG","SSL_OP_TLS_BLOCK_PADDING_BUG","SSL_OP_TLS_D5_BUG","SSL_OP_TLS_ROLLBACK_BUG","ENGINE_METHOD_RSA","ENGINE_METHOD_DSA","ENGINE_METHOD_DH","ENGINE_METHOD_RAND","ENGINE_METHOD_EC","ENGINE_METHOD_CIPHERS","ENGINE_METHOD_DIGESTS","ENGINE_METHOD_PKEY_METHS","ENGINE_METHOD_PKEY_ASN1_METHS","ENGINE_METHOD_ALL","ENGINE_METHOD_NONE","DH_CHECK_P_NOT_SAFE_PRIME","DH_CHECK_P_NOT_PRIME","DH_UNABLE_TO_CHECK_GENERATOR","DH_NOT_SUITABLE_GENERATOR","ALPN_ENABLED","RSA_PKCS1_PADDING","RSA_SSLV23_PADDING","RSA_NO_PADDING","RSA_PKCS1_OAEP_PADDING","RSA_X931_PADDING","RSA_PKCS1_PSS_PADDING","RSA_PSS_SALTLEN_DIGEST","RSA_PSS_SALTLEN_MAX_SIGN","RSA_PSS_SALTLEN_AUTO","defaultCoreCipherList","TLS1_VERSION","TLS1_1_VERSION","TLS1_2_VERSION","TLS1_3_VERSION","POINT_CONVERSION_COMPRESSED","POINT_CONVERSION_UNCOMPRESSED","POINT_CONVERSION_HYBRID"],"mappings":"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","sourcesContent":["// Taken by printing node.crypto.constants\n// Node declares them as enums on v8 directly\n// Whenever the API gets updated (or some dependency like OpenSSL) I guess we will have to revisit these\nexport const constants = {\n  OPENSSL_VERSION_NUMBER: 269488367,\n  SSL_OP_ALL: 2147485780,\n  SSL_OP_ALLOW_NO_DHE_KEX: 1024,\n  SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: 262144,\n  SSL_OP_CIPHER_SERVER_PREFERENCE: 4194304,\n  SSL_OP_CISCO_ANYCONNECT: 32768,\n  SSL_OP_COOKIE_EXCHANGE: 8192,\n  SSL_OP_CRYPTOPRO_TLSEXT_BUG: 2147483648,\n  SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: 2048,\n  SSL_OP_EPHEMERAL_RSA: 0,\n  SSL_OP_LEGACY_SERVER_CONNECT: 4,\n  SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: 0,\n  SSL_OP_MICROSOFT_SESS_ID_BUG: 0,\n  SSL_OP_MSIE_SSLV2_RSA_PADDING: 0,\n  SSL_OP_NETSCAPE_CA_DN_BUG: 0,\n  SSL_OP_NETSCAPE_CHALLENGE_BUG: 0,\n  SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: 0,\n  SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: 0,\n  SSL_OP_NO_COMPRESSION: 131072,\n  SSL_OP_NO_ENCRYPT_THEN_MAC: 524288,\n  SSL_OP_NO_QUERY_MTU: 4096,\n  SSL_OP_NO_RENEGOTIATION: 1073741824,\n  SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: 65536,\n  SSL_OP_NO_SSLv2: 0,\n  SSL_OP_NO_SSLv3: 33554432,\n  SSL_OP_NO_TICKET: 16384,\n  SSL_OP_NO_TLSv1: 67108864,\n  SSL_OP_NO_TLSv1_1: 268435456,\n  SSL_OP_NO_TLSv1_2: 134217728,\n  SSL_OP_NO_TLSv1_3: 536870912,\n  SSL_OP_PKCS1_CHECK_1: 0,\n  SSL_OP_PKCS1_CHECK_2: 0,\n  SSL_OP_PRIORITIZE_CHACHA: 2097152,\n  SSL_OP_SINGLE_DH_USE: 0,\n  SSL_OP_SINGLE_ECDH_USE: 0,\n  SSL_OP_SSLEAY_080_CLIENT_DH_BUG: 0,\n  SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: 0,\n  SSL_OP_TLS_BLOCK_PADDING_BUG: 0,\n  SSL_OP_TLS_D5_BUG: 0,\n  SSL_OP_TLS_ROLLBACK_BUG: 8388608,\n  ENGINE_METHOD_RSA: 1,\n  ENGINE_METHOD_DSA: 2,\n  ENGINE_METHOD_DH: 4,\n  ENGINE_METHOD_RAND: 8,\n  ENGINE_METHOD_EC: 2048,\n  ENGINE_METHOD_CIPHERS: 64,\n  ENGINE_METHOD_DIGESTS: 128,\n  ENGINE_METHOD_PKEY_METHS: 512,\n  ENGINE_METHOD_PKEY_ASN1_METHS: 1024,\n  ENGINE_METHOD_ALL: 65535,\n  ENGINE_METHOD_NONE: 0,\n  DH_CHECK_P_NOT_SAFE_PRIME: 2,\n  DH_CHECK_P_NOT_PRIME: 1,\n  DH_UNABLE_TO_CHECK_GENERATOR: 4,\n  DH_NOT_SUITABLE_GENERATOR: 8,\n  ALPN_ENABLED: 1,\n  RSA_PKCS1_PADDING: 1,\n  RSA_SSLV23_PADDING: 2,\n  RSA_NO_PADDING: 3,\n  RSA_PKCS1_OAEP_PADDING: 4,\n  RSA_X931_PADDING: 5,\n  RSA_PKCS1_PSS_PADDING: 6,\n  RSA_PSS_SALTLEN_DIGEST: -1,\n  RSA_PSS_SALTLEN_MAX_SIGN: -2,\n  RSA_PSS_SALTLEN_AUTO: -2,\n  defaultCoreCipherList:\n    'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA256:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!SRP:!CAMELLIA',\n  TLS1_VERSION: 769,\n  TLS1_1_VERSION: 770,\n  TLS1_2_VERSION: 771,\n  TLS1_3_VERSION: 772,\n  POINT_CONVERSION_COMPRESSED: 2,\n  POINT_CONVERSION_UNCOMPRESSED: 4,\n  POINT_CONVERSION_HYBRID: 6,\n};\n"]}

package/lib/module/index.js

@@ -1,2 +1,4 @@
+import { QuickCrypto } from './QuickCrypto';
 export * from './QuickCrypto';
+export default QuickCrypto;
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAd","sourcesContent":["export * from './QuickCrypto';\n"]}
+{"version":3,"sources":["index.ts"],"names":["QuickCrypto"],"mappings":"AAAA,SAASA,WAAT,QAA4B,eAA5B;AAEA,cAAc,eAAd;AAEA,eAAeA,WAAf","sourcesContent":["import { QuickCrypto } from './QuickCrypto';\n\nexport * from './QuickCrypto';\n\nexport default QuickCrypto;\n"]}

package/lib/module/keys.js

@@ -0,0 +1,193 @@
+import { binaryLikeToArrayBuffer, isStringOrBuffer } from './Utils'; // 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
+
+var KFormatType;
+
+(function (KFormatType) {
+  KFormatType[KFormatType["kKeyFormatDER"] = 0] = "kKeyFormatDER";
+  KFormatType[KFormatType["kKeyFormatPEM"] = 1] = "kKeyFormatPEM";
+  KFormatType[KFormatType["kKeyFormatJWK"] = 2] = "kKeyFormatJWK";
+})(KFormatType || (KFormatType = {}));
+
+var KeyInputContext;
+
+(function (KeyInputContext) {
+  KeyInputContext[KeyInputContext["kConsumePublic"] = 0] = "kConsumePublic";
+  KeyInputContext[KeyInputContext["kConsumePrivate"] = 1] = "kConsumePrivate";
+  KeyInputContext[KeyInputContext["kCreatePublic"] = 2] = "kCreatePublic";
+  KeyInputContext[KeyInputContext["kCreatePrivate"] = 3] = "kCreatePrivate";
+})(KeyInputContext || (KeyInputContext = {}));
+
+var KeyEncoding;
+
+(function (KeyEncoding) {
+  KeyEncoding[KeyEncoding["kKeyEncodingPKCS1"] = 0] = "kKeyEncodingPKCS1";
+  KeyEncoding[KeyEncoding["kKeyEncodingPKCS8"] = 1] = "kKeyEncodingPKCS8";
+  KeyEncoding[KeyEncoding["kKeyEncodingSPKI"] = 2] = "kKeyEncodingSPKI";
+  KeyEncoding[KeyEncoding["kKeyEncodingSEC1"] = 3] = "kKeyEncodingSEC1";
+})(KeyEncoding || (KeyEncoding = {}));
+
+const encodingNames = {
+  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',
+  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',
+  [KeyEncoding.kKeyEncodingSPKI]: 'spki',
+  [KeyEncoding.kKeyEncodingSEC1]: 'sec1'
+};
+
+function option(name, objName) {
+  return objName === undefined ? `options.${name}` : `options.${objName}.${name}`;
+}
+
+function parseKeyFormat(formatStr, defaultFormat, optionName) {
+  if (formatStr === undefined && defaultFormat !== undefined) return defaultFormat;else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;else if (formatStr === 'der') return KFormatType.kKeyFormatDER;else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;
+  throw new Error(`Invalid key format str: ${optionName}`); // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);
+}
+
+function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
+  if (typeStr === undefined && !required) {
+    return undefined;
+  } else if (typeStr === 'pkcs1') {
+    if (keyType !== undefined && keyType !== 'rsa') {
+      throw new Error(`Crypto incompatible key options: ${typeStr} can only be used for RSA keys`); // throw new ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(
+      //   typeStr,
+      //   'can only be used for RSA keys'
+      // );
+    }
+
+    return KeyEncoding.kKeyEncodingPKCS1;
+  } else if (typeStr === 'spki' && isPublic !== false) {
+    return KeyEncoding.kKeyEncodingSPKI;
+  } else if (typeStr === 'pkcs8' && isPublic !== true) {
+    return KeyEncoding.kKeyEncodingPKCS8;
+  } else if (typeStr === 'sec1' && isPublic !== true) {
+    if (keyType !== undefined && keyType !== 'ec') {
+      throw new Error(`Incompatible key options ${typeStr} can only be used for EC keys`);
+    }
+
+    return KeyEncoding.kKeyEncodingSEC1;
+  }
+
+  throw new Error(`Invalid option ${optionName} - ${typeStr}`);
+}
+
+function parseKeyFormatAndType(enc, keyType, isPublic, objName) {
+  const {
+    format: formatStr,
+    type: typeStr
+  } = enc;
+  const isInput = keyType === undefined;
+  const format = parseKeyFormat(formatStr, isInput ? KFormatType.kKeyFormatPEM : undefined, option('format', objName));
+  const isRequired = (!isInput || format === KFormatType.kKeyFormatDER) && format !== KFormatType.kKeyFormatJWK;
+  const type = parseKeyType(typeStr, isRequired, keyType, isPublic, option('type', objName));
+  return {
+    format,
+    type
+  };
+}
+
+function parseKeyEncoding(enc, keyType, isPublic, objName) {
+  // validateObject(enc, 'options');
+  const isInput = keyType === undefined;
+  const {
+    format,
+    type
+  } = parseKeyFormatAndType(enc, keyType, isPublic, objName);
+  let cipher, passphrase, encoding;
+
+  if (isPublic !== true) {
+    ({
+      cipher,
+      passphrase,
+      encoding
+    } = enc);
+
+    if (!isInput) {
+      if (cipher != null) {
+        if (typeof cipher !== 'string') throw new Error(`Invalid argument ${option('cipher', objName)}: ${cipher}`);
+
+        if (format === KFormatType.kKeyFormatDER && (type === KeyEncoding.kKeyEncodingPKCS1 || type === KeyEncoding.kKeyEncodingSEC1)) {
+          throw new Error(`Incompatible key options ${encodingNames[type]} does not support encryption`);
+        }
+      } else if (passphrase !== undefined) {
+        throw new Error(`invalid argument ${option('cipher', objName)}: ${cipher}`);
+      }
+    }
+
+    if (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase) || !isInput && cipher != null && !isStringOrBuffer(passphrase)) {
+      throw new Error(`Invalid argument value ${option('passphrase', objName)}: ${passphrase}`);
+    }
+  }
+
+  if (passphrase !== undefined) passphrase = binaryLikeToArrayBuffer(passphrase, encoding);
+  return {
+    format,
+    type,
+    cipher,
+    passphrase
+  };
+}
+
+function prepareAsymmetricKey(key, ctx) {
+  // TODO(osp) check, KeyObject some node object
+  // if (isKeyObject(key)) {
+  //   // Best case: A key object, as simple as that.
+  //   return { data: getKeyObjectHandle(key, ctx) };
+  // } else
+  // if (isCryptoKey(key)) {
+  //   return { data: getKeyObjectHandle(key[kKeyObject], ctx) };
+  // } else
+  if (isStringOrBuffer(key)) {
+    // Expect PEM by default, mostly for backward compatibility.
+    return {
+      format: KFormatType.kKeyFormatPEM,
+      data: binaryLikeToArrayBuffer(key)
+    };
+  } else if (typeof key === 'object') {
+    const {
+      key: data,
+      encoding // format
+
+    } = key; // // The 'key' property can be a KeyObject as well to allow specifying
+    // // additional options such as padding along with the key.
+    // if (isKeyObject(data)) return { data: getKeyObjectHandle(data, ctx) };
+    // else if (isCryptoKey(data))
+    //   return { data: getKeyObjectHandle(data[kKeyObject], ctx) };
+    // else if (isJwk(data) && format === 'jwk')
+    //   return { data: getKeyObjectHandleFromJwk(data, ctx), format: 'jwk' };
+    // Either PEM or DER using PKCS#1 or SPKI.
+
+    if (!isStringOrBuffer(data)) {
+      throw new Error('prepareAsymmetricKey: key is not a string or ArrayBuffer');
+    }
+
+    const isPublic = ctx === KeyInputContext.kConsumePrivate || ctx === KeyInputContext.kCreatePrivate ? false : undefined;
+    return {
+      data: binaryLikeToArrayBuffer(data, encoding),
+      ...parseKeyEncoding(key, undefined, isPublic)
+    };
+  }
+
+  throw new Error('[prepareAsymetricKey] Invalid argument key: ${key}');
+} // TODO(osp) any here is a node KeyObject
+
+
+export function preparePrivateKey(key) {
+  return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);
+} // TODO(osp) any here is a node KeyObject
+
+export function preparePublicOrPrivateKey(key) {
+  return prepareAsymmetricKey(key, KeyInputContext.kConsumePublic);
+} // Parses the public key encoding based on an object. keyType must be undefined
+// when this is used to parse an input encoding and must be a valid key type if
+// used to parse an output encoding.
+
+export function parsePublicKeyEncoding(enc, keyType, objName) {
+  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);
+} // Parses the private key encoding based on an object. keyType must be undefined
+// when this is used to parse an input encoding and must be a valid key type if
+// used to parse an output encoding.
+
+export function parsePrivateKeyEncoding(enc, keyType, objName) {
+  return parseKeyEncoding(enc, keyType, false, objName);
+}
+//# sourceMappingURL=keys.js.map

package/lib/module/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["keys.ts"],"names":["binaryLikeToArrayBuffer","isStringOrBuffer","KFormatType","KeyInputContext","KeyEncoding","encodingNames","kKeyEncodingPKCS1","kKeyEncodingPKCS8","kKeyEncodingSPKI","kKeyEncodingSEC1","option","name","objName","undefined","parseKeyFormat","formatStr","defaultFormat","optionName","kKeyFormatPEM","kKeyFormatDER","kKeyFormatJWK","Error","parseKeyType","typeStr","required","keyType","isPublic","parseKeyFormatAndType","enc","format","type","isInput","isRequired","parseKeyEncoding","cipher","passphrase","encoding","prepareAsymmetricKey","key","ctx","data","kConsumePrivate","kCreatePrivate","preparePrivateKey","preparePublicOrPrivateKey","kConsumePublic","parsePublicKeyEncoding","parsePrivateKeyEncoding"],"mappings":"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","sourcesContent":["import { BinaryLike, binaryLikeToArrayBuffer, isStringOrBuffer } from './Utils';\n\n// On node this value is defined on the native side, for now I'm just creating it here in JS\n// TODO(osp) move this into native side to make sure they always match\nenum KFormatType {\n  kKeyFormatDER,\n  kKeyFormatPEM,\n  kKeyFormatJWK,\n}\n\nenum KeyInputContext {\n  kConsumePublic,\n  kConsumePrivate,\n  kCreatePublic,\n  kCreatePrivate,\n}\n\nenum KeyEncoding {\n  kKeyEncodingPKCS1,\n  kKeyEncodingPKCS8,\n  kKeyEncodingSPKI,\n  kKeyEncodingSEC1,\n}\n\nconst encodingNames = {\n  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',\n  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',\n  [KeyEncoding.kKeyEncodingSPKI]: 'spki',\n  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',\n};\n\nfunction option(name: string, objName: string | undefined) {\n  return objName === undefined\n    ? `options.${name}`\n    : `options.${objName}.${name}`;\n}\n\nfunction parseKeyFormat(\n  formatStr: string,\n  defaultFormat: KFormatType | undefined,\n  optionName?: string\n) {\n  if (formatStr === undefined && defaultFormat !== undefined)\n    return defaultFormat;\n  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;\n  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;\n  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;\n  throw new Error(`Invalid key format str: ${optionName}`);\n  // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);\n}\n\nfunction parseKeyType(\n  typeStr: string,\n  required: boolean,\n  keyType: string,\n  isPublic: boolean,\n  optionName: string\n) {\n  if (typeStr === undefined && !required) {\n    return undefined;\n  } else if (typeStr === 'pkcs1') {\n    if (keyType !== undefined && keyType !== 'rsa') {\n      throw new Error(\n        `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`\n      );\n      // throw new ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(\n      //   typeStr,\n      //   'can only be used for RSA keys'\n      // );\n    }\n    return KeyEncoding.kKeyEncodingPKCS1;\n  } else if (typeStr === 'spki' && isPublic !== false) {\n    return KeyEncoding.kKeyEncodingSPKI;\n  } else if (typeStr === 'pkcs8' && isPublic !== true) {\n    return KeyEncoding.kKeyEncodingPKCS8;\n  } else if (typeStr === 'sec1' && isPublic !== true) {\n    if (keyType !== undefined && keyType !== 'ec') {\n      throw new Error(\n        `Incompatible key options ${typeStr} can only be used for EC keys`\n      );\n    }\n    return KeyEncoding.kKeyEncodingSEC1;\n  }\n\n  throw new Error(`Invalid option ${optionName} - ${typeStr}`);\n}\n\nfunction parseKeyFormatAndType(\n  enc: any,\n  keyType: any,\n  isPublic: any,\n  objName: any\n) {\n  const { format: formatStr, type: typeStr } = enc;\n\n  const isInput = keyType === undefined;\n  const format = parseKeyFormat(\n    formatStr,\n    isInput ? KFormatType.kKeyFormatPEM : undefined,\n    option('format', objName)\n  );\n\n  const isRequired =\n    (!isInput || format === KFormatType.kKeyFormatDER) &&\n    format !== KFormatType.kKeyFormatJWK;\n  const type = parseKeyType(\n    typeStr,\n    isRequired,\n    keyType,\n    isPublic,\n    option('type', objName)\n  );\n  return { format, type };\n}\n\nfunction parseKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  objName?: string\n) {\n  // validateObject(enc, 'options');\n\n  const isInput = keyType === undefined;\n\n  const { format, type } = parseKeyFormatAndType(\n    enc,\n    keyType,\n    isPublic,\n    objName\n  );\n\n  let cipher, passphrase, encoding;\n  if (isPublic !== true) {\n    ({ cipher, passphrase, encoding } = enc);\n\n    if (!isInput) {\n      if (cipher != null) {\n        if (typeof cipher !== 'string')\n          throw new Error(\n            `Invalid argument ${option('cipher', objName)}: ${cipher}`\n          );\n        if (\n          format === KFormatType.kKeyFormatDER &&\n          (type === KeyEncoding.kKeyEncodingPKCS1 ||\n            type === KeyEncoding.kKeyEncodingSEC1)\n        ) {\n          throw new Error(\n            `Incompatible key options ${encodingNames[type]} does not support encryption`\n          );\n        }\n      } else if (passphrase !== undefined) {\n        throw new Error(\n          `invalid argument ${option('cipher', objName)}: ${cipher}`\n        );\n      }\n    }\n\n    if (\n      (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) ||\n      (!isInput && cipher != null && !isStringOrBuffer(passphrase))\n    ) {\n      throw new Error(\n        `Invalid argument value ${option('passphrase', objName)}: ${passphrase}`\n      );\n    }\n  }\n\n  if (passphrase !== undefined)\n    passphrase = binaryLikeToArrayBuffer(passphrase, encoding);\n\n  return { format, type, cipher, passphrase };\n}\n\nfunction prepareAsymmetricKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; passphrase?: string },\n  ctx: KeyInputContext\n): {\n  format: KFormatType;\n  data: ArrayBuffer;\n  type?: any;\n  passphrase?: any;\n} {\n  // TODO(osp) check, KeyObject some node object\n  // if (isKeyObject(key)) {\n  //   // Best case: A key object, as simple as that.\n  //   return { data: getKeyObjectHandle(key, ctx) };\n  // } else\n  // if (isCryptoKey(key)) {\n  //   return { data: getKeyObjectHandle(key[kKeyObject], ctx) };\n  // } else\n  if (isStringOrBuffer(key)) {\n    // Expect PEM by default, mostly for backward compatibility.\n    return {\n      format: KFormatType.kKeyFormatPEM,\n      data: binaryLikeToArrayBuffer(key),\n    };\n  } else if (typeof key === 'object') {\n    const {\n      key: data,\n      encoding,\n      // format\n    } = key;\n    // // The 'key' property can be a KeyObject as well to allow specifying\n    // // additional options such as padding along with the key.\n    // if (isKeyObject(data)) return { data: getKeyObjectHandle(data, ctx) };\n    // else if (isCryptoKey(data))\n    //   return { data: getKeyObjectHandle(data[kKeyObject], ctx) };\n    // else if (isJwk(data) && format === 'jwk')\n    //   return { data: getKeyObjectHandleFromJwk(data, ctx), format: 'jwk' };\n    // Either PEM or DER using PKCS#1 or SPKI.\n    if (!isStringOrBuffer(data)) {\n      throw new Error(\n        'prepareAsymmetricKey: key is not a string or ArrayBuffer'\n      );\n    }\n\n    const isPublic =\n      ctx === KeyInputContext.kConsumePrivate ||\n      ctx === KeyInputContext.kCreatePrivate\n        ? false\n        : undefined;\n\n    return {\n      data: binaryLikeToArrayBuffer(data, encoding),\n      ...parseKeyEncoding(key, undefined, isPublic),\n    };\n  }\n\n  throw new Error('[prepareAsymetricKey] Invalid argument key: ${key}');\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePrivateKey(\n  key:\n    | BinaryLike\n    | {\n        key: any;\n        encoding?: string;\n        format?: any;\n        padding?: number;\n        passphrase?: string;\n      }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePublicOrPrivateKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; padding?: number }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePublic);\n}\n\n// Parses the public key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePublicKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);\n}\n\n// Parses the private key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePrivateKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, false, objName);\n}\n"]}

package/lib/typescript/Cipher.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import Stream from 'stream';
 import { BinaryLike, CipherEncoding, Encoding } from './Utils';
-import type { Buffer } from '@craftzdog/react-native-buffer';
+import { Buffer } from '@craftzdog/react-native-buffer';
 declare class CipherCommon extends Stream.Transform {
     private internal;
     private decoder;
@@ -27,4 +28,60 @@ export declare function createDecipher(algorithm: string, password: BinaryLike,
 export declare function createDecipheriv(algorithm: string, key: BinaryLike, iv: BinaryLike | null, options?: Stream.TransformOptions): Decipher;
 export declare function createCipher(algorithm: string, password: BinaryLike, options?: Stream.TransformOptions): Cipher;
 export declare function createCipheriv(algorithm: string, key: BinaryLike, iv: BinaryLike | null, options?: Stream.TransformOptions): Cipher;
+export declare const publicEncrypt: (options: {
+    key: any;
+    encoding?: string;
+    format?: any;
+    padding?: any;
+    oaepHash?: any;
+    oaepLabel?: any;
+    passphrase?: string;
+}, buffer: BinaryLike) => Buffer;
+export declare const publicDecrypt: (options: {
+    key: any;
+    encoding?: string;
+    format?: any;
+    padding?: any;
+    oaepHash?: any;
+    oaepLabel?: any;
+    passphrase?: string;
+}, buffer: BinaryLike) => Buffer;
+export declare const privateDecrypt: (options: {
+    key: any;
+    encoding?: string;
+    format?: any;
+    padding?: any;
+    oaepHash?: any;
+    oaepLabel?: any;
+    passphrase?: string;
+}, buffer: BinaryLike) => Buffer;
+declare type GenerateKeyPairOptions = {
+    modulusLength: number;
+    publicExponent?: number;
+    hashAlgorithm?: string;
+    mgf1HashAlgorithm?: string;
+    saltLength?: number;
+    divisorLength?: number;
+    namedCurve?: string;
+    prime?: Buffer;
+    primeLength?: number;
+    generator?: number;
+    groupName?: string;
+    publicKeyEncoding?: any;
+    privateKeyEncoding?: any;
+    paramEncoding?: string;
+    hash?: any;
+    mgf1Hash?: any;
+};
+declare type GenerateKeyPairCallback = (error: unknown | null, publicKey?: Buffer, privateKey?: Buffer) => void;
+export declare function generateKeyPair(type: string, callback: GenerateKeyPairCallback): void;
+export declare function generateKeyPair(type: string, options: GenerateKeyPairOptions, callback: GenerateKeyPairCallback): void;
+export declare function generateKeyPairSync(type: string): {
+    publicKey: any;
+    privateKey: any;
+};
+export declare function generateKeyPairSync(type: string, options: GenerateKeyPairOptions): {
+    publicKey: any;
+    privateKey: any;
+};
 export {};

package/lib/typescript/NativeQuickCrypto/Cipher.d.ts

@@ -1,4 +1,10 @@
 import type { BinaryLike } from 'src/Utils';
+import type { Buffer } from '@craftzdog/react-native-buffer';
+export declare enum RSAKeyVariant {
+    kKeyVariantRSA_SSA_PKCS1_v1_5 = 0,
+    kKeyVariantRSA_PSS = 1,
+    kKeyVariantRSA_OAEP = 2
+}
 export declare type InternalCipher = {
     update: (data: BinaryLike | ArrayBufferView) => ArrayBuffer;
     final: () => ArrayBuffer;
@@ -20,3 +26,7 @@ export declare type CreateDecipherMethod = (params: {
     cipher_key: ArrayBuffer;
     auth_tag_len: number;
 }) => InternalCipher;
+export declare type PublicEncryptMethod = (data: ArrayBuffer, format: number, type: any, passphrase: any, buffer: ArrayBuffer, padding: number, oaepHash: any, oaepLabel: any) => Buffer;
+export declare type PrivateDecryptMethod = (data: ArrayBuffer, format: number, type: any, passphrase: any, buffer: ArrayBuffer, padding: number, oaepHash: any, oaepLabel: any) => Buffer;
+export declare type GenerateKeyPairMethod = (keyVariant: RSAKeyVariant, modulusLength: number, publicExponent: number, ...rest: any[]) => Promise<[error: unknown, publicBuffer: any, privateBuffer: any]>;
+export declare type GenerateKeyPairSyncMethod = (keyVariant: RSAKeyVariant, modulusLength: number, publicExponent: number, ...rest: any[]) => [error: unknown, publicBuffer: any, privateBuffer: any];

package/lib/typescript/NativeQuickCrypto/NativeQuickCrypto.d.ts

@@ -2,7 +2,7 @@ import type { CreateHmacMethod } from './hmac';
 import type { CreateHashMethod } from './hash';
 import type { Pbkdf2Object } from './pbkdf2';
 import type { RandomObject } from './random';
-import type { CreateCipherMethod, CreateDecipherMethod } from './Cipher';
+import type { CreateCipherMethod, CreateDecipherMethod, PublicEncryptMethod, PrivateDecryptMethod, GenerateKeyPairMethod, GenerateKeyPairSyncMethod } from './Cipher';
 interface NativeQuickCryptoSpec {
     createHmac: CreateHmacMethod;
     pbkdf2: Pbkdf2Object;
@@ -10,6 +10,11 @@ interface NativeQuickCryptoSpec {
     createHash: CreateHashMethod;
     createCipher: CreateCipherMethod;
     createDecipher: CreateDecipherMethod;
+    publicEncrypt: PublicEncryptMethod;
+    publicDecrypt: PublicEncryptMethod;
+    privateDecrypt: PrivateDecryptMethod;
+    generateKeyPair: GenerateKeyPairMethod;
+    generateKeyPairSync: GenerateKeyPairSyncMethod;
 }
 declare global {
     function nativeCallSyncHook(): unknown;

package/lib/typescript/QuickCrypto.d.ts

@@ -1,5 +1,5 @@
 import * as random from './random';
-import { createCipher, createCipheriv, createDecipher, createDecipheriv } from './Cipher';
+import { createCipher, createCipheriv, createDecipher, createDecipheriv, generateKeyPair, generateKeyPairSync } from './Cipher';
 import { createHmac } from './Hmac';
 import { createHash } from './Hash';
 export declare const QuickCrypto: {
@@ -28,4 +28,108 @@ export declare const QuickCrypto: {
     createCipheriv: typeof createCipheriv;
     createDecipher: typeof createDecipher;
     createDecipheriv: typeof createDecipheriv;
+    publicEncrypt: (options: {
+        key: any;
+        encoding?: string | undefined;
+        format?: any;
+        padding?: any;
+        oaepHash?: any;
+        oaepLabel?: any;
+        passphrase?: string | undefined;
+    }, buffer: import("./Utils").BinaryLike) => import("@craftzdog/react-native-buffer").Buffer;
+    publicDecrypt: (options: {
+        key: any;
+        encoding?: string | undefined;
+        format?: any;
+        padding?: any;
+        oaepHash?: any;
+        oaepLabel?: any;
+        passphrase?: string | undefined;
+    }, buffer: import("./Utils").BinaryLike) => import("@craftzdog/react-native-buffer").Buffer;
+    privateDecrypt: (options: {
+        key: any;
+        encoding?: string | undefined;
+        format?: any;
+        padding?: any;
+        oaepHash?: any;
+        oaepLabel?: any;
+        passphrase?: string | undefined;
+    }, buffer: import("./Utils").BinaryLike) => import("@craftzdog/react-native-buffer").Buffer;
+    generateKeyPair: typeof generateKeyPair;
+    generateKeyPairSync: typeof generateKeyPairSync;
+    constants: {
+        OPENSSL_VERSION_NUMBER: number;
+        SSL_OP_ALL: number;
+        SSL_OP_ALLOW_NO_DHE_KEX: number;
+        SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
+        SSL_OP_CIPHER_SERVER_PREFERENCE: number;
+        SSL_OP_CISCO_ANYCONNECT: number;
+        SSL_OP_COOKIE_EXCHANGE: number;
+        SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;
+        SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;
+        SSL_OP_EPHEMERAL_RSA: number;
+        SSL_OP_LEGACY_SERVER_CONNECT: number;
+        SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number;
+        SSL_OP_MICROSOFT_SESS_ID_BUG: number;
+        SSL_OP_MSIE_SSLV2_RSA_PADDING: number;
+        SSL_OP_NETSCAPE_CA_DN_BUG: number;
+        SSL_OP_NETSCAPE_CHALLENGE_BUG: number;
+        SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number;
+        SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number;
+        SSL_OP_NO_COMPRESSION: number;
+        SSL_OP_NO_ENCRYPT_THEN_MAC: number;
+        SSL_OP_NO_QUERY_MTU: number;
+        SSL_OP_NO_RENEGOTIATION: number;
+        SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;
+        SSL_OP_NO_SSLv2: number;
+        SSL_OP_NO_SSLv3: number;
+        SSL_OP_NO_TICKET: number;
+        SSL_OP_NO_TLSv1: number;
+        SSL_OP_NO_TLSv1_1: number;
+        SSL_OP_NO_TLSv1_2: number;
+        SSL_OP_NO_TLSv1_3: number;
+        SSL_OP_PKCS1_CHECK_1: number;
+        SSL_OP_PKCS1_CHECK_2: number;
+        SSL_OP_PRIORITIZE_CHACHA: number;
+        SSL_OP_SINGLE_DH_USE: number;
+        SSL_OP_SINGLE_ECDH_USE: number;
+        SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number;
+        SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number;
+        SSL_OP_TLS_BLOCK_PADDING_BUG: number;
+        SSL_OP_TLS_D5_BUG: number;
+        SSL_OP_TLS_ROLLBACK_BUG: number;
+        ENGINE_METHOD_RSA: number;
+        ENGINE_METHOD_DSA: number;
+        ENGINE_METHOD_DH: number;
+        ENGINE_METHOD_RAND: number;
+        ENGINE_METHOD_EC: number;
+        ENGINE_METHOD_CIPHERS: number;
+        ENGINE_METHOD_DIGESTS: number;
+        ENGINE_METHOD_PKEY_METHS: number;
+        ENGINE_METHOD_PKEY_ASN1_METHS: number;
+        ENGINE_METHOD_ALL: number;
+        ENGINE_METHOD_NONE: number;
+        DH_CHECK_P_NOT_SAFE_PRIME: number;
+        DH_CHECK_P_NOT_PRIME: number;
+        DH_UNABLE_TO_CHECK_GENERATOR: number;
+        DH_NOT_SUITABLE_GENERATOR: number;
+        ALPN_ENABLED: number;
+        RSA_PKCS1_PADDING: number;
+        RSA_SSLV23_PADDING: number;
+        RSA_NO_PADDING: number;
+        RSA_PKCS1_OAEP_PADDING: number;
+        RSA_X931_PADDING: number;
+        RSA_PKCS1_PSS_PADDING: number;
+        RSA_PSS_SALTLEN_DIGEST: number;
+        RSA_PSS_SALTLEN_MAX_SIGN: number;
+        RSA_PSS_SALTLEN_AUTO: number;
+        defaultCoreCipherList: string;
+        TLS1_VERSION: number;
+        TLS1_1_VERSION: number;
+        TLS1_2_VERSION: number;
+        TLS1_3_VERSION: number;
+        POINT_CONVERSION_COMPRESSED: number;
+        POINT_CONVERSION_UNCOMPRESSED: number;
+        POINT_CONVERSION_HYBRID: number;
+    };
 };

package/lib/typescript/Utils.d.ts

@@ -7,7 +7,18 @@ export declare type Encoding = BinaryToTextEncoding | CharacterEncoding | Legacy
 export declare type CipherEncoding = Encoding | 'buffer';
 export declare function setDefaultEncoding(encoding: CipherEncoding): void;
 export declare function getDefaultEncoding(): CipherEncoding;
+export declare const kEmptyObject: any;
 export declare function isBuffer(buf: any): buf is Buffer;
 export declare function toArrayBuffer(buf: Buffer): ArrayBuffer;
 export declare function binaryLikeToArrayBuffer(input: BinaryLike, encoding?: string): ArrayBuffer;
 export declare function ab2str(buf: ArrayBuffer, encoding?: string): string;
+export declare function validateString(str: any, name?: string): str is string;
+export declare function validateFunction(f: any): f is Function;
+export declare function isStringOrBuffer(val: any): val is string | ArrayBuffer;
+export declare function validateObject<T>(value: any, name: string, options?: {
+    allowArray: boolean;
+    allowFunction: boolean;
+    nullable: boolean;
+} | null): value is T;
+export declare function validateInt32(value: any, name: string, min?: number, max?: number): void;
+export declare function validateUint32(value: number, name: string, positive?: boolean): void;