pi-codex-auto-review 0.1.0

package/node_modules/node-forge/RELEASE.md

@@ -0,0 +1,19 @@
+Forge Release Process
+=====================
+
+Prepare a Release
+-----------------
+
+* Follow the [Semantic Versioning][] guidelines.
+* Ensure [tests pass](./README.md#testing).
+* Ensure [CHANGELOG.md](./CHANGELOG.md) is up-to-date using [Keep a
+  CHANGELOG][] style.
+
+Publish to NPM
+--------------
+
+As of Forge 1.0.0 publishing is performed using the `pubnpm` script from
+https://github.com/digitalbazaar/publish-script.
+
+[Keep a CHANGELOG]: https://keepachangelog.com/
+[Semantic Versioning]: https://semver.org/

package/node_modules/node-forge/SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security issues to security@digitalbazaar.com.

package/node_modules/node-forge/examples/create-cert.js

@@ -0,0 +1,110 @@
+var forge = require('..');
+
+console.log('Generating 2048-bit key-pair...');
+var keys = forge.pki.rsa.generateKeyPair(2048);
+console.log('Key-pair created.');
+
+console.log('Creating self-signed certificate...');
+var cert = forge.pki.createCertificate();
+cert.publicKey = keys.publicKey;
+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: 'example.org'
+}, {
+  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/*,
+  pathLenConstraint: 4*/
+}, {
+  name: 'keyUsage',
+  keyCertSign: true,
+  digitalSignature: true,
+  nonRepudiation: true,
+  keyEncipherment: true,
+  dataEncipherment: true
+}, {
+  name: 'extKeyUsage',
+  serverAuth: true,
+  clientAuth: true,
+  codeSigning: true,
+  emailProtection: true,
+  timeStamping: true
+}, {
+  name: 'nsCertType',
+  client: true,
+  server: true,
+  email: true,
+  objsign: true,
+  sslCA: true,
+  emailCA: true,
+  objCA: true
+}, {
+  name: 'subjectAltName',
+  altNames: [{
+    type: 6, // URI
+    value: 'http://example.org/webid#me'
+  }, {
+    type: 7, // IP
+    ip: '127.0.0.1'
+  }]
+}, {
+  name: 'subjectKeyIdentifier'
+}]);
+// FIXME: add authorityKeyIdentifier extension
+
+// self-sign certificate
+cert.sign(keys.privateKey/*, forge.md.sha256.create()*/);
+console.log('Certificate created.');
+
+// PEM-format keys and cert
+var pem = {
+  privateKey: forge.pki.privateKeyToPem(keys.privateKey),
+  publicKey: forge.pki.publicKeyToPem(keys.publicKey),
+  certificate: forge.pki.certificateToPem(cert)
+};
+
+console.log('\nKey-Pair:');
+console.log(pem.privateKey);
+console.log(pem.publicKey);
+
+console.log('\nCertificate:');
+console.log(pem.certificate);
+
+// verify certificate
+var caStore = forge.pki.createCaStore();
+caStore.addCertificate(cert);
+try {
+  forge.pki.verifyCertificateChain(caStore, [cert],
+    function(vfd, depth, chain) {
+      if(vfd === true) {
+        console.log('SubjectKeyIdentifier verified: ' +
+          cert.verifySubjectKeyIdentifier());
+        console.log('Certificate verified.');
+      }
+      return true;
+    });
+} catch(ex) {
+  console.log('Certificate verification failure: ' +
+    JSON.stringify(ex, null, 2));
+}

package/node_modules/node-forge/examples/create-csr.js

