@j3r3mcdev/oast-server 1.1.6 → 1.1.8

package/src/listeners/dns/dns.extractor.ts

@@ -1,14 +1,14 @@
-export class DnsExtractor {
-  static extract(packet: any) {
-    if (!packet?.questions?.[0]) {
-      throw new Error("Invalid DNS packet");
-    }
-
-    return {
-      ip: packet.client?.address ?? "",
-      query: packet.questions[0].name ?? "",
-      type: packet.questions[0].type ?? "",
-      raw: packet,
-    };
-  }
-}
+export class DnsExtractor {
+  static extract(packet: any) {
+    if (!packet?.questions?.[0]) {
+      throw new Error("Invalid DNS packet");
+    }
+
+    return {
+      ip: packet.client?.address ?? "",
+      query: packet.questions[0].name ?? "",
+      type: packet.questions[0].type ?? "",
+      raw: packet,
+    };
+  }
+}

package/src/listeners/dns/dns.listener.ts

@@ -1,61 +1,61 @@
-import { Logger } from "../../core/logger";
-import { CoreRouter } from "../../core/router";
-import { EventNormalizer } from "../../core/event.normalizer";
-
-export interface DnsListenerOptions {
-  server: any; // instance dns2 ou autre
-  logger?: Logger;
-}
-
-export class DnsListener {
-  private logger: Logger;
-
-  constructor(
-    private router: CoreRouter,
-    private options: DnsListenerOptions,
-  ) {
-    this.logger = options.logger ?? new Logger({ context: "DnsListener" });
-  }
-
-  async start(): Promise<void> {
-    this.options.server.on("request", async (req: any, send: any) => {
-      await this.handleQuery(req, send);
-    });
-
-    this.logger.info("DNS Listener started");
-  }
-
-  async stop(): Promise<void> {
-    if (this.options.server.close) {
-      this.options.server.close();
-    }
-    this.logger.info("DNS Listener stopped");
-  }
-
-  private async handleQuery(packet: any, send: any) {
-    try {
-      const rawEvent = {
-        ip: packet?.client?.address ?? "",
-        query: packet?.questions?.[0]?.name ?? "",
-        recordType: packet?.questions?.[0]?.type ?? "",
-        raw: packet,
-      };
-
-      const normalized = EventNormalizer.normalizeDns(rawEvent);
-
-      await this.router.dispatch(normalized);
-
-      send({
-        success: true,
-        eventId: normalized.id,
-      });
-    } catch (err: any) {
-      this.logger.error("DNS Listener error", { error: err.message });
-
-      send({
-        success: false,
-        error: err.message,
-      });
-    }
-  }
-}
+import { Logger } from "../../core/logger";
+import { CoreRouter } from "../../core/router";
+import { EventNormalizer } from "../../core/event.normalizer";
+
+export interface DnsListenerOptions {
+  server: any; // instance dns2 ou autre
+  logger?: Logger;
+}
+
+export class DnsListener {
+  private logger: Logger;
+
+  constructor(
+    private router: CoreRouter,
+    private options: DnsListenerOptions,
+  ) {
+    this.logger = options.logger ?? new Logger({ context: "DnsListener" });
+  }
+
+  async start(): Promise<void> {
+    this.options.server.on("request", async (req: any, send: any) => {
+      await this.handleQuery(req, send);
+    });
+
+    this.logger.info("DNS Listener started");
+  }
+
+  async stop(): Promise<void> {
+    if (this.options.server.close) {
+      this.options.server.close();
+    }
+    this.logger.info("DNS Listener stopped");
+  }
+
+  private async handleQuery(packet: any, send: any) {
+    try {
+      const rawEvent = {
+        ip: packet?.client?.address ?? "",
+        query: packet?.questions?.[0]?.name ?? "",
+        recordType: packet?.questions?.[0]?.type ?? "",
+        raw: packet,
+      };
+
+      const normalized = EventNormalizer.normalizeDns(rawEvent);
+
+      await this.router.dispatch(normalized);
+
+      send({
+        success: true,
+        eventId: normalized.id,
+      });
+    } catch (err: any) {
+      this.logger.error("DNS Listener error", { error: err.message });
+
+      send({
+        success: false,
+        error: err.message,
+      });
+    }
+  }
+}

