pi-codex-auto-review 0.1.0

package/node_modules/node-forge/package.json

@@ -0,0 +1,123 @@
+{
+  "name": "node-forge",
+  "version": "1.4.1-0",
+  "description": "JavaScript implementations of network transports, cryptography, ciphers, PKI, message digests, and various utilities.",
+  "homepage": "https://github.com/digitalbazaar/forge",
+  "author": {
+    "name": "Digital Bazaar, Inc.",
+    "email": "support@digitalbazaar.com",
+    "url": "http://digitalbazaar.com/"
+  },
+  "contributors": [
+    "Dave Longley <dlongley@digitalbazaar.com>",
+    "David I. Lehn <dlehn@digitalbazaar.com>",
+    "Stefan Siegl <stesie@brokenpipe.de>",
+    "Christoph Dorn <christoph@christophdorn.com>"
+  ],
+  "devDependencies": {
+    "browserify": "^16.5.2",
+    "commander": "^2.20.0",
+    "cross-env": "^5.2.1",
+    "eslint": "^7.27.0",
+    "eslint-config-digitalbazaar": "^2.8.0",
+    "express": "^4.16.2",
+    "karma": "^4.4.1",
+    "karma-browserify": "^7.0.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-edge-launcher": "^0.4.2",
+    "karma-firefox-launcher": "^1.3.0",
+    "karma-ie-launcher": "^1.0.0",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-sauce-launcher": "^2.0.2",
+    "karma-sourcemap-loader": "^0.3.8",
+    "karma-tap-reporter": "0.0.6",
+    "karma-webpack": "^4.0.2",
+    "mocha": "^5.2.0",
+    "mocha-lcov-reporter": "^1.2.0",
+    "nodejs-websocket": "^1.7.1",
+    "nyc": "^15.1.0",
+    "opts": "^1.2.7",
+    "webpack": "^4.44.1",
+    "webpack-cli": "^3.3.12",
+    "worker-loader": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/digitalbazaar/forge"
+  },
+  "bugs": {
+    "url": "https://github.com/digitalbazaar/forge/issues",
+    "email": "support@digitalbazaar.com"
+  },
+  "license": "(BSD-3-Clause OR GPL-2.0)",
+  "main": "lib/index.js",
+  "files": [
+    "lib/*.js",
+    "flash/swf/*.swf",
+    "dist/*.min.js",
+    "dist/*.min.js.map"
+  ],
+  "engines": {
+    "node": ">= 6.13.0"
+  },
+  "keywords": [
+    "aes",
+    "asn",
+    "asn.1",
+    "cbc",
+    "crypto",
+    "cryptography",
+    "csr",
+    "des",
+    "gcm",
+    "hmac",
+    "http",
+    "https",
+    "md5",
+    "network",
+    "pkcs",
+    "pki",
+    "prng",
+    "rc2",
+    "rsa",
+    "sha1",
+    "sha256",
+    "sha384",
+    "sha512",
+    "ssh",
+    "tls",
+    "x.509",
+    "x509"
+  ],
+  "scripts": {
+    "prepublish": "npm run build",
+    "build": "webpack",
+    "test-build": "webpack --config webpack-tests.config.js",
+    "test": "npm run test-node",
+    "test-node": "cross-env NODE_ENV=test mocha -t 30000 -R ${REPORTER:-spec} tests/unit/index.js",
+    "test-karma": "karma start",
+    "test-karma-sauce": "karma start karma-sauce.conf",
+    "test-server": "node tests/server.js",
+    "test-server-ws": "node tests/websockets/server-ws.js",
+    "test-server-webid": "node tests/websockets/server-webid.js",
+    "coverage": "rm -rf coverage && nyc --reporter=lcov --reporter=text-summary npm test",
+    "coverage-ci": "rm -rf coverage && nyc --reporter=lcovonly npm test",
+    "coverage-report": "nyc report",
+    "lint": "eslint *.js lib/*.js tests/*.js tests/**/*.js examples/*.js flash/*.js"
+  },
+  "nyc": {
+    "exclude": [
+      "tests"
+    ]
+  },
+  "jspm": {
+    "format": "amd"
+  },
+  "browser": {
+    "buffer": false,
+    "crypto": false,
+    "process": false
+  }
+}

package/node_modules/node-forge/tests/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  env: {
+    mocha: true
+  }
+};

package/node_modules/node-forge/tests/README.md

