HY2XS_flamy/orchestrator/test/redaction.test.ts

import { afterEach, describe, expect, test } from "bun:test";
import {
  REDACTED,
  isSecretKey,
  redactEnv,
  redactLogText,
  redactYaml,
  redactYamlFallback,
  sanitizeUrlValue
} from "../src/lib/redaction";

const MACHINE_TOKEN = "hy2xs-machine-token-must-not-leak";
const OBFS_PASSWORD = "hy2xs-obfs-password-must-not-leak";

const SERVER_CONFIG = `listen: 0.0.0.0:443

acme:
  domains:
    - vpn.example.com
  email: admin@example.com
  ca: letsencrypt
  dir: /var/lib/hysteria/acme
  listenHost: 0.0.0.0
  type: http

auth:
  type: http
  http:
    url: http://127.0.0.1:8080/internal/hysteria/auth?access_token=${MACHINE_TOKEN}
    insecure: false

obfs:
  type: gecko
  gecko:
    password: "${OBFS_PASSWORD}"
    minPacketSize: 512
    maxPacketSize: 1200

trafficStats:
  listen: 127.0.0.1:36712
  secret: "${MACHINE_TOKEN}"
`;

afterEach(() => {
  // Тесты не должны зависеть друг от друга через глобальное состояние.
});

describe("редакция серверного конфига", () => {
  // Регрессия: правило `auth:\\s*(.*)` подставляло маркер в заголовок mapping'а
  // и оставляло вложенный auth.http.url с machine token нетронутым.
  test("machine token не переживает редакцию", () => {
    const redacted = redactYaml(SERVER_CONFIG);
    expect(redacted).not.toContain(MACHINE_TOKEN);
  });

  test("obfs-пароль не переживает редакцию", () => {
    expect(redactYaml(SERVER_CONFIG)).not.toContain(OBFS_PASSWORD);
  });

  test("результат остаётся валидным YAML", () => {
    const parsed = Bun.YAML.parse(redactYaml(SERVER_CONFIG)) as Record<string, unknown>;
    expect(parsed.listen).toBe("0.0.0.0:443");
    const auth = parsed.auth as Record<string, unknown>;
    const http = auth.http as Record<string, unknown>;
    expect(String(http.url)).toContain("127.0.0.1:8080/internal/hysteria/auth");
    // В query-параметре маркер приходит percent-encoded — так же, как это
    // делает Go-санитайзер админки: результат обязан остаться валидным URL.
    expect(String(http.url)).toContain(encodeURIComponent(REDACTED));
  });

  test("несекретные поля сохраняются: диагностика должна оставаться полезной", () => {
    const parsed = Bun.YAML.parse(redactYaml(SERVER_CONFIG)) as Record<string, unknown>;
    const acme = parsed.acme as Record<string, unknown>;
    expect(acme.email).toBe("admin@example.com");
    expect(acme.ca).toBe("letsencrypt");
    const obfs = parsed.obfs as Record<string, unknown>;
    const gecko = obfs.gecko as Record<string, unknown>;
    expect(gecko.minPacketSize).toBe(512);
    expect(gecko.maxPacketSize).toBe(1200);
    expect(gecko.password).toBe(REDACTED);
  });

  test("неизвестное upstream-поле с секретоподобным именем вырезается", () => {
    const yaml = `future:\n  apiKey: super-secret\n  privateKey: also-secret\n  harmless: keep-me\n`;
    const parsed = Bun.YAML.parse(redactYaml(yaml)) as Record<string, unknown>;
    const future = parsed.future as Record<string, unknown>;
    expect(future.apiKey).toBe(REDACTED);
    expect(future.privateKey).toBe(REDACTED);
    expect(future.harmless).toBe("keep-me");
  });

  test("вложенное дерево под секретным ключом вырезается целиком", () => {
    const yaml = `acme:\n  dns:\n    name: cloudflare\n    config:\n      api_token: leak-me\n      zone: example.com\n`;
    const parsed = Bun.YAML.parse(redactYaml(yaml)) as Record<string, unknown>;
    const dns = (parsed.acme as Record<string, unknown>).dns as Record<string, unknown>;
    const cfg = dns.config as Record<string, unknown>;
    expect(cfg.api_token).toBe(REDACTED);
    // acme.dns.config — карта, где секретны все значения, а не только ключ.
    expect(cfg.zone).toBe(REDACTED);
    expect(dns.name).toBe("cloudflare");
  });

  // Паритет с Go-санитайзером админки: URL-значение определяется по самому
  // значению, а не по имени ключа. Обе реализации описывают один контракт и
  // не имеют права расходиться.
  test("URL под произвольным именем ключа теряет секреты, но сохраняет адрес", () => {
    const yaml =
      "future:\n" +
      "  endpoint: https://svc-user:svc-p4ss@relay.example.com/?access_token=endpoint-token\n" +
      "  mirrors:\n" +
      "    - https://mirror-user:mirror-p4ss@mirror.example.com/pull\n";
    const parsed = Bun.YAML.parse(redactYaml(yaml)) as Record<string, unknown>;
    const future = parsed.future as Record<string, unknown>;

    const endpoint = String(future.endpoint);
    expect(endpoint).toContain("relay.example.com");
    expect(endpoint).not.toContain("svc-p4ss");
    expect(endpoint).not.toContain("endpoint-token");

    const mirrors = future.mirrors as string[];
    expect(mirrors).toHaveLength(1);
    expect(mirrors[0]).toContain("mirror.example.com");
    expect(mirrors[0]).not.toContain("mirror-p4ss");
  });

  test("не-URL скаляры проходят редакцию без изменений", () => {
    const yaml =
      "bandwidth:\n  up: 50 mbps\n  down: 50 mbps\n" +
      "quic:\n  maxIdleTimeout: 30s\n  initStreamReceiveWindow: 8388608\n" +
      "outbounds:\n  - addr: 10.0.0.1:1080\n";
    const parsed = Bun.YAML.parse(redactYaml(yaml)) as Record<string, unknown>;
    const bandwidth = parsed.bandwidth as Record<string, unknown>;
    const quic = parsed.quic as Record<string, unknown>;
    const outbounds = parsed.outbounds as Record<string, unknown>[];

    expect(bandwidth.up).toBe("50 mbps");
    expect(quic.maxIdleTimeout).toBe("30s");
    expect(quic.initStreamReceiveWindow).toBe(8388608);
    expect(outbounds[0].addr).toBe("10.0.0.1:1080");
  });

  test("невалидный YAML не роняет редакцию и всё равно чистится", () => {
    const broken = `auth:\n  http:\n    url: http://127.0.0.1:8080/x?access_token=${MACHINE_TOKEN}\n\t bad-tab: [`;
    const redacted = redactYaml(broken);
    expect(redacted).not.toContain(MACHINE_TOKEN);
  });

  test("построчный резервный проход тоже вырезает секреты", () => {
    const redacted = redactYamlFallback(SERVER_CONFIG);
    expect(redacted).not.toContain(MACHINE_TOKEN);
    expect(redacted).not.toContain(OBFS_PASSWORD);
  });
});

