pi-codex-auto-review 0.1.0

package/node_modules/node-forge/tests/legacy/webid.js

@@ -0,0 +1,313 @@
+/**
+ * Forge Web ID Tests
+ *
+ * @author Dave Longley
+ *
+ * Copyright (c) 2010 Digital Bazaar, Inc. All rights reserved.
+ */
+(function($)
+{
+   // load flash socket pool
+   window.forge.socketPool = {};
+   window.forge.socketPool.ready = function()
+   {
+      // init forge xhr
+      forge.xhr.init({
+         flashId: 'socketPool',
+         policyPort: 19945,
+         msie: $.browser.msie,
+         connections: 10,
+         caCerts: [],
+         verify: function(c, verified, depth, certs)
+         {
+            // don't care about cert verification for test
+            return true;
+         }
+      });
+   };
+   swfobject.embedSWF(
+      '/forge/SocketPool.swf', 'socketPool', '0', '0', '9.0.0',
+      false, {}, {allowscriptaccess: 'always'}, {});
+})(jQuery);
+
+jQuery(function($)
+{
+   var cat = 'forge.tests.webid';
+
+   // local alias
+   var forge = window.forge;
+
+   $('#create').click(function()
+   {
+      var bits = $('#bits')[0].value;
+      var uri = $('#uri')[0].value;
+      var commonName = $('#commonName')[0].value;
+      forge.log.debug(cat, 'generating ' + bits +
+         '-bit RSA key-pair and certificate...');
+
+      // function to create cert
+      var createCert = function(keys)
+      {
+         try
+         {
+            var cert = forge.pki.createCertificate();
+            cert.serialNumber = '01';
+            cert.validity.notBefore = new Date();
+            cert.validity.notAfter = new Date();
+            cert.validity.notAfter.setFullYear(
+               cert.validity.notBefore.getFullYear() + 1);
+            var attrs = [{
+               name: 'commonName',
+               value: commonName
+            }, {
+               name: 'countryName',
+               value: 'US'
+            }, {
+               shortName: 'ST',
+               value: 'Virginia'
+            }, {
+               name: 'localityName',
+               value: 'Blacksburg'
+            }, {
+               name: 'organizationName',
+               value: 'Test'
+            }, {
+               shortName: 'OU',
+               value: 'Test'
+            }];
+            cert.setSubject(attrs);
+            cert.setIssuer(attrs);
+            cert.setExtensions([{
+               name: 'basicConstraints',
+               cA: true
+            }, {
+               name: 'keyUsage',
+               keyCertSign: true,
+               digitalSignature: true,
+               nonRepudiation: true,
+               keyEncipherment: true,
+               dataEncipherment: true
+            }, {
+               name: 'subjectAltName',
+               altNames: [{
+                  type: 6, // URI
+                  value: uri
+               }]
+            }]);
+            // FIXME: add subjectKeyIdentifier extension
+            // FIXME: add authorityKeyIdentifier extension
+            cert.publicKey = keys.publicKey;
+
+            // self-sign certificate
+            cert.sign(keys.privateKey);
+
+            // verify certificate
+            forge.log.debug('verified', cert.verify(cert));
+
+            forge.log.debug(cat, 'certificate:', cert);
+            //forge.log.debug(cat,
+            //   forge.asn1.prettyPrint(forge.pki.certificateToAsn1(cert)));
+            var keyPem = forge.pki.privateKeyToPem(keys.privateKey);
+            var certPem = forge.pki.certificateToPem(cert);
+            forge.log.debug(cat, keyPem);
+            forge.log.debug(cat, certPem);
+
+            forge.log.debug(cat, 'storing certificate and private key...');
+            try
+            {
+               // get flash API
+               var flashApi = document.getElementById('socketPool');
+
+               // get web ids collection
+               var webids = forge.util.getItem(
+                  flashApi, 'forge.test.webid', 'webids');
+               webids = webids || {};
+
+               // add web id
+               webids[uri] = {
+                  certificate: certPem,
+                  privateKey: keyPem
+               };
+
+               // update web ids collection
+               forge.util.setItem(
+                  flashApi, 'forge.test.webid', 'webids', webids);
+
+               forge.log.debug(cat, 'certificate and private key stored');
+               $('#show').click();
+            }
+            catch(ex)
+            {
+               forge.log.error(cat, ex);
+            }
+         }
+         catch(ex)
+         {
+            forge.log.error(cat, ex, ex.message ? ex.message : '');
+         }
+      };
+
+      // create key-generation state and function to step algorithm
+      var progress = $('#progress');
+      progress.html('Generating ' + bits + '-bit key-pair.');
+      var state = forge.pki.rsa.createKeyPairGenerationState(bits);
+      var kgTime = +new Date();
+      var step = function()
+      {
+         // step key-generation
+         if(!forge.pki.rsa.stepKeyPairGenerationState(state, 1000))
+         {
+            progress.html(progress.html() + '.');
+            setTimeout(step, 1);
+         }
+         // key-generation complete
+         else
+         {
+            kgTime = +new Date() - kgTime;
+            forge.log.debug(cat, 'Total key-gen time', kgTime + 'ms');
+            createCert(state.keys);
+            progress.html(progress.html() + 'done. Time=' + kgTime + 'ms');
+         }
+      };
+
+      // run key-gen algorithm
+      setTimeout(step, 0);
+   });
+
+   $('#show').click(function()
+   {
+      forge.log.debug(cat, 'get stored web IDs...');
+      try
+      {
+         // get flash API
+         var flashApi = document.getElementById('socketPool');
+
+         // get web ids collection
+         var webids = forge.util.getItem(
+            flashApi, 'forge.test.webid', 'webids');
+         webids = webids || {};
+
+         var html = '<ul>';
+         var webid, cert;
+         for(var key in webids)
+         {
+            webid = webids[key];
+            cert = forge.pki.certificateFromPem(webid.certificate);
+            html += '<li><p>' + key + '</p>';
+
+            var attr;
+            for(var n = 0; n < cert.subject.attributes.length; ++n)
+            {
+               attr = cert.subject.attributes[n];
+               html += attr.name + ': ' + attr.value + '<br/>';
+            }
+
+            //html += '<p>' + webid.certificate + '</p></li>';
+            html += '</li>';
+         }
+         if(html === '<ul>')
+         {
+            html = 'None';
+         }
+         else
+         {
+            html += '</ul>';
+         }
+
+         $('#webids').html(html);
+
+         forge.log.debug(cat, 'Web IDs retrieved');
+      }
+      catch(ex)
+      {
+         forge.log.error(cat, ex);
+      }
+   });
+
+   $('#clear').click(function()
+   {
+      forge.log.debug(cat, 'clearing all web IDs...');
+      try
+      {
+         // get flash API
+         var flashApi = document.getElementById('socketPool');
+         forge.util.clearItems(flashApi, 'forge.test.webid');
+         $('#webids').html('None');
+         forge.log.debug(cat, 'Web IDs cleared');
+      }
+      catch(ex)
+      {
+         forge.log.error(cat, ex);
+      }
+   });
+
+   $('#authenticate').click(function()
+   {
+      forge.log.debug(cat, 'doing Web ID authentication...');
+
+      try
+      {
+         // get flash API
+         var flashApi = document.getElementById('socketPool');
+
+         // get web ids collection
+         var webids = forge.util.getItem(
+            flashApi, 'forge.test.webid', 'webids');
+         webids = webids || {};
+
+         var uri = $('#webid')[0].value;
+         var webid = webids[uri];
+
+         $.ajax(
+         {
+            type: 'GET',
+            url: '/',
+            success: function(data, textStatus, xhr)
+            {
+               if(data !== '')
+               {
+                  forge.log.debug(cat, 'authentication completed');
+                  forge.log.debug(cat, data);
+               }
+               else
+               {
+                  forge.log.error(cat, 'authentication failed');
+               }
+            },
+            error: function(xhr, textStatus, errorThrown)
+            {
+               forge.log.error(cat, 'authentication failed');
+            },
+            xhr: function()
+            {
+               return forge.xhr.create({
+                  // FIXME: change URL
+                  url: 'https://localhost:4433',
+                  connections: 10,
+                  caCerts: [],
+                  verify: function(c, verified, depth, certs)
+                  {
+                     // don't care about cert verification for test
+                     return true;
+                  },
+                  getCertificate: function(c)
+                  {
+                     //forge.log.debug(cat, 'using cert', webid.certificate);
+                     return webid.certificate;
+                  },
+                  getPrivateKey: function(c)
+                  {
+                     //forge.log.debug(cat,
+                     //   'using private key', webid.privateKey);
+                     return webid.privateKey;
+                  }
+               });
+            }
+         });
+      }
+      catch(ex)
+      {
+         forge.log.error(cat, ex);
+      }
+   });
+});