@@ -0,0 +1,4 @@
+Forge Tests
+===========
+
+See the [testing](../README.md#testing) section of the main README.

package/node_modules/node-forge/tests/benchmarks/aes-speed.js

@@ -0,0 +1,62 @@
+var forge = require('../..');
+
+console.log('Times in 1000s of bytes/sec processed.');
+
+aes_128('AES-CBC');
+aes_128('AES-CFB');
+aes_128('AES-OFB');
+aes_128('AES-CTR');
+aes_128('AES-GCM');
+
+function aes_128(algorithm) {
+  console.log('Running ' + algorithm + ' for 5 seconds...');
+
+  var size = 1024;
+  var key = forge.random.getBytesSync(16);
+  var iv = forge.random.getBytes(algorithm === 'AES-GCM' ? 12 : 16);
+  var plain = forge.random.getBytesSync(size);
+
+  // run for 5 seconds
+  var start = new Date().getTime();
+
+  var now;
+  var totalEncrypt = 0;
+  var totalDecrypt = 0;
+  var cipher;
+  var count = 0;
+  var passed = 0;
+  while(passed < 5000) {
+    var input = forge.util.createBuffer(plain);
+
+    // encrypt, only measuring update() and finish()
+    cipher = forge.cipher.createCipher(algorithm, key);
+    cipher.start({iv: iv});
+    now = new Date().getTime();
+    cipher.update(input);
+    cipher.finish();
+    totalEncrypt += new Date().getTime() - now;
+
+    var ciphertext = cipher.output;
+    var tag = cipher.mode.tag;
+    count += cipher.output.length();
+
+    // decrypt, only measuring update() and finish()
+    cipher = forge.cipher.createDecipher(algorithm, key);
+    cipher.start({iv: iv, tag: tag});
+    now = new Date().getTime();
+    cipher.update(ciphertext);
+    if(!cipher.finish()) {
+      throw new Error('Decryption error.');
+    }
+    totalDecrypt += new Date().getTime() - now;
+
+    passed = new Date().getTime() - start;
+  }
+
+  count = count / 1000;
+  totalEncrypt /= 1000;
+  totalDecrypt /= 1000;
+  console.log('encrypt: ' + (count / totalEncrypt) + ' k/sec');
+  console.log('decrypt: ' + (count / totalDecrypt) + ' k/sec');
+  console.log();
+}

package/node_modules/node-forge/tests/benchmarks/so-44303784.js

@@ -0,0 +1,246 @@
+// https://stackoverflow.com/questions/44303784/javascript-aes-encryption-is-slow
+
+// Test decryption with single update(), many update()s, and node
+// Test chunk size for many update()s
+
+const forge = require('../..');
+const assert = require('assert');
+const crypto = require('crypto');
+
+const pwd = 'aStringPassword';
+const iv = forge.random.getBytesSync(16);
+const salt = forge.random.getBytesSync(16);
+const key = forge.pkcs5.pbkdf2(pwd, salt, 100, 16);
+
+function test_forge(bytes) {
+  const buf = forge.util.createBuffer(bytes);
+  const start = new Date();
+
+  const decipher = forge.cipher.createDecipher('AES-CBC', key);
+  decipher.start({iv: iv});
+  decipher.update(buf);
+  const result = decipher.finish();
+  assert(result);
+  const plain = decipher.output.getBytes();
+
+  const time = (new Date() - start) / 1000;
+  //console.log(`decrypted in ${time}s`);
+
+  return {
+    time,
+    plain
+  };
+}
+
+function test_forge_chunk(bytes, chunkSize) {
+  if(!chunkSize) {
+    chunkSize = 1024 * 16;
+  }
+  const start = new Date();
+
+  const decipher = forge.cipher.createDecipher('AES-CBC', key);
+  decipher.start({iv: iv});
+  const length = bytes.length;
+  let index = 0;
+  let plain = '';
+  do {
+    plain += decipher.output.getBytes();
+    const buf = forge.util.createBuffer(bytes.substr(index, chunkSize));
+    decipher.update(buf);
+    index += chunkSize;
+  } while(index < length);
+  const result = decipher.finish();
+  assert(result);
+  plain += decipher.output.getBytes();
+
+  const time = (new Date() - start) / 1000;
+  //console.log(`decrypted in ${time}s`);
+
+  return {
+    time,
+    plain
+  };
+}
+
+function test_node(bytes) {
+  const bufb = Buffer.from(bytes, 'binary');
+  const ivb = Buffer.from(iv, 'binary');
+  const keyb = Buffer.from(key, 'binary');
+
+  const start = new Date();
+
+  const decipher = crypto.createDecipheriv('aes-128-cbc', keyb, ivb);
+
+  let plain = decipher.update(bufb, 'utf8', 'utf8');
+  plain += decipher.final('utf8');
+
+  const time = (new Date() - start) / 1000;
+  //console.log(`decrypted in ${time}s`);
+
+  return {
+    time,
+    plain
+  };
+}
+
+function data(megs) {
+  // slower single chunk
+  const start = new Date();
+  var x = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+  var plain = '';
+  const minlen = megs * 1024 * 1024;
+  while(plain.length < minlen) {
+    plain += x;
+  }
+  const cipher = forge.cipher.createCipher('AES-CBC', key);
+  cipher.start({iv: iv});
+  cipher.update(forge.util.createBuffer(plain));
+  const result = cipher.finish();
+  assert(result);
+  const encrypted = cipher.output.getBytes();
+
+  const time = (new Date() - start) / 1000;
+  //console.log(`data m:${megs} t:${time}s m/s:${megs/time}`);
+
+  return {
+    plain,
+    encrypted,
+    time
+  };
+}
+
+function data_chunk(megs, chunkSize) {
+  if(!chunkSize) {
+    chunkSize = 1024 * 16;
+  }
+
+  // faster with chunksize
+  const start = new Date();
+  // make some large plain text bigger than some size
+  var x = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+  var plain = '';
+  const minlen = megs * 1024 * 1024;
+  while(plain.length < minlen) {
+    plain += x;
+  }
+
+  const cipher = forge.cipher.createCipher('AES-CBC', key);
+  cipher.start({iv: iv});
+  const length = plain.length;
+  let index = 0;
+  let encrypted = '';
+  do {
+    encrypted += cipher.output.getBytes();
+    const buf = forge.util.createBuffer(plain.substr(index, chunkSize));
+    cipher.update(buf);
+    index += chunkSize;
+  } while(index < length);
+  const result = cipher.finish();
+  assert(result);
+  encrypted += cipher.output.getBytes();
+
+  const time = (new Date() - start) / 1000;
+  //console.log(`data_chunk m:${megs} t:${time}s m/s:${megs/time}`);
+
+  return {
+    plain,
+    encrypted,
+    time
+  };
+}
+
+function compareImpl() {
+  const maxmegs = 20;
+  let csv = '';
+  // sweep input size
+  for(let i = 1; i <= maxmegs; ++i) {
+    //const input = data(i);
+    const input = data_chunk(i, 1024 * 64);
+
+    // forge w/ one chunk
+    const tfs = [
+      test_forge(input.encrypted),
+      test_forge(input.encrypted),
+      test_forge(input.encrypted)
+    ];
+    tfs.forEach(res => assert(input.plain == res.plain));
+    const tf = tfs.reduce((prev, cur) => prev.time < cur.time ? prev : cur);
+
+    // forge w/ chunks
+    const chunkSize = 1024 * 64;
+    const tfcs = [
+      test_forge_chunk(input.encrypted, chunkSize),
+      test_forge_chunk(input.encrypted, chunkSize),
+      test_forge_chunk(input.encrypted, chunkSize)
+    ];
+    tfcs.forEach(res => assert(input.plain == res.plain));
+    const tfc = tfcs.reduce((prev, cur) => prev.time < cur.time ? prev : cur);
+
+    // node
+    const tns = [
+      test_node(input.encrypted),
+      test_node(input.encrypted),
+      test_node(input.encrypted)
+    ];
+    tns.forEach(res => assert(input.plain == res.plain));
+    const tn = tns.reduce((prev, cur) => prev.time < cur.time ? prev : cur);
+
+    /* eslint-disable max-len */
+    csv += `${i}\t${tf.time}\t${i / tf.time}\t${tfc.time}\t${i / tfc.time}\t${tn.time}\t${i / tn.time}\t${tf.time / tn.time}\t${tfc.time / tn.time}\n`;
+    console.log(`m:${i} tf:${tf.time} tf/s:${i / tf.time} tfc:${tfc.time} tfc/s:${i / tfc.time} tn:${tn.time} tn/s:${i / tn.time} sf:${tf.time / tn.time} sfc:${tfc.time / tn.time}`);
+    /* eslint-enable max-len */
+  }
+  console.log(csv);
+}
+
+function compareDecChunkSize() {
+  const megs = 10;
+  let csv = '';
+  const input = data_chunk(megs, 1024 * 64);
+  function _test(k) {
+    const chunkSize = 1024 * k;
+    const tfcs = [
+      test_forge_chunk(input.encrypted, chunkSize),
+      test_forge_chunk(input.encrypted, chunkSize),
+      test_forge_chunk(input.encrypted, chunkSize)
+    ];
+    tfcs.forEach(res => assert(input.plain == res.plain));
+    const tfc = tfcs.reduce((prev, cur) => prev.time < cur.time ? prev : cur);
+    csv += `${k}\t${tfc.time}\t${megs / tfc.time}\n`;
+    console.log(`k:${k} tfc:${tfc.time} tfc/s:${megs / tfc.time}`);
+  }
+  // sweep KB chunkSize
+  const sweep = [
+    1, 2, 4, 8, 16, 32, 64, 96, 128, 160, 192, 256,
+    320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024
+  ];
+  sweep.forEach(k => _test(k));
+  console.log(csv);
+}
+
+function compareEncChunkSize() {
+  const megs = 10;
+  let csv = '';
+  function _test(k) {
+    const chunkSize = 1024 * k;
+    const dcs = [
+      data_chunk(megs, chunkSize),
+      data_chunk(megs, chunkSize),
+      data_chunk(megs, chunkSize)
+    ];
+    const dc = dcs.reduce((prev, cur) => prev.time < cur.time ? prev : cur);
+    csv += `${k}\t${dc.time}\t${megs / dc.time}\n`;
+    console.log(`k:${k} dc:${dc.time} dc/s:${megs / dc.time}`);
+  }
+  // sweep KB chunkSize
+  const sweep = [
+    1, 2, 4, 8, 16, 32, 64, 96, 128, 160, 192, 256,
+    320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024
+  ];
+  sweep.forEach(k => _test(k));
+  console.log(csv);
+}
+
+compareImpl();
+//compareDecChunkSize();
+//compareEncChunkSize();

package/node_modules/node-forge/tests/flash/README.md

@@ -0,0 +1,7 @@
+Flash Cross-Domain URLLoader Test
+=================================
+
+Note: out of date.
+
+See the main forge `flash/README.md` and `flash/package.json` for hints on how
+to build this code.

package/node_modules/node-forge/tests/flash/Test.as

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2010 Digital Bazaar, Inc. All rights reserved.
+ *
+ * @author Dave Longley
+ */
+package
+{
+   import flash.display.Sprite;
+
+   public class Test extends Sprite
+   {
+      import flash.events.*;
+      import flash.net.*;
+
+      import flash.external.ExternalInterface;
+      import flash.system.Security;
+
+      public function Test()
+      {
+         try
+         {
+            // FIXME: replace 'localhost' with cross-domain host to hit
+            var xhost:String = "localhost";
+            Security.loadPolicyFile("xmlsocket://" + xhost + ":80");
+
+            var loader:URLLoader = new URLLoader();
+            loader.addEventListener(
+               Event.COMPLETE, completeHandler);
+            loader.addEventListener(
+               Event.OPEN, openHandler);
+            loader.addEventListener(
+               ProgressEvent.PROGRESS, progressHandler);
+            loader.addEventListener(
+               SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
+            loader.addEventListener(
+               HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);
+            loader.addEventListener(
+               IOErrorEvent.IO_ERROR, ioErrorHandler);
+
+            var request:URLRequest = new URLRequest(
+               "http://" + xhost + "/index.html");
+            loader.load(request);
+         }
+         catch(e:Error)
+         {
+            log("error=" + e.errorID + "," + e.name + "," + e.message);
+            throw e;
+         }
+      }
+
+      private function log(obj:Object):void
+      {
+         if(obj is String)
+         {
+            var str:String = obj as String;
+            ExternalInterface.call("console.log", "Test", str);
+         }
+         else if(obj is Error)
+         {
+            var e:Error = obj as Error;
+            log("error=" + e.errorID + "," + e.name + "," + e.message);
+         }
+      }
+
+      private function completeHandler(event:Event):void
+      {
+         var loader:URLLoader = URLLoader(event.target);
+         log("complete: " + loader.data);
+      }
+
+      private function openHandler(event:Event):void
+      {
+         log("open: " + event);
+      }
+
+      private function progressHandler(event:ProgressEvent):void
+      {
+         log("progress:" + event.bytesLoaded + " total: " + event.bytesTotal);
+      }
+
+      private function securityErrorHandler(event:SecurityErrorEvent):void
+      {
+         log("securityError: " + event);
+      }
+
+      private function httpStatusHandler(event:HTTPStatusEvent):void
+      {
+         log("httpStatus: " + event);
+      }
+
+      private function ioErrorHandler(event:IOErrorEvent):void
+      {
+         log("ioError: " + event);
+      }
+   }
+}

package/node_modules/node-forge/tests/flash/build-flash.xml

@@ -0,0 +1,7 @@
+<flex-config>
+   <compiler>
+      <source-path>
+         <path-element>.</path-element>
+      </source-path>
+   </compiler>
+</flex-config>

package/node_modules/node-forge/tests/flash/index.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html lang="en">
+   <head>
+      <link type="text/css" rel="stylesheet" media="all" href="screen.css" />
+      <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/swfobject/2.2/swfobject.js"></script>
+
+      <script type="text/javascript">
+      //<![CDATA[
+      swfobject.embedSWF(
+         'Test.swf', 'test', '0', '0', '9.0.0',
+         false, {}, {allowscriptaccess: 'always'}, {});
+      //]]>
+      </script>
+   </head>
+   <body>
+      <div class="header">
+         <h1>Flash Cross-Domain URLLoader Test</h1>
+      </div>
+
+      <div class="content">
+
+      <div id="test">
+         <p>Could not load the flash test.</p>
+      </div>
+
+      </div>
+   </body>
+</html>

package/node_modules/node-forge/tests/index.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+   <meta name="author" content="Digital Bazaar, Inc.; http://digitalbazaar.com/" />
+   <meta name="description" content="Forge Tests" />
+   <link type="text/css" rel="stylesheet" media="all" href="/tests.css" />
+   <title>Forge Tests</title>
+</head>
+
+<body>
+  <div class="header">
+     <h1>Forge Tests</h1>
+  </div>
+  <div class="content">
+     <fieldset class="section">
+       <ul>
+         <li>These are various tests of the <a href="https://github.com/digitalbazaar/forge">Forge</a> JavaScript libraries.</li>
+         <li>Please see the code and documentation for details.</li>
+       </ul>
+     </fieldset>
+     <fieldset class="section">
+        <legend>Tests</legend>
+        <ul>
+           <li><a href="/unit">Unit Tests</a></li>
+           <li><a href="/legacy">Legacy Tests</a></li>
+        </ul>
+     </fieldset>
+  </div>
+  <div class="footer">
+     Copyright &copy; 2010-2016 <a href="http://digitalbazaar.com/">Digital Bazaar, Inc.</a>
+  </div>
+</body>
+</html>

package/node_modules/node-forge/tests/issues/heartbleed.js

@@ -0,0 +1,55 @@
+var forge = require('../..');
+var net = require('net');
+
+var socket = new net.Socket();
+
+var client = forge.tls.createConnection({
+  server: false,
+  verify: function(connection, verified, depth, certs) {
+    // skip verification for testing
+    return true;
+  },
+  connected: function(connection) {
+    // heartbleeds 2k
+    console.log('[tls] connected');
+    connection.prepareHeartbeatRequest('', 2048);
+    setTimeout(function() {
+      client.close();
+    }, 1000);
+  },
+  tlsDataReady: function(connection) {
+    // encrypted data is ready to be sent to the server
+    var data = connection.tlsData.getBytes();
+    socket.write(data, 'binary');
+  },
+  dataReady: function(connection) {
+    // clear data from the server is ready
+    var data = connection.data.getBytes();
+    console.log('[tls] received from the server: ' + data);
+  },
+  heartbeatReceived: function(c, payload) {
+    console.log('Heartbleed:\n' + payload.toHex());
+    client.close();
+  },
+  closed: function() {
+    console.log('[tls] disconnected');
+    socket.end();
+  },
+  error: function(connection, error) {
+    console.log('[tls] error', error);
+  }
+});
+
+socket.on('connect', function() {
+  console.log('[socket] connected');
+  client.handshake();
+});
+socket.on('data', function(data) {
+  client.process(data.toString('binary'));
+});
+socket.on('end', function() {
+  console.log('[socket] disconnected');
+});
+
+// connect
+socket.connect(443, 'yahoo.com');