package/src/listeners/http/__tests__/http.extractor.test.ts

@@ -1,59 +1,59 @@
-import { describe, it, expect } from "@jest/globals";
-import { HttpExtractor } from "../http.extractor";
-
-describe("HttpExtractor", () => {
-  it("extrait correctement un RawEvent complet", () => {
-    const req: any = {
-      ip: "1.1.1.1",
-      method: "POST",
-      path: "/login",
-      url: "/login",
-      headers: {
-        "x-forwarded-for": "2.2.2.2",
-        host: "localhost",
-      },
-      query: { a: 1 },
-      body: { user: "admin" },
-    };
-
-    const extracted = HttpExtractor.extract(req);
-
-    expect(extracted).toEqual({
-      ip: "1.1.1.1", // priorité à req.ip
-      method: "POST",
-      path: "/login",
-      headers: req.headers,
-      query: { a: 1 },
-      body: { user: "admin" },
-      raw: req,
-    });
-  });
-
-  it("utilise x-forwarded-for si req.ip est absent", () => {
-    const req: any = {
-      method: "GET",
-      url: "/",
-      headers: { "x-forwarded-for": "9.9.9.9" },
-    };
-
-    const extracted = HttpExtractor.extract(req);
-
-    expect(extracted.ip).toBe("9.9.9.9");
-  });
-
-  it("retourne une structure complète même si des champs manquent", () => {
-    const req: any = {};
-
-    const extracted = HttpExtractor.extract(req);
-
-    expect(extracted).toEqual({
-      ip: "",
-      method: undefined,
-      path: undefined,
-      headers: {},
-      query: {},
-      body: null,
-      raw: req,
-    });
-  });
-});
+import { describe, it, expect } from "@jest/globals";
+import { HttpExtractor } from "../http.extractor";
+
+describe("HttpExtractor", () => {
+  it("extrait correctement un RawEvent complet", () => {
+    const req: any = {
+      ip: "1.1.1.1",
+      method: "POST",
+      path: "/login",
+      url: "/login",
+      headers: {
+        "x-forwarded-for": "2.2.2.2",
+        host: "localhost",
+      },
+      query: { a: 1 },
+      body: { user: "admin" },
+    };
+
+    const extracted = HttpExtractor.extract(req);
+
+    expect(extracted).toEqual({
+      ip: "1.1.1.1", // priorité à req.ip
+      method: "POST",
+      path: "/login",
+      headers: req.headers,
+      query: { a: 1 },
+      body: { user: "admin" },
+      raw: req,
+    });
+  });
+
+  it("utilise x-forwarded-for si req.ip est absent", () => {
+    const req: any = {
+      method: "GET",
+      url: "/",
+      headers: { "x-forwarded-for": "9.9.9.9" },
+    };
+
+    const extracted = HttpExtractor.extract(req);
+
+    expect(extracted.ip).toBe("9.9.9.9");
+  });
+
+  it("retourne une structure complète même si des champs manquent", () => {
+    const req: any = {};
+
+    const extracted = HttpExtractor.extract(req);
+
+    expect(extracted).toEqual({
+      ip: "",
+      method: undefined,
+      path: undefined,
+      headers: {},
+      query: {},
+      body: null,
+      raw: req,
+    });
+  });
+});

package/src/listeners/http/__tests__/http.listener.test.ts

