dashboard-shell-shell 1.0.111

package/utils/crypto/browserMd5.js

@@ -0,0 +1,183 @@
+import { Buffer } from 'buffer';
+import { isEmptyData, convertToBuffer } from './browserHashUtils';
+
+const BLOCK_SIZE = 64;
+
+const DIGEST_LENGTH = 16;
+
+/**
+ * @api private
+ */
+function Md5() {
+  this.state = [
+    0x67452301,
+    0xEFCDAB89,
+    0x98BADCFE,
+    0x10325476,
+  ];
+  this.buffer = new DataView(new ArrayBuffer(BLOCK_SIZE));
+  this.bufferLength = 0;
+  this.bytesHashed = 0;
+  this.finished = false;
+}
+
+/**
+ * @api private
+ */
+export default Md5;
+
+Md5.BLOCK_SIZE = BLOCK_SIZE;
+
+Md5.prototype.update = function(sourceData) {
+  if (isEmptyData(sourceData)) {
+    return this;
+  } else if (this.finished) {
+    throw new Error('Attempted to update an already finished hash.');
+  }
+
+  const data = convertToBuffer(sourceData);
+  let position = 0;
+  let byteLength = data.byteLength;
+
+  this.bytesHashed += byteLength;
+  while (byteLength > 0) {
+    this.buffer.setUint8(this.bufferLength++, data[position++]);
+    byteLength--;
+    if (this.bufferLength === BLOCK_SIZE) {
+      this.hashBuffer();
+      this.bufferLength = 0;
+    }
+  }
+
+  return this;
+};
+
+Md5.prototype.digest = function(encoding) {
+  if (!this.finished) {
+    const _a = this; const buffer = _a.buffer; const undecoratedLength = _a.bufferLength; const bytesHashed = _a.bytesHashed;
+    const bitsHashed = bytesHashed * 8;
+
+    buffer.setUint8(this.bufferLength++, 128);
+    // Ensure the final block has enough room for the hashed length
+    if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
+      for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
+        buffer.setUint8(i, 0);
+      }
+      this.hashBuffer();
+      this.bufferLength = 0;
+    }
+    for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
+      buffer.setUint8(i, 0);
+    }
+    buffer.setUint32(BLOCK_SIZE - 8, bitsHashed >>> 0, true);
+    buffer.setUint32(BLOCK_SIZE - 4, Math.floor(bitsHashed / 0x100000000), true);
+    this.hashBuffer();
+    this.finished = true;
+  }
+  const out = new DataView(new ArrayBuffer(DIGEST_LENGTH));
+
+  for (let i = 0; i < 4; i++) {
+    out.setUint32(i * 4, this.state[i], true);
+  }
+
+  // eslint-disable-next-line node/no-deprecated-api
+  const buff = new Buffer(out.buffer, out.byteOffset, out.byteLength);
+
+  return encoding ? buff.toString(encoding) : buff;
+};
+
+Md5.prototype.hashBuffer = function() {
+  const _a = this; const buffer = _a.buffer; const state = _a.state;
+  let a = state[0]; let b = state[1]; let c = state[2]; let d = state[3];
+
+  a = ff(a, b, c, d, buffer.getUint32(0, true), 7, 0xD76AA478);
+  d = ff(d, a, b, c, buffer.getUint32(4, true), 12, 0xE8C7B756);
+  c = ff(c, d, a, b, buffer.getUint32(8, true), 17, 0x242070DB);
+  b = ff(b, c, d, a, buffer.getUint32(12, true), 22, 0xC1BDCEEE);
+  a = ff(a, b, c, d, buffer.getUint32(16, true), 7, 0xF57C0FAF);
+  d = ff(d, a, b, c, buffer.getUint32(20, true), 12, 0x4787C62A);
+  c = ff(c, d, a, b, buffer.getUint32(24, true), 17, 0xA8304613);
+  b = ff(b, c, d, a, buffer.getUint32(28, true), 22, 0xFD469501);
+  a = ff(a, b, c, d, buffer.getUint32(32, true), 7, 0x698098D8);
+  d = ff(d, a, b, c, buffer.getUint32(36, true), 12, 0x8B44F7AF);
+  c = ff(c, d, a, b, buffer.getUint32(40, true), 17, 0xFFFF5BB1);
+  b = ff(b, c, d, a, buffer.getUint32(44, true), 22, 0x895CD7BE);
+  a = ff(a, b, c, d, buffer.getUint32(48, true), 7, 0x6B901122);
+  d = ff(d, a, b, c, buffer.getUint32(52, true), 12, 0xFD987193);
+  c = ff(c, d, a, b, buffer.getUint32(56, true), 17, 0xA679438E);
+  b = ff(b, c, d, a, buffer.getUint32(60, true), 22, 0x49B40821);
+  a = gg(a, b, c, d, buffer.getUint32(4, true), 5, 0xF61E2562);
+  d = gg(d, a, b, c, buffer.getUint32(24, true), 9, 0xC040B340);
+  c = gg(c, d, a, b, buffer.getUint32(44, true), 14, 0x265E5A51);
+  b = gg(b, c, d, a, buffer.getUint32(0, true), 20, 0xE9B6C7AA);
+  a = gg(a, b, c, d, buffer.getUint32(20, true), 5, 0xD62F105D);
+  d = gg(d, a, b, c, buffer.getUint32(40, true), 9, 0x02441453);
+  c = gg(c, d, a, b, buffer.getUint32(60, true), 14, 0xD8A1E681);
+  b = gg(b, c, d, a, buffer.getUint32(16, true), 20, 0xE7D3FBC8);
+  a = gg(a, b, c, d, buffer.getUint32(36, true), 5, 0x21E1CDE6);
+  d = gg(d, a, b, c, buffer.getUint32(56, true), 9, 0xC33707D6);
+  c = gg(c, d, a, b, buffer.getUint32(12, true), 14, 0xF4D50D87);
+  b = gg(b, c, d, a, buffer.getUint32(32, true), 20, 0x455A14ED);
+  a = gg(a, b, c, d, buffer.getUint32(52, true), 5, 0xA9E3E905);
+  d = gg(d, a, b, c, buffer.getUint32(8, true), 9, 0xFCEFA3F8);
+  c = gg(c, d, a, b, buffer.getUint32(28, true), 14, 0x676F02D9);
+  b = gg(b, c, d, a, buffer.getUint32(48, true), 20, 0x8D2A4C8A);
+  a = hh(a, b, c, d, buffer.getUint32(20, true), 4, 0xFFFA3942);
+  d = hh(d, a, b, c, buffer.getUint32(32, true), 11, 0x8771F681);
+  c = hh(c, d, a, b, buffer.getUint32(44, true), 16, 0x6D9D6122);
+  b = hh(b, c, d, a, buffer.getUint32(56, true), 23, 0xFDE5380C);
+  a = hh(a, b, c, d, buffer.getUint32(4, true), 4, 0xA4BEEA44);
+  d = hh(d, a, b, c, buffer.getUint32(16, true), 11, 0x4BDECFA9);
+  c = hh(c, d, a, b, buffer.getUint32(28, true), 16, 0xF6BB4B60);
+  b = hh(b, c, d, a, buffer.getUint32(40, true), 23, 0xBEBFBC70);
+  a = hh(a, b, c, d, buffer.getUint32(52, true), 4, 0x289B7EC6);
+  d = hh(d, a, b, c, buffer.getUint32(0, true), 11, 0xEAA127FA);
+  c = hh(c, d, a, b, buffer.getUint32(12, true), 16, 0xD4EF3085);
+  b = hh(b, c, d, a, buffer.getUint32(24, true), 23, 0x04881D05);
+  a = hh(a, b, c, d, buffer.getUint32(36, true), 4, 0xD9D4D039);
+  d = hh(d, a, b, c, buffer.getUint32(48, true), 11, 0xE6DB99E5);
+  c = hh(c, d, a, b, buffer.getUint32(60, true), 16, 0x1FA27CF8);
+  b = hh(b, c, d, a, buffer.getUint32(8, true), 23, 0xC4AC5665);
+  a = ii(a, b, c, d, buffer.getUint32(0, true), 6, 0xF4292244);
+  d = ii(d, a, b, c, buffer.getUint32(28, true), 10, 0x432AFF97);
+  c = ii(c, d, a, b, buffer.getUint32(56, true), 15, 0xAB9423A7);
+  b = ii(b, c, d, a, buffer.getUint32(20, true), 21, 0xFC93A039);
+  a = ii(a, b, c, d, buffer.getUint32(48, true), 6, 0x655B59C3);
+  d = ii(d, a, b, c, buffer.getUint32(12, true), 10, 0x8F0CCC92);
+  c = ii(c, d, a, b, buffer.getUint32(40, true), 15, 0xFFEFF47D);
+  b = ii(b, c, d, a, buffer.getUint32(4, true), 21, 0x85845DD1);
+  a = ii(a, b, c, d, buffer.getUint32(32, true), 6, 0x6FA87E4F);
+  d = ii(d, a, b, c, buffer.getUint32(60, true), 10, 0xFE2CE6E0);
+  c = ii(c, d, a, b, buffer.getUint32(24, true), 15, 0xA3014314);
+  b = ii(b, c, d, a, buffer.getUint32(52, true), 21, 0x4E0811A1);
+  a = ii(a, b, c, d, buffer.getUint32(16, true), 6, 0xF7537E82);
+  d = ii(d, a, b, c, buffer.getUint32(44, true), 10, 0xBD3AF235);
+  c = ii(c, d, a, b, buffer.getUint32(8, true), 15, 0x2AD7D2BB);
+  b = ii(b, c, d, a, buffer.getUint32(36, true), 21, 0xEB86D391);
+  state[0] = (a + state[0]) & 0xFFFFFFFF;
+  state[1] = (b + state[1]) & 0xFFFFFFFF;
+  state[2] = (c + state[2]) & 0xFFFFFFFF;
+  state[3] = (d + state[3]) & 0xFFFFFFFF;
+};
+
+function cmn(q, a, b, x, s, t) {
+  a = (((a + q) & 0xFFFFFFFF) + ((x + t) & 0xFFFFFFFF)) & 0xFFFFFFFF;
+
+  return (((a << s) | (a >>> (32 - s))) + b) & 0xFFFFFFFF;
+}
+
+function ff(a, b, c, d, x, s, t) {
+  return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+}
+
+function gg(a, b, c, d, x, s, t) {
+  return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+}
+
+function hh(a, b, c, d, x, s, t) {
+  return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a, b, c, d, x, s, t) {
+  return cmn(c ^ (b | (~d)), a, b, x, s, t);
+}

