Allow importing CA keys in both PKCS#8 & PKCS#1 formats

Unfortunately it seems node-forge has been exporting to PKCS#1 up until
now, which is not well supported. We now export PKCS#8, but we still
want to handle all the existing keys out there, so we need to include
this as a fallback (and long-term too, it may be useful to support a
wider range of key inputs for custom Mockttp use cases).

Author: pimterry

src/main.ts

@@ -74,15 +74,15 @@ export type { ServerMockedEndpoint } from "./server/mocked-endpoint";
 export {
     generateCACertificate,
     generateSPKIFingerprint
-} from './util/tls';
+} from './util/certificates';
 
 // Export various referenced utility types:
 export type {
     CAOptions,
     PEM,
     CertDataOptions,
     CertPathOptions
-} from './util/tls';
+} from './util/certificates';
 export type { CachedDns, DnsLookupFunction } from './util/dns';
 export type { Serialized, SerializedValue } from './serialization/serialization';
 

src/mockttp.ts

@@ -1,7 +1,7 @@
 import { stripIndent } from "common-tags";
 import * as cors from 'cors';
 
-import type { CAOptions } from './util/tls';
+import type { CAOptions } from './util/certificates';
 
 import { RequestRuleBuilder } from "./rules/requests/request-rule-builder";
 import { WebSocketRuleBuilder } from "./rules/websockets/websocket-rule-builder";

src/server/http-combo-server.ts

