@mug-lab/cookie-auth-proxy 0.1.0

package/src/sensitive.js

@@ -0,0 +1,107 @@
+/**
+ * 履歴表示やStub作成時に認証情報を残さないためのマスク/除外処理。
+ */
+
+/**
+ * 設定値のヘッダ名配列を小文字Setへ正規化する。
+ */
+function sensitiveHeaderSet(config) {
+  return new Set(
+    (config.sensitiveHeaderNames || []).map((name) =>
+      String(name).trim().toLowerCase(),
+    ),
+  );
+}
+
+/**
+ * 設定値のCookie名配列をSetへ正規化する。
+ */
+function sensitiveCookieSet(config) {
+  return new Set(
+    (config.sensitiveCookieNames || []).map((name) => String(name).trim()),
+  );
+}
+
+/**
+ * 指定ヘッダ名がセンシティブ扱いか判定する。
+ */
+function isSensitiveHeaderName(config, name) {
+  return sensitiveHeaderSet(config).has(String(name).toLowerCase());
+}
+
+/**
+ * 共有・表示向けにセンシティブヘッダ値をマスクする。
+ */
+function maskSensitiveHeaders(headers, config) {
+  if (!headers || typeof headers !== "object") return {};
+  const sensitiveHeaders = sensitiveHeaderSet(config);
+
+  return Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => {
+      const lowerName = String(name).toLowerCase();
+      if (sensitiveHeaders.has(lowerName)) {
+        return [name, maskHeaderValue(value)];
+      }
+      if (lowerName === "cookie" || lowerName === "set-cookie") {
+        return [name, maskCookieHeaderValue(value, config)];
+      }
+      return [name, value];
+    }),
+  );
+}
+
+/**
+ * Stub作成時にセンシティブヘッダ自体を除外する。
+ */
+function omitSensitiveHeaders(headers, config) {
+  if (!headers || typeof headers !== "object") return {};
+  const sensitiveHeaders = sensitiveHeaderSet(config);
+
+  return Object.fromEntries(
+    Object.entries(headers).filter(
+      ([name]) => !sensitiveHeaders.has(String(name).toLowerCase()),
+    ),
+  );
+}
+
+/**
+ * Cookieヘッダ内の指定Cookie値だけをマスクする。
+ */
+function maskSensitiveCookieHeader(headerValue, config) {
+  const sensitiveCookies = sensitiveCookieSet(config);
+  if (sensitiveCookies.size === 0) return headerValue;
+
+  return String(headerValue || "")
+    .split(";")
+    .map((part) => {
+      const trimmed = part.trim();
+      const index = trimmed.indexOf("=");
+      if (index === -1) return trimmed;
+      const name = trimmed.slice(0, index).trim();
+      return sensitiveCookies.has(name) ? `${name}=***` : trimmed;
+    })
+    .join("; ");
+}
+
+/**
+ * Cookie系ヘッダ値を文字列/配列どちらでもCookie名単位でマスクする。
+ */
+function maskCookieHeaderValue(value, config) {
+  return Array.isArray(value)
+    ? value.map((entry) => maskSensitiveCookieHeader(entry, config))
+    : maskSensitiveCookieHeader(value, config);
+}
+
+/**
+ * ヘッダ値の形を保ったまま固定値へ置き換える。
+ */
+function maskHeaderValue(value) {
+  return Array.isArray(value) ? value.map(() => "***") : "***";
+}
+
+module.exports = {
+  isSensitiveHeaderName,
+  maskSensitiveCookieHeader,
+  maskSensitiveHeaders,
+  omitSensitiveHeaders,
+};

package/src/server/admin-server.js

