react-native-quick-crypto 0.2.0

package/lib/commonjs/pbkdf2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["pbkdf2.ts"],"names":["WRONG_PASS","WRON_SALT","sanitizeInput","input","errorMsg","e","nativePbkdf2","NativeQuickCrypto","pbkdf2","password","salt","iterations","keylen","arg0","arg1","digest","callback","undefined","Error","sanitizedPassword","sanitizedSalt","then","res","Buffer","from","pbkdf2Sync","algo","result"],"mappings":";;;;;;;;AAAA;;AACA;;AACA;;AAEA,MAAMA,UAAU,GACd,kEADF;AAEA,MAAMC,SAAS,GAAI,8DAAnB;;AAMA,SAASC,aAAT,CAAuBC,KAAvB,EAA0CC,QAA1C,EAAyE;AACvE,MAAI;AACF,WAAO,oCAAwBD,KAAxB,CAAP;AACD,GAFD,CAEE,OAAOE,CAAP,EAAe;AACf,UAAMD,QAAN;AACD;AACF;;AAED,MAAME,YAAY,GAAGC,qCAAkBC,MAAvC;;AAiBO,SAASA,MAAT,CACLC,QADK,EAELC,IAFK,EAGLC,UAHK,EAILC,MAJK,EAKLC,IALK,EAMLC,IANK,EAOC;AACN,MAAIC,MAAM,GAAG,MAAb;AACA,MAAIC,QAAJ;;AACA,MAAI,OAAOH,IAAP,KAAgB,QAApB,EAA8B;AAC5BE,IAAAA,MAAM,GAAGF,IAAT;;AACA,QAAI,OAAOC,IAAP,KAAgB,UAApB,EAAgC;AAC9BE,MAAAA,QAAQ,GAAGF,IAAX;AACD;AACF,GALD,MAKO;AACL,QAAI,OAAOD,IAAP,KAAgB,UAApB,EAAgC;AAC9BG,MAAAA,QAAQ,GAAGH,IAAX;AACD;AACF;;AACD,MAAIG,QAAQ,KAAKC,SAAjB,EAA4B;AAC1B,UAAM,IAAIC,KAAJ,CAAU,gCAAV,CAAN;AACD;;AAED,QAAMC,iBAAiB,GAAGjB,aAAa,CAACO,QAAD,EAAWT,UAAX,CAAvC;AACA,QAAMoB,aAAa,GAAGlB,aAAa,CAACQ,IAAD,EAAOT,SAAP,CAAnC;AAEAK,EAAAA,YAAY,CACTE,MADH,CACUW,iBADV,EAC6BC,aAD7B,EAC4CT,UAD5C,EACwDC,MADxD,EACgEG,MADhE,EAEGM,IAFH,CAGKC,GAAD,IAAsB;AACpBN,IAAAA,QAAQ,CAAE,IAAF,EAAQO,0BAAOC,IAAP,CAAYF,GAAZ,CAAR,CAAR;AACD,GALL,EAMKjB,CAAD,IAAc;AACZW,IAAAA,QAAQ,CAAEX,CAAF,CAAR;AACD,GARL;AAUD;;AACM,SAASoB,UAAT,CACLhB,QADK,EAELC,IAFK,EAGLC,UAHK,EAILC,MAJK,EAKLG,MALK,EAMG;AACR,QAAMI,iBAAiB,GAAGjB,aAAa,CAACO,QAAD,EAAWT,UAAX,CAAvC;AACA,QAAMoB,aAAa,GAAGlB,aAAa,CAACQ,IAAD,EAAOT,SAAP,CAAnC;AAEA,QAAMyB,IAAI,GAAGX,MAAM,GAAGA,MAAH,GAAY,MAA/B;AACA,MAAIY,MAAmB,GAAGrB,YAAY,CAACmB,UAAb,CACxBN,iBADwB,EAExBC,aAFwB,EAGxBT,UAHwB,EAIxBC,MAJwB,EAKxBc,IALwB,CAA1B;AAQA,SAAOH,0BAAOC,IAAP,CAAYG,MAAZ,CAAP;AACD","sourcesContent":["import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';\nimport { Buffer } from '@craftzdog/react-native-buffer';\nimport { BinaryLike, binaryLikeToArrayBuffer } from './Utils';\n\nconst WRONG_PASS =\n  'Password must be a string, a Buffer, a typed array or a DataView';\nconst WRON_SALT = `Salt must be a string, a Buffer, a typed array or a DataView`;\n\ntype Password = BinaryLike;\ntype Salt = BinaryLike;\ntype Pbkdf2Callback = (err: Error | null, derivedKey?: Buffer) => void;\n\nfunction sanitizeInput(input: BinaryLike, errorMsg: string): ArrayBuffer {\n  try {\n    return binaryLikeToArrayBuffer(input);\n  } catch (e: any) {\n    throw errorMsg;\n  }\n}\n\nconst nativePbkdf2 = NativeQuickCrypto.pbkdf2;\n\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  digest: string,\n  callback: Pbkdf2Callback\n): void;\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  callback: Pbkdf2Callback\n): void;\nexport function pbkdf2(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  arg0?: unknown,\n  arg1?: unknown\n): void {\n  let digest = 'sha1';\n  let callback: undefined | Pbkdf2Callback;\n  if (typeof arg0 === 'string') {\n    digest = arg0;\n    if (typeof arg1 === 'function') {\n      callback = arg1 as Pbkdf2Callback;\n    }\n  } else {\n    if (typeof arg0 === 'function') {\n      callback = arg0 as Pbkdf2Callback;\n    }\n  }\n  if (callback === undefined) {\n    throw new Error('No callback provided to pbkdf2');\n  }\n\n  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);\n  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);\n\n  nativePbkdf2\n    .pbkdf2(sanitizedPassword, sanitizedSalt, iterations, keylen, digest)\n    .then(\n      (res: ArrayBuffer) => {\n        callback!(null, Buffer.from(res));\n      },\n      (e: Error) => {\n        callback!(e);\n      }\n    );\n}\nexport function pbkdf2Sync(\n  password: Password,\n  salt: Salt,\n  iterations: number,\n  keylen: number,\n  digest?: string\n): Buffer {\n  const sanitizedPassword = sanitizeInput(password, WRONG_PASS);\n  const sanitizedSalt = sanitizeInput(salt, WRON_SALT);\n\n  const algo = digest ? digest : 'sha1';\n  let result: ArrayBuffer = nativePbkdf2.pbkdf2Sync(\n    sanitizedPassword,\n    sanitizedSalt,\n    iterations,\n    keylen,\n    algo\n  );\n\n  return Buffer.from(result);\n}\n"]}