package/utils/crypto/browserSha1.js

@@ -0,0 +1,149 @@
+import { Buffer } from 'buffer';
+import { isEmptyData, convertToBuffer } from './browserHashUtils';
+
+const BLOCK_SIZE = 64;
+const DIGEST_LENGTH = 20;
+
+/**
+ * @api private
+ */
+function Sha1() {
+  this.h0 = 0x67452301;
+  this.h1 = 0xEFCDAB89;
+  this.h2 = 0x98BADCFE;
+  this.h3 = 0x10325476;
+  this.h4 = 0xC3D2E1F0;
+  // The first 64 bytes (16 words) is the data chunk
+  this.block = new Uint32Array(80);
+  this.offset = 0;
+  this.shift = 24;
+  this.totalLength = 0;
+}
+
+/**
+ * @api private
+ */
+export default Sha1;
+
+Sha1.BLOCK_SIZE = BLOCK_SIZE;
+
+Sha1.prototype.update = function(data) {
+  if (this.finished) {
+    throw new Error('Attempted to update an already finished hash.');
+  }
+
+  if (isEmptyData(data)) {
+    return this;
+  }
+
+  data = convertToBuffer(data);
+
+  const length = data.length;
+
+  this.totalLength += length * 8;
+  for (let i = 0; i < length; i++) {
+    this.write(data[i]);
+  }
+
+  return this;
+};
+
+Sha1.prototype.write = function write(byte) {
+  this.block[this.offset] |= (byte & 0xFF) << this.shift;
+  if (this.shift) {
+    this.shift -= 8;
+  } else {
+    this.offset++;
+    this.shift = 24;
+  }
+
+  if (this.offset === 16) {
+    this.processBlock();
+  }
+};
+
+Sha1.prototype.digest = function(encoding) {
+  // Pad
+  this.write(0x80);
+  if (this.offset > 14 || (this.offset === 14 && this.shift < 24)) {
+    this.processBlock();
+  }
+  this.offset = 14;
+  this.shift = 24;
+
+  // 64-bit length big-endian
+  this.write(0x00); // numbers this big aren't accurate in javascript anyway
+  this.write(0x00); // ..So just hard-code to zero.
+  this.write(this.totalLength > 0xFFFFFFFFFF ? this.totalLength / 0x10000000000 : 0x00);
+  this.write(this.totalLength > 0xFFFFFFFF ? this.totalLength / 0x100000000 : 0x00);
+  for (let s = 24; s >= 0; s -= 8) {
+    this.write(this.totalLength >> s);
+  }
+  // The value in state is little-endian rather than big-endian, so flip
+  // each word into a new Uint8Array
+  // eslint-disable-next-line node/no-deprecated-api
+  const out = new Buffer(DIGEST_LENGTH);
+  const outView = new DataView(out.buffer);
+
+  outView.setUint32(0, this.h0, false);
+  outView.setUint32(4, this.h1, false);
+  outView.setUint32(8, this.h2, false);
+  outView.setUint32(12, this.h3, false);
+  outView.setUint32(16, this.h4, false);
+
+  return encoding ? out.toString(encoding) : out;
+};
+
+Sha1.prototype.processBlock = function processBlock() {
+  // Extend the sixteen 32-bit words into eighty 32-bit words:
+  for (let i = 16; i < 80; i++) {
+    const w = this.block[i - 3] ^ this.block[i - 8] ^ this.block[i - 14] ^ this.block[i - 16];
+
+    this.block[i] = (w << 1) | (w >>> 31);
+  }
+
+  // Initialize hash value for this chunk:
+  let a = this.h0;
+  let b = this.h1;
+  let c = this.h2;
+  let d = this.h3;
+  let e = this.h4;
+  let f, k;
+
+  // Main loop:
+  for (let i = 0; i < 80; i++) {
+    if (i < 20) {
+      f = d ^ (b & (c ^ d));
+      k = 0x5A827999;
+    } else if (i < 40) {
+      f = b ^ c ^ d;
+      k = 0x6ED9EBA1;
+    } else if (i < 60) {
+      f = (b & c) | (d & (b | c));
+      k = 0x8F1BBCDC;
+    } else {
+      f = b ^ c ^ d;
+      k = 0xCA62C1D6;
+    }
+    const temp = (a << 5 | a >>> 27) + f + e + k + (this.block[i] | 0);
+
+    e = d;
+    d = c;
+    c = (b << 30 | b >>> 2);
+    b = a;
+    a = temp;
+  }
+
+  // Add this chunk's hash to result so far:
+  this.h0 = (this.h0 + a) | 0;
+  this.h1 = (this.h1 + b) | 0;
+  this.h2 = (this.h2 + c) | 0;
+  this.h3 = (this.h3 + d) | 0;
+  this.h4 = (this.h4 + e) | 0;
+
+  // The block is now reusable.
+  this.offset = 0;
+  for (let i = 0; i < 16; i++) {
+    this.block[i] = 0;
+  }
+};

