web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/node_modules/@noble/ciphers/esm/chacha.js

@@ -0,0 +1,226 @@
+'use strict';
+
+var _arx = require('./_arx.js');
+var _poly1305 = require('./_poly1305.js');
+var utils = require('./utils.js');
+
+/**
+ * [ChaCha20](https://cr.yp.to/chacha.html) stream cipher, released
+ * in 2008. Developed after Salsa20, ChaCha aims to increase diffusion per round.
+ * It was standardized in [RFC 8439](https://datatracker.ietf.org/doc/html/rfc8439) and
+ * is now used in TLS 1.3.
+ *
+ * [XChaCha20](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha)
+ * extended-nonce variant is also provided. Similar to XSalsa, it's safe to use with
+ * randomly-generated nonces.
+ *
+ * Check out [PDF](http://cr.yp.to/chacha/chacha-20080128.pdf) and
+ * [wiki](https://en.wikipedia.org/wiki/Salsa20).
+ * @module
+ */
+/**
+ * ChaCha core function.
+ */
+// prettier-ignore
+function chachaCore(s, k, n, out, cnt) {
+  let rounds = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 20;
+  let y00 = s[0],
+    y01 = s[1],
+    y02 = s[2],
+    y03 = s[3],
+    // "expa"   "nd 3"  "2-by"  "te k"
+    y04 = k[0],
+    y05 = k[1],
+    y06 = k[2],
+    y07 = k[3],
+    // Key      Key     Key     Key
+    y08 = k[4],
+    y09 = k[5],
+    y10 = k[6],
+    y11 = k[7],
+    // Key      Key     Key     Key
+    y12 = cnt,
+    y13 = n[0],
+    y14 = n[1],
+    y15 = n[2]; // Counter  Counter	Nonce   Nonce
+  // Save state to temporary variables
+  let x00 = y00,
+    x01 = y01,
+    x02 = y02,
+    x03 = y03,
+    x04 = y04,
+    x05 = y05,
+    x06 = y06,
+    x07 = y07,
+    x08 = y08,
+    x09 = y09,
+    x10 = y10,
+    x11 = y11,
+    x12 = y12,
+    x13 = y13,
+    x14 = y14,
+    x15 = y15;
+  for (let r = 0; r < rounds; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = _arx.rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = _arx.rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = _arx.rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = _arx.rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = _arx.rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = _arx.rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = _arx.rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = _arx.rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = _arx.rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = _arx.rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = _arx.rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = _arx.rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = _arx.rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = _arx.rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = _arx.rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = _arx.rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = _arx.rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = _arx.rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = _arx.rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = _arx.rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = _arx.rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = _arx.rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = _arx.rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = _arx.rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = _arx.rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = _arx.rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = _arx.rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = _arx.rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = _arx.rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = _arx.rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = _arx.rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = _arx.rotl(x04 ^ x09, 7);
+  }
+  // Write output
+  let oi = 0;
+  out[oi++] = y00 + x00 | 0;
+  out[oi++] = y01 + x01 | 0;
+  out[oi++] = y02 + x02 | 0;
+  out[oi++] = y03 + x03 | 0;
+  out[oi++] = y04 + x04 | 0;
+  out[oi++] = y05 + x05 | 0;
+  out[oi++] = y06 + x06 | 0;
+  out[oi++] = y07 + x07 | 0;
+  out[oi++] = y08 + x08 | 0;
+  out[oi++] = y09 + x09 | 0;
+  out[oi++] = y10 + x10 | 0;
+  out[oi++] = y11 + x11 | 0;
+  out[oi++] = y12 + x12 | 0;
+  out[oi++] = y13 + x13 | 0;
+  out[oi++] = y14 + x14 | 0;
+  out[oi++] = y15 + x15 | 0;
+}
+/**
+ * ChaCha stream cipher. Conforms to RFC 8439 (IETF, TLS). 12-byte nonce, 4-byte counter.
+ * With 12-byte nonce, it's not safe to use fill it with random (CSPRNG), due to collision chance.
+ */
+const chacha20 = /* @__PURE__ */_arx.createCipher(chachaCore, {
+  counterRight: false,
+  counterLength: 4,
+  allowShortKeys: false
+});
+const ZEROS16 = /* @__PURE__ */new Uint8Array(16);
+// Pad to digest size with zeros
+const updatePadded = (h, msg) => {
+  h.update(msg);
+  const left = msg.length % 16;
+  if (left) h.update(ZEROS16.subarray(left));
+};
+const ZEROS32 = /* @__PURE__ */new Uint8Array(32);
+function computeTag(fn, key, nonce, data, AAD) {
+  const authKey = fn(key, nonce, ZEROS32);
+  const h = _poly1305.poly1305.create(authKey);
+  if (AAD) updatePadded(h, AAD);
+  updatePadded(h, data);
+  const num = utils.u64Lengths(data.length, AAD ? AAD.length : 0, true);
+  h.update(num);
+  const res = h.digest();
+  utils.clean(authKey, num);
+  return res;
+}
+/**
+ * AEAD algorithm from RFC 8439.
+ * Salsa20 and chacha (RFC 8439) use poly1305 differently.
+ * We could have composed them similar to:
+ * https://github.com/paulmillr/scure-base/blob/b266c73dde977b1dd7ef40ef7a23cc15aab526b3/index.ts#L250
+ * But it's hard because of authKey:
+ * In salsa20, authKey changes position in salsa stream.
+ * In chacha, authKey can't be computed inside computeTag, it modifies the counter.
+ */
+const _poly1305_aead = xorStream => (key, nonce, AAD) => {
+  const tagLength = 16;
+  return {
+    encrypt(plaintext, output) {
+      const plength = plaintext.length;
+      output = utils.getOutput(plength + tagLength, output, false);
+      output.set(plaintext);
+      const oPlain = output.subarray(0, -tagLength);
+      xorStream(key, nonce, oPlain, oPlain, 1);
+      const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
+      output.set(tag, plength); // append tag
+      utils.clean(tag);
+      return output;
+    },
+    decrypt(ciphertext, output) {
+      output = utils.getOutput(ciphertext.length - tagLength, output, false);
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = computeTag(xorStream, key, nonce, data, AAD);
+      if (!utils.equalBytes(passedTag, tag)) throw new Error('invalid tag');
+      output.set(ciphertext.subarray(0, -tagLength));
+      xorStream(key, nonce, output, output, 1); // start stream with i=1
+      utils.clean(tag);
+      return output;
+    }
+  };
+};
+/**
+ * ChaCha20-Poly1305 from RFC 8439.
+ *
+ * Unsafe to use random nonces under the same key, due to collision chance.
+ * Prefer XChaCha instead.
+ */
+const chacha20poly1305 = /* @__PURE__ */utils.wrapCipher({
+  blockSize: 64,
+  nonceLength: 12,
+  tagLength: 16
+}, _poly1305_aead(chacha20));
+
+exports._poly1305_aead = _poly1305_aead;
+exports.chacha20 = chacha20;
+exports.chacha20poly1305 = chacha20poly1305;

