@rancher/shell 0.1.0

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, unicorn/no-new-buffer
+  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, unicorn/no-new-buffer
+  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;
+};

package/utils/crypto/index.js

@@ -0,0 +1,181 @@
+/* eslint-disable node/no-deprecated-api, unicorn/no-new-buffer */
+import { Buffer } from 'buffer';
+import Md5 from './browserMd5';
+import Sha256 from './browserSha256';
+import Sha1 from './browserSha1';
+
+// lib/util.js
+const NORMAL = 'normal';
+const URL = 'url';
+
+export function base64Encode(string, alphabet = NORMAL) {
+  let buf;
+
+  if (string === null || typeof string === 'undefined') {
+    return string;
+  }
+
+  if ( typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from ) {
+    buf = Buffer.from(string);
+  } else {
+    buf = new Buffer(string);
+  }
+  if (alphabet === URL) {
+    const m = {
+      '+': '-',
+      '/': '_',
+    };
+
+    return buf.toString('base64').replace(/[+/]|=+$/g, char => m[char] || '');
+  }
+
+  return buf.toString('base64');
+}
+
+export function base64DecodeToBuffer(string) {
+  if (string === null || typeof string === 'undefined') {
+    return string;
+  }
+
+  if ( typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from ) {
+    return Buffer.from(string, 'base64');
+  } else {
+    return new Buffer(string, 'base64');
+  }
+}
+
+export function base64Decode(string) {
+  return !string ? string : base64DecodeToBuffer(string.replace(/[-_]/g, char => char === '-' ? '+' : '/')).toString();
+}
+
+export function md5(data, digest, callback) {
+  return hash('md5', data, digest, callback);
+}
+
+export function sha256(data, digest, callback) {
+  return hash('sha256', data, digest, callback);
+}
+
+export function binarySize(val) {
+  const size = `${ val }`.length;
+
+  // It is base64 encoded, so adjust size
+  let realSize = (3 * size / 4) ;
+
+  // Might be one or two padding characters
+  if (val.length > 0 && val[val.length - 1] === '=') {
+    realSize--;
+    if (val.length > 1 && val[val.length - 2] === '=') {
+      realSize--;
+    }
+  }
+
+  return realSize;
+}
+
+// *****************************
+// Below here be dragons
+// *****************************
+
+function hash(algorithm, data, digest, callback) {
+  const hash = createHash(algorithm);
+
+  if ( !digest ) {
+    digest = 'binary';
+  }
+
+  if ( digest === 'buffer' ) {
+    digest = undefined;
+  }
+
+  if ( typeof data === 'string' ) {
+    data = new Buffer(data);
+  }
+
+  const sliceFn = arraySliceFn(data);
+  let isBuffer = Buffer.isBuffer(data);
+
+  // Identifying objects with an ArrayBuffer as buffers
+  if ( typeof ArrayBuffer !== 'undefined' && data && data.buffer instanceof ArrayBuffer) {
+    isBuffer = true;
+  }
+
+  if ( callback && typeof data === 'object' && typeof data.on === 'function' && !isBuffer ) {
+    data.on('data', (chunk) => {
+      hash.update(chunk);
+    });
+
+    data.on('error', (err) => {
+      callback(err);
+    });
+
+    data.on('end', () => {
+      callback(null, hash.digest(digest));
+    });
+  } else if (callback && sliceFn && !isBuffer && typeof FileReader !== 'undefined') {
+    // this might be a File/Blob
+    let index = 0; const size = 1024 * 512;
+    const reader = new FileReader();
+
+    reader.onerror = function() {
+      callback(new Error('Failed to read data.'));
+    };
+
+    reader.onload = function() {
+      const buf = new Buffer(new Uint8Array(reader.result));
+
+      hash.update(buf);
+      index += buf.length;
+      reader._continueReading();
+    };
+
+    reader._continueReading = function() {
+      if (index >= data.size) {
+        callback(null, hash.digest(digest));
+
+        return;
+      }
+
+      let back = index + size;
+
+      if (back > data.size) {
+        back = data.size;
+      }
+
+      reader.readAsArrayBuffer(sliceFn.call(data, index, back));
+    };
+
+    reader._continueReading();
+  } else {
+    if ( typeof data === 'object' && !isBuffer ) {
+      data = new Buffer(new Uint8Array(data));
+    }
+
+    const out = hash.update(data).digest(digest);
+
+    if (callback) {
+      callback(null, out);
+    }
+
+    return out;
+  }
+}
+
+function createHash(alg) {
+  alg = alg.toLowerCase();
+  if (alg === 'md5') {
+    return new Md5();
+  } else if (alg === 'sha256') {
+    return new Sha256();
+  } else if (alg === 'sha1') {
+    return new Sha1();
+  }
+
+  throw new Error(`Hash algorithm ${ alg } is not supported`);
+}
+
+function arraySliceFn(obj) {
+  const fn = obj.slice || obj.webkitSlice || obj.mozSlice;
+
+  return typeof fn === 'function' ? fn : null;
+}