describe("редакция env-артефактов", () => {
  const POST_INSTALL = [
    "PACKAGE_VERSION=1.0.0",
    "HY2_AUTH_MODE=http",
    `HY2_AUTH_URL=http://127.0.0.1:8080/internal/hysteria/auth?access_token=${MACHINE_TOKEN}`,
    `HY2_OBFS_PASSWORD=${OBFS_PASSWORD}`,
    "HY2_PORT=443"
  ].join("\n");

  // Регрессия: HY2_AUTH_URL не подходит ни под один key-маркер, но несёт
  // machine token в значении.
  test("секрет внутри URL-значения вырезается, даже если имя ключа несекретное", () => {
    const redacted = redactEnv(POST_INSTALL);
    expect(redacted).not.toContain(MACHINE_TOKEN);
    expect(redacted).toContain("HY2_AUTH_URL=http://127.0.0.1:8080/internal/hysteria/auth");
  });

  test("ключи-секреты вырезаются по имени", () => {
    expect(redactEnv(POST_INSTALL)).toContain(`HY2_OBFS_PASSWORD=${REDACTED}`);
    expect(redactEnv(POST_INSTALL)).not.toContain(OBFS_PASSWORD);
  });

  test("несекретные строки не трогаются", () => {
    const redacted = redactEnv(POST_INSTALL);
    expect(redacted).toContain("PACKAGE_VERSION=1.0.0");
    expect(redacted).toContain("HY2_PORT=443");
  });

  test("runtime-конфиг теряет все секреты", () => {
    const runtime = [
      "HY2XS_CONFIG_SCHEMA_VERSION=2",
      `HY2XS_HYSTERIA_TRAFFIC_STATS_SECRET=${MACHINE_TOKEN}`,
      `HY2XS_HYSTERIA_OBFS_PASSWORD=${OBFS_PASSWORD}`,
      "HY2XS_ADMIN_CON_PASS=connection-password",
      "HY2XS_ADMIN_INITIAL_PASSWORD=initial-password"
    ].join("\n");

    const redacted = redactEnv(runtime);
    expect(redacted).not.toContain(MACHINE_TOKEN);
    expect(redacted).not.toContain(OBFS_PASSWORD);
    expect(redacted).not.toContain("connection-password");
    expect(redacted).not.toContain("initial-password");
    expect(redacted).toContain("HY2XS_CONFIG_SCHEMA_VERSION=2");
  });
});