@@ -0,0 +1,66 @@
+var forge = require('..');
+
+console.log('Generating 2048-bit key-pair...');
+var keys = forge.pki.rsa.generateKeyPair(2048);
+console.log('Key-pair created.');
+
+console.log('Creating certification request (CSR) ...');
+var csr = forge.pki.createCertificationRequest();
+csr.publicKey = keys.publicKey;
+csr.setSubject([{
+  name: 'commonName',
+  value: 'example.org'
+}, {
+  name: 'countryName',
+  value: 'US'
+}, {
+  shortName: 'ST',
+  value: 'Virginia'
+}, {
+  name: 'localityName',
+  value: 'Blacksburg'
+}, {
+  name: 'organizationName',
+  value: 'Test'
+}, {
+  shortName: 'OU',
+  value: 'Test'
+}]);
+// add optional attributes
+csr.setAttributes([{
+  name: 'challengePassword',
+  value: 'password'
+}, {
+  name: 'unstructuredName',
+  value: 'My company'
+}]);
+
+// sign certification request
+csr.sign(keys.privateKey/*, forge.md.sha256.create()*/);
+console.log('Certification request (CSR) created.');
+
+// PEM-format keys and csr
+var pem = {
+  privateKey: forge.pki.privateKeyToPem(keys.privateKey),
+  publicKey: forge.pki.publicKeyToPem(keys.publicKey),
+  csr: forge.pki.certificationRequestToPem(csr)
+};
+
+console.log('\nKey-Pair:');
+console.log(pem.privateKey);
+console.log(pem.publicKey);
+
+console.log('\nCertification Request (CSR):');
+console.log(pem.csr);
+
+// verify certification request
+try {
+  if(csr.verify()) {
+    console.log('Certification request (CSR) verified.');
+  } else {
+    throw new Error('Signature not verified.');
+  }
+} catch(err) {
+  console.log('Certification request (CSR) verification failure: ' +
+    JSON.stringify(err, null, 2));
+}

package/node_modules/node-forge/examples/create-pkcs12.js

@@ -0,0 +1,160 @@
+var forge = require('..');
+
+try {
+  // generate a keypair
+  console.log('Generating 2048-bit key-pair...');
+  var keys = forge.pki.rsa.generateKeyPair(2048);
+  console.log('Key-pair created.');
+
+  // create a certificate
+  console.log('Creating self-signed certificate...');
+  var cert = forge.pki.createCertificate();
+  cert.publicKey = keys.publicKey;
+  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: 'example.org'
+  }, {
+    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: 'http://example.org/webid#me'
+    }]
+  }]);
+
+  // self-sign certificate
+  cert.sign(keys.privateKey);
+  console.log('Certificate created.');
+
+  // create PKCS12
+  console.log('\nCreating PKCS#12...');
+  var password = 'password';
+  var newPkcs12Asn1 = forge.pkcs12.toPkcs12Asn1(
+    keys.privateKey, [cert], password,
+    {generateLocalKeyId: true, friendlyName: 'test'});
+  var newPkcs12Der = forge.asn1.toDer(newPkcs12Asn1).getBytes();
+
+  console.log('\nBase64-encoded new PKCS#12:');
+  console.log(forge.util.encode64(newPkcs12Der));
+
+  // create CA store (w/own certificate in this example)
+  var caStore = forge.pki.createCaStore([cert]);
+
+  console.log('\nLoading new PKCS#12 to confirm...');
+  loadPkcs12(newPkcs12Der, password, caStore);
+} catch(ex) {
+  if(ex.stack) {
+    console.log(ex.stack);
+  } else {
+    console.log('Error', ex);
+  }
+}
+
+function loadPkcs12(pkcs12Der, password, caStore) {
+  var pkcs12Asn1 = forge.asn1.fromDer(pkcs12Der);
+  var pkcs12 = forge.pkcs12.pkcs12FromAsn1(pkcs12Asn1, false, password);
+
+  // load keypair and cert chain from safe content(s) and map to key ID
+  var map = {};
+  for(var sci = 0; sci < pkcs12.safeContents.length; ++sci) {
+    var safeContents = pkcs12.safeContents[sci];
+    console.log('safeContents ' + (sci + 1));
+
+    for(var sbi = 0; sbi < safeContents.safeBags.length; ++sbi) {
+      var safeBag = safeContents.safeBags[sbi];
+      console.log('safeBag.type: ' + safeBag.type);
+
+      var localKeyId = null;
+      if(safeBag.attributes.localKeyId) {
+        localKeyId = forge.util.bytesToHex(
+          safeBag.attributes.localKeyId[0]);
+        console.log('localKeyId: ' + localKeyId);
+        if(!(localKeyId in map)) {
+          map[localKeyId] = {
+            privateKey: null,
+            certChain: []
+          };
+        }
+      } else {
+        // no local key ID, skip bag
+        continue;
+      }
+
+      // this bag has a private key
+      if(safeBag.type === forge.pki.oids.pkcs8ShroudedKeyBag) {
+        console.log('found private key');
+        map[localKeyId].privateKey = safeBag.key;
+      } else if(safeBag.type === forge.pki.oids.certBag) {
+        // this bag has a certificate
+        console.log('found certificate');
+        map[localKeyId].certChain.push(safeBag.cert);
+      }
+    }
+  }
+
+  console.log('\nPKCS#12 Info:');
+
+  for(var localKeyId in map) {
+    var entry = map[localKeyId];
+    console.log('\nLocal Key ID: ' + localKeyId);
+    if(entry.privateKey) {
+      var privateKeyP12Pem = forge.pki.privateKeyToPem(entry.privateKey);
+      var encryptedPrivateKeyP12Pem = forge.pki.encryptRsaPrivateKey(
+        entry.privateKey, password);
+
+      console.log('\nPrivate Key:');
+      console.log(privateKeyP12Pem);
+      console.log('Encrypted Private Key (password: "' + password + '"):');
+      console.log(encryptedPrivateKeyP12Pem);
+    } else {
+      console.log('');
+    }
+    if(entry.certChain.length > 0) {
+      console.log('Certificate chain:');
+      var certChain = entry.certChain;
+      for(var i = 0; i < certChain.length; ++i) {
+        var certP12Pem = forge.pki.certificateToPem(certChain[i]);
+        console.log(certP12Pem);
+      }
+
+      var chainVerified = false;
+      try {
+        chainVerified = forge.pki.verifyCertificateChain(caStore, certChain);
+      } catch(ex) {
+        chainVerified = ex;
+      }
+      console.log('Certificate chain verified: ', chainVerified);
+    }
+  }
+}

