@j3r3mcdev/oast-server 1.1.13 → 1.1.14

package/src/listeners/api/api.listener.ts

@@ -1,50 +0,0 @@
-import { createServer, IncomingMessage, Server, ServerResponse } from "http";
-import { Logger } from "../../core/logger";
-import { StorageManager } from "../../core/storage";
-import { handleApiRequest } from "./api.routes";
-import { ApiSse } from "./api.sse";
-
-export interface ApiListenerOptions {
-  port: number;
-  logger?: Logger;
-}
-
-export class ApiListener {
-  private logger: Logger;
-  private server: Server | null = null;
-  private sse: ApiSse;
-
-  constructor(
-    private storage: StorageManager,
-    private options: ApiListenerOptions,
-  ) {
-    this.logger = options.logger ?? new Logger({ context: "ApiListener" });
-    this.sse = new ApiSse(this.logger);
-  }
-
-  async start() {
-    this.server = createServer((req: IncomingMessage, res: ServerResponse) => {
-      void handleApiRequest(req, res, this.storage, this.sse, this.logger);
-    });
-
-    this.server.listen(this.options.port, () => {
-      this.logger.info(`API Listener started on port ${this.options.port}`);
-    });
-  }
-
-  async stop() {
-    this.sse.closeAll();
-
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-
-    this.logger.info("API Listener stopped");
-  }
-
-  // Méthode appelée par ton CoreRouter / CoreServer après chaque event
-  public broadcastEvent(event: any) {
-    this.sse.broadcast(event);
-  }
-}

package/src/listeners/api/api.routes.ts

@@ -1,104 +0,0 @@
-import { IncomingMessage, ServerResponse } from "http";
-import { Logger } from "../../core/logger";
-import { StorageManager } from "../../core/storage";
-import { ApiSse } from "./api.sse";
-import { ApiController } from "./api.controllers";
-import { EventNormalizer } from "../../core/event.normalizer";
-
-export async function handleApiRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  storage: StorageManager,
-  sse: ApiSse,
-  logger: Logger,
-): Promise<void> {
-  try {
-    const url = new URL(req.url ?? "", `http://${req.headers.host}`);
-    const path = url.pathname;
-    const method = req.method ?? "GET";
-
-    //
-    // ---------------------------
-    // POST /  (API EVENT)
-    // ---------------------------
-    //
-    if (method === "POST" && path === "/") {
-      let body = "";
-      req.on("data", (chunk) => (body += chunk));
-      req.on("end", async () => {
-        try {
-          const parsed = JSON.parse(body);
-
-          const normalized = EventNormalizer.normalizeApi({
-            ip: req.socket.remoteAddress ?? "",
-            body: parsed,
-            raw: parsed,
-          });
-
-          await storage.save(normalized);
-
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ success: true }));
-        } catch (err: any) {
-          logger.error("API POST error", err);
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ success: false, error: err.message }));
-        }
-      });
-      return;
-    }
-
-    //
-    // ---------------------------
-    // SSE STREAM
-    // ---------------------------
-    if (method === "GET" && path === "/events/stream") {
-      await sse.handle(res);
-      return;
-    }
-
-    //
-    // ---------------------------
-    // ROUTES REST
-    // ---------------------------
-    if (method === "GET" && path === "/events") {
-      await ApiController.listEvents(url, res, storage);
-      return;
-    }
-
-    if (method === "GET" && path.startsWith("/events/")) {
-      const id = path.split("/")[2];
-      await ApiController.getEvent(id, res, storage);
-      return;
-    }
-
-    if (method === "DELETE" && path === "/events") {
-      await ApiController.deleteAll(res, storage);
-      return;
-    }
-
-    if (method === "DELETE" && path.startsWith("/events/")) {
-      const id = path.split("/")[2];
-      await ApiController.deleteOne(id, res, storage);
-      return;
-    }
-
-    if (method === "GET" && path === "/stats") {
-      await ApiController.stats(res, storage);
-      return;
-    }
-
-    // 404
-    res.writeHead(404, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ success: false, error: "Not found" }));
-  } catch (err: any) {
-    logger.error("API error", { error: err?.message ?? String(err) });
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(
-      JSON.stringify({
-        success: false,
-        error: err?.message ?? "Internal server error",
-      }),
-    );
-  }
-}

package/src/listeners/api/api.sse.ts

@@ -1,38 +0,0 @@
-import { ServerResponse } from "http";
-import { Logger } from "../../core/logger";
-
-export class ApiSse {
-  private clients: Set<ServerResponse> = new Set();
-
-  constructor(private logger: Logger) {}
-
-  handle(res: ServerResponse): void {
-    res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    });
-
-    this.clients.add(res);
-    res.write(`event: connected\ndata: "ok"\n\n`);
-
-    res.on("close", () => {
-      this.clients.delete(res);
-      this.logger.debug?.("SSE client disconnected");
-    });
-  }
-
-  broadcast(event: any): void {
-    const payload = `event: event\ndata: ${JSON.stringify(event)}\n\n`;
-    for (const client of this.clients) {
-      client.write(payload);
-    }
-  }
-
-  closeAll(): void {
-    for (const client of this.clients) {
-      client.end();
-    }
-    this.clients.clear();
-  }
-}