describe("санитизация URL", () => {
  test("креденшелы в URL вырезаются", () => {
    expect(sanitizeUrlValue("https://user:hunter2@example.com/x")).not.toContain("hunter2");
  });

  test("секретные query-параметры вырезаются, остальные сохраняются", () => {
    const out = sanitizeUrlValue("https://example.com/x?access_token=abc&page=2");
    expect(out).not.toContain("abc");
    expect(out).toContain("page=2");
  });

  test("не-URL строка возвращается как есть", () => {
    expect(sanitizeUrlValue("просто строка")).toBe("просто строка");
    expect(sanitizeUrlValue("")).toBe("");
  });
});

/**
 * Регрессия diagnostics-бандла: env и YAML в нём редактировались, а
 * journal-admin.log копировался как есть. Пока админка логировала RequestURI,
 * в этом файле лежал действующий machine token, и бандл уносил его наружу.
 */
describe("редакция журналов в diagnostics-бандле", () => {
  const JOURNAL_LINE =
    'авг 27 12:00:01 host hy2xs-admin[123]: {"level":"info","reqUri":"/internal/hysteria/auth?access_token=' +
    MACHINE_TOKEN +
    '"}';

  test("machine token из journald-строки вырезается", () => {
    const out = redactLogText(JOURNAL_LINE);
    expect(out).not.toContain(MACHINE_TOKEN);
    expect(out).toContain("/internal/hysteria/auth");
  });

  test("адрес остаётся читаемым: host, port и path не теряются", () => {
    const out = redactLogText(
      `auth backend error: Post http://127.0.0.1:8080/internal/hysteria/auth?access_token=${MACHINE_TOKEN}: EOF`
    );
    expect(out).not.toContain(MACHINE_TOKEN);
    expect(out).toContain("127.0.0.1:8080");
    expect(out).toContain("/internal/hysteria/auth");
  });

  test("секрет вне URL тоже вырезается", () => {
    for (const line of [
      `starting with access_token=${MACHINE_TOKEN}`,
      `trafficStats secret=${MACHINE_TOKEN} rejected`,
      `obfs password: ${OBFS_PASSWORD}`
    ]) {
      const out = redactLogText(line);
      expect(out).not.toContain(MACHINE_TOKEN);
      expect(out).not.toContain(OBFS_PASSWORD);
      expect(out).toContain(REDACTED);
    }
  });

  test("обычные строки журнала не меняются", () => {
    const line = "server up and running, listening on 0.0.0.0:443";
    expect(redactLogText(line)).toBe(line);
    expect(redactLogText("")).toBe("");
  });

  test("хвостовая пунктуация сохраняется", () => {
    const out = redactLogText(
      `failed to call http://127.0.0.1:8080/internal/hysteria/auth?access_token=${MACHINE_TOKEN}.`
    );
    expect(out).not.toContain(MACHINE_TOKEN);
    expect(out.endsWith(".")).toBe(true);
  });

  test("повторный проход ничего не ломает", () => {
    const once = redactLogText(JOURNAL_LINE);
    expect(redactLogText(once)).toBe(once);
  });
});

describe("маркеры секретных имён", () => {
  test("покрывают типовые секретоподобные имена", () => {
    for (const key of [
      "password",
      "obfsPassword",
      "secret",
      "access_token",
      "apiKey",
      "api_key",
      "privateKey",
      "authorization",
      "cookie",
      "bearer",
      "signature",
      "passphrase"
    ]) {
      expect(isSecretKey(key)).toBe(true);
    }
  });

  test("не задевают обычные поля", () => {
    for (const key of ["listen", "type", "domains", "minPacketSize", "email", "ca", "dir"]) {
      expect(isSecretKey(key)).toBe(false);
    }
  });
});