pi-codex-auto-review 0.1.2 → 0.1.3

package/node_modules/node-forge/lib/baseN.js

@@ -1,186 +0,0 @@
-/**
- * Base-N/Base-X encoding/decoding functions.
- *
- * Original implementation from base-x:
- * https://github.com/cryptocoinjs/base-x
- *
- * Which is MIT licensed:
- *
- * The MIT License (MIT)
- *
- * Copyright base-x contributors (c) 2016
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-var api = {};
-module.exports = api;
-
-// baseN alphabet indexes
-var _reverseAlphabets = {};
-
-/**
- * BaseN-encodes a Uint8Array using the given alphabet.
- *
- * @param input the Uint8Array to encode.
- * @param maxline the maximum number of encoded characters per line to use,
- *          defaults to none.
- *
- * @return the baseN-encoded output string.
- */
-api.encode = function(input, alphabet, maxline) {
-  if(typeof alphabet !== 'string') {
-    throw new TypeError('"alphabet" must be a string.');
-  }
-  if(maxline !== undefined && typeof maxline !== 'number') {
-    throw new TypeError('"maxline" must be a number.');
-  }
-
-  var output = '';
-
-  if(!(input instanceof Uint8Array)) {
-    // assume forge byte buffer
-    output = _encodeWithByteBuffer(input, alphabet);
-  } else {
-    var i = 0;
-    var base = alphabet.length;
-    var first = alphabet.charAt(0);
-    var digits = [0];
-    for(i = 0; i < input.length; ++i) {
-      for(var j = 0, carry = input[i]; j < digits.length; ++j) {
-        carry += digits[j] << 8;
-        digits[j] = carry % base;
-        carry = (carry / base) | 0;
-      }
-
-      while(carry > 0) {
-        digits.push(carry % base);
-        carry = (carry / base) | 0;
-      }
-    }
-
-    // deal with leading zeros
-    for(i = 0; input[i] === 0 && i < input.length - 1; ++i) {
-      output += first;
-    }
-    // convert digits to a string
-    for(i = digits.length - 1; i >= 0; --i) {
-      output += alphabet[digits[i]];
-    }
-  }
-
-  if(maxline) {
-    var regex = new RegExp('.{1,' + maxline + '}', 'g');
-    output = output.match(regex).join('\r\n');
-  }
-
-  return output;
-};
-
-/**
- * Decodes a baseN-encoded (using the given alphabet) string to a
- * Uint8Array.
- *
- * @param input the baseN-encoded input string.
- *
- * @return the Uint8Array.
- */
-api.decode = function(input, alphabet) {
-  if(typeof input !== 'string') {
-    throw new TypeError('"input" must be a string.');
-  }
-  if(typeof alphabet !== 'string') {
-    throw new TypeError('"alphabet" must be a string.');
-  }
-
-  var table = _reverseAlphabets[alphabet];
-  if(!table) {
-    // compute reverse alphabet
-    table = _reverseAlphabets[alphabet] = [];
-    for(var i = 0; i < alphabet.length; ++i) {
-      table[alphabet.charCodeAt(i)] = i;
-    }
-  }
-
-  // remove whitespace characters
-  input = input.replace(/\s/g, '');
-
-  var base = alphabet.length;
-  var first = alphabet.charAt(0);
-  var bytes = [0];
-  for(var i = 0; i < input.length; i++) {
-    var value = table[input.charCodeAt(i)];
-    if(value === undefined) {
-      return;
-    }
-
-    for(var j = 0, carry = value; j < bytes.length; ++j) {
-      carry += bytes[j] * base;
-      bytes[j] = carry & 0xff;
-      carry >>= 8;
-    }
-
-    while(carry > 0) {
-      bytes.push(carry & 0xff);
-      carry >>= 8;
-    }
-  }
-
-  // deal with leading zeros
-  for(var k = 0; input[k] === first && k < input.length - 1; ++k) {
-    bytes.push(0);
-  }
-
-  if(typeof Buffer !== 'undefined') {
-    return Buffer.from(bytes.reverse());
-  }
-
-  return new Uint8Array(bytes.reverse());
-};
-
-function _encodeWithByteBuffer(input, alphabet) {
-  var i = 0;
-  var base = alphabet.length;
-  var first = alphabet.charAt(0);
-  var digits = [0];
-  for(i = 0; i < input.length(); ++i) {
-    for(var j = 0, carry = input.at(i); j < digits.length; ++j) {
-      carry += digits[j] << 8;
-      digits[j] = carry % base;
-      carry = (carry / base) | 0;
-    }
-
-    while(carry > 0) {
-      digits.push(carry % base);
-      carry = (carry / base) | 0;
-    }
-  }
-
-  var output = '';
-
-  // deal with leading zeros
-  for(i = 0; input.at(i) === 0 && i < input.length() - 1; ++i) {
-    output += first;
-  }
-  // convert digits to a string
-  for(i = digits.length - 1; i >= 0; --i) {
-    output += alphabet[digits[i]];
-  }
-
-  return output;
-}