@@ -0,0 +1,562 @@
+const fs = require("node:fs");
+const http = require("node:http");
+const path = require("node:path");
+const {
+  getActiveApiCookie,
+  setApiCookie,
+  setApiOrigin,
+  setClientOrigin,
+} = require("../config");
+const {
+  exportJsonOverride,
+  exportStub,
+  normalizeJsonOverride,
+  normalizeStub,
+} = require("../runtime");
+const { log } = require("../logger");
+const {
+  maskSensitiveHeaders,
+  omitSensitiveHeaders,
+} = require("../sensitive");
+
+/**
+ * 履歴確認や実行時設定変更に使うローカル管理サーバを起動する。
+ *
+ * @param {object} config runtime状態を含むマージ済みプロキシ設定。
+ * @returns {import("node:http").Server} listen済みの管理HTTPサーバ。
+ */
+function startAdminServer(config) {
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(
+      req.url,
+      `http://${req.headers.host || `${config.adminHost}:${config.adminPort}`}`,
+    );
+
+    try {
+      if (
+        isCrossSiteBrowserRequest(
+          req,
+          `http://${req.headers.host || `${config.adminHost}:${config.adminPort}`}`,
+        )
+      ) {
+        sendJson(res, 403, {
+          error: "Cross-site admin requests are not allowed.",
+        });
+        return;
+      }
+
+      if (req.method === "OPTIONS") {
+        sendText(
+          res,
+          403,
+          "CORS is not enabled for the admin API.",
+          "text/plain; charset=utf-8",
+        );
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/") {
+        sendText(res, 200, readAdminHtml(config), "text/html; charset=utf-8");
+        return;
+      }
+
+      const assetMatch = url.pathname.match(
+        /^\/admin\/([a-z0-9-]+\.(?:css|js))$/,
+      );
+      if (req.method === "GET" && assetMatch) {
+        const filename = assetMatch[1];
+        const contentType = filename.endsWith(".css")
+          ? "text/css; charset=utf-8"
+          : "application/javascript; charset=utf-8";
+        sendText(res, 200, readAdminAsset(filename), contentType);
+        return;
+      }
+
+      if (!isValidAdminCsrfToken(req, config)) {
+        sendJson(res, 403, { error: "Invalid admin CSRF token." });
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/admin/state") {
+        sendJson(res, 200, {
+          listen: config.publicOriginUrl.origin,
+          clientOrigin: config.clientOriginUrl.origin,
+          apiOrigin: config.apiOriginUrl ? config.apiOriginUrl.origin : "",
+          apiOriginAllowedPatterns: config.apiOriginAllowedPatterns,
+          apiCookie: getActiveApiCookie(config),
+          sensitiveHeaderNames: config.sensitiveHeaderNames,
+          sensitiveCookieNames: config.sensitiveCookieNames,
+          adminNotice: String(config.adminNotice || ""),
+          serverAppPath: config.serverAppPath || "/",
+          adminOrigin: `http://${config.adminHost}:${config.adminPort}`,
+          hasCookie: Boolean(getActiveApiCookie(config)),
+          historyCount: config.runtime.history.length,
+          stubsEnabled: config.runtime.stubsEnabled,
+          stubs: config.runtime.stubs,
+          jsonOverridesEnabled: config.runtime.jsonOverridesEnabled,
+          jsonOverrides: config.runtime.jsonOverrides,
+        });
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/admin/state") {
+        const body = await readJsonBody(req, config.maxAdminBodyBytes);
+        if (Object.prototype.hasOwnProperty.call(body, "clientOrigin"))
+          setClientOrigin(config, body.clientOrigin);
+        if (Object.prototype.hasOwnProperty.call(body, "apiOrigin"))
+          setApiOrigin(config, body.apiOrigin);
+        if (Object.prototype.hasOwnProperty.call(body, "apiCookie"))
+          setApiCookie(config, body.apiCookie);
+        if (Object.prototype.hasOwnProperty.call(body, "stubsEnabled")) {
+          config.runtime.stubsEnabled = Boolean(body.stubsEnabled);
+        }
+        if (
+          Object.prototype.hasOwnProperty.call(body, "jsonOverridesEnabled")
+        ) {
+          config.runtime.jsonOverridesEnabled = Boolean(
+            body.jsonOverridesEnabled,
+          );
+        }
+        sendJson(res, 200, {
+          ok: true,
+          clientOrigin: config.clientOriginUrl.origin,
+          apiOrigin: config.apiOriginUrl ? config.apiOriginUrl.origin : "",
+          hasCookie: Boolean(getActiveApiCookie(config)),
+          stubsEnabled: config.runtime.stubsEnabled,
+          jsonOverridesEnabled: config.runtime.jsonOverridesEnabled,
+        });
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/admin/history") {
+        const history =
+          url.searchParams.get("summary") === "1"
+            ? config.runtime.history.map((item) =>
+                summarizeHistoryItem(item, config),
+              )
+            : config.runtime.history.map((item) =>
+                historyItemForAdmin(item, config),
+              );
+        sendJson(res, 200, history);
+        return;
+      }
+
+      const historyMatch = url.pathname.match(/^\/admin\/history\/(\d+)$/);
+      if (historyMatch && req.method === "GET") {
+        const item = config.runtime.history.find(
+          (entry) => String(entry.id) === historyMatch[1],
+        );
+        if (!item) {
+          sendJson(res, 404, { error: "History item not found" });
+          return;
+        }
+
+        sendJson(res, 200, historyItemForAdmin(item, config));
+        return;
+      }
+
+      if (req.method === "DELETE" && url.pathname === "/admin/history") {
+        config.runtime.history = [];
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/admin/stubs") {
+        sendJson(res, 200, config.runtime.stubs);
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/admin/json-overrides") {
+        sendJson(res, 200, config.runtime.jsonOverrides);
+        return;
+      }
+
+      if (
+        req.method === "GET" &&
+        url.pathname === "/admin/json-overrides/export"
+      ) {
+        sendJson(res, 200, {
+          version: 1,
+          exportedAt: new Date().toISOString(),
+          jsonOverrides: config.runtime.jsonOverrides.map(exportJsonOverride),
+        });
+        return;
+      }
+
+      if (
+        req.method === "POST" &&
+        url.pathname === "/admin/json-overrides/import"
+      ) {
+        const body = await readJsonBody(req, config.maxAdminBodyBytes);
+        const imported = Array.isArray(body)
+          ? body
+          : body.jsonOverrides || body.overrides;
+        if (!Array.isArray(imported)) {
+          sendJson(res, 400, {
+            error:
+              "Import file must be an array or an object with a jsonOverrides array.",
+          });
+          return;
+        }
+
+        const overrides = imported
+          .map((override) =>
+            normalizeJsonOverride({ ...override, id: undefined }),
+          )
+          .filter(Boolean);
+
+        if (body.mode === "append") {
+          config.runtime.jsonOverrides.push(...overrides);
+        } else {
+          config.runtime.jsonOverrides = overrides;
+        }
+
+        sendJson(res, 200, {
+          ok: true,
+          mode: body.mode === "append" ? "append" : "replace",
+          count: overrides.length,
+          jsonOverridesEnabled: config.runtime.jsonOverridesEnabled,
+        });
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/admin/json-overrides") {
+        const override = normalizeJsonOverride(
+          await readJsonBody(req, config.maxAdminBodyBytes),
+        );
+        if (!override) {
+          sendJson(res, 400, { error: "Invalid JSON override" });
+          return;
+        }
+
+        config.runtime.jsonOverrides.unshift(override);
+        sendJson(res, 201, override);
+        return;
+      }
+
+      const overrideMatch = url.pathname.match(
+        /^\/admin\/json-overrides\/([^/]+)$/,
+      );
+      if (overrideMatch && req.method === "DELETE") {
+        config.runtime.jsonOverrides = config.runtime.jsonOverrides.filter(
+          (override) => override.id !== overrideMatch[1],
+        );
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
+      if (overrideMatch && req.method === "PATCH") {
+        const patch = await readJsonBody(req, config.maxAdminBodyBytes);
+        const override = config.runtime.jsonOverrides.find(
+          (entry) => entry.id === overrideMatch[1],
+        );
+        if (!override) {
+          sendJson(res, 404, { error: "JSON override not found" });
+          return;
+        }
+
+        const normalized = normalizeJsonOverride({ ...override, ...patch });
+        normalized.id = override.id;
+        Object.assign(override, normalized);
+        sendJson(res, 200, override);
+        return;
+      }
+
+      const overrideMoveMatch = url.pathname.match(
+        /^\/admin\/json-overrides\/([^/]+)\/move$/,
+      );
+      if (overrideMoveMatch && req.method === "POST") {
+        const body = await readJsonBody(req, config.maxAdminBodyBytes);
+        const index = config.runtime.jsonOverrides.findIndex(
+          (entry) => entry.id === overrideMoveMatch[1],
+        );
+        const delta = body.direction === "down" ? 1 : -1;
+        const nextIndex = index + delta;
+
+        if (
+          index === -1 ||
+          nextIndex < 0 ||
+          nextIndex >= config.runtime.jsonOverrides.length
+        ) {
+          sendJson(res, 200, { ok: true, moved: false });
+          return;
+        }
+
+        const [override] = config.runtime.jsonOverrides.splice(index, 1);
+        config.runtime.jsonOverrides.splice(nextIndex, 0, override);
+        sendJson(res, 200, { ok: true, moved: true });
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/admin/stubs/export") {
+        sendJson(res, 200, {
+          version: 2,
+          exportedAt: new Date().toISOString(),
+          stubs: config.runtime.stubs.map(exportStub),
+        });
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/admin/stubs/import") {
+        const body = await readJsonBody(req, config.maxAdminBodyBytes);
+        const imported = Array.isArray(body) ? body : body.stubs;
+        if (!Array.isArray(imported)) {
+          sendJson(res, 400, {
+            error:
+              "Import file must be an array or an object with a stubs array.",
+          });
+          return;
+        }
+
+        const stubs = imported
+          .map((stub) =>
+            normalizeStub(sanitizeStubInput({ ...stub, id: undefined }, config)),
+          )
+          .filter(Boolean);
+
+        if (body.mode === "append") {
+          config.runtime.stubs.push(...stubs);
+        } else {
+          config.runtime.stubs = stubs;
+        }
+
+        sendJson(res, 200, {
+          ok: true,
+          mode: body.mode === "append" ? "append" : "replace",
+          count: stubs.length,
+          stubsEnabled: config.runtime.stubsEnabled,
+        });
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/admin/stubs") {
+        const stub = normalizeStub(
+          sanitizeStubInput(
+            await readJsonBody(req, config.maxAdminBodyBytes),
+            config,
+          ),
+        );
+        if (!stub) {
+          sendJson(res, 400, { error: "Invalid stub" });
+          return;
+        }
+
+        config.runtime.stubs.unshift(stub);
+        sendJson(res, 201, stub);
+        return;
+      }
+
+      const stubMatch = url.pathname.match(/^\/admin\/stubs\/([^/]+)$/);
+      if (stubMatch && req.method === "DELETE") {
+        config.runtime.stubs = config.runtime.stubs.filter(
+          (stub) => stub.id !== stubMatch[1],
+        );
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
+      if (stubMatch && req.method === "PATCH") {
+        const patch = await readJsonBody(req, config.maxAdminBodyBytes);
+        const stub = config.runtime.stubs.find(
+          (entry) => entry.id === stubMatch[1],
+        );
+        if (!stub) {
+          sendJson(res, 404, { error: "Stub not found" });
+          return;
+        }
+
+        const normalized = normalizeStub(
+          sanitizeStubInput({ ...stub, ...patch }, config),
+        );
+        normalized.id = stub.id;
+        Object.assign(stub, normalized);
+        sendJson(res, 200, stub);
+        return;
+      }
+
+      const moveMatch = url.pathname.match(/^\/admin\/stubs\/([^/]+)\/move$/);
+      if (moveMatch && req.method === "POST") {
+        const body = await readJsonBody(req, config.maxAdminBodyBytes);
+        const index = config.runtime.stubs.findIndex(
+          (entry) => entry.id === moveMatch[1],
+        );
+        const delta = body.direction === "down" ? 1 : -1;
+        const nextIndex = index + delta;
+
+        if (
+          index === -1 ||
+          nextIndex < 0 ||
+          nextIndex >= config.runtime.stubs.length
+        ) {
+          sendJson(res, 200, { ok: true, moved: false });
+          return;
+        }
+
+        const [stub] = config.runtime.stubs.splice(index, 1);
+        config.runtime.stubs.splice(nextIndex, 0, stub);
+        sendJson(res, 200, { ok: true, moved: true });
+        return;
+      }
+
+      sendJson(res, 404, { error: "Not found" });
+    } catch (error) {
+      sendJson(res, error.statusCode || 500, { error: error.message });
+    }
+  });
+
+  server.listen(config.adminPort, config.adminHost, () => {
+    log(
+      config,
+      "info",
+      `Admin   -> http://${config.adminHost}:${config.adminPort}`,
+    );
+  });
+
+  return server;
+}
+
+/**
+ * 値を整形済みJSONレスポンスとして送信する。
+ */
+function sendJson(res, status, value) {
+  sendText(
+    res,
+    status,
+    JSON.stringify(value, null, 2),
+    "application/json; charset=utf-8",
+  );
+}
+
+/**
+ * 一覧取得用に重いレスポンス本文を除いた履歴サマリを作る。
+ */
+function summarizeHistoryItem(item, config) {
+  return {
+    ...item,
+    responseHeaders: maskSensitiveHeaders(item.responseHeaders || {}, config),
+    responseBody: "",
+    responseBodyBase64: "",
+  };
+}
+
+/**
+ * 管理画面へ返す履歴詳細からセンシティブ値をマスクし、Stub化用ヘッダを別枠で返す。
+ */
+function historyItemForAdmin(item, config) {
+  return {
+    ...item,
+    responseHeaders: maskSensitiveHeaders(item.responseHeaders || {}, config),
+    stubResponseHeaders: omitSensitiveHeaders(
+      item.responseHeaders || {},
+      config,
+    ),
+  };
+}
+
+/**
+ * Stub保存前に共有すべきでないヘッダを除外する。
+ */
+function sanitizeStubInput(stub, config) {
+  return {
+    ...stub,
+    headers: omitSensitiveHeaders(stub.headers || {}, config),
+  };
+}
+
+/**
+ * 文字列をHTTPレスポンスとして送信する。
+ */
+function sendText(res, status, text, contentType) {
+  const body = Buffer.from(text, "utf8");
+  sendBytes(res, status, body, contentType);
+}
+
+/**
+ * バイト列をHTTPレスポンスとして送信する。
+ */
+function sendBytes(res, status, body, contentType) {
+  res.writeHead(status, {
+    "content-type": contentType,
+    "cache-control": "no-store",
+    "content-length": body.length,
+  });
+  res.end(body);
+}
+
+/**
+ * HTTPリクエスト本文をJSONとして読み込む。
+ */
+function readJsonBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    let tooLarge = false;
+    req.on("data", (chunk) => {
+      if (tooLarge) return;
+      total += chunk.length;
+      if (total > maxBytes) {
+        tooLarge = true;
+        const error = new Error("Admin request body is too large.");
+        error.statusCode = 413;
+        reject(error);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      const text = Buffer.concat(chunks).toString("utf8");
+      if (!text.trim()) {
+        resolve({});
+        return;
+      }
+
+      try {
+        resolve(JSON.parse(text));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+/**
+ * ブラウザからのcross-site管理リクエストを拒否する。
+ */
+function isCrossSiteBrowserRequest(req, expectedOrigin) {
+  const origin = req.headers.origin;
+  if (origin && origin !== expectedOrigin) return true;
+
+  const fetchSite = String(req.headers["sec-fetch-site"] || "").toLowerCase();
+  return fetchSite === "cross-site";
+}
+
+/**
+ * 管理画面HTMLをファイルから読み込む。
+ */
+function readAdminHtml(config) {
+  const html = fs.readFileSync(
+    path.join(__dirname, "..", "admin.html"),
+    "utf8",
+  );
+  return html.replace(
+    "</head>",
+    `<script>window.__COOKIE_AUTH_PROXY_CSRF__=${JSON.stringify(config.adminCsrfToken)};</script></head>`,
+  );
+}
+
+/**
+ * 管理画面用の静的アセットを読み込む。
+ */
+function readAdminAsset(filename) {
+  return fs.readFileSync(path.join(__dirname, "..", "admin", filename), "utf8");
+}
+
+module.exports = { startAdminServer };
+
+/**
+ * 管理API呼び出しにHTML埋め込み済みCSRFトークンが付いているか判定する。
+ */
+function isValidAdminCsrfToken(req, config) {
+  return req.headers["x-csrf-token"] === config.adminCsrfToken;
+}