Add cert to Chrome, and allow multi-port interceptor activation

Author: pimterry

bin/run

@@ -9,5 +9,5 @@ if (dev) {
   require('ts-node').register({project})
 }
 
-require(`../${dev ? 'src' : 'lib'}`).run()
+require(`../${dev ? 'src' : 'lib'}/cli`).run()
 .catch(require('@oclif/errors/handle'))

src/cli.ts

@@ -0,0 +1,21 @@
+import { Command, flags } from '@oclif/command'
+import { runHTK } from './index';
+
+class HttpToolkitServer extends Command {
+    static description = 'run the HTTP Toolkit server'
+
+    static flags = {
+        version: flags.version({char: 'v'}),
+        help: flags.help({char: 'h'}),
+
+        config: flags.string({char: 'c', description: 'path in which to store config files'}),
+    }
+
+    async run() {
+        const { flags } = this.parse(HttpToolkitServer);
+
+        await runHTK({ configPath: flags.config });
+    }
+}
+
+export = HttpToolkitServer;

src/config.d.ts

@@ -0,0 +1,3 @@
+export interface HtkConfig {
+    configPath: string;
+}

src/htk-server.ts

@@ -2,7 +2,8 @@ import * as _ from 'lodash';
 import { GraphQLServer } from 'graphql-yoga'
 import { GraphQLScalarType } from 'graphql';
 
-import { buildInterceptors } from './interceptors';
+import { HtkConfig } from './config';
+import { buildInterceptors, Interceptor } from './interceptors';
 
 const typeDefs = `
     type Query {
@@ -13,32 +14,53 @@ const typeDefs = `
     type Mutation {
         activateInterceptor(
             id: ID!,
+            proxyPort: Int!,
             options: Json
         ): Boolean!
+        deactivateInterceptor(
+            id: ID!,
+            proxyPort: Int!
+        ): Boolean!
     }
 
     type Interceptor {
         id: ID!
-        isActive: Boolean!
         version: String!
+
+        isActivable: Boolean!
+        isActive(proxyPort: Int!): Boolean!
     }
 
     scalar Json
     scalar Error
 `
 
-const buildResolvers = (configPath: string) => {
-    let interceptors = buildInterceptors(configPath);
-
+const buildResolvers = (interceptors: _.Dictionary<Interceptor>) => {
     return {
         Query: {
             version: async () => (await import('../package.json')).version,
             interceptors: () => _.values(interceptors),
         },
 
         Mutation: {
-            activateInterceptor: (__: void, args: _.Dictionary<any>) => {
+            activateInterceptor: async (__: void, args: _.Dictionary<any>) => {
+                const { id, proxyPort, options } = args;
+                await interceptors[id].activate(proxyPort, options);
+                return interceptors[id].isActive(proxyPort);
+            },
+            deactivateInterceptor: async (__: void, args: _.Dictionary<any>) => {
+                const { id, proxyPort, options } = args;
+                await interceptors[id].deactivate(proxyPort, options);
+                return !interceptors[id].isActive(proxyPort);
+            }
+        },
 
+        Interceptor: {
+            isActivable: (interceptor: Interceptor) => {
+                return interceptor.isActivable();
+            },
+            isActive: (interceptor: Interceptor, args: _.Dictionary<any>) => {
+                return interceptor.isActive(args.proxyPort);
             }
         },
 
@@ -75,10 +97,12 @@ export class HttpToolkitServer {
 
     private graphql: GraphQLServer;
 
-    constructor(options: { configPath: string }) {
+    constructor(config: HtkConfig) {
+        let interceptors = buildInterceptors(config);
+
         this.graphql = new GraphQLServer({
             typeDefs,
-            resolvers: buildResolvers(options.configPath)
+            resolvers: buildResolvers(interceptors)
         });
     }
 

src/index.ts

@@ -1,21 +1,66 @@
-import { Command, flags } from '@oclif/command'
-import { runHTK } from './run-htk';
+import * as util from 'util';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as envPaths from 'env-paths';
+import { getStandalone, generateCACertificate } from 'mockttp';
 
-class HttpToolkitServer extends Command {
-    static description = 'run the HTTP Toolkit server'
+import { HttpToolkitServer } from './htk-server';
 
-    static flags = {
-        version: flags.version({char: 'v'}),
-        help: flags.help({char: 'h'}),
+const canAccess = util.promisify(fs.access);
+const mkDir = util.promisify(fs.mkdir);
+const writeFile = util.promisify(fs.writeFile);
 
-        config: flags.string({char: 'c', description: 'path in which to store config files'}),
-    }
+const ensureDirectoryExists = (path: string) =>
+    canAccess(path).catch(() => mkDir(path, { recursive: true }));
 
-    async run() {
-        const { flags } = this.parse(HttpToolkitServer);
+async function generateHTTPSConfig(configPath: string) {
+    const keyPath = path.join(configPath, 'ca.key');
+    const certPath = path.join(configPath, 'ca.pem');
 
-        await runHTK({ configPath: flags.config });
-    }
+    await Promise.all([
+        canAccess(keyPath, fs.constants.R_OK),
+        canAccess(certPath, fs.constants.R_OK)
+    ]).catch(() => {
+        const newCertPair = generateCACertificate({
+            commonName: 'HTTP Toolkit CA - DO NOT TRUST'
+        });
+
+        return Promise.all([
+            writeFile(keyPath, newCertPair.key),
+            writeFile(certPath, newCertPair.cert)
+        ]);
+    });
+
+    return {
+        keyPath,
+        certPath,
+        keyLength: 2048 // Reasonably secure keys please
+    };
 }
 
-export = HttpToolkitServer;
+export async function runHTK(options: {
+    configPath?: string
+}) {
+    const configPath = options.configPath || envPaths('httptoolkit', { suffix: '' }).config;
+
+    await ensureDirectoryExists(configPath);
+
+    const httpsConfig = await generateHTTPSConfig(configPath);
+
+    // Start a standalone server
+    const standalone = getStandalone({
+        serverDefaults: {
+            cors: false,
+            https: httpsConfig
+        }
+    });
+    standalone.start();
+
+    // Start a HTK server
+    const htkServer = new HttpToolkitServer({
+        configPath
+    });
+    await htkServer.start();
+
+    console.log('Server started');
+}

src/interceptors/fresh-chrome.ts

@@ -1,43 +1,62 @@
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as path from 'path';
+
 import * as _ from 'lodash';
+import { generateSPKIFingerprint } from 'mockttp';
+
+import { HtkConfig } from '../config';
 
 import { getAvailableBrowsers, launchBrowser, BrowserInstance } from '../browsers';
 
-let browser: BrowserInstance | undefined;
+const readFile = promisify(fs.readFile);
+
+let browsers: _.Dictionary<BrowserInstance> = {};
 
 export class FreshChrome {
     id = 'fresh-chrome';
     version = '1.0.0';
 
-    constructor(private configPath: string) { }
+    constructor(private config: HtkConfig) { }
 
-    get isActive() {
-        return browser != null && !!browser.pid;
+    isActive(proxyPort: number) {
+        return browsers[proxyPort] != null && !!browsers[proxyPort].pid;
     }
 
-    async checkIfAvailable() {
-        const browsers = await getAvailableBrowsers(this.configPath);
+    async isActivable() {
+        const browsers = await getAvailableBrowsers(this.config.configPath);
 
         return _(browsers)
             .map(b => b.name)
             .includes('chrome')
 
     }
 
-    async activate() {
-        if (this.isActive) return;
+    async activate(proxyPort: number) {
+        if (this.isActive(proxyPort)) return;
 
-        browser = await launchBrowser('https://example.com', {
-            browser: 'chrome'
-        }, this.configPath);
-    }
+        const certificatePem = await readFile(path.join(this.config.configPath, 'ca.pem'), 'utf8');
+        const spkiFingerprint = generateSPKIFingerprint(certificatePem);
 
-    async deactivate() {
-        if (this.isActive) {
-            browser!.process.kill();
+        const browser = await launchBrowser('https://example.com', {
+            browser: 'chrome',
+            proxy: `https://localhost:${proxyPort}`,
+            options: [
+                `--ignore-certificate-errors-spki-list=${spkiFingerprint}`
+            ]
+        }, this.config.configPath);
 