package/node_modules/node-forge/tests/legacy/ws-webid.js

@@ -0,0 +1,120 @@
+var websocket_webid = function(host, port) {
+  var cat = 'ws';
+
+  // TODO: get private key and certificate from local storage
+  var privateKey =
+    '-----BEGIN RSA PRIVATE KEY-----\r\n' +
+    'MIICXAIBAAKBgQCTmE8QLARsC57Z1OrOaLM6AS3fn70N7BvlU7z7yw8UpcJA/jOl\r\n' +
+    'NWu7eS9uzuckdVZ9FE0+x3DRvhtDI6K+18dcrUWtl5ADWXcs1QS3/7bGh7IybFyY\r\n' +
+    '0xT4VzLHcx6K4PNmfkjAQdyOz/EsuRqZ/ngIQ2tdHdkkzdQPECbTvFeG2wIDAQAB\r\n' +
+    'AoGAds3l7l2QHaxo7GzfqNBMXEdwto2tLxS8C6eQ+pkkBXm72HcF+Vj75AcTMD2p\r\n' +
+    'fwZYXQxHdV4yqRI+fZeku7uTA/3yBAAvNobbEN5jtHnq0ZTO/HO8HuHkKrCvD8c3\r\n' +
+    '0rJV6lNIuaARI9jZFf6HVchW3PMjKUpYhTs/sFhRxmsMpTkCQQDu8TPzXRmN1aw8\r\n' +
+    'tSI2Nyn8QUy9bw/12tlVaZIhrcVCiJl7JHGqSCowTqZlwmJIjd4W0zWjTvS7tEeO\r\n' +
+    'FaZHtP8lAkEAniGvm8S9zyzmhWRRIuU6EE2dtTbeAa5aSOK3nBaaNu2cHUxWle+J\r\n' +
+    '8lE4uequ9wqDG1AfOLobPmHReccmOI6N/wJAIP/I1/RkohT/a4bsiaZGsyLlkUf0\r\n' +
+    'YVTvLP+ege44zv6Ei+A1nnnG8dL64hTdc/27zVUwFDTEUeQM+c99nmudzQJBAApY\r\n' +
+    'qeTHOqQTjAGuTqC53tKyQV9Z96yke8PJEbpkwDJX2Z8RH5kv0xbHua5wbII9bdab\r\n' +
+    'p29OvfmW7N3K6fVJXoECQHK8FDC0i8v1Ui8FoBmt+Z1c1+/9TCEE0abUQ6rfOUbm\r\n' +
+    'XHMMac/n4qDs0OoCjR4u46dpoK+WN7zcg56tToFPVow=\r\n' +
+    '-----END RSA PRIVATE KEY-----';
+  // FIXME: this hardcodes a specific URL for a demo server that is gone
+  // - hard coded cert is expired
+  // - reimplement to provide a server to host URL and return proper data
+  // - dynamically create the certificate for the custom URL
+  var certificate =
+    '-----BEGIN CERTIFICATE-----\r\n' +
+    'MIICgDCCAemgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMRMwEQYDVQQDEwpKb2hu\r\n' +
+    'IFNtaXRoMRMwEQYDVQQHEwpCbGFja3NidXJnMREwDwYDVQQIEwhWaXJnaW5pYTEL\r\n' +
+    'MAkGA1UEBhMCVVMxDDAKBgNVBAoTA0ZvbzAeFw0xMDExMjYxNzUxMzJaFw0xMTEx\r\n' +
+    'MjYxNzUxMzJaMFgxEzARBgNVBAMTCkpvaG4gU21pdGgxEzARBgNVBAcTCkJsYWNr\r\n' +
+    'c2J1cmcxETAPBgNVBAgTCFZpcmdpbmlhMQswCQYDVQQGEwJVUzEMMAoGA1UEChMD\r\n' +
+    'Rm9vMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCTmE8QLARsC57Z1OrOaLM6\r\n' +
+    'AS3fn70N7BvlU7z7yw8UpcJA/jOlNWu7eS9uzuckdVZ9FE0+x3DRvhtDI6K+18dc\r\n' +
+    'rUWtl5ADWXcs1QS3/7bGh7IybFyY0xT4VzLHcx6K4PNmfkjAQdyOz/EsuRqZ/ngI\r\n' +
+    'Q2tdHdkkzdQPECbTvFeG2wIDAQABo1owWDAMBgNVHRMEBTADAQH/MAsGA1UdDwQE\r\n' +
+    'AwIC9DA7BgNVHREENDAyhjBodHRwOi8vd2ViaWQuZGlnaXRhbGJhemFhci5jb20v\r\n' +
+    'aWRzLzE1MzQ1NzI2NDcjbWUwDQYJKoZIhvcNAQEFBQADgYEAPNm8albI4w6anynw\r\n' +
+    'XE/+00sCVks9BbgTcIpRqZPGqSuTRwoYW35isNLDqFqIUdVREMvFrEn3nOlOyKi0\r\n' +
+    '29G8JtLHFSXZsqf38Zou/bGAhtEH1AVEbM2bRtEnG8IW24jL8hiciz4htxmjnkHN\r\n' +
+    'JnQ8SQtUSWplGnz0vMFEOv6JbnI=\r\n' +
+    '-----END CERTIFICATE-----';
+
+  // create websocket
+  var ws = new WebSocket('ws://' + host + ':' + port);
+  forge.log.debug(cat, 'Created WebSocket', ws);
+
+  // create TLS client
+  var success = false;
+  var tls = forge.tls.createConnection({
+    server: false,
+    caStore: [],
+    sessionCache: {},
+    // supported cipher suites in order of preference
+    cipherSuites: [
+      forge.tls.CipherSuites.TLS_RSA_WITH_AES_128_CBC_SHA,
+      forge.tls.CipherSuites.TLS_RSA_WITH_AES_256_CBC_SHA],
+    virtualHost: host,
+    verify: function(c, verified, depth, certs) {
+      forge.log.debug(cat,
+        'TLS Client verifying certificate w/CN: \"' +
+          certs[0].subject.getField('CN').value + '\"');
+      // accept any certificate from the server for this test
+      return true;
+    },
+    connected: function(c) {
+      forge.log.debug(cat, 'Client connected');
+    },
+    getCertificate: function(c, hint) {
+      forge.log.debug(cat, 'Client using client-certificate');
+      return certificate;
+    },
+    getPrivateKey: function(c, cert) {
+      return privateKey;
+    },
+    tlsDataReady: function(c) {
+      // send base64-encoded TLS data to server
+      ws.send(forge.util.encode64(c.tlsData.getBytes()));
+    },
+    dataReady: function(c) {
+      var response = c.data.getBytes();
+      forge.log.debug(cat, 'Client received \"' + response + '\"');
+      try {
+        response = JSON.parse(response);
+        success = response.success;
+
+        // TODO: call window.authenticate on response json, just like
+        // w/flash version
+      } catch(ex) {}
+      c.close();
+    },
+    closed: function(c) {
+      forge.log.debug(cat, 'Client disconnected');
+      if(success) {
+        forge.log.debug(cat, 'PASS');
+      } else {
+        forge.log.debug(cat, 'FAIL');
+      }
+    },
+    error: function(c, error) {
+      forge.log.debug(cat, 'Client error: ' + error.message, error);
+    }
+  });
+
+  ws.onopen = function(evt) {
+    forge.log.debug(cat, 'WebSocket connected');
+
+    // do TLS handshake
+    tls.handshake();
+  };
+  ws.onmessage = function(evt) {
+    // base64-decode data and process it
+    tls.process(forge.util.decode64(evt.data));
+  };
+  ws.onclose = function(evt) {
+    forge.log.debug(cat, 'WebSocket closed', evt);
+  };
+  ws.onerror = function(evt) {
+    forge.log.debug(cat, 'WebSocket error', evt);
+  };
+};