package/node_modules/node-forge/lib/cipher.js

@@ -1,230 +0,0 @@
-/**
- * Cipher base API.
- *
- * @author Dave Longley
- *
- * Copyright (c) 2010-2014 Digital Bazaar, Inc.
- */
-var forge = require('./forge');
-require('./util');
-
-module.exports = forge.cipher = forge.cipher || {};
-
-// registered algorithms
-forge.cipher.algorithms = forge.cipher.algorithms || {};
-
-/**
- * Creates a cipher object that can be used to encrypt data using the given
- * algorithm and key. The algorithm may be provided as a string value for a
- * previously registered algorithm or it may be given as a cipher algorithm
- * API object.
- *
- * @param algorithm the algorithm to use, either a string or an algorithm API
- *          object.
- * @param key the key to use, as a binary-encoded string of bytes or a
- *          byte buffer.
- *
- * @return the cipher.
- */
-forge.cipher.createCipher = function(algorithm, key) {
-  var api = algorithm;
-  if(typeof api === 'string') {
-    api = forge.cipher.getAlgorithm(api);
-    if(api) {
-      api = api();
-    }
-  }
-  if(!api) {
-    throw new Error('Unsupported algorithm: ' + algorithm);
-  }
-
-  // assume block cipher
-  return new forge.cipher.BlockCipher({
-    algorithm: api,
-    key: key,
-    decrypt: false
-  });
-};
-
-/**
- * Creates a decipher object that can be used to decrypt data using the given
- * algorithm and key. The algorithm may be provided as a string value for a
- * previously registered algorithm or it may be given as a cipher algorithm
- * API object.
- *
- * @param algorithm the algorithm to use, either a string or an algorithm API
- *          object.
- * @param key the key to use, as a binary-encoded string of bytes or a
- *          byte buffer.
- *
- * @return the cipher.
- */
-forge.cipher.createDecipher = function(algorithm, key) {
-  var api = algorithm;
-  if(typeof api === 'string') {
-    api = forge.cipher.getAlgorithm(api);
-    if(api) {
-      api = api();
-    }
-  }
-  if(!api) {
-    throw new Error('Unsupported algorithm: ' + algorithm);
-  }
-
-  // assume block cipher
-  return new forge.cipher.BlockCipher({
-    algorithm: api,
-    key: key,
-    decrypt: true
-  });
-};
-
-/**
- * Registers an algorithm by name. If the name was already registered, the
- * algorithm API object will be overwritten.
- *
- * @param name the name of the algorithm.
- * @param algorithm the algorithm API object.
- */
-forge.cipher.registerAlgorithm = function(name, algorithm) {
-  name = name.toUpperCase();
-  forge.cipher.algorithms[name] = algorithm;
-};
-
-/**
- * Gets a registered algorithm by name.
- *
- * @param name the name of the algorithm.
- *
- * @return the algorithm, if found, null if not.
- */
-forge.cipher.getAlgorithm = function(name) {
-  name = name.toUpperCase();
-  if(name in forge.cipher.algorithms) {
-    return forge.cipher.algorithms[name];
-  }
-  return null;
-};
-
-var BlockCipher = forge.cipher.BlockCipher = function(options) {
-  this.algorithm = options.algorithm;
-  this.mode = this.algorithm.mode;
-  this.blockSize = this.mode.blockSize;
-  this._finish = false;
-  this._input = null;
-  this.output = null;
-  this._op = options.decrypt ? this.mode.decrypt : this.mode.encrypt;
-  this._decrypt = options.decrypt;
-  this.algorithm.initialize(options);
-};
-
-/**
- * Starts or restarts the encryption or decryption process, whichever
- * was previously configured.
- *
- * For non-GCM mode, the IV may be a binary-encoded string of bytes, an array
- * of bytes, a byte buffer, or an array of 32-bit integers. If the IV is in
- * bytes, then it must be Nb (16) bytes in length. If the IV is given in as
- * 32-bit integers, then it must be 4 integers long.
- *
- * Note: an IV is not required or used in ECB mode.
- *
- * For GCM-mode, the IV must be given as a binary-encoded string of bytes or
- * a byte buffer. The number of bytes should be 12 (96 bits) as recommended
- * by NIST SP-800-38D but another length may be given.
- *
- * @param options the options to use:
- *          iv the initialization vector to use as a binary-encoded string of
- *            bytes, null to reuse the last ciphered block from a previous
- *            update() (this "residue" method is for legacy support only).
- *          additionalData additional authentication data as a binary-encoded
- *            string of bytes, for 'GCM' mode, (default: none).
- *          tagLength desired length of authentication tag, in bits, for
- *            'GCM' mode (0-128, default: 128).
- *          tag the authentication tag to check if decrypting, as a
- *             binary-encoded string of bytes.
- *          output the output the buffer to write to, null to create one.
- */
-BlockCipher.prototype.start = function(options) {
-  options = options || {};
-  var opts = {};
-  for(var key in options) {
-    opts[key] = options[key];
-  }
-  opts.decrypt = this._decrypt;
-  this._finish = false;
-  this._input = forge.util.createBuffer();
-  this.output = options.output || forge.util.createBuffer();
-  this.mode.start(opts);
-};
-
-/**
- * Updates the next block according to the cipher mode.
- *
- * @param input the buffer to read from.
- */
-BlockCipher.prototype.update = function(input) {
-  if(input) {
-    // input given, so empty it into the input buffer
-    this._input.putBuffer(input);
-  }
-
-  // do cipher operation until it needs more input and not finished
-  while(!this._op.call(this.mode, this._input, this.output, this._finish) &&
-    !this._finish) {}
-
-  // free consumed memory from input buffer
-  this._input.compact();
-};
-
-/**
- * Finishes encrypting or decrypting.
- *
- * @param pad a padding function to use in CBC mode, null for default,
- *          signature(blockSize, buffer, decrypt).
- *
- * @return true if successful, false on error.
- */
-BlockCipher.prototype.finish = function(pad) {
-  // backwards-compatibility w/deprecated padding API
-  // Note: will overwrite padding functions even after another start() call
-  if(pad && (this.mode.name === 'ECB' || this.mode.name === 'CBC')) {
-    this.mode.pad = function(input) {
-      return pad(this.blockSize, input, false);
-    };
-    this.mode.unpad = function(output) {
-      return pad(this.blockSize, output, true);
-    };
-  }
-
-  // build options for padding and afterFinish functions
-  var options = {};
-  options.decrypt = this._decrypt;
-
-  // get # of bytes that won't fill a block
-  options.overflow = this._input.length() % this.blockSize;
-
-  if(!this._decrypt && this.mode.pad) {
-    if(!this.mode.pad(this._input, options)) {
-      return false;
-    }
-  }
-
-  // do final update
-  this._finish = true;
-  this.update();
-
-  if(this._decrypt && this.mode.unpad) {
-    if(!this.mode.unpad(this.output, options)) {
-      return false;
-    }
-  }
-
-  if(this.mode.afterFinish) {
-    if(!this.mode.afterFinish(this.output, options)) {
-      return false;
-    }
-  }
-
-  return true;
-};