-            await new Promise((resolve) => browser!.process.on('exit', resolve));
+        browsers[proxyPort] = browser;
+        browser.process.once('exit', () => {
+            delete browsers[proxyPort];
+        });
+    }
 
-            browser = undefined;
+    async deactivate(proxyPort: number) {
+        if (this.isActive(proxyPort)) {
+            const browser = browsers[proxyPort];
+            browser!.process.kill();
+            await new Promise((resolve) => browser!.process.once('exit', resolve));
         }
     }
 };

src/interceptors/index.ts

@@ -1,19 +1,22 @@
 import * as _ from 'lodash';
 
+import { HtkConfig } from '../config';
+
 import { FreshChrome } from './fresh-chrome';
 
 export interface Interceptor {
     id: string;
     version: string;
-    isActive: boolean;
 
-    checkIfAvailable(): Promise<boolean>;
-    activate(options?: any): Promise<void>;
-    deactivate(): Promise<void>;
+    isActivable(): Promise<boolean>;
+    isActive(proxyPort: number): boolean;
+
+    activate(proxyPort: number, options?: any): Promise<void>;
+    deactivate(proxyPort: number, options?: any): Promise<void>;
 }
 
-export function buildInterceptors(configPath: string): _.Dictionary<Interceptor> {
+export function buildInterceptors(config: HtkConfig): _.Dictionary<Interceptor> {
     return _.keyBy([
-        new FreshChrome(configPath)
+        new FreshChrome(config)
     ], (interceptor) => interceptor.id);
 }