roster-server 3.1.0 → 3.2.1

package/README.md

@@ -272,7 +272,7 @@ const dnsChallenge = {
 
 Pass this as the constructor's `dnsChallenge` option. To use another provider, install its Greenlock DNS plugin in the consuming application and supply its module name and provider options. Configure DNS timing on that object with `propagationDelay`, `dryRunDelay`, `dnsPollIntervalMs`, and `dnsPollTimeoutMs`; the wrapper's polling interval defaults to `15000` ms.
 
-`serverKeyType: 'EC-P256'` makes each full TLS handshake much cheaper for the server than the default RSA key. It applies to certificates issued after the change: renewal reuses a certificate's existing key. To move an existing name to the new key type, remove its directory under `greenlockStorePath/live/` and restart; Roster issues a new certificate on the first connection for that name.
+New certificates use an `EC-P256` key by default, which makes each full TLS handshake much cheaper for the server than an RSA key. Clients that cannot negotiate ECDSA, such as Windows XP or Android 2.x, need `serverKeyType: 'RSA-2048'`. The key type applies to certificates issued after it is set: renewal reuses a certificate's existing key, so certificates issued before 3.2.0 keep their RSA key. To move an existing name to the configured key type, remove its directory under `greenlockStorePath/live/` and restart; Roster issues a new certificate on the first connection for that name.
 
 Roster's file-based SNI resolvers cache TLS contexts and detect changed certificate files through metadata, including updates from another process. Concurrent requests for the same certificate name share loads and checks. Standalone startup reuses the initialized certificate runtime and Roster's cancellable renewal loop. Loading an existing certificate does not itself force renewal.
 
@@ -299,7 +299,7 @@ Pass operational settings through the constructor, using the consuming applicati
 | `isolation` | `true` (`false` with `cluster`) | One process per site directory under `start()`; `false` or `{ restartDelayMs, backlog, helloTimeoutMs }` (defaults `1000`, `511`, `10000`). See [site isolation](#site-isolation). |
 | `tlsMinVersion`, `tlsMaxVersion` | `TLSv1.2`, `TLSv1.3` | Protocol limits for created HTTPS servers. |
 | `keepAliveTimeoutMs` | Node.js default (`5000`) | Idle time before a site server closes a keep-alive connection, in isolated and main-process sites. Set it above the interval at which clients repeat requests so they reuse the connection instead of paying a new TLS handshake. |
-| `serverKeyType` | `RSA-2048` | Key for newly issued certificates: `RSA-2048`, `RSA-3072`, `RSA-4096`, `EC-P256`, or `EC-P384`. See [certificates](#certificates-and-dns). |
+| `serverKeyType` | `EC-P256` | Key for newly issued certificates: `EC-P256`, `EC-P384`, `RSA-2048`, `RSA-3072`, or `RSA-4096`. See [certificates](#certificates-and-dns). |
 | `skipLocalCheck` | `true` | Skips Greenlock dry-run/local challenge checks. |
 | `dnsChallenge` | CLI wrapper | DNS-01 options or `false`; see [certificates](#certificates-and-dns). |
 | `disableWildcard`, `combineWildcardCerts` | `false`, `false` | Wildcard registration and certificate behavior. |

package/index.js

@@ -139,6 +139,12 @@ function buildCertLookupCandidates(servername) {
     return candidates;
 }
 
+// The certificate stored for a host's own subject serves it; a wildcard or zone
+// certificate found as a fallback serves only the names it covers.
+function certDirServesHost(certDir, host, certificate) {
+    return certDirCandidatesForSubject(host).includes(certDir) || certificate.checkHost(host) !== undefined;
+}
+
 function certCoversName(certPem, name) {
     try {
         const x509 = new crypto.X509Certificate(certPem);
@@ -360,7 +366,7 @@ class Roster {
         if (this.keepAliveTimeoutMs !== undefined && (!Number.isFinite(this.keepAliveTimeoutMs) || this.keepAliveTimeoutMs <= 0)) {
             throw new TypeError('keepAliveTimeoutMs must be a positive finite number');
         }
-        this.serverKeyType = options.serverKeyType ?? 'RSA-2048';
+        this.serverKeyType = options.serverKeyType ?? 'EC-P256';
         if (!SERVER_KEY_TYPES.includes(this.serverKeyType)) {
             throw new TypeError(`serverKeyType must be one of ${SERVER_KEY_TYPES.join(', ')}`);
         }
@@ -887,7 +893,7 @@ class Roster {
         const candidates = buildCertLookupCandidates(host);
         for (const candidate of candidates) {
             const pems = this._loadCert(candidate);
-            if (pems) return pems;
+            if (pems && certDirServesHost(candidate, host, new crypto.X509Certificate(pems.cert))) return pems;
         }
         return null;
     }
@@ -1096,8 +1102,8 @@ class Roster {
                 pending = this._loadSecureContext(subject).finally(() => this._contextLoads.delete(subject));
                 this._contextLoads.set(subject, pending);
             }
-            const context = await pending;
-            if (context) return context;
+            const loaded = await pending;
+            if (loaded && certDirServesHost(subject, host, loaded.certificate)) return loaded.context;
         }
         return null;
     }
@@ -1116,12 +1122,16 @@ class Roster {
         this._assertOpen();
         const version = stats.map(stat => `${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`).join('|');
         const cached = this._secureContexts.get(subject);
-        if (cached && cached.version === version) return cached.context;
+        if (cached && cached.version === version) return cached;
         const [key, cert, chain] = await Promise.all(files.map(file => fs.promises.readFile(file, 'utf8')));
         this._assertOpen();
-        const context = tls.createSecureContext({ key, cert: cert + chain });
-        this._secureContexts.set(subject, { version, context });
-        return context;
+        const loaded = {
+            version,
+            context: tls.createSecureContext({ key, cert: cert + chain }),
+            certificate: new crypto.X509Certificate(cert)
+        };
+        this._secureContexts.set(subject, loaded);
+        return loaded;
     }
 
     _checkCertificate(servername) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roster-server",
-  "version": "3.1.0",
+  "version": "3.2.1",
   "description": "👾 RosterServer - A domain host router to host multiple HTTPS.",
   "main": "index.js",
   "repository": {

package/test/https-integration.test.js

@@ -32,8 +32,9 @@ function certificate(roster, subject, serial) {
     const key = path.join(directory, 'privkey.pem');
     const cert = path.join(directory, 'cert.pem');
     const keyArgs = fs.existsSync(key) ? ['-key', key] : ['-newkey', 'rsa:2048', '-nodes', '-keyout', key];
-    execFileSync('openssl', ['req', '-x509', ...keyArgs, '-out', cert,
-        '-subj', '/CN=example.com', '-days', '1', '-set_serial', String(serial)], { stdio: 'ignore' });
+    const name = subject.replace(/^_wildcard_\./, '*.');
+    execFileSync('openssl', ['req', '-x509', ...keyArgs, '-out', cert, '-subj', '/CN=example.com',
+        '-addext', `subjectAltName=DNS:${name}`, '-days', '1', '-set_serial', String(serial)], { stdio: 'ignore' });
     fs.writeFileSync(path.join(directory, 'chain.pem'), '');
     return directory;
 }

package/test/roster-server.test.js

@@ -822,8 +822,8 @@ describe('Roster generateConfigJson', () => {
                 roster.generateConfigJson();
                 return JSON.parse(fs.readFileSync(path.join(tmpDir, 'config.json'), 'utf8')).defaults.serverKeyType;
             };
-            assert.strictEqual(keyTypeFor({}), 'RSA-2048');
-            assert.strictEqual(keyTypeFor({ serverKeyType: 'EC-P256' }), 'EC-P256');
+            assert.strictEqual(keyTypeFor({}), 'EC-P256');
+            assert.strictEqual(keyTypeFor({ serverKeyType: 'RSA-2048' }), 'RSA-2048');
         } finally {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }

package/test/static-and-tls.test.js

@@ -218,6 +218,44 @@ it('reuses TLS contexts, coalesces concurrent loads, and reloads changed certifi
     assert.equal(roster._secureContexts.size, 0);
 });
 
+function installCertificate(root, directoryName, names) {
+    const directory = path.join(root, 'live', directoryName);
+    fs.mkdirSync(directory, { recursive: true });
+    execFileSync('openssl', ['req', '-x509', '-newkey', 'ec', '-pkeyopt', 'ec_paramgen_curve:P-256', '-nodes',
+        '-keyout', path.join(directory, 'privkey.pem'), '-out', path.join(directory, 'cert.pem'),
+        '-subj', `/CN=${names[0]}`, '-addext', `subjectAltName=${names.map(name => `DNS:${name}`).join(',')}`,
+        '-days', '1'], { stdio: 'ignore' });
+    fs.writeFileSync(path.join(directory, 'chain.pem'), '');
+}
+
+it('falls back to zone and wildcard certificates only when they cover the host', async t => {
+    const root = temporaryDirectory(t);
+    installCertificate(root, 'example.com', ['example.com', 'www.example.com']);
+    installCertificate(root, '_wildcard_.wild.example.com', ['*.wild.example.com']);
+    const roster = new Roster({ local: true, wwwPath: root, greenlockStorePath: root });
+    t.after(() => roster.close());
+    const issued = [];
+    roster._greenlockRuntime = {
+        get: async ({ servername }) => {
+            issued.push(servername);
+            installCertificate(root, servername, [servername]);
+        }
+    };
+
+    const www = await roster._getSecureContext('www.example.com');
+    assert.equal(www, roster._secureContexts.get('example.com').context);
+    const wild = await roster._getSecureContext('shop.wild.example.com');
+    assert.equal(wild, roster._secureContexts.get('_wildcard_.wild.example.com').context);
+    assert.deepEqual(issued, []);
+
+    const uncovered = await roster._getSecureContext('api.example.com');
+    assert.deepEqual(issued, ['api.example.com']);
+    assert.equal(uncovered, roster._secureContexts.get('api.example.com').context);
+
+    assert.match(roster._resolvePemsForServername('www.example.com').cert, /BEGIN CERTIFICATE/);
+    assert.equal(roster._resolvePemsForServername('mail.example.com'), null);
+});
+
 it('coalesces certificate checks and prevents new issuance after close', async t => {
     const root = temporaryDirectory(t);
     const roster = new Roster({ local: true, wwwPath: root });