@@ -18,7 +18,7 @@ import {
 import { URLPattern } from "urlpattern-polyfill";
 
 import { Destination, TlsHandshakeFailure } from '../types';
-import { getCA } from '../util/tls';
+import { getCA } from '../util/certificates';
 import { shouldPassThrough } from '../util/server-utils';
 import { getDestination } from '../util/url';
 import {

src/util/tls.ts renamed to src/util/certificates.ts

@@ -7,6 +7,9 @@ import * as x509 from '@peculiar/x509';
 import * as asn1X509 from '@peculiar/asn1-x509';
 import * as asn1Schema from '@peculiar/asn1-schema';
 
+// Import for PKCS#8 structure
+import { PrivateKeyInfo } from '@peculiar/asn1-pkcs8';
+
 const crypto = globalThis.crypto;
 
 export type CAOptions = (CertDataOptions | CertPathOptions);
@@ -71,11 +74,50 @@ function arrayBufferToPem(buffer: ArrayBuffer, label: string): string {
     return `-----BEGIN ${label}-----\n${lines.join('\n')}\n-----END ${label}-----\n`;
 }
 
+// OID for rsaEncryption - used to wrap PKCS#1 keys into PKCS#8 below:
+const rsaEncryptionOid = "1.2.840.113549.1.1.1";
+
 async function pemToCryptoKey(pem: string) {
-    const derKey = x509.PemConverter.decodeFirst(pem);
+    // The PEM might be PKCS#8 ("BEGIN PRIVATE KEY") or PKCS#1 ("BEGIN
+    // RSA PRIVATE KEY"). We want to transparently accept both, but
+    // we can only import PKCS#8, so we detect & convert if required.
+
+    const keyData = x509.PemConverter.decodeFirst(pem);
+    let pkcs8KeyData: ArrayBuffer;
+
+    try {
+        // Try to parse the PEM as PKCS#8 PrivateKeyInfo - if it works,
+        // we can just use it directly as-is:
+        asn1Schema.AsnConvert.parse(keyData, PrivateKeyInfo);
+        pkcs8KeyData = keyData;
+    } catch (e: any) {
+        // If parsing as PKCS#8 fails, assume it's PKCS#1 (RSAPrivateKey)
+        // and proceed to wrap it as an RSA key in a PrivateKeyInfo structure.
+        const rsaPrivateKeyDer = keyData;
+
+        try {
+            const privateKeyInfo = new PrivateKeyInfo({
+                version: 0,
+                privateKeyAlgorithm: new asn1X509.AlgorithmIdentifier({
+                    algorithm: rsaEncryptionOid
+                }),
+                privateKey: new asn1Schema.OctetString(rsaPrivateKeyDer)
+            });
+            pkcs8KeyData = asn1Schema.AsnConvert.serialize(privateKeyInfo);
+        } catch (conversionError: any) {
+            throw new Error(
+                `Unsupported or malformed key format. Failed to parse as PKCS#8 with ${
+                    e.message || e.toString()
+                } and failed to convert to PKCS#1 with ${
+                    conversionError.message || conversionError.toString()
+                }`
+            );
+        }
+    }
+
     return await crypto.subtle.importKey(
-        "pkcs8",
-        derKey,
+        "pkcs8", // N.b, pkcs1 is not supported, which is why we need the above
+        pkcs8KeyData,
         { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
         true, // Extractable
         ["sign"]
@@ -243,7 +285,10 @@ export async function getCA(options: CAOptions): Promise<CA> {
         throw new Error('Unrecognized https options: you need to provide either a keyPath & certPath, or a key & cert.')
     }
 
-    return new CA(certOptions);
+    const caCert = new x509.X509Certificate(certOptions.cert.toString());
+    const caKey = await pemToCryptoKey(certOptions.key.toString());
+
+    return new CA(caCert, caKey, options);
 }
 
 // We share a single keypair across all certificates in this process, and
@@ -261,20 +306,22 @@ const KEY_PAIR_ALGO = {
     publicExponent: new Uint8Array([1, 0, 1])
 };
 
-export class CA {
-    private caCert: x509.X509Certificate;
-    private caKey: Promise<CryptoKey>;
-    private options: CertDataOptions;
+export type { CA };
+
+class CA {
+    private options: BaseCAOptions;
 
     private certCache: { [domain: string]: GeneratedCertificate };
 
-    constructor(options: CertDataOptions) {
-        this.caKey = pemToCryptoKey(options.key.toString());
-        this.caCert = new x509.X509Certificate(options.cert.toString());
+    constructor(
+        private caCert: x509.X509Certificate,
+        private caKey: CryptoKey,
+        options?: BaseCAOptions
+    ) {
         this.certCache = {};
         this.options = options ?? {};
 
-        const keyLength = options.keyLength || 2048;
+        const keyLength = this.options.keyLength || 2048;
 
         if (!KEY_PAIR || KEY_PAIR.length < keyLength) {
             // If we have no key, or not a long enough one, generate one.
@@ -376,7 +423,7 @@ export class CA {
             notAfter,
             signingAlgorithm: KEY_PAIR_ALGO,
             publicKey: leafKeyPair.publicKey,
-            signingKey: await this.caKey,
+            signingKey: this.caKey,
             extensions
         });
 

test/ca.spec.ts renamed to test/certificates.spec.ts

@@ -12,7 +12,7 @@ import {
     nodeOnly
 } from "./test-utils";
 
-import { CA, generateCACertificate, generateSPKIFingerprint } from '../src/util/tls';
+import { getCA, CA, generateCACertificate, generateSPKIFingerprint } from '../src/util/certificates';
 
 const validateLintSiteCertResults = (cert: string, results: any[]) => {
     // We don't worry about warnings
@@ -50,7 +50,7 @@ nodeOnly(() => {
         });
 
         it("can generate a certificate for a domain", async () => {
-            const ca = new CA({ key: await caKey, cert: await caCert, keyLength: 2048 });
+            const ca = await getCA({ key: await caKey, cert: await caCert, keyLength: 2048 });
 
             const { cert, key } = await ca.generateCertificate('localhost')
 
@@ -65,7 +65,7 @@ nodeOnly(() => {
         });
 
         it("can calculate the SPKI fingerprint for a certificate", async () => {
-            const ca = new CA({ key: await caKey, cert: await caCert, keyLength: 2048 });
+            const ca = await getCA({ key: await caKey, cert: await caCert, keyLength: 2048 });
 
             const { cert } = await ca.generateCertificate('localhost');
 
@@ -75,6 +75,15 @@ nodeOnly(() => {
             expect(caFingerprint).not.to.equal(certFingerprint);
         });
 
+        it("can use a PKCS#1 RSA private key as a CA", async () => {
+            // We only need these for backward compatibility, but it is generally good practice to
+            // be able to handle this properly, and very convenient if you currently have one.
+            await getCA({
+                keyPath: path.join(__dirname, 'fixtures', 'ca-pkcs1.key'),
+                certPath: path.join(__dirname, 'fixtures', 'ca-pkcs1.pem'),
+            });
+        });
+
         describe("with a constrained CA", () => {
             let constrainedCA: CA;
             let constrainedCaCert: string;
@@ -99,7 +108,7 @@ nodeOnly(() => {
                     nameConstraints: { permitted: ["example.com"] },
                 });
                 constrainedCaCert = rootCa.cert;
-                constrainedCA = new CA(rootCa);
+                constrainedCA = await getCA(rootCa);
             });
 
             it("can generate a valid certificate for a domain included in a constrained CA", async () => {
@@ -166,7 +175,7 @@ nodeOnly(() => {
 
         it("should generate a CA certificate that can be used to create domain certificates", async () => {
             const caCertificate = await caCertificatePromise;
-            const ca = new CA({ key: caCertificate.key, cert: caCertificate.cert, keyLength: 1024 });
+            const ca = await getCA({ key: caCertificate.key, cert: caCertificate.cert, keyLength: 1024 });
 
             const { cert, key } = await ca.generateCertificate('localhost');
 
@@ -204,7 +213,7 @@ nodeOnly(() => {
             this.timeout(5000); // Large cert + remote request can make this slow
 
             const caCertificate = await caCertificatePromise;
-            const ca = new CA({ key: caCertificate.key, cert: caCertificate.cert, keyLength: 2048 });
+            const ca = await getCA({ key: caCertificate.key, cert: caCertificate.cert, keyLength: 2048 });
 
             const { cert } = await ca.generateCertificate('httptoolkit.com');
 
@@ -237,7 +246,7 @@ nodeOnly(() => {
             this.timeout(10_000); // Large cert + remote request can make this slow
 
             const caCertificate = await caCertificatePromise;
-            const ca = new CA({ key: caCertificate.key, cert: caCertificate.cert, keyLength: 2048 });
+            const ca = await getCA({ key: caCertificate.key, cert: caCertificate.cert, keyLength: 2048 });
 
             const { cert } = await ca.generateCertificate('under_score.httptoolkit.com');
 

test/fixtures/ca-pkcs1.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEA78UsLr+Es1VmCiD1gDQPAzetgSbqPWFx27h4+CP5t86l1dqU
+jb+6lwi+vKOehyaW2LfkwJpB9XhY4Uc7hMNKhvp8mRJZ765IjQwlN05E0PlsmvuC
+cVUpg/f6MBOkKnRPRfAuV2SQ1ESrjcLzjVGEOOAkOb4hGaYOs+n2V/noWpE2qTuW
+yjhlMajwgXm3gjWaxGNo2ETYBobqF5bYoBgdrX8yfrlzz8yrv8SL1Pds+j+EeTfJ
+uYubrRs5AYUzmckY5AZy95nyzwo/gMvQMLT72SrxyZEuY4M5GDwOSklek9jsgWeG
+AMjdmMkn58v50Fu8QEfHCiml0c9KYu7AA0NKYQIDAQABAoIBACGvZonpy7OjLYsC
+PuNkTPCjh5tzs2hssoGPLOWVrk1huaAuDX1NoKH770oSxaCQrhQj374kXdxl7Dy4
+FHdONX/5nHwn3R1Ec7pnKKpYs2fVhunOKHESKRs6gTp0Y/W38fQuLmCGRyefPyfT
+KgLiXyxbZxN6r+1JzFp/5eVNvZRNeUvB0moNhLdeL5AXqz8wdD5lDH4Wijj2x/XV
+vMvdgCXMU4ZavPXx8gGt45AV9DKGxwKaihTxIFHjVwE6a2MkcScnENNNJcjN2lcx
+i+NJc0JF3PcM2MpgfEzTwAuRJXCTgJpBrh+HOKGNJsOZZwNNLuqXttJCzhgJli8O
+J04FwB0CgYEA/B9Adrm1VQlA9AZbhziIz+yn+Ipjl8iqVB85zDQlqIOqIlwWl2Av
+DXzQHQv6xVZ+qViKZu75saEB3hpAW/jjUB3Yr9ZeOfJLjf9qqtpHL8789yxgYLZV
+nGCVkJJ8I6z4lzqSV341WvOug5Uj3Cl58savdqABjMe4+Y/u7K7a2TUCgYEA83VI
+z/NDi0AFiJlrBBqcXnA8pdgkZz5ssmytPvsPk0KUJvNXRguJhGLkDKMW4VV4rODy
+4JW47FVxKB3/IIeCmwNFuRwwBWiVCehQTRvygxUVGDT/7Zitxw3wcJl4DUMXKHE0
+lMZlGcmt96p28Ob/+e4TspIw7f73qZQBq+J1Pf0CgYA/zIi7gnLoedb96T3wEdZN
+B03aDur01cqETwKJMgj1g5vh5fuxgp1lhFgFgaqLlT+oCse7FG4LDPs0AOCYZXrg
+Iy1aEZz2fOGxpRiQ83tgFbjds1UQJBO15pryYp8XSAX//spZaY6G3XMjyPGyHKzH
+So/MLOE3hrLANDP5oKWwoQKBgA3YWqawz+OIZYgqKWLXXJMmUNyhmRhh/W58LbIK
+Nw2J2MEKT6lFGLH1qcBqOe/gm3dBZ66L9TNDfKbqZcrkyfGk0v8+8iAsnWUt1/s6
+nqUDuupggTly2FccnNLad3BRo2yCW5omWjOIO6N9BzyV9nKxLl+WXr/6Iv161EmB
+HGfFAoGAbh0ksL/JqKe/1loOcMJhj5RdSnAsAAZl7A+4m1mTZuyOxmM2LGsYQg1v
+hIiVycyF1BHZn8kFFHSw4faW5FcAvZNmHGwIHLQYLbUk4VNlHM7jihsDmvA4ABH8
+ioyjJNBAUiokO75HfkNI5LxDZyEagnQqfVCYL6qvzIov/pq8ZJU=
+-----END RSA PRIVATE KEY-----

test/fixtures/ca-pkcs1.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDTzCCAjegAwIBAgIRCpNHMwVuHkN8kDPxTfXWZNowDQYJKoZIhvcNAQELBQAw
+QTEYMBYGA1UEAxMPSFRUUCBUb29sa2l0IENBMQswCQYDVQQGEwJYWDEYMBYGA1UE
+ChMPSFRUUCBUb29sa2l0IENBMB4XDTI1MDYxMTEzNDExNVoXDTI2MDYxMjEzNDEx
+NVowQTEYMBYGA1UEAxMPSFRUUCBUb29sa2l0IENBMQswCQYDVQQGEwJYWDEYMBYG
+A1UEChMPSFRUUCBUb29sa2l0IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEA78UsLr+Es1VmCiD1gDQPAzetgSbqPWFx27h4+CP5t86l1dqUjb+6lwi+
+vKOehyaW2LfkwJpB9XhY4Uc7hMNKhvp8mRJZ765IjQwlN05E0PlsmvuCcVUpg/f6
+MBOkKnRPRfAuV2SQ1ESrjcLzjVGEOOAkOb4hGaYOs+n2V/noWpE2qTuWyjhlMajw
+gXm3gjWaxGNo2ETYBobqF5bYoBgdrX8yfrlzz8yrv8SL1Pds+j+EeTfJuYubrRs5
+AYUzmckY5AZy95nyzwo/gMvQMLT72SrxyZEuY4M5GDwOSklek9jsgWeGAMjdmMkn
+58v50Fu8QEfHCiml0c9KYu7AA0NKYQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/
+MA4GA1UdDwEB/wQEAwIBxjAdBgNVHQ4EFgQUKs/5Gl7a4AWsCGwQhHCwqRI5mFgw
+DQYJKoZIhvcNAQELBQADggEBAHd+Kx9d/dvdm20s3J2hMaKeHznVknA2l6FNmLVo
+nMqYKSNWez8SvtfZMDJYcI7p9150CIzMyh5RBYMFSeH/raKDJnDn3rtEthujoNdC
+5q4UnjOkx1QdoPmt74XxIjTuP5eD3+30kYEI/3+ryBhLUx9SGsL4jucfP3m4Psb/
+TM3iL5U14KZp/qE9ChRVl8u8ARH8mEnUp9QW7K9rwLUbfmpn1qudOoswfTlepp7i
++YrBXD49TYPbvZDRXmLdlijjAym6CyeI1VwTnOKidmvZobTLS2sUtktYHxtQMfpN
+y0zgFDU0S1yLoZZrwwjOWsTTW2qHVAv2P4LOEQZGNm9kolw=
+-----END CERTIFICATE-----

test/integration/proxying/https-proxying.spec.ts

@@ -18,7 +18,7 @@ import {
     DestroyableServer,
     ignoreNetworkError
 } from "../../test-utils";
-import { CA } from "../../../src/util/tls";
+import { getCA } from "../../../src/util/certificates";
 import { streamToBuffer } from "../../../src/util/buffer-utils";
 
 const INITIAL_ENV = _.cloneDeep(process.env);
@@ -320,7 +320,7 @@ nodeOnly(() => {
                 beforeEach(async () => {
                     const caKey = await fs.readFile('./test/fixtures/test-ca.key');
                     const caCert = await fs.readFile('./test/fixtures/test-ca.pem');
-                    const ca = new CA({ key: caKey.toString(), cert: caCert.toString(), keyLength: 1024 });
+                    const ca = await getCA({ key: caKey.toString(), cert: caCert.toString(), keyLength: 1024 });
 
                     const cert = await ca.generateCertificate('localhost');
 

test/integration/websockets.spec.ts

@@ -19,7 +19,7 @@ import {
     makeDestroyable,
     delay
 } from '../test-utils';
-import { getCA } from '../../src/util/tls';
+import { getCA } from '../../src/util/certificates';
 import { pairFlatRawHeaders } from '../../src/util/header-utils';
 
 browserOnly(() => {