package/lib/commonjs/random.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRandomValues = getRandomValues;
+exports.pseudoRandomBytes = exports.prng = void 0;
+exports.randomBytes = randomBytes;
+exports.randomFill = randomFill;
+exports.randomFillSync = randomFillSync;
+exports.randomInt = randomInt;
+exports.rng = void 0;
+
+var _NativeQuickCrypto = require("./NativeQuickCrypto/NativeQuickCrypto");
+
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+
+var _Utils = require("../src/Utils");
+
+const random = _NativeQuickCrypto.NativeQuickCrypto.random;
+
+function randomFill(buffer) {
+  var _ref, _ref2;
+
+  if (typeof (_ref = (arguments.length <= 1 ? 0 : arguments.length - 1) - 1 + 1, _ref < 1 || arguments.length <= _ref ? undefined : arguments[_ref]) !== 'function') {
+    throw new Error('No callback provided to randomDill');
+  }
+
+  const callback = (_ref2 = (arguments.length <= 1 ? 0 : arguments.length - 1) - 1 + 1, _ref2 < 1 || arguments.length <= _ref2 ? undefined : arguments[_ref2]);
+  let offset = 0;
+  let size = buffer.byteLength;
+
+  if (typeof (arguments.length <= 3 ? undefined : arguments[3]) === 'function') {
+    offset = arguments.length <= 1 ? undefined : arguments[1];
+    size = arguments.length <= 2 ? undefined : arguments[2];
+  }
+
+  if (typeof (arguments.length <= 2 ? undefined : arguments[2]) === 'function') {
+    offset = arguments.length <= 1 ? undefined : arguments[1];
+  }
+
+  random.randomFill((0, _Utils.isBuffer)(buffer) ? buffer.buffer : buffer, offset, size).then(() => {
+    callback(null, buffer);
+  }, e => {
+    callback(e);
+  });
+}
+
+function randomFillSync(buffer) {
+  let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  let size = arguments.length > 2 ? arguments[2] : undefined;
+  random.randomFillSync(buffer.buffer ? buffer.buffer : buffer, offset, size !== null && size !== void 0 ? size : buffer.byteLength);
+  return buffer;
+}
+
+function randomBytes(size, callback) {
+  const buf = new _reactNativeBuffer.Buffer(size);
+
+  if (callback === undefined) {
+    randomFillSync(buf.buffer, 0, size);
+    return buf;
+  }
+
+  randomFill(buf.buffer, 0, size, error => {
+    if (error) {
+      callback(error);
+    }
+
+    callback(null, buf);
+  });
+}
+
+const rng = randomBytes;
+exports.rng = rng;
+const pseudoRandomBytes = randomBytes;
+exports.pseudoRandomBytes = pseudoRandomBytes;
+const prng = randomBytes;
+exports.prng = prng;
+// The rest of the file is taken from https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js
+// Largest integer we can read from a buffer.
+// e.g.: Buffer.from("ff".repeat(6), "hex").readUIntBE(0, 6);
+const RAND_MAX = 0xffffffffffff; // Cache random data to use in randomInt. The cache size must be evenly
+// divisible by 6 because each attempt to obtain a random int uses 6 bytes.
+
+const randomCache = new _reactNativeBuffer.Buffer(6 * 1024);
+let randomCacheOffset = randomCache.length;
+let asyncCacheFillInProgress = false;
+const asyncCachePendingTasks = []; // Generates an integer in [min, max) range where min is inclusive and max is
+// exclusive.
+
+function randomInt(arg1, arg2, callback) {
+  // Detect optional min syntax
+  // randomInt(max)
+  // randomInt(max, callback)
+  let max;
+  let min;
+  const minNotSpecified = typeof arg2 === 'undefined' || typeof arg2 === 'function';
+
+  if (minNotSpecified) {
+    callback = arg2;
+    max = arg1;
+    min = 0;
+  } else {
+    min = arg1;
+    max = arg2;
+  }
+
+  const isSync = typeof callback === 'undefined';
+
+  if (!Number.isSafeInteger(min)) {
+    // todo throw new ERR_INVALID_ARG_TYPE('min', 'a safe integer', min);
+    throw 'ERR_INVALID_ARG_TYPE';
+  }
+
+  if (!Number.isSafeInteger(max)) {
+    // todo throw new ERR_INVALID_ARG_TYPE('max', 'a safe integer', max);
+    throw 'ERR_INVALID_ARG_TYPE';
+  }
+
+  if (max <= min) {
+    /* todo throw new ERR_OUT_OF_RANGE(
+      'max',
+      `greater than the value of "min" (${min})`,
+      max
+    );*/
+    throw 'ERR_OUT_OF_RANGE';
+  } // First we generate a random int between [0..range)
+
+
+  const range = max - min;
+
+  if (!(range <= RAND_MAX)) {
+    /* todo throw new ERR_OUT_OF_RANGE(
+      `max${minNotSpecified ? '' : ' - min'}`,
+      `<= ${RAND_MAX}`,
+      range
+    );*/
+    throw 'ERR_OUT_OF_RANGE';
+  } // For (x % range) to produce an unbiased value greater than or equal to 0 and
+  // less than range, x must be drawn randomly from the set of integers greater
+  // than or equal to 0 and less than randLimit.
+
+
+  const randLimit = RAND_MAX - RAND_MAX % range; // If we don't have a callback, or if there is still data in the cache, we can
+  // do this synchronously, which is super fast.
+
+  while (isSync || randomCacheOffset < randomCache.length) {
+    if (randomCacheOffset === randomCache.length) {
+      // This might block the thread for a bit, but we are in sync mode.
+      randomFillSync(randomCache);
+      randomCacheOffset = 0;
+    }
+
+    const x = randomCache.readUIntBE(randomCacheOffset, 6);
+    randomCacheOffset += 6;
+
+    if (x < randLimit) {
+      const n = x % range + min;
+      if (isSync) return n;
+      process.nextTick(callback, undefined, n);
+      return;
+    }
+  } // At this point, we are in async mode with no data in the cache. We cannot
+  // simply refill the cache, because another async call to randomInt might
+  // already be doing that. Instead, queue this call for when the cache has
+  // been refilled.
+
+
+  if (callback !== undefined) {
+    // it is (typescript doesn't know it)
+    asyncCachePendingTasks.push({
+      min,
+      max,
+      callback
+    });
+    asyncRefillRandomIntCache();
+  }
+}
+
+function asyncRefillRandomIntCache() {
+  if (asyncCacheFillInProgress) return;
+  asyncCacheFillInProgress = true;
+  randomFill(randomCache, err => {
+    asyncCacheFillInProgress = false;
+    const tasks = asyncCachePendingTasks;
+    const errorReceiver = err && tasks.shift();
+    if (!err) randomCacheOffset = 0; // Restart all pending tasks. If an error occurred, we only notify a single
+    // callback (errorReceiver) about it. This way, every async call to
+    // randomInt has a chance of being successful, and it avoids complex
+    // exception handling here.
+
+    tasks.splice(0).forEach(task => {
+      randomInt(task.min, task.max, task.callback);
+    }); // This is the only call that might throw, and is therefore done at the end.
+
+    if (errorReceiver) errorReceiver.callback(err, 0);
+  });
+} // Really just the Web Crypto API alternative
+// to require('crypto').randomFillSync() with an
+// additional limitation that the input buffer is
+// not allowed to exceed 65536 bytes, and can only
+// be an integer-type TypedArray.
+
+
+function getRandomValues(data) {
+  if (data.byteLength > 65536) {
+    throw new Error('The requested length exceeds 65,536 bytes');
+  }
+
+  randomFillSync(data, 0);
+  return data;
+}
+//# sourceMappingURL=random.js.map