package/node_modules/node-forge/tests/legacy/xhr.html

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html lang="en">
+   <head>
+      <title>Forge XmlHttpRequest Test</title>
+      <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/swfobject/2.2/swfobject.js"></script>
+      <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
+      <script type="text/javascript" src="/forge/forge.all.js"></script>
+      <script type="text/javascript" src="/support/task.js"></script>
+      <script type="text/javascript" src="xhr.js"></script>
+
+      <link type="text/css" rel="stylesheet" media="all" href="/tests.css" />
+      <style type="text/css">
+         .ready { color: inherit; background: inherit; }
+         .testing { color: black; background: yellow; }
+         .pass{ color: white; background: green; }
+         .fail{ color: white; background: red; }
+      </style>
+   </head>
+<body>
+<div class="nav">
+   <a href="..">Forge Tests</a> /
+   <a href=".">Legacy</a> /
+   XHR
+</div>
+
+<div class="header">
+   <h1>XmlHttpRequest Tests</h1>
+</div>
+
+<div class="content">
+
+<!-- div used to hold the flash socket pool implementation -->
+<div id="socketPool">
+   <p>Could not load the flash SocketPool.</p>
+</div>
+
+<fieldset class="section">
+   <ul>
+     <li>Use the controls below to test the XHR wrapper.</li>
+   </ul>
+</fieldset>
+
+<fieldset class="section">
+<legend>Control</legend>
+   <button id="start">Start</button>
+   <button id="reset">Reset</button>
+   <br/>
+   <input id="scroll" type="checkbox" />Scroll Tests
+   <br/>
+   <button id="stress">Stress</button>
+</fieldset>
+
+<fieldset class="section">
+<legend>Progress</legend>
+Status: <span id="status">?</span><br/>
+Pass: <span id="pass">?</span>/<span id="total">?</span><br/>
+Fail: <span id="fail">?</span>
+</fieldset>
+
+<fieldset class="section">
+<legend>Tests</legend>
+<div id="tests"></div>
+</fieldset>
+
+</div>
+</body>
+</html>