pi-codex-auto-review 0.1.2 → 0.1.3

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

@@ -1,168 +0,0 @@
-/**
- * Javascript implementation of RSA-KEM.
- *
- * @author Lautaro Cozzani Rodriguez
- * @author Dave Longley
- *
- * Copyright (c) 2014 Lautaro Cozzani <lautaro.cozzani@scytl.com>
- * Copyright (c) 2014 Digital Bazaar, Inc.
- */
-var forge = require('./forge');
-require('./util');
-require('./random');
-require('./jsbn');
-
-module.exports = forge.kem = forge.kem || {};
-
-var BigInteger = forge.jsbn.BigInteger;
-
-/**
- * The API for the RSA Key Encapsulation Mechanism (RSA-KEM) from ISO 18033-2.
- */
-forge.kem.rsa = {};
-
-/**
- * Creates an RSA KEM API object for generating a secret asymmetric key.
- *
- * The symmetric key may be generated via a call to 'encrypt', which will
- * produce a ciphertext to be transmitted to the recipient and a key to be
- * kept secret. The ciphertext is a parameter to be passed to 'decrypt' which
- * will produce the same secret key for the recipient to use to decrypt a
- * message that was encrypted with the secret key.
- *
- * @param kdf the KDF API to use (eg: new forge.kem.kdf1()).
- * @param options the options to use.
- *          [prng] a custom crypto-secure pseudo-random number generator to use,
- *            that must define "getBytesSync".
- */
-forge.kem.rsa.create = function(kdf, options) {
-  options = options || {};
-  var prng = options.prng || forge.random;
-
-  var kem = {};
-
-  /**
-   * Generates a secret key and its encapsulation.
-   *
-   * @param publicKey the RSA public key to encrypt with.
-   * @param keyLength the length, in bytes, of the secret key to generate.
-   *
-   * @return an object with:
-   *   encapsulation: the ciphertext for generating the secret key, as a
-   *     binary-encoded string of bytes.
-   *   key: the secret key to use for encrypting a message.
-   */
-  kem.encrypt = function(publicKey, keyLength) {
-    // generate a random r where 1 < r < n
-    var byteLength = Math.ceil(publicKey.n.bitLength() / 8);
-    var r;
-    do {
-      r = new BigInteger(
-        forge.util.bytesToHex(prng.getBytesSync(byteLength)),
-        16).mod(publicKey.n);
-    } while(r.compareTo(BigInteger.ONE) <= 0);
-
-    // prepend r with zeros
-    r = forge.util.hexToBytes(r.toString(16));
-    var zeros = byteLength - r.length;
-    if(zeros > 0) {
-      r = forge.util.fillString(String.fromCharCode(0), zeros) + r;
-    }
-
-    // encrypt the random
-    var encapsulation = publicKey.encrypt(r, 'NONE');
-
-    // generate the secret key
-    var key = kdf.generate(r, keyLength);
-
-    return {encapsulation: encapsulation, key: key};
-  };
-
-  /**
-   * Decrypts an encapsulated secret key.
-   *
-   * @param privateKey the RSA private key to decrypt with.
-   * @param encapsulation the ciphertext for generating the secret key, as
-   *          a binary-encoded string of bytes.
-   * @param keyLength the length, in bytes, of the secret key to generate.
-   *
-   * @return the secret key as a binary-encoded string of bytes.
-   */
-  kem.decrypt = function(privateKey, encapsulation, keyLength) {
-    // decrypt the encapsulation and generate the secret key
-    var r = privateKey.decrypt(encapsulation, 'NONE');
-    return kdf.generate(r, keyLength);
-  };
-
-  return kem;
-};
-
-// TODO: add forge.kem.kdf.create('KDF1', {md: ..., ...}) API?
-
-/**
- * Creates a key derivation API object that implements KDF1 per ISO 18033-2.
- *
- * @param md the hash API to use.
- * @param [digestLength] an optional digest length that must be positive and
- *          less than or equal to md.digestLength.
- *
- * @return a KDF1 API object.
- */
-forge.kem.kdf1 = function(md, digestLength) {
-  _createKDF(this, md, 0, digestLength || md.digestLength);
-};
-
-/**
- * Creates a key derivation API object that implements KDF2 per ISO 18033-2.
- *
- * @param md the hash API to use.
- * @param [digestLength] an optional digest length that must be positive and
- *          less than or equal to md.digestLength.
- *
- * @return a KDF2 API object.
- */
-forge.kem.kdf2 = function(md, digestLength) {
-  _createKDF(this, md, 1, digestLength || md.digestLength);
-};
-
-/**
- * Creates a KDF1 or KDF2 API object.
- *
- * @param md the hash API to use.
- * @param counterStart the starting index for the counter.
- * @param digestLength the digest length to use.
- *
- * @return the KDF API object.
- */
-function _createKDF(kdf, md, counterStart, digestLength) {
-  /**
-   * Generate a key of the specified length.
-   *
-   * @param x the binary-encoded byte string to generate a key from.
-   * @param length the number of bytes to generate (the size of the key).
-   *
-   * @return the key as a binary-encoded string.
-   */
-  kdf.generate = function(x, length) {
-    var key = new forge.util.ByteBuffer();
-
-    // run counter from counterStart to ceil(length / Hash.len)
-    var k = Math.ceil(length / digestLength) + counterStart;
-
-    var c = new forge.util.ByteBuffer();
-    for(var i = counterStart; i < k; ++i) {
-      // I2OSP(i, 4): convert counter to an octet string of 4 octets
-      c.putInt32(i);
-
-      // digest 'x' and the counter and add the result to the key
-      md.start();
-      md.update(x + c.getBytes());
-      var hash = md.digest();
-      key.putBytes(hash.getBytes(digestLength));
-    }
-
-    // truncate to the correct key length
-    key.truncate(key.length() - length);
-    return key.getBytes();
-  };
-}

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