package/lib/commonjs/random.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["random.ts"],"names":["random","NativeQuickCrypto","randomFill","buffer","Error","callback","offset","size","byteLength","then","e","randomFillSync","randomBytes","buf","Buffer","undefined","error","rng","pseudoRandomBytes","prng","RAND_MAX","randomCache","randomCacheOffset","length","asyncCacheFillInProgress","asyncCachePendingTasks","randomInt","arg1","arg2","max","min","minNotSpecified","isSync","Number","isSafeInteger","range","randLimit","x","readUIntBE","n","process","nextTick","push","asyncRefillRandomIntCache","err","tasks","errorReceiver","shift","splice","forEach","task","getRandomValues","data"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AAEA,MAAMA,MAAM,GAAGC,qCAAkBD,MAAjC;;AAgCO,SAASE,UAAT,CAAoBC,MAApB,EAAuD;AAAA;;AAC5D,MAAI,eAAY,qDAAc,CAA1B,8EAAiC,UAArC,EAAiD;AAC/C,UAAM,IAAIC,KAAJ,CAAU,oCAAV,CAAN;AACD;;AAED,QAAMC,QAAQ,YAAQ,qDAAc,CAAtB,4EAAd;AAKA,MAAIC,MAAc,GAAG,CAArB;AACA,MAAIC,IAAY,GAAGJ,MAAM,CAACK,UAA1B;;AAEA,MAAI,8DAAmB,UAAvB,EAAmC;AACjCF,IAAAA,MAAM,mDAAN;AACAC,IAAAA,IAAI,mDAAJ;AACD;;AAED,MAAI,8DAAmB,UAAvB,EAAmC;AACjCD,IAAAA,MAAM,mDAAN;AACD;;AAEDN,EAAAA,MAAM,CACHE,UADH,CACc,qBAASC,MAAT,IAAmBA,MAAM,CAACA,MAA1B,GAAmCA,MADjD,EACyDG,MADzD,EACiEC,IADjE,EAEGE,IAFH,CAGI,MAAM;AACJJ,IAAAA,QAAQ,CAAC,IAAD,EAAOF,MAAP,CAAR;AACD,GALL,EAMKO,CAAD,IAAc;AACZL,IAAAA,QAAQ,CAACK,CAAD,CAAR;AACD,GARL;AAUD;;AAQM,SAASC,cAAT,CAAwBR,MAAxB,EAAwE;AAAA,MAAnCG,MAAmC,uEAAlB,CAAkB;AAAA,MAAfC,IAAe;AAC7EP,EAAAA,MAAM,CAACW,cAAP,CACER,MAAM,CAACA,MAAP,GAAgBA,MAAM,CAACA,MAAvB,GAAgCA,MADlC,EAEEG,MAFF,EAGEC,IAHF,aAGEA,IAHF,cAGEA,IAHF,GAGUJ,MAAM,CAACK,UAHjB;AAKA,SAAOL,MAAP;AACD;;AASM,SAASS,WAAT,CACLL,IADK,EAELF,QAFK,EAGe;AACpB,QAAMQ,GAAG,GAAG,IAAIC,yBAAJ,CAAWP,IAAX,CAAZ;;AAEA,MAAIF,QAAQ,KAAKU,SAAjB,EAA4B;AAC1BJ,IAAAA,cAAc,CAACE,GAAG,CAACV,MAAL,EAAa,CAAb,EAAgBI,IAAhB,CAAd;AACA,WAAOM,GAAP;AACD;;AAEDX,EAAAA,UAAU,CAACW,GAAG,CAACV,MAAL,EAAa,CAAb,EAAgBI,IAAhB,EAAuBS,KAAD,IAAyB;AACvD,QAAIA,KAAJ,EAAW;AACTX,MAAAA,QAAQ,CAACW,KAAD,CAAR;AACD;;AACDX,IAAAA,QAAQ,CAAC,IAAD,EAAOQ,GAAP,CAAR;AACD,GALS,CAAV;AAMD;;AAEM,MAAMI,GAAG,GAAGL,WAAZ;;AACA,MAAMM,iBAAiB,GAAGN,WAA1B;;AACA,MAAMO,IAAI,GAAGP,WAAb;;AASP;AAEA;AACA;AACA,MAAMQ,QAAQ,GAAG,cAAjB,C,CAEA;AACA;;AACA,MAAMC,WAAW,GAAG,IAAIP,yBAAJ,CAAW,IAAI,IAAf,CAApB;AACA,IAAIQ,iBAAiB,GAAGD,WAAW,CAACE,MAApC;AACA,IAAIC,wBAAwB,GAAG,KAA/B;AACA,MAAMC,sBAA8B,GAAG,EAAvC,C,CAEA;AACA;;AAUO,SAASC,SAAT,CACLC,IADK,EAELC,IAFK,EAGLvB,QAHK,EAIU;AACf;AACA;AACA;AACA,MAAIwB,GAAJ;AACA,MAAIC,GAAJ;AACA,QAAMC,eAAe,GACnB,OAAOH,IAAP,KAAgB,WAAhB,IAA+B,OAAOA,IAAP,KAAgB,UADjD;;AAGA,MAAIG,eAAJ,EAAqB;AACnB1B,IAAAA,QAAQ,GAAGuB,IAAX;AACAC,IAAAA,GAAG,GAAGF,IAAN;AACAG,IAAAA,GAAG,GAAG,CAAN;AACD,GAJD,MAIO;AACLA,IAAAA,GAAG,GAAGH,IAAN;AACAE,IAAAA,GAAG,GAAGD,IAAN;AACD;;AAED,QAAMI,MAAM,GAAG,OAAO3B,QAAP,KAAoB,WAAnC;;AACA,MAAI,CAAC4B,MAAM,CAACC,aAAP,CAAqBJ,GAArB,CAAL,EAAgC;AAC9B;AACA,UAAM,sBAAN;AACD;;AACD,MAAI,CAACG,MAAM,CAACC,aAAP,CAAqBL,GAArB,CAAL,EAAgC;AAC9B;AACA,UAAM,sBAAN;AACD;;AACD,MAAIA,GAAG,IAAIC,GAAX,EAAgB;AACd;AACJ;AACA;AACA;AACA;AACI,UAAM,kBAAN;AACD,GAlCc,CAoCf;;;AACA,QAAMK,KAAK,GAAGN,GAAG,GAAGC,GAApB;;AAEA,MAAI,EAAEK,KAAK,IAAIf,QAAX,CAAJ,EAA0B;AACxB;AACJ;AACA;AACA;AACA;AACI,UAAM,kBAAN;AACD,GA9Cc,CAgDf;AACA;AACA;;;AACA,QAAMgB,SAAS,GAAGhB,QAAQ,GAAIA,QAAQ,GAAGe,KAAzC,CAnDe,CAqDf;AACA;;AACA,SAAOH,MAAM,IAAIV,iBAAiB,GAAGD,WAAW,CAACE,MAAjD,EAAyD;AACvD,QAAID,iBAAiB,KAAKD,WAAW,CAACE,MAAtC,EAA8C;AAC5C;AACAZ,MAAAA,cAAc,CAACU,WAAD,CAAd;AACAC,MAAAA,iBAAiB,GAAG,CAApB;AACD;;AAED,UAAMe,CAAC,GAAGhB,WAAW,CAACiB,UAAZ,CAAuBhB,iBAAvB,EAA0C,CAA1C,CAAV;AACAA,IAAAA,iBAAiB,IAAI,CAArB;;AAEA,QAAIe,CAAC,GAAGD,SAAR,EAAmB;AACjB,YAAMG,CAAC,GAAIF,CAAC,GAAGF,KAAL,GAAcL,GAAxB;AACA,UAAIE,MAAJ,EAAY,OAAOO,CAAP;AACZC,MAAAA,OAAO,CAACC,QAAR,CAAiBpC,QAAjB,EAAuCU,SAAvC,EAAkDwB,CAAlD;AACA;AACD;AACF,GAvEc,CAyEf;AACA;AACA;AACA;;;AACA,MAAIlC,QAAQ,KAAKU,SAAjB,EAA4B;AAC1B;AACAU,IAAAA,sBAAsB,CAACiB,IAAvB,CAA4B;AAAEZ,MAAAA,GAAF;AAAOD,MAAAA,GAAP;AAAYxB,MAAAA;AAAZ,KAA5B;AACAsC,IAAAA,yBAAyB;AAC1B;AACF;;AAED,SAASA,yBAAT,GAAqC;AACnC,MAAInB,wBAAJ,EAA8B;AAE9BA,EAAAA,wBAAwB,GAAG,IAA3B;AACAtB,EAAAA,UAAU,CAACmB,WAAD,EAAeuB,GAAD,IAAS;AAC/BpB,IAAAA,wBAAwB,GAAG,KAA3B;AAEA,UAAMqB,KAAK,GAAGpB,sBAAd;AACA,UAAMqB,aAAa,GAAGF,GAAG,IAAIC,KAAK,CAACE,KAAN,EAA7B;AACA,QAAI,CAACH,GAAL,EAAUtB,iBAAiB,GAAG,CAApB,CALqB,CAO/B;AACA;AACA;AACA;;AACAuB,IAAAA,KAAK,CAACG,MAAN,CAAa,CAAb,EAAgBC,OAAhB,CAAyBC,IAAD,IAAU;AAChCxB,MAAAA,SAAS,CAACwB,IAAI,CAACpB,GAAN,EAAWoB,IAAI,CAACrB,GAAhB,EAAqBqB,IAAI,CAAC7C,QAA1B,CAAT;AACD,KAFD,EAX+B,CAe/B;;AACA,QAAIyC,aAAJ,EAAmBA,aAAa,CAACzC,QAAd,CAAuBuC,GAAvB,EAA4B,CAA5B;AACpB,GAjBS,CAAV;AAkBD,C,CAED;AACA;AACA;AACA;AACA;;;AAQO,SAASO,eAAT,CAAyBC,IAAzB,EAAyC;AAC9C,MAAIA,IAAI,CAAC5C,UAAL,GAAkB,KAAtB,EAA6B;AAC3B,UAAM,IAAIJ,KAAJ,CAAU,2CAAV,CAAN;AACD;;AACDO,EAAAA,cAAc,CAACyC,IAAD,EAAO,CAAP,CAAd;AACA,SAAOA,IAAP;AACD","sourcesContent":["import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';\nimport { Buffer } from '@craftzdog/react-native-buffer';\nimport { isBuffer } from '../src/Utils';\n\nconst random = NativeQuickCrypto.random;\n\ntype TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | Float32Array\n  | Float64Array;\ntype ArrayBufferView = TypedArray | DataView | ArrayBufferLike | Buffer;\n\nexport function randomFill<T extends ArrayBufferView>(\n  buffer: T,\n  callback: (err: Error | null, buf: T) => void\n): void;\n\nexport function randomFill<T extends ArrayBufferView>(\n  buffer: T,\n  offset: number,\n  callback: (err: Error | null, buf: T) => void\n): void;\n\nexport function randomFill<T extends ArrayBufferView>(\n  buffer: T,\n  offset: number,\n  size: number,\n  callback: (err: Error | null, buf: T) => void\n): void;\n\nexport function randomFill(buffer: any, ...rest: any[]): void {\n  if (typeof rest[rest.length - 1] !== 'function') {\n    throw new Error('No callback provided to randomDill');\n  }\n\n  const callback = rest[rest.length - 1] as any as (\n    err: Error | null,\n    buf?: ArrayBuffer\n  ) => void;\n\n  let offset: number = 0;\n  let size: number = buffer.byteLength;\n\n  if (typeof rest[2] === 'function') {\n    offset = rest[0];\n    size = rest[1];\n  }\n\n  if (typeof rest[1] === 'function') {\n    offset = rest[0];\n  }\n\n  random\n    .randomFill(isBuffer(buffer) ? buffer.buffer : buffer, offset, size)\n    .then(\n      () => {\n        callback(null, buffer);\n      },\n      (e: Error) => {\n        callback(e);\n      }\n    );\n}\n\nexport function randomFillSync<T extends ArrayBufferView>(\n  buffer: T,\n  offset?: number,\n  size?: number\n): T;\n\nexport function randomFillSync(buffer: any, offset: number = 0, size?: number) {\n  random.randomFillSync(\n    buffer.buffer ? buffer.buffer : buffer,\n    offset,\n    size ?? buffer.byteLength\n  );\n  return buffer;\n}\n\nexport function randomBytes(size: number): ArrayBuffer;\n\nexport function randomBytes(\n  size: number,\n  callback: (err: Error | null, buf?: ArrayBuffer) => void\n): void;\n\nexport function randomBytes(\n  size: number,\n  callback?: (err: Error | null, buf?: ArrayBuffer) => void\n): void | ArrayBuffer {\n  const buf = new Buffer(size);\n\n  if (callback === undefined) {\n    randomFillSync(buf.buffer, 0, size);\n    return buf;\n  }\n\n  randomFill(buf.buffer, 0, size, (error: Error | null) => {\n    if (error) {\n      callback(error);\n    }\n    callback(null, buf);\n  });\n}\n\nexport const rng = randomBytes;\nexport const pseudoRandomBytes = randomBytes;\nexport const prng = randomBytes;\n\ntype RandomIntCallback = (err: Error | null, value: number) => void;\ntype Task = {\n  min: number;\n  max: number;\n  callback: RandomIntCallback;\n};\n\n// The rest of the file is taken from https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js\n\n// Largest integer we can read from a buffer.\n// e.g.: Buffer.from(\"ff\".repeat(6), \"hex\").readUIntBE(0, 6);\nconst RAND_MAX = 0xffff_ffff_ffff;\n\n// Cache random data to use in randomInt. The cache size must be evenly\n// divisible by 6 because each attempt to obtain a random int uses 6 bytes.\nconst randomCache = new Buffer(6 * 1024);\nlet randomCacheOffset = randomCache.length;\nlet asyncCacheFillInProgress = false;\nconst asyncCachePendingTasks: Task[] = [];\n\n// Generates an integer in [min, max) range where min is inclusive and max is\n// exclusive.\n\nexport function randomInt(max: number, callback: RandomIntCallback): void;\nexport function randomInt(max: number): number;\nexport function randomInt(\n  min: number,\n  max: number,\n  callback: RandomIntCallback\n): void;\nexport function randomInt(min: number, max: number): number;\nexport function randomInt(\n  arg1: number,\n  arg2?: number | RandomIntCallback,\n  callback?: RandomIntCallback\n): void | number {\n  // Detect optional min syntax\n  // randomInt(max)\n  // randomInt(max, callback)\n  let max: number;\n  let min: number;\n  const minNotSpecified =\n    typeof arg2 === 'undefined' || typeof arg2 === 'function';\n\n  if (minNotSpecified) {\n    callback = arg2 as any as undefined | RandomIntCallback;\n    max = arg1;\n    min = 0;\n  } else {\n    min = arg1;\n    max = arg2 as any as number;\n  }\n\n  const isSync = typeof callback === 'undefined';\n  if (!Number.isSafeInteger(min)) {\n    // todo throw new ERR_INVALID_ARG_TYPE('min', 'a safe integer', min);\n    throw 'ERR_INVALID_ARG_TYPE';\n  }\n  if (!Number.isSafeInteger(max)) {\n    // todo throw new ERR_INVALID_ARG_TYPE('max', 'a safe integer', max);\n    throw 'ERR_INVALID_ARG_TYPE';\n  }\n  if (max <= min) {\n    /* todo throw new ERR_OUT_OF_RANGE(\n      'max',\n      `greater than the value of \"min\" (${min})`,\n      max\n    );*/\n    throw 'ERR_OUT_OF_RANGE';\n  }\n\n  // First we generate a random int between [0..range)\n  const range = max - min;\n\n  if (!(range <= RAND_MAX)) {\n    /* todo throw new ERR_OUT_OF_RANGE(\n      `max${minNotSpecified ? '' : ' - min'}`,\n      `<= ${RAND_MAX}`,\n      range\n    );*/\n    throw 'ERR_OUT_OF_RANGE';\n  }\n\n  // For (x % range) to produce an unbiased value greater than or equal to 0 and\n  // less than range, x must be drawn randomly from the set of integers greater\n  // than or equal to 0 and less than randLimit.\n  const randLimit = RAND_MAX - (RAND_MAX % range);\n\n  // If we don't have a callback, or if there is still data in the cache, we can\n  // do this synchronously, which is super fast.\n  while (isSync || randomCacheOffset < randomCache.length) {\n    if (randomCacheOffset === randomCache.length) {\n      // This might block the thread for a bit, but we are in sync mode.\n      randomFillSync(randomCache);\n      randomCacheOffset = 0;\n    }\n\n    const x = randomCache.readUIntBE(randomCacheOffset, 6);\n    randomCacheOffset += 6;\n\n    if (x < randLimit) {\n      const n = (x % range) + min;\n      if (isSync) return n;\n      process.nextTick(callback as Function, undefined, n);\n      return;\n    }\n  }\n\n  // At this point, we are in async mode with no data in the cache. We cannot\n  // simply refill the cache, because another async call to randomInt might\n  // already be doing that. Instead, queue this call for when the cache has\n  // been refilled.\n  if (callback !== undefined) {\n    // it is (typescript doesn't know it)\n    asyncCachePendingTasks.push({ min, max, callback });\n    asyncRefillRandomIntCache();\n  }\n}\n\nfunction asyncRefillRandomIntCache() {\n  if (asyncCacheFillInProgress) return;\n\n  asyncCacheFillInProgress = true;\n  randomFill(randomCache, (err) => {\n    asyncCacheFillInProgress = false;\n\n    const tasks = asyncCachePendingTasks;\n    const errorReceiver = err && tasks.shift();\n    if (!err) randomCacheOffset = 0;\n\n    // Restart all pending tasks. If an error occurred, we only notify a single\n    // callback (errorReceiver) about it. This way, every async call to\n    // randomInt has a chance of being successful, and it avoids complex\n    // exception handling here.\n    tasks.splice(0).forEach((task) => {\n      randomInt(task.min, task.max, task.callback);\n    });\n\n    // This is the only call that might throw, and is therefore done at the end.\n    if (errorReceiver) errorReceiver.callback(err, 0);\n  });\n}\n\n// Really just the Web Crypto API alternative\n// to require('crypto').randomFillSync() with an\n// additional limitation that the input buffer is\n// not allowed to exceed 65536 bytes, and can only\n// be an integer-type TypedArray.\ntype DataType =\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | Uint8Array\n  | Uint16Array\n  | Uint32Array;\nexport function getRandomValues(data: DataType) {\n  if (data.byteLength > 65536) {\n    throw new Error('The requested length exceeds 65,536 bytes');\n  }\n  randomFillSync(data, 0);\n  return data;\n}\n"]}

package/lib/module/Cipher.js

@@ -0,0 +1,287 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* eslint-disable no-dupe-class-members */
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import Stream from 'stream';
+import { binaryLikeToArrayBuffer, getDefaultEncoding } from './Utils';
+// TODO(osp) re-enable type specific constructors
+// They are nice to have but not absolutely necessary
+// import type {
+//   CipherCCMOptions,
+//   CipherCCMTypes,
+//   CipherGCMTypes,
+//   CipherGCMOptions,
+//   // CipherKey,
+//   // KeyObject,
+//   // TODO @Szymon20000 This types seem to be missing? Where did you get this definitions from?
+//   // CipherOCBTypes,
+//   // CipherOCBOptions,
+// } from 'crypto'; // Node crypto typings
+import { StringDecoder } from 'string_decoder';
+import { Buffer as SBuffer } from 'safe-buffer';
+const createInternalCipher = NativeQuickCrypto.createCipher;
+const createInternalDecipher = NativeQuickCrypto.createDecipher;
+
+function getUIntOption(options, key) {
+  let value;
+
+  if (options && (value = options[key]) != null) {
+    // >>> Turns any type into a positive integer (also sets the sign bit to 0)
+    // eslint-disable-next-line no-bitwise
+    if (value >>> 0 !== value) throw new Error(`options.${key}: ${value}`);
+    return value;
+  }
+
+  return -1;
+}
+
+function normalizeEncoding(enc) {
+  if (!enc) return 'utf8';
+  var retried;
+
+  while (true) {
+    switch (enc) {
+      case 'utf8':
+      case 'utf-8':
+        return 'utf8';
+
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+      case 'utf-16le':
+        return 'utf16le';
+
+      case 'latin1':
+      case 'binary':
+        return 'latin1';
+
+      case 'base64':
+      case 'ascii':
+      case 'hex':
+        return enc;
+
+      default:
+        if (retried) return; // undefined
+
+        enc = ('' + enc).toLowerCase();
+        retried = true;
+    }
+  }
+}
+
+function validateEncoding(data, encoding) {
+  const normalizedEncoding = normalizeEncoding(encoding);
+  const length = data.length;
+
+  if (normalizedEncoding === 'hex' && length % 2 !== 0) {
+    throw new Error(`Encoding ${encoding} not valid for data length ${length}`);
+  }
+}
+
+function getDecoder(decoder, encoding) {
+  return decoder !== null && decoder !== void 0 ? decoder : new StringDecoder(encoding);
+}
+
+class CipherCommon extends Stream.Transform {
+  constructor(cipherType, cipherKey, isCipher) {
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    let iv = arguments.length > 4 ? arguments[4] : undefined;
+    super(options);
+
+    _defineProperty(this, "internal", void 0);
+
+    _defineProperty(this, "decoder", void 0);
+
+    const cipherKeyBuffer = binaryLikeToArrayBuffer(cipherKey); // TODO(osp) This might not be smart, check again after release
+
+    const authTagLength = getUIntOption(options, 'authTagLength');
+    const args = {
+      cipher_type: cipherType,
+      cipher_key: cipherKeyBuffer,
+      iv,
+      ...options,
+      auth_tag_len: authTagLength
+    };
+    this.internal = isCipher ? createInternalCipher(args) : createInternalDecipher(args);
+  }
+
+  update(data, inputEncoding, outputEncoding) {
+    var _inputEncoding, _outputEncoding;
+
+    const defaultEncoding = getDefaultEncoding();
+    inputEncoding = (_inputEncoding = inputEncoding) !== null && _inputEncoding !== void 0 ? _inputEncoding : defaultEncoding;
+    outputEncoding = (_outputEncoding = outputEncoding) !== null && _outputEncoding !== void 0 ? _outputEncoding : defaultEncoding;
+
+    if (typeof data === 'string') {
+      validateEncoding(data, inputEncoding);
+    } else if (!ArrayBuffer.isView(data)) {
+      throw new Error('Invalid data argument');
+    }
+
+    if (typeof data === 'string') {
+      // On node this is handled on the native side
+      // on our case we need to correctly send the arraybuffer to the jsi side
+      inputEncoding = inputEncoding === 'buffer' ? 'utf8' : inputEncoding;
+      data = binaryLikeToArrayBuffer(data, inputEncoding);
+    } else {
+      data = binaryLikeToArrayBuffer(data, inputEncoding);
+    }
+
+    const ret = this.internal.update(data);
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      this.decoder = getDecoder(this.decoder, outputEncoding);
+      return this.decoder.write(SBuffer.from(ret));
+    }
+
+    return ret;
+  }
+
+  final(outputEncoding) {
+    const ret = this.internal.final();
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      this.decoder = getDecoder(this.decoder, outputEncoding);
+      return this.decoder.end(SBuffer.from(ret));
+    }
+
+    return ret;
+  }
+
+  _transform(chunk, encoding, callback) {
+    this.push(this.update(chunk, encoding));
+    callback();
+  }
+
+  _flush(callback) {
+    this.push(this.final());
+    callback();
+  }
+
+  setAutoPadding(autoPadding) {
+    this.internal.setAutoPadding(!!autoPadding);
+    return this;
+  }
+
+  setAAD(buffer, options) {
+    this.internal.setAAD({
+      data: buffer.buffer,
+      plaintextLength: options === null || options === void 0 ? void 0 : options.plaintextLength
+    });
+    return this;
+  } // protected getAuthTag(): Buffer {
+  //   return Buffer.from(this.internal.getAuthTag());
+  // }
+
+
+  setAuthTag(tag) {
+    this.internal.setAuthTag(tag.buffer);
+    return this;
+  }
+
+}
+
+class Cipher extends CipherCommon {
+  constructor(cipherType, cipherKey) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let iv = arguments.length > 3 ? arguments[3] : undefined;
+
+    if (iv != null) {
+      iv = binaryLikeToArrayBuffer(iv);
+    }
+
+    super(cipherType, cipherKey, true, options, iv);
+  }
+
+}
+
+class Decipher extends CipherCommon {
+  constructor(cipherType, cipherKey) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let iv = arguments.length > 3 ? arguments[3] : undefined;
+
+    if (iv != null) {
+      iv = binaryLikeToArrayBuffer(iv);
+    }
+
+    super(cipherType, cipherKey, false, options, iv);
+  }
+
+} // TODO(osp) This definitions cause typescript errors when using the API
+// export function createDecipher(
+//   algorithm: CipherCCMTypes,
+//   password: BinaryLike,
+//   options: CipherCCMOptions
+// ): Decipher;
+// export function createDecipher(
+//   algorithm: CipherGCMTypes,
+//   password: BinaryLike,
+//   options?: CipherGCMOptions
+// ): Decipher;
+
+
+export function createDecipher(algorithm, password, options) {
+  return new Decipher(algorithm, password, options);
+} // TODO(osp) This definitions cause typescript errors when using the API
+// export function createDecipheriv(
+//   algorithm: CipherCCMTypes,
+//   key: BinaryLike,
+//   iv: BinaryLike,
+//   options: CipherCCMOptions
+// ): Decipher;
+// export function createDecipheriv(
+//   algorithm: CipherOCBTypes,
+//   key: BinaryLike,
+//   iv: BinaryLike,
+//   options: CipherOCBOptions
+// ): DecipherOCB;
+// export function createDecipheriv(
+//   algorithm: CipherGCMTypes,
+//   key: BinaryLike,
+//   iv: BinaryLike,
+//   options?: CipherGCMOptions
+// ): Decipher;
+
+export function createDecipheriv(algorithm, key, iv, options) {
+  return new Decipher(algorithm, key, options, iv);
+} // TODO(osp) This definitions cause typescript errors when using the API
+// commenting them out for now
+// export function createCipher(
+//   algorithm: CipherCCMTypes,
+//   password: BinaryLike,
+//   options: CipherCCMOptions
+// ): Cipher;
+// export function createCipher(
+//   algorithm: CipherGCMTypes,
+//   password: BinaryLike,
+//   options?: CipherGCMOptions
+// ): Cipher;
+
+export function createCipher(algorithm, password, options) {
+  return new Cipher(algorithm, password, options);
+} // TODO(osp) on all the createCipheriv methods, node seems to use a "KeyObject" is seems to be a thread safe
+// object that creates keys and what not. Not sure if we should support it.
+// Fow now I replaced all of them to BinaryLike
+// export function createCipheriv(
+//   algorithm: CipherCCMTypes,
+//   key: BinaryLike,
+//   iv: BinaryLike,
+//   options: CipherCCMOptions
+// ): Cipher;
+// export function createCipheriv(
+//   algorithm: CipherOCBTypes,
+//   key: BinaryLike,
+//   iv: BinaryLike,
+//   options: CipherOCBOptions
+// ): CipherOCB;
+// export function createCipheriv(
+//   algorithm: CipherGCMTypes,
+//   key: BinaryLike,
+//   iv: BinaryLike,
+//   options?: CipherGCMOptions
+// ): Cipher;
+
+export function createCipheriv(algorithm, key, iv, options) {
+  return new Cipher(algorithm, key, options, iv);
+}
+//# sourceMappingURL=Cipher.js.map

