[AUTH-1236] Optionally support accepting HTTPS connections in addition to HTTP

src/cli.ts

@@ -19,6 +19,14 @@ async function main(argv: string[]) {
     .option("--default-tape <tape-name>", "Name of the default tape", "default")
     .option("-h, --host <host>", "Host to proxy (not required in replay mode)")
     .option("-p, --port <port>", "Local port to serve on", "3000")
+    .option(
+      "--https-key <filename.pem>",
+      "Enable HTTPS server with this key. Also requires --https-cert."
+    )
+    .option(
+      "--https-cert <filename.pem>",
+      "Enable HTTPS server with this cert. Also requires --https-key."
+    )
     .option(
       "-r, --redact-headers <headers>",
       "Request headers to redact",
@@ -32,6 +40,8 @@ async function main(argv: string[]) {
   const host: string = program.host;
   const port = parseInt(program.port, 10);
   const redactHeaders: string[] = program.redactHeaders;
+  const httpsKey: string = program.httpsKey;
+  const httpsCert: string = program.httpsCert;
 
   switch (initialMode) {
     case "record":
@@ -72,6 +82,8 @@ async function main(argv: string[]) {
     defaultTapeName,
     enableLogging: true,
     redactHeaders,
+    httpsKey,
+    httpsCert,
   });
   await server.start(port);
   console.log(chalk.green(`Proxying in ${initialMode} mode on port ${port}.`));

src/server.ts

@@ -1,6 +1,9 @@
 import assertNever from "assert-never";
 import chalk from "chalk";
+import fs from "fs";
 import http from "http";
+import https from "https";
+import net from "net";
 import { ensureBuffer } from "./buffer";
 import { findNextRecordToReplay, findRecordMatches } from "./matcher";
 import { Mode } from "./modes";
@@ -12,7 +15,7 @@ import { TapeRecord } from "./tape";
  * A server that proxies or replays requests depending on the mode.
  */
 export class RecordReplayServer {
-  private server: http.Server;
+  private server: net.Server;
   private persistence: Persistence;
 
   private mode: Mode;
@@ -32,6 +35,8 @@ export class RecordReplayServer {
     timeout?: number;
     enableLogging?: boolean;
     redactHeaders?: string[];
+    httpsKey?: string;
+    httpsCert?: string;
   }) {
     this.currentTapeRecords = [];
     this.mode = options.initialMode;
@@ -43,7 +48,10 @@ export class RecordReplayServer {
     this.defaultTape = options.defaultTapeName;
     this.loadTape(this.defaultTape);
 
-    this.server = http.createServer(async (req, res) => {
+    const handler = async (
+      req: http.IncomingMessage,
+      res: http.ServerResponse
+    ) => {
       if (!req.url) {
         if (this.loggingEnabled) {
           console.error(chalk.red("Received a request without URL."));
@@ -85,6 +93,50 @@ export class RecordReplayServer {
         res.statusCode = 500;
         res.end();
       }
+    };
+
+    const httpServer = http.createServer(handler);
+    let httpsServer: https.Server | null = null;
+    if (options.httpsKey && options.httpsCert) {
+      const httpsOptions = {
+        key: fs.readFileSync(options.httpsKey),
+        cert: fs.readFileSync(options.httpsCert),
+      };
+      httpsServer = https.createServer(httpsOptions, handler);
+    }
+
+    // Copied from https://stackoverflow.com/a/42019773/16286019
+    this.server = net.createServer((socket) => {
+      socket.once("data", (buffer) => {
+        // Pause the socket
+        socket.pause();
+
+        // Determine if this is an HTTP(s) request
+        const byte = buffer[0];
+
+        let server;
+        // First byte of HTTPS is a 22.
+        if (byte === 22) {
+          server = httpsServer;
+        } else if (32 < byte && byte < 127) {
+          server = httpServer;
+        }
+
+        if (server) {
+          // Push the buffer back onto the front of the data stream
+          socket.unshift(buffer);
+
+          // Emit the socket to the HTTP(s) server
+          server.emit("connection", socket);
+        }
+
+        // As of NodeJS 10.x the socket must be
+        // resumed asynchronously or the socket
+        // connection hangs, potentially crashing
+        // the process. Prior to NodeJS 10.x
+        // the socket may be resumed synchronously.
+        process.nextTick(() => socket.resume());
+      });
     });
   }