package/node_modules/node-forge/examples/imap.js

@@ -0,0 +1,46 @@
+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) {
+    console.log('[tls] connected');
+  },
+  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);
+    client.close();
+  },
+  closed: function() {
+    console.log('[tls] disconnected');
+  },
+  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 to gmail's imap server
+socket.connect(993, 'imap.gmail.com');

package/node_modules/node-forge/examples/sign-p7.js

@@ -0,0 +1,115 @@
+var forge = require('..');
+
+try {
+  // create PKCS#7 signed data
+  var p7 = forge.pkcs7.createSignedData();
+  p7.content = forge.util.createBuffer('Some content to be signed.', 'utf8');
+  var signers = ['a', 'b'];
+  for(var i = 0; i < signers.length; ++i) {
+    var signer = createSigner(signers[i]);
+    p7.addCertificate(signer.certificate);
+    p7.addSigner({
+      key: signer.keys.privateKey,
+      certificate: signer.certificate,
+      digestAlgorithm: forge.pki.oids.sha256,
+      authenticatedAttributes: [{
+        type: forge.pki.oids.contentType,
+        value: forge.pki.oids.data
+      }, {
+        type: forge.pki.oids.messageDigest
+        // value will be auto-populated at signing time
+      }, {
+        type: forge.pki.oids.signingTime
+        // value will be auto-populated at signing time
+        //value: new Date('2050-01-01T00:00:00Z')
+      }]
+    });
+  }
+
+  p7.sign();
+
+  var pem = forge.pkcs7.messageToPem(p7);
+  console.log('Signed PKCS #7 message:\n' + pem);
+} catch(ex) {
+  if(ex.stack) {
+    console.log(ex.stack);
+  } else {
+    console.log('Error', ex);
+  }
+}
+
+function createSigner(name) {
+  console.log('Creating signer "' + name + '"...');
+
+  // generate a keypair
+  console.log('Generating 2048-bit key-pair...');
+  var keys = forge.pki.rsa.generateKeyPair(2048);
+  console.log('Key-pair created:');
+  console.log(forge.pki.privateKeyToPem(keys.privateKey));
+  console.log(forge.pki.publicKeyToPem(keys.publicKey));
+
+  // create a certificate
+  var certificate = createCertificate(name, keys);
+  console.log('Signer "' + name + '" created.');
+
+  return {
+    name: name,
+    keys: keys,
+    certificate: certificate
+  };
+}
+
+function createCertificate(name, keys) {
+  // create a certificate
+  console.log('Creating self-signed certificate...');
+  var cert = forge.pki.createCertificate();
+  cert.publicKey = keys.publicKey;
+  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: name
+  }, {
+    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: 'http://example.org/webid#me'
+    }]
+  }]);
+
+  // self-sign certificate
+  cert.sign(keys.privateKey);
+  console.log('Certificate created: \n' + forge.pki.certificateToPem(cert));
+
+  return cert;
+}