package/src/listeners/dns/__tests__/dns.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from "@jest/globals";
-import { DnsListener } from "../dns.listener";
-import { EventNormalizer } from "../../../core/event.normalizer";
-import { CoreRouter } from "../../../core/router";
-
-// Mock EventNormalizer
-jest.mock("../../../core/event.normalizer", () => ({
-  EventNormalizer: {
-    normalizeDns: jest.fn(),
-  },
-}));
-
-describe("DnsListener", () => {
-  let router: CoreRouter;
-  let server: any;
-  let listener: DnsListener;
-
-  beforeEach(() => {
-    router = {
-      dispatch: jest
-        .fn<(event: any) => Promise<void>>()
-        .mockResolvedValue(undefined),
-    } as any;
-
-    server = {
-      on: jest.fn(),
-      close: jest.fn(),
-    };
-
-    listener = new DnsListener(router, { server });
-  });
-
-  it("traite un paquet DNS valide et renvoie eventId", async () => {
-    const send = jest.fn();
-
-    (EventNormalizer.normalizeDns as jest.Mock).mockReturnValue({
-      id: "dns-123",
-      source: "dns",
-    });
-
-    await listener.start();
-
-    // simulate server.on("request", callback)
-    const callback = server.on.mock.calls[0][1];
-
-    const packet = {
-      client: { address: "1.2.3.4" },
-      questions: [{ name: "example.com", type: "A" }],
-    };
-
-    await callback(packet, send);
-
-    expect(EventNormalizer.normalizeDns).toHaveBeenCalled();
-    expect(router.dispatch).toHaveBeenCalled();
-    expect(send).toHaveBeenCalledWith({
-      success: true,
-      eventId: "dns-123",
-    });
-  });
-
-  it("renvoie une erreur si normalizeDns échoue", async () => {
-    const send = jest.fn();
-
-    (EventNormalizer.normalizeDns as jest.Mock).mockImplementation(() => {
-      throw new Error("bad dns");
-    });
-
-    await listener.start();
-
-    const callback = server.on.mock.calls[0][1];
-
-    const packet = {
-      client: { address: "1.2.3.4" },
-      questions: [{ name: "example.com", type: "A" }],
-    };
-
-    await callback(packet, send);
-
-    expect(send).toHaveBeenCalledWith({
-      success: false,
-      error: "bad dns",
-    });
-  });
-
-  it("renvoie une erreur si router.dispatch échoue", async () => {
-    const send = jest.fn();
-
-    (EventNormalizer.normalizeDns as jest.Mock).mockReturnValue({
-      id: "dns-999",
-      source: "dns",
-    });
-
-    (
-      router.dispatch as jest.MockedFunction<(event: any) => Promise<void>>
-    ).mockRejectedValueOnce(new Error("dispatch failed"));
-
-    await listener.start();
-
-    const callback = server.on.mock.calls[0][1];
-
-    const packet = {
-      client: { address: "1.2.3.4" },
-      questions: [{ name: "example.com", type: "A" }],
-    };
-
-    await callback(packet, send);
-
-    expect(send).toHaveBeenCalledWith({
-      success: false,
-      error: "dispatch failed",
-    });
-  });
-
-  it("stop() appelle server.close si disponible", async () => {
-    await listener.stop();
-    expect(server.close).toHaveBeenCalled();
-  });
-});

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

@@ -1,14 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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,
-    };
-  }
-}

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

@@ -1,110 +0,0 @@
-import http, { IncomingMessage, ServerResponse } from "http";
-import { Logger } from "../../core/logger";
-import { CoreRouter } from "../../core/router";
-import { EventNormalizer } from "../../core/event.normalizer";
-
-export interface HttpListenerOptions {
-  port: number;
-  logger?: Logger;
-}
-
-export class HttpListener {
-  private server?: http.Server;
-  private logger: Logger;
-
-  constructor(
-    private router: CoreRouter,
-    private options: HttpListenerOptions,
-  ) {
-    this.logger = options.logger ?? new Logger({ context: "HttpListener" });
-  }
-
-  async start(): Promise<void> {
-    return new Promise((resolve) => {
-      this.server = http.createServer(async (req, res) => {
-        await this.handleRequest(req, res);
-      });
-
-      this.server.listen(this.options.port, () => {
-        this.logger.info(`HTTP Listener started on port ${this.options.port}`);
-        resolve();
-      });
-    });
-  }
-
-  async stop(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (!this.server) return resolve();
-
-      this.server.close((err) => {
-        if (err) return reject(err);
-        this.logger.info("HTTP Listener stopped");
-        resolve();
-      });
-    });
-  }
-
-  private async handleRequest(req: IncomingMessage, res: ServerResponse) {
-    try {
-      const body = await this.readBody(req);
-
-      const ipHeader = req.headers["x-forwarded-for"];
-      const ip =
-        typeof ipHeader === "string"
-          ? ipHeader
-          : Array.isArray(ipHeader)
-            ? ipHeader[0]
-            : (req.socket.remoteAddress ?? "");
-
-      const rawEvent = {
-        ip,
-        method: req.method ?? "",
-        path: req.url ?? "",
-        headers: req.headers,
-        query: {}, // parsing optionnel
-        body,
-        raw: req,
-      };
-
-      const normalized = EventNormalizer.normalizeHttp(rawEvent);
-
-      await this.router.dispatch(normalized);
-
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(
-        JSON.stringify({
-          success: true,
-          eventId: normalized.id,
-        }),
-      );
-    } catch (err: any) {
-      this.logger.error("HTTP Listener error", err);
-
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(
-        JSON.stringify({
-          success: false,
-          error: err.message,
-        }),
-      );
-    }
-  }
-
-  private readBody(req: IncomingMessage): Promise<any> {
-    return new Promise((resolve) => {
-      let data = "";
-
-      req.on("data", (chunk) => {
-        data += chunk;
-      });
-
-      req.on("end", () => {
-        try {
-          resolve(JSON.parse(data || "{}"));
-        } catch {
-          resolve(data);
-        }
-      });
-    });
-  }
-}