@@ -1,319 +0,0 @@
-/**
- * Cross-browser support for logging in a web application.
- *
- * @author David I. Lehn <dlehn@digitalbazaar.com>
- *
- * Copyright (c) 2008-2013 Digital Bazaar, Inc.
- */
-var forge = require('./forge');
-require('./util');
-
-/* LOG API */
-module.exports = forge.log = forge.log || {};
-
-/**
- * Application logging system.
- *
- * Each logger level available as it's own function of the form:
- *   forge.log.level(category, args...)
- * The category is an arbitrary string, and the args are the same as
- * Firebug's console.log API. By default the call will be output as:
- *   'LEVEL [category] <args[0]>, args[1], ...'
- * This enables proper % formatting via the first argument.
- * Each category is enabled by default but can be enabled or disabled with
- * the setCategoryEnabled() function.
- */
-// list of known levels
-forge.log.levels = [
-  'none', 'error', 'warning', 'info', 'debug', 'verbose', 'max'];
-// info on the levels indexed by name:
-//   index: level index
-//   name: uppercased display name
-var sLevelInfo = {};
-// list of loggers
-var sLoggers = [];
-/**
- * Standard console logger. If no console support is enabled this will
- * remain null. Check before using.
- */
-var sConsoleLogger = null;
-
-// logger flags
-/**
- * Lock the level at the current value. Used in cases where user config may
- * set the level such that only critical messages are seen but more verbose
- * messages are needed for debugging or other purposes.
- */
-forge.log.LEVEL_LOCKED = (1 << 1);
-/**
- * Always call log function. By default, the logging system will check the
- * message level against logger.level before calling the log function. This
- * flag allows the function to do its own check.
- */
-forge.log.NO_LEVEL_CHECK = (1 << 2);
-/**
- * Perform message interpolation with the passed arguments. "%" style
- * fields in log messages will be replaced by arguments as needed. Some
- * loggers, such as Firebug, may do this automatically. The original log
- * message will be available as 'message' and the interpolated version will
- * be available as 'fullMessage'.
- */
-forge.log.INTERPOLATE = (1 << 3);
-
-// setup each log level
-for(var i = 0; i < forge.log.levels.length; ++i) {
-  var level = forge.log.levels[i];
-  sLevelInfo[level] = {
-    index: i,
-    name: level.toUpperCase()
-  };
-}
-
-/**
- * Message logger. Will dispatch a message to registered loggers as needed.
- *
- * @param message message object
- */
-forge.log.logMessage = function(message) {
-  var messageLevelIndex = sLevelInfo[message.level].index;
-  for(var i = 0; i < sLoggers.length; ++i) {
-    var logger = sLoggers[i];
-    if(logger.flags & forge.log.NO_LEVEL_CHECK) {
-      logger.f(message);
-    } else {
-      // get logger level
-      var loggerLevelIndex = sLevelInfo[logger.level].index;
-      // check level
-      if(messageLevelIndex <= loggerLevelIndex) {
-        // message critical enough, call logger
-        logger.f(logger, message);
-      }
-    }
-  }
-};
-
-/**
- * Sets the 'standard' key on a message object to:
- * "LEVEL [category] " + message
- *
- * @param message a message log object
- */
-forge.log.prepareStandard = function(message) {
-  if(!('standard' in message)) {
-    message.standard =
-      sLevelInfo[message.level].name +
-      //' ' + +message.timestamp +
-      ' [' + message.category + '] ' +
-      message.message;
-  }
-};
-
-/**
- * Sets the 'full' key on a message object to the original message
- * interpolated via % formatting with the message arguments.
- *
- * @param message a message log object.
- */
-forge.log.prepareFull = function(message) {
-  if(!('full' in message)) {
-    // copy args and insert message at the front
-    var args = [message.message];
-    args = args.concat([] || message['arguments']);
-    // format the message
-    message.full = forge.util.format.apply(this, args);
-  }
-};
-
-/**
- * Applies both preparseStandard() and prepareFull() to a message object and
- * store result in 'standardFull'.
- *
- * @param message a message log object.
- */
-forge.log.prepareStandardFull = function(message) {
-  if(!('standardFull' in message)) {
-    // FIXME implement 'standardFull' logging
-    forge.log.prepareStandard(message);
-    message.standardFull = message.standard;
-  }
-};
-
-// create log level functions
-if(true) {
-  // levels for which we want functions
-  var levels = ['error', 'warning', 'info', 'debug', 'verbose'];
-  for(var i = 0; i < levels.length; ++i) {
-    // wrap in a function to ensure proper level var is passed
-    (function(level) {
-      // create function for this level
-      forge.log[level] = function(category, message/*, args...*/) {
-        // convert arguments to real array, remove category and message
-        var args = Array.prototype.slice.call(arguments).slice(2);
-        // create message object
-        // Note: interpolation and standard formatting is done lazily
-        var msg = {
-          timestamp: new Date(),
-          level: level,
-          category: category,
-          message: message,
-          'arguments': args
-          /*standard*/
-          /*full*/
-          /*fullMessage*/
-        };
-        // process this message
-        forge.log.logMessage(msg);
-      };
-    })(levels[i]);
-  }
-}
-
-/**
- * Creates a new logger with specified custom logging function.
- *
- * The logging function has a signature of:
- *   function(logger, message)
- * logger: current logger
- * message: object:
- *   level: level id
- *   category: category
- *   message: string message
- *   arguments: Array of extra arguments
- *   fullMessage: interpolated message and arguments if INTERPOLATE flag set
- *
- * @param logFunction a logging function which takes a log message object
- *          as a parameter.
- *
- * @return a logger object.
- */
-forge.log.makeLogger = function(logFunction) {
-  var logger = {
-    flags: 0,
-    f: logFunction
-  };
-  forge.log.setLevel(logger, 'none');
-  return logger;
-};
-
-/**
- * Sets the current log level on a logger.
- *
- * @param logger the target logger.
- * @param level the new maximum log level as a string.
- *
- * @return true if set, false if not.
- */
-forge.log.setLevel = function(logger, level) {
-  var rval = false;
-  if(logger && !(logger.flags & forge.log.LEVEL_LOCKED)) {
-    for(var i = 0; i < forge.log.levels.length; ++i) {
-      var aValidLevel = forge.log.levels[i];
-      if(level == aValidLevel) {
-        // set level
-        logger.level = level;
-        rval = true;
-        break;
-      }
-    }
-  }
-
-  return rval;
-};
-
-/**
- * Locks the log level at its current value.
- *
- * @param logger the target logger.
- * @param lock boolean lock value, default to true.
- */
-forge.log.lock = function(logger, lock) {
-  if(typeof lock === 'undefined' || lock) {
-    logger.flags |= forge.log.LEVEL_LOCKED;
-  } else {
-    logger.flags &= ~forge.log.LEVEL_LOCKED;
-  }
-};
-
-/**
- * Adds a logger.
- *
- * @param logger the logger object.
- */
-forge.log.addLogger = function(logger) {
-  sLoggers.push(logger);
-};
-
-// setup the console logger if possible, else create fake console.log
-if(typeof(console) !== 'undefined' && 'log' in console) {
-  var logger;
-  if(console.error && console.warn && console.info && console.debug) {
-    // looks like Firebug-style logging is available
-    // level handlers map
-    var levelHandlers = {
-      error: console.error,
-      warning: console.warn,
-      info: console.info,
-      debug: console.debug,
-      verbose: console.debug
-    };
-    var f = function(logger, message) {
-      forge.log.prepareStandard(message);
-      var handler = levelHandlers[message.level];
-      // prepend standard message and concat args
-      var args = [message.standard];
-      args = args.concat(message['arguments'].slice());
-      // apply to low-level console function
-      handler.apply(console, args);
-    };
-    logger = forge.log.makeLogger(f);
-  } else {
-    // only appear to have basic console.log
-    var f = function(logger, message) {
-      forge.log.prepareStandardFull(message);
-      console.log(message.standardFull);
-    };
-    logger = forge.log.makeLogger(f);
-  }
-  forge.log.setLevel(logger, 'debug');
-  forge.log.addLogger(logger);
-  sConsoleLogger = logger;
-} else {
-  // define fake console.log to avoid potential script errors on
-  // browsers that do not have console logging
-  console = {
-    log: function() {}
-  };
-}
-
-/*
- * Check for logging control query vars in current URL.
- *
- * console.level=<level-name>
- * Set's the console log level by name.  Useful to override defaults and
- * allow more verbose logging before a user config is loaded.
- *
- * console.lock=<true|false>
- * Lock the console log level at whatever level it is set at.  This is run
- * after console.level is processed.  Useful to force a level of verbosity
- * that could otherwise be limited by a user config.
- */
-if(sConsoleLogger !== null &&
-  typeof window !== 'undefined' && window.location
-) {
-  var query = new URL(window.location.href).searchParams;
-  if(query.has('console.level')) {
-    // set with last value
-    forge.log.setLevel(
-      sConsoleLogger, query.get('console.level').slice(-1)[0]);
-  }
-  if(query.has('console.lock')) {
-    // set with last value
-    var lock = query.get('console.lock').slice(-1)[0];
-    if(lock == 'true') {
-      forge.log.lock(sConsoleLogger);
-    }
-  }
-}
-
-// provide public access to console logger
-forge.log.consoleLogger = sConsoleLogger;

package/node_modules/node-forge/lib/md.all.js

@@ -1,13 +0,0 @@
-/**
- * Node.js module for all known Forge message digests.
- *
- * @author Dave Longley
- *
- * Copyright 2011-2017 Digital Bazaar, Inc.
- */
-module.exports = require('./md');
-
-require('./md5');
-require('./sha1');
-require('./sha256');
-require('./sha512');

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

@@ -1,11 +0,0 @@
-/**
- * Node.js module for Forge message digests.
- *
- * @author Dave Longley
- *
- * Copyright 2011-2017 Digital Bazaar, Inc.
- */
-var forge = require('./forge');
-
-module.exports = forge.md = forge.md || {};
-forge.md.algorithms = forge.md.algorithms || {};