package/dist/cjs/node_modules/@noble/ciphers/esm/utils.js

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array';
+}
+/** Asserts something is boolean. */
+function abool(b) {
+  if (typeof b !== 'boolean') throw new Error(`boolean expected, not ${b}`);
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes(b) {
+  if (!isBytes(b)) throw new Error('Uint8Array expected');
+  for (var _len = arguments.length, lengths = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    lengths[_key - 1] = arguments[_key];
+  }
+  if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance) {
+  let checkFinished = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (instance.destroyed) throw new Error('Hash instance has been destroyed');
+  if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('digestInto() expects output buffer of length at least ' + min);
+  }
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean() {
+  for (var _len2 = arguments.length, arrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    arrays[_key2] = arguments[_key2];
+  }
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = /* @__PURE__ */(() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+  if (typeof str !== 'string') throw new Error('string expected');
+  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+  if (typeof data === 'string') data = utf8ToBytes(data);else if (isBytes(data)) data = copyBytes(data);else throw new Error('Uint8Array expected, got ' + typeof data);
+  return data;
+}
+function checkOpts(defaults, opts) {
+  if (opts == null || typeof opts !== 'object') throw new Error('options must be defined');
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
+/** Compares 2 uint8array-s in kinda constant time. */
+function equalBytes(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+/**
+ * Wraps a cipher: validates args, ensures encrypt() can only be called once.
+ * @__NO_SIDE_EFFECTS__
+ */
+const wrapCipher = (params, constructor) => {
+  function wrappedCipher(key) {
+    // Validate key
+    abytes(key);
+    // Big-Endian hardware is rare. Just in case someone still decides to run ciphers:
+    if (!isLE) throw new Error('Non little-endian hardware is not yet supported');
+    // Validate nonce if nonceLength is present
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+    if (params.nonceLength !== undefined) {
+      const nonce = args[0];
+      if (!nonce) throw new Error('nonce / iv required');
+      if (params.varSizeNonce) abytes(nonce);else abytes(nonce, params.nonceLength);
+    }
+    // Validate AAD if tagLength present
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== undefined) {
+      abytes(args[1]);
+    }
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== undefined) {
+        if (fnLength !== 2) throw new Error('cipher output not supported');
+        abytes(output);
+      }
+    };
+    // Create wrapped cipher with validation and single-use encryption
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called) throw new Error('cannot encrypt() twice with same key + nonce');
+        called = true;
+        abytes(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data);
+        if (tagl && data.length < tagl) throw new Error('invalid ciphertext length: smaller than tagLength=' + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+/**
+ * By default, returns u8a of length.
+ * When out is available, it checks it for validity and uses it.
+ */
+function getOutput(expectedLength, out) {
+  let onlyAligned = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  if (out === undefined) return new Uint8Array(expectedLength);
+  if (out.length !== expectedLength) throw new Error('invalid output length, expected ' + expectedLength + ', got: ' + out.length);
+  if (onlyAligned && !isAligned32(out)) throw new Error('invalid output, must be aligned');
+  return out;
+}
+/** Polyfill for Safari 14. */
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === 'function') return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(0xffffffff);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = 4 ;
+  const l = 0 ;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function u64Lengths(dataLength, aadLength, isLE) {
+  abool(isLE);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  setBigUint64(view, 0, BigInt(aadLength), isLE);
+  setBigUint64(view, 8, BigInt(dataLength), isLE);
+  return num;
+}
+// Is byte array aligned to 4 byte offset (u32)?
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+// copy bytes to new u8a (aligned). Because Buffer.slice is broken.
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+
+exports.abool = abool;
+exports.abytes = abytes;
+exports.aexists = aexists;
+exports.anumber = anumber;
+exports.aoutput = aoutput;
+exports.checkOpts = checkOpts;
+exports.clean = clean;
+exports.copyBytes = copyBytes;
+exports.createView = createView;
+exports.equalBytes = equalBytes;
+exports.getOutput = getOutput;
+exports.isAligned32 = isAligned32;
+exports.isBytes = isBytes;
+exports.isLE = isLE;
+exports.setBigUint64 = setBigUint64;
+exports.toBytes = toBytes;
+exports.u32 = u32;
+exports.u64Lengths = u64Lengths;
+exports.utf8ToBytes = utf8ToBytes;
+exports.wrapCipher = wrapCipher;

package/dist/cjs/node_modules/@noble/curves/esm/_shortw_utils.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var hmac = require('../../hashes/esm/hmac.js');
+var utils = require('../../hashes/esm/utils.js');
+var weierstrass = require('./abstract/weierstrass.js');
+
+/**
+ * Utilities for short weierstrass curves, combined with noble-hashes.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** connects noble-curves to noble-hashes */
+function getHash(hash) {
+  return {
+    hash,
+    hmac: function (key) {
+      for (var _len = arguments.length, msgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        msgs[_key - 1] = arguments[_key];
+      }
+      return hmac.hmac(hash, key, utils.concatBytes(...msgs));
+    },
+    randomBytes: utils.randomBytes
+  };
+}
+function createCurve(curveDef, defHash) {
+  const create = hash => weierstrass.weierstrass({
+    ...curveDef,
+    ...getHash(hash)
+  });
+  return {
+    ...create(defHash),
+    create
+  };
+}
+
+exports.createCurve = createCurve;
+exports.getHash = getHash;