@@ -1,133 +1,133 @@
-import {
-  describe,
-  it,
-  expect,
-  jest,
-  beforeEach,
-  afterEach,
-} from "@jest/globals";
-import http from "http";
-import { HttpListener } from "../http.listener";
-import { EventNormalizer } from "../../../core/event.normalizer";
-
-// Mock EventNormalizer
-jest.mock("../../../core/event.normalizer", () => ({
-  EventNormalizer: {
-    normalizeHttp: jest.fn(),
-  },
-}));
-
-// Helper pour requêtes HTTP
-async function makeRequest(port: number, path: string): Promise<string> {
-  return new Promise((resolve) => {
-    const req = http.request(
-      {
-        hostname: "localhost",
-        port,
-        path,
-        method: "GET",
-      },
-      (res) => {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => resolve(data));
-      },
-    );
-
-    req.end();
-  });
-}
-
-describe("HttpListener (PRO)", () => {
-  let listener: HttpListener;
-  let router: { dispatch: jest.Mock };
-  let port: number;
-
-  beforeEach(() => {
-    router = {
-      dispatch: jest.fn(),
-    };
-
-    port = 10000 + Math.floor(Math.random() * 5000);
-  });
-
-  afterEach(async () => {
-    if (listener) {
-      await listener.stop();
-    }
-  });
-
-  it("normalise, dispatch et renvoie un eventId", async () => {
-    listener = new HttpListener(router as any, { port });
-    await listener.start();
-
-    // NormalizedHttpEvent VALIDE
-    (EventNormalizer.normalizeHttp as jest.Mock).mockReturnValue({
-      id: "evt-123",
-      type: "http",
-      timestamp: Date.now(),
-      sourceIp: "127.0.0.1",
-      request: {
-        method: "GET",
-        path: "/test",
-        headers: {},
-        query: {},
-        body: "",
-      },
-    });
-
-    const response = await makeRequest(port, "/test");
-    const json = JSON.parse(response);
-
-    expect(EventNormalizer.normalizeHttp).toHaveBeenCalled();
-    expect(router.dispatch).toHaveBeenCalled();
-    expect(json).toEqual({
-      success: true,
-      eventId: "evt-123",
-    });
-  });
-
-  it("renvoie 500 si normalizeHttp lance une erreur", async () => {
-    listener = new HttpListener(router as any, { port });
-    await listener.start();
-
-    (EventNormalizer.normalizeHttp as jest.Mock).mockImplementation(() => {
-      throw new Error("bad request");
-    });
-
-    const response = await makeRequest(port, "/err");
-    const json = JSON.parse(response);
-
-    expect(json.success).toBe(false);
-    expect(json.error).toBe("bad request");
-  });
-
-  it("renvoie 500 si router.dispatch rejette une erreur", async () => {
-    listener = new HttpListener(router as any, { port });
-    await listener.start();
-
-    (EventNormalizer.normalizeHttp as jest.Mock).mockReturnValue({
-      id: "evt-999",
-      type: "http",
-      timestamp: Date.now(),
-      sourceIp: "127.0.0.1",
-      request: {
-        method: "GET",
-        path: "/dispatch-error",
-        headers: {},
-        query: {},
-        body: "",
-      },
-    });
-
-    (router.dispatch as any).mockRejectedValueOnce(
-      new Error("dispatch failed"),
-    );
-
-    const response = await makeRequest(port, "/dispatch-error");
-    const json = JSON.parse(response);
-
-    expect(json.success).toBe(false);
-    expect(json.error).toBe("dispatch failed");
-  });
-});
+import {
+  describe,
+  it,
+  expect,
+  jest,
+  beforeEach,
+  afterEach,
+} from "@jest/globals";
+import http from "http";
+import { HttpListener } from "../http.listener";
+import { EventNormalizer } from "../../../core/event.normalizer";
+
+// Mock EventNormalizer
+jest.mock("../../../core/event.normalizer", () => ({
+  EventNormalizer: {
+    normalizeHttp: jest.fn(),
+  },
+}));
+
+// Helper pour requêtes HTTP
+async function makeRequest(port: number, path: string): Promise<string> {
+  return new Promise((resolve) => {
+    const req = http.request(
+      {
+        hostname: "localhost",
+        port,
+        path,
+        method: "GET",
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => resolve(data));
+      },
+    );
+
+    req.end();
+  });
+}
+
+describe("HttpListener (PRO)", () => {
+  let listener: HttpListener;
+  let router: { dispatch: jest.Mock };
+  let port: number;
+
+  beforeEach(() => {
+    router = {
+      dispatch: jest.fn(),
+    };
+
+    port = 10000 + Math.floor(Math.random() * 5000);
+  });
+
+  afterEach(async () => {
+    if (listener) {
+      await listener.stop();
+    }
+  });
+
+  it("normalise, dispatch et renvoie un eventId", async () => {
+    listener = new HttpListener(router as any, { port });
+    await listener.start();
+
+    // NormalizedHttpEvent VALIDE
+    (EventNormalizer.normalizeHttp as jest.Mock).mockReturnValue({
+      id: "evt-123",
+      type: "http",
+      timestamp: Date.now(),
+      sourceIp: "127.0.0.1",
+      request: {
+        method: "GET",
+        path: "/test",
+        headers: {},
+        query: {},
+        body: "",
+      },
+    });
+
+    const response = await makeRequest(port, "/test");
+    const json = JSON.parse(response);
+
+    expect(EventNormalizer.normalizeHttp).toHaveBeenCalled();
+    expect(router.dispatch).toHaveBeenCalled();
+    expect(json).toEqual({
+      success: true,
+      eventId: "evt-123",
+    });
+  });
+
+  it("renvoie 500 si normalizeHttp lance une erreur", async () => {
+    listener = new HttpListener(router as any, { port });
+    await listener.start();
+
+    (EventNormalizer.normalizeHttp as jest.Mock).mockImplementation(() => {
+      throw new Error("bad request");
+    });
+
+    const response = await makeRequest(port, "/err");
+    const json = JSON.parse(response);
+
+    expect(json.success).toBe(false);
+    expect(json.error).toBe("bad request");
+  });
+
+  it("renvoie 500 si router.dispatch rejette une erreur", async () => {
+    listener = new HttpListener(router as any, { port });
+    await listener.start();
+
+    (EventNormalizer.normalizeHttp as jest.Mock).mockReturnValue({
+      id: "evt-999",
+      type: "http",
+      timestamp: Date.now(),
+      sourceIp: "127.0.0.1",
+      request: {
+        method: "GET",
+        path: "/dispatch-error",
+        headers: {},
+        query: {},
+        body: "",
+      },
+    });
+
+    (router.dispatch as any).mockRejectedValueOnce(
+      new Error("dispatch failed"),
+    );
+
+    const response = await makeRequest(port, "/dispatch-error");
+    const json = JSON.parse(response);
+
+    expect(json.success).toBe(false);
+    expect(json.error).toBe("dispatch failed");
+  });
+});

package/src/listeners/http/http.extractor.ts

@@ -1,15 +1,15 @@
-export class HttpExtractor {
-  static extract(req: any) {
-    const headers = req.headers ?? {};
-
-    return {
-      ip: req.ip ?? headers["x-forwarded-for"] ?? "",
-      method: req.method, // ← PAS de fallback ""
-      path: req.path ?? req.url, // ← PAS de fallback ""
-      headers,
-      query: req.query ?? {},
-      body: req.body ?? null,
-      raw: req,
-    };
-  }
-}
+export class HttpExtractor {
+  static extract(req: any) {
+    const headers = req.headers ?? {};
+
+    return {
+      ip: req.ip ?? headers["x-forwarded-for"] ?? "",
+      method: req.method, // ← PAS de fallback ""
+      path: req.path ?? req.url, // ← PAS de fallback ""
+      headers,
+      query: req.query ?? {},
+      body: req.body ?? null,
+      raw: req,
+    };
+  }
+}