package/lib/module/Cipher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Cipher.ts"],"names":["NativeQuickCrypto","Stream","binaryLikeToArrayBuffer","getDefaultEncoding","StringDecoder","Buffer","SBuffer","createInternalCipher","createCipher","createInternalDecipher","createDecipher","getUIntOption","options","key","value","Error","normalizeEncoding","enc","retried","toLowerCase","validateEncoding","data","encoding","normalizedEncoding","length","getDecoder","decoder","CipherCommon","Transform","constructor","cipherType","cipherKey","isCipher","iv","cipherKeyBuffer","authTagLength","args","cipher_type","cipher_key","auth_tag_len","internal","update","inputEncoding","outputEncoding","defaultEncoding","ArrayBuffer","isView","ret","write","from","final","end","_transform","chunk","callback","push","_flush","setAutoPadding","autoPadding","setAAD","buffer","plaintextLength","setAuthTag","tag","Cipher","Decipher","algorithm","password","createDecipheriv","createCipheriv"],"mappings":"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,C,CAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,OAAO,SAASwD,gBAAT,CACLF,SADK,EAELrD,GAFK,EAGLoB,EAHK,EAILrB,OAJK,EAKK;AACV,SAAO,IAAIqD,QAAJ,CAAaC,SAAb,EAAwBrD,GAAxB,EAA6BD,OAA7B,EAAsCqB,EAAtC,CAAP;AACD,C,CAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,OAAO,SAASzB,YAAT,CACL0D,SADK,EAELC,QAFK,EAGLvD,OAHK,EAIG;AACR,SAAO,IAAIoD,MAAJ,CAAWE,SAAX,EAAsBC,QAAtB,EAAgCvD,OAAhC,CAAP;AACD,C,CAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,OAAO,SAASyD,cAAT,CACLH,SADK,EAELrD,GAFK,EAGLoB,EAHK,EAILrB,OAJK,EAKG;AACR,SAAO,IAAIoD,MAAJ,CAAWE,SAAX,EAAsBrD,GAAtB,EAA2BD,OAA3B,EAAoCqB,EAApC,CAAP;AACD","sourcesContent":["/* eslint-disable no-dupe-class-members */\nimport { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';\nimport Stream from 'stream';\nimport {\n  BinaryLike,\n  binaryLikeToArrayBuffer,\n  CipherEncoding,\n  Encoding,\n  getDefaultEncoding,\n} from './Utils';\nimport type { InternalCipher } from './NativeQuickCrypto/Cipher';\n// TODO(osp) re-enable type specific constructors\n// They are nice to have but not absolutely necessary\n// import type {\n//   CipherCCMOptions,\n//   CipherCCMTypes,\n//   CipherGCMTypes,\n//   CipherGCMOptions,\n//   // CipherKey,\n//   // KeyObject,\n//   // TODO @Szymon20000 This types seem to be missing? Where did you get this definitions from?\n//   // CipherOCBTypes,\n//   // CipherOCBOptions,\n// } from 'crypto'; // Node crypto typings\nimport { StringDecoder } from 'string_decoder';\nimport type { Buffer } from '@craftzdog/react-native-buffer';\nimport { Buffer as SBuffer } from 'safe-buffer';\n\nconst createInternalCipher = NativeQuickCrypto.createCipher;\nconst createInternalDecipher = NativeQuickCrypto.createDecipher;\n\nfunction getUIntOption(options: Record<string, any>, key: string) {\n  let value;\n  if (options && (value = options[key]) != null) {\n    // >>> Turns any type into a positive integer (also sets the sign bit to 0)\n    // eslint-disable-next-line no-bitwise\n    if (value >>> 0 !== value) throw new Error(`options.${key}: ${value}`);\n    return value;\n  }\n  return -1;\n}\n\nfunction normalizeEncoding(enc: string) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n}\n\nfunction validateEncoding(data: string, encoding: string) {\n  const normalizedEncoding = normalizeEncoding(encoding);\n  const length = data.length;\n\n  if (normalizedEncoding === 'hex' && length % 2 !== 0) {\n    throw new Error(`Encoding ${encoding} not valid for data length ${length}`);\n  }\n}\n\nfunction getDecoder(decoder?: StringDecoder, encoding?: BufferEncoding) {\n  return decoder ?? new StringDecoder(encoding);\n}\n\nclass CipherCommon extends Stream.Transform {\n  private internal: InternalCipher;\n  private decoder: StringDecoder | undefined;\n\n  constructor(\n    cipherType: string,\n    cipherKey: BinaryLike,\n    isCipher: boolean,\n    options: Record<string, any> = {},\n    iv?: BinaryLike | null\n  ) {\n    super(options);\n    const cipherKeyBuffer = binaryLikeToArrayBuffer(cipherKey);\n    // TODO(osp) This might not be smart, check again after release\n    const authTagLength = getUIntOption(options, 'authTagLength');\n    const args = {\n      cipher_type: cipherType,\n      cipher_key: cipherKeyBuffer,\n      iv,\n      ...options,\n      auth_tag_len: authTagLength,\n    };\n    this.internal = isCipher\n      ? createInternalCipher(args)\n      : createInternalDecipher(args);\n  }\n\n  update(\n    data: BinaryLike,\n    inputEncoding?: CipherEncoding,\n    outputEncoding?: CipherEncoding\n  ): ArrayBuffer | string {\n    const defaultEncoding = getDefaultEncoding();\n    inputEncoding = inputEncoding ?? defaultEncoding;\n    outputEncoding = outputEncoding ?? defaultEncoding;\n\n    if (typeof data === 'string') {\n      validateEncoding(data, inputEncoding);\n    } else if (!ArrayBuffer.isView(data)) {\n      throw new Error('Invalid data argument');\n    }\n\n    if (typeof data === 'string') {\n      // On node this is handled on the native side\n      // on our case we need to correctly send the arraybuffer to the jsi side\n      inputEncoding = inputEncoding === 'buffer' ? 'utf8' : inputEncoding;\n      data = binaryLikeToArrayBuffer(data, inputEncoding);\n    } else {\n      data = binaryLikeToArrayBuffer(data as any, inputEncoding);\n    }\n\n    const ret = this.internal.update(data);\n\n    if (outputEncoding && outputEncoding !== 'buffer') {\n      this.decoder = getDecoder(this.decoder, outputEncoding);\n\n      return this.decoder!.write(SBuffer.from(ret) as any);\n    }\n\n    return ret;\n  }\n\n  final(): ArrayBuffer;\n  final(outputEncoding: BufferEncoding | 'buffer'): string;\n  final(outputEncoding?: BufferEncoding | 'buffer'): ArrayBuffer | string {\n    const ret = this.internal.final();\n\n    if (outputEncoding && outputEncoding !== 'buffer') {\n      this.decoder = getDecoder(this.decoder, outputEncoding);\n\n      return this.decoder!.end(SBuffer.from(ret) as any);\n    }\n\n    return ret;\n  }\n\n  _transform(chunk: BinaryLike, encoding: Encoding, callback: () => void) {\n    this.push(this.update(chunk, encoding));\n    callback();\n  }\n\n  _flush(callback: () => void) {\n    this.push(this.final());\n    callback();\n  }\n\n  public setAutoPadding(autoPadding?: boolean): this {\n    this.internal.setAutoPadding(!!autoPadding);\n    return this;\n  }\n\n  public setAAD(\n    buffer: Buffer,\n    options?: {\n      plaintextLength: number;\n    }\n  ): this {\n    this.internal.setAAD({\n      data: buffer.buffer,\n      plaintextLength: options?.plaintextLength,\n    });\n    return this;\n  }\n\n  // protected getAuthTag(): Buffer {\n  //   return Buffer.from(this.internal.getAuthTag());\n  // }\n\n  public setAuthTag(tag: Buffer): this {\n    this.internal.setAuthTag(tag.buffer);\n    return this;\n  }\n}\n\nclass Cipher extends CipherCommon {\n  constructor(\n    cipherType: string,\n    cipherKey: BinaryLike,\n    options: Record<string, any> = {},\n    iv?: BinaryLike | null\n  ) {\n    if (iv != null) {\n      iv = binaryLikeToArrayBuffer(iv);\n    }\n    super(cipherType, cipherKey, true, options, iv);\n  }\n}\n\nclass Decipher extends CipherCommon {\n  constructor(\n    cipherType: string,\n    cipherKey: BinaryLike,\n    options: Record<string, any> = {},\n    iv?: BinaryLike | null\n  ) {\n    if (iv != null) {\n      iv = binaryLikeToArrayBuffer(iv);\n    }\n\n    super(cipherType, cipherKey, false, options, iv);\n  }\n}\n\n// TODO(osp) This definitions cause typescript errors when using the API\n// export function createDecipher(\n//   algorithm: CipherCCMTypes,\n//   password: BinaryLike,\n//   options: CipherCCMOptions\n// ): Decipher;\n// export function createDecipher(\n//   algorithm: CipherGCMTypes,\n//   password: BinaryLike,\n//   options?: CipherGCMOptions\n// ): Decipher;\nexport function createDecipher(\n  algorithm: string,\n  password: BinaryLike,\n  options?: Stream.TransformOptions\n): Decipher {\n  return new Decipher(algorithm, password, options);\n}\n\n// TODO(osp) This definitions cause typescript errors when using the API\n// export function createDecipheriv(\n//   algorithm: CipherCCMTypes,\n//   key: BinaryLike,\n//   iv: BinaryLike,\n//   options: CipherCCMOptions\n// ): Decipher;\n// export function createDecipheriv(\n//   algorithm: CipherOCBTypes,\n//   key: BinaryLike,\n//   iv: BinaryLike,\n//   options: CipherOCBOptions\n// ): DecipherOCB;\n// export function createDecipheriv(\n//   algorithm: CipherGCMTypes,\n//   key: BinaryLike,\n//   iv: BinaryLike,\n//   options?: CipherGCMOptions\n// ): Decipher;\nexport function createDecipheriv(\n  algorithm: string,\n  key: BinaryLike,\n  iv: BinaryLike | null,\n  options?: Stream.TransformOptions\n): Decipher {\n  return new Decipher(algorithm, key, options, iv);\n}\n\n// TODO(osp) This definitions cause typescript errors when using the API\n// commenting them out for now\n// export function createCipher(\n//   algorithm: CipherCCMTypes,\n//   password: BinaryLike,\n//   options: CipherCCMOptions\n// ): Cipher;\n// export function createCipher(\n//   algorithm: CipherGCMTypes,\n//   password: BinaryLike,\n//   options?: CipherGCMOptions\n// ): Cipher;\nexport function createCipher(\n  algorithm: string,\n  password: BinaryLike,\n  options?: Stream.TransformOptions\n): Cipher {\n  return new Cipher(algorithm, password, options);\n}\n\n// TODO(osp) on all the createCipheriv methods, node seems to use a \"KeyObject\" is seems to be a thread safe\n// object that creates keys and what not. Not sure if we should support it.\n// Fow now I replaced all of them to BinaryLike\n// export function createCipheriv(\n//   algorithm: CipherCCMTypes,\n//   key: BinaryLike,\n//   iv: BinaryLike,\n//   options: CipherCCMOptions\n// ): Cipher;\n// export function createCipheriv(\n//   algorithm: CipherOCBTypes,\n//   key: BinaryLike,\n//   iv: BinaryLike,\n//   options: CipherOCBOptions\n// ): CipherOCB;\n// export function createCipheriv(\n//   algorithm: CipherGCMTypes,\n//   key: BinaryLike,\n//   iv: BinaryLike,\n//   options?: CipherGCMOptions\n// ): Cipher;\nexport function createCipheriv(\n  algorithm: string,\n  key: BinaryLike,\n  iv: BinaryLike | null,\n  options?: Stream.TransformOptions\n): Cipher {\n  return new Cipher(algorithm, key, options, iv);\n}\n"]}

package/lib/module/Hash.js

@@ -0,0 +1,87 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* eslint-disable no-dupe-class-members */
+import 'react-native';
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import { toArrayBuffer } from './Utils';
+import Stream from 'stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+global.process.nextTick = setImmediate;
+const createInternalHash = NativeQuickCrypto.createHash;
+export function createHash(algorithm, options) {
+  return new Hash(algorithm, options);
+}
+
+class Hash extends Stream.Transform {
+  constructor(arg, options) {
+    super(options !== null && options !== void 0 ? options : undefined);
+
+    _defineProperty(this, "internalHash", void 0);
+
+    if (arg instanceof Hash) {
+      this.internalHash = arg.internalHash.copy(options === null || options === void 0 ? void 0 : options.outputLength);
+    } else {
+      this.internalHash = createInternalHash(arg, options === null || options === void 0 ? void 0 : options.outputLength);
+    }
+  }
+
+  copy(options) {
+    const copy = new Hash(this, options);
+    return copy;
+  }
+  /**
+   * Updates the hash content with the given `data`, the encoding of which
+   * is given in `inputEncoding`.
+   * If `encoding` is not provided, and the `data` is a string, an
+   * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+   *
+   * This can be called many times with new data as it is streamed.
+   * @since v0.1.92
+   * @param inputEncoding The `encoding` of the `data` string.
+   */
+
+
+  update(data, inputEncoding) {
+    if (data instanceof ArrayBuffer) {
+      this.internalHash.update(data);
+      return this;
+    }
+
+    const buffer = Buffer.from(data, inputEncoding);
+    this.internalHash.update(toArrayBuffer(buffer));
+    return this;
+  }
+
+  _transform(chunk, encoding, callback) {
+    this.update(chunk, encoding);
+    callback();
+  }
+
+  _flush(callback) {
+    this.push(this.digest());
+    callback();
+  }
+  /**
+   * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
+   * If `encoding` is provided a string will be returned; otherwise
+   * a `Buffer` is returned.
+   *
+   * The `Hash` object can not be used again after `hash.digest()` method has been
+   * called. Multiple calls will cause an error to be thrown.
+   * @since v0.1.92
+   * @param encoding The `encoding` of the return value.
+   */
+
+
+  digest(encoding) {
+    const result = this.internalHash.digest();
+
+    if (encoding && encoding !== 'buffer') {
+      return Buffer.from(result).toString(encoding);
+    }
+
+    return Buffer.from(result);
+  }
+
+}
+//# sourceMappingURL=Hash.js.map