package/utils/custom-validators.js

@@ -0,0 +1,45 @@
+import { flowOutput } from '@shell/utils/validators/flow-output';
+import { logdna } from '@shell/utils/validators/logging-outputs';
+import { clusterIp, externalName, servicePort } from '@shell/utils/validators/service';
+import { ruleGroups, groupsAreValid } from '@shell/utils/validators/prometheusrule';
+import { interval, matching } from '@shell/utils/validators/monitoring-route';
+import { containerImages } from '@shell/utils/validators/container-images';
+import { cronSchedule } from '@shell/utils/validators/cron-schedule';
+import { podAffinity } from '@shell/utils/validators/pod-affinity';
+import { roleTemplateRules } from '@shell/utils/validators/role-template';
+import { clusterName } from '@shell/utils/validators/cluster-name';
+import { isHttps, backupTarget } from '@shell/utils/validators/setting';
+
+import { imageUrl, fileRequired } from '@shell/utils/validators/vm-image';
+
+import { vmNetworks, vmDisks } from '@shell/utils/validators/vm';
+import { dataVolumeSize } from '@shell/utils/validators/vm-datavolumes';
+
+/**
+* Custom validation functions beyond normal scalr types
+* Validator must export a function name should match the validator name on the customValidationRules rule
+* Exported function is used as a lookup key in resource-class:validationErrors:customValidationRules loop
+*/
+export default {
+  clusterName,
+  clusterIp,
+  externalName,
+  flowOutput,
+  groupsAreValid,
+  logdna,
+  ruleGroups,
+  interval,
+  servicePort,
+  matching,
+  containerImages,
+  cronSchedule,
+  podAffinity,
+  roleTemplateRules,
+  isHttps,
+  backupTarget,
+  imageUrl,
+  dataVolumeSize,
+  vmNetworks,
+  vmDisks,
+  fileRequired,
+};

package/utils/download.js

@@ -0,0 +1,35 @@
+import JSZip from 'jszip';
+
+export async function downloadFile(fileName, content, contentType = 'text/plain;charset=utf-8') {
+  const blob = new Blob([content], { type: contentType });
+  const { saveAs } = await import('file-saver');
+
+  return saveAs(blob, fileName);
+}
+
+// {[fileName1]:data1, [fileName2]:data2}
+export function generateZip(files) {
+  // Moving this to a dynamic const JSZip = import('jszip') didn't work... figure out later
+  const zip = new JSZip();
+
+  for ( const fileName in files) {
+    zip.file(fileName, files[fileName]);
+  }
+
+  return zip.generateAsync({ type: 'blob' }).then((contents) => {
+    return contents;
+  });
+}
+
+export function downloadUrl(url, id = '__downloadIframe') {
+  let iframe = document.getElementById(id);
+
+  if ( !iframe ) {
+    iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    iframe.id = id;
+    document.body.appendChild(iframe);
+  }
+
+  iframe.src = url;
+}