package/utils/crypto/browserSha256.js

@@ -0,0 +1,237 @@
+/* eslint-disable camelcase */
+import { Buffer } from 'buffer';
+import { isEmptyData, convertToBuffer } from './browserHashUtils';
+
+const BLOCK_SIZE = 64;
+
+const DIGEST_LENGTH = 32;
+
+const KEY = new Uint32Array([
+  0x428A2F98,
+  0x71374491,
+  0xB5C0FBCF,
+  0xE9B5DBA5,
+  0x3956C25B,
+  0x59F111F1,
+  0x923F82A4,
+  0xAB1C5ED5,
+  0xD807AA98,
+  0x12835B01,
+  0x243185BE,
+  0x550C7DC3,
+  0x72BE5D74,
+  0x80DEB1FE,
+  0x9BDC06A7,
+  0xC19BF174,
+  0xE49B69C1,
+  0xEFBE4786,
+  0x0FC19DC6,
+  0x240CA1CC,
+  0x2DE92C6F,
+  0x4A7484AA,
+  0x5CB0A9DC,
+  0x76F988DA,
+  0x983E5152,
+  0xA831C66D,
+  0xB00327C8,
+  0xBF597FC7,
+  0xC6E00BF3,
+  0xD5A79147,
+  0x06CA6351,
+  0x14292967,
+  0x27B70A85,
+  0x2E1B2138,
+  0x4D2C6DFC,
+  0x53380D13,
+  0x650A7354,
+  0x766A0ABB,
+  0x81C2C92E,
+  0x92722C85,
+  0xA2BFE8A1,
+  0xA81A664B,
+  0xC24B8B70,
+  0xC76C51A3,
+  0xD192E819,
+  0xD6990624,
+  0xF40E3585,
+  0x106AA070,
+  0x19A4C116,
+  0x1E376C08,
+  0x2748774C,
+  0x34B0BCB5,
+  0x391C0CB3,
+  0x4ED8AA4A,
+  0x5B9CCA4F,
+  0x682E6FF3,
+  0x748F82EE,
+  0x78A5636F,
+  0x84C87814,
+  0x8CC70208,
+  0x90BEFFFA,
+  0xA4506CEB,
+  0xBEF9A3F7,
+  0xC67178F2
+]);
+
+const MAX_HASHABLE_LENGTH = 2 ** 53 - 1;
+
+/**
+ * @private
+ */
+function Sha256() {
+  this.state = [
+    0x6A09E667,
+    0xBB67AE85,
+    0x3C6EF372,
+    0xA54FF53A,
+    0x510E527F,
+    0x9B05688C,
+    0x1F83D9AB,
+    0x5BE0CD19,
+  ];
+  this.temp = new Int32Array(64);
+  this.buffer = new Uint8Array(64);
+  this.bufferLength = 0;
+  this.bytesHashed = 0;
+  /**
+     * @private
+     */
+  this.finished = false;
+}
+
+/**
+ * @api private
+ */
+export default Sha256;
+
+Sha256.BLOCK_SIZE = BLOCK_SIZE;
+
+Sha256.prototype.update = function(data) {
+  if (this.finished) {
+    throw new Error('Attempted to update an already finished hash.');
+  }
+
+  if (isEmptyData(data)) {
+    return this;
+  }
+
+  data = convertToBuffer(data);
+
+  let position = 0;
+  let byteLength = data.byteLength;
+
+  this.bytesHashed += byteLength;
+  if (this.bytesHashed * 8 > MAX_HASHABLE_LENGTH) {
+    throw new Error('Cannot hash more than 2^53 - 1 bits');
+  }
+
+  while (byteLength > 0) {
+    this.buffer[this.bufferLength++] = data[position++];
+    byteLength--;
+    if (this.bufferLength === BLOCK_SIZE) {
+      this.hashBuffer();
+      this.bufferLength = 0;
+    }
+  }
+
+  return this;
+};
+
+Sha256.prototype.digest = function(encoding) {
+  if (!this.finished) {
+    const bitsHashed = this.bytesHashed * 8;
+    const bufferView = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    const undecoratedLength = this.bufferLength;
+
+    bufferView.setUint8(this.bufferLength++, 0x80);
+    // Ensure the final block has enough room for the hashed length
+    if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
+      for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
+        bufferView.setUint8(i, 0);
+      }
+      this.hashBuffer();
+      this.bufferLength = 0;
+    }
+    for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
+      bufferView.setUint8(i, 0);
+    }
+    bufferView.setUint32(BLOCK_SIZE - 8, Math.floor(bitsHashed / 0x100000000), true);
+    bufferView.setUint32(BLOCK_SIZE - 4, bitsHashed);
+    this.hashBuffer();
+    this.finished = true;
+  }
+  // The value in state is little-endian rather than big-endian, so flip
+  // each word into a new Uint8Array
+  // eslint-disable-next-line node/no-deprecated-api
+  const out = new Buffer(DIGEST_LENGTH);
+
+  for (let i = 0; i < 8; i++) {
+    out[i * 4] = (this.state[i] >>> 24) & 0xFF;
+    out[i * 4 + 1] = (this.state[i] >>> 16) & 0xFF;
+    out[i * 4 + 2] = (this.state[i] >>> 8) & 0xFF;
+    out[i * 4 + 3] = (this.state[i] >>> 0) & 0xFF;
+  }
+
+  return encoding ? out.toString(encoding) : out;
+};
+
+Sha256.prototype.hashBuffer = function() {
+  const _a = this;
+  const buffer = _a.buffer;
+  const state = _a.state;
+  let state0 = state[0];
+  let state1 = state[1];
+  let state2 = state[2];
+  let state3 = state[3];
+  let state4 = state[4];
+  let state5 = state[5];
+  let state6 = state[6];
+  let state7 = state[7];
+
+  for (let i = 0; i < BLOCK_SIZE; i++) {
+    if (i < 16) {
+      this.temp[i] = (((buffer[i * 4] & 0xFF) << 24) |
+                ((buffer[(i * 4) + 1] & 0xFF) << 16) |
+                ((buffer[(i * 4) + 2] & 0xFF) << 8) |
+                (buffer[(i * 4) + 3] & 0xFF));
+    } else {
+      let u = this.temp[i - 2];
+      const t1_1 = (u >>> 17 | u << 15) ^
+                (u >>> 19 | u << 13) ^
+                (u >>> 10);
+
+      u = this.temp[i - 15];
+      const t2_1 = (u >>> 7 | u << 25) ^
+                (u >>> 18 | u << 14) ^
+                (u >>> 3);
+
+      this.temp[i] = (t1_1 + this.temp[i - 7] | 0) +
+                (t2_1 + this.temp[i - 16] | 0);
+    }
+    const t1 = (((((state4 >>> 6 | state4 << 26) ^
+            (state4 >>> 11 | state4 << 21) ^
+            (state4 >>> 25 | state4 << 7)) +
+            ((state4 & state5) ^ (~state4 & state6))) | 0) +
+            ((state7 + ((KEY[i] + this.temp[i]) | 0)) | 0)) | 0;
+    const t2 = (((state0 >>> 2 | state0 << 30) ^
+            (state0 >>> 13 | state0 << 19) ^
+            (state0 >>> 22 | state0 << 10)) + ((state0 & state1) ^ (state0 & state2) ^ (state1 & state2))) | 0;
+
+    state7 = state6;
+    state6 = state5;
+    state5 = state4;
+    state4 = (state3 + t1) | 0;
+    state3 = state2;
+    state2 = state1;
+    state1 = state0;
+    state0 = (t1 + t2) | 0;
+  }
+  state[0] += state0;
+  state[1] += state1;
+  state[2] += state2;
+  state[3] += state3;
+  state[4] += state4;
+  state[5] += state5;
+  state[6] += state6;
+  state[7] += state7;
+};