@j3r3mcdev/oast-server 1.1.13 → 1.1.14

package/src/bootstrap.ts

@@ -1,89 +0,0 @@
-import { Logger } from "./core/logger";
-import { StorageManager } from "./core/storage";
-import { CoreRouter } from "./core/router";
-import { CoreServer } from "./core/server";
-
-// Listeners
-import { ApiListener } from "./listeners/api/api.listener";
-import { HttpListener } from "./listeners/http/http.listener";
-import { DnsListener } from "./listeners/dns/dns.listener";
-import { SmtpListener } from "./listeners/smtp/smtp.listener";
-import { TcpListener } from "./listeners/tcp/tcp.listener";
-
-async function main() {
-  const logger = new Logger({ context: "Bootstrap" });
-
-  // Core components
-  const storage = new StorageManager({
-    logger: logger.withContext("Storage"),
-  });
-
-  const router = new CoreRouter(storage, {
-    logger: logger.withContext("CoreRouter"),
-  });
-
-  // ---------------------------
-  // LISTENERS
-  // ---------------------------
-
-  // API → (router, storage, options)
-  const apiListener = new ApiListener(storage, {
-    port: 3100,
-    logger: logger.withContext("ApiListener"),
-  });
-
-  // HTTP → (router, options)
-  const httpListener = new HttpListener(router, {
-    port: 8080,
-    logger: logger.withContext("HttpListener"),
-  });
-
-  // DNS → (router, options)
-  const dnsListener = new DnsListener(router, {
-    server: {} as any,
-    logger: logger.withContext("DnsListener"),
-  });
-
-  const smtpListener = new SmtpListener(router, {
-    server: {} as any,
-    logger: logger.withContext("SmtpListener"),
-  });
-
-  // TCP → (router, storage, options)
-  const tcpListener = new TcpListener(router, storage, {
-    port: 9000,
-    logger: logger.withContext("TcpListener"),
-  });
-
-  // ---------------------------
-  // CORE SERVER
-  // ---------------------------
-  const server = new CoreServer({
-    logger: logger.withContext("CoreServer"),
-    storage,
-    listeners: [
-      apiListener,
-      httpListener,
-      dnsListener,
-      smtpListener,
-      tcpListener,
-    ],
-  });
-
-  await server.start();
-
-  // Graceful shutdown
-  const shutdown = async () => {
-    logger.warn("Received shutdown signal, stopping server...");
-    await server.stop();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}
-
-main().catch((err) => {
-  console.error("Fatal error in bootstrap:", err);
-  process.exit(1);
-});

package/src/core/__tests__/core-router.test.ts

@@ -1,30 +0,0 @@
-import { CoreRouter, RouterHook } from "../router";
-import { MemoryStorage } from "../../storage-adapters/adapters/memory.storage";
-import { AnyNormalizedEvent } from "../../types/event.types";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("CoreRouter", () => {
-  const event: AnyNormalizedEvent = {
-    id: "abc",
-    type: "http",
-    timestamp: 111,
-    sourceIp: "1.1.1.1",
-    request: {
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-    },
-  };
-
-  it("appelle les hooks", async () => {
-    const hook: RouterHook = jest.fn((e: AnyNormalizedEvent) => {}); // ← FIX
-
-    const router = new CoreRouter(new MemoryStorage(), { hooks: [hook] });
-
-    await router.dispatch(event);
-
-    expect(hook).toHaveBeenCalledWith(event);
-  });
-});

package/src/core/__tests__/core-server.test.ts

@@ -1,44 +0,0 @@
-import { CoreServer } from "../../core/server";
-import { StorageManager } from "../../core/storage";
-import { Logger } from "../../core/logger";
-import { describe, it, expect } from "@jest/globals";
-
-class FakeListener {
-  started = false;
-  stopped = false;
-
-  async start() {
-    this.started = true;
-  }
-
-  async stop() {
-    this.stopped = true;
-  }
-}
-
-describe("CoreServer", () => {
-  it("démarre et arrête les listeners", async () => {
-    const listener = new FakeListener();
-
-    const server = new CoreServer({
-      storage: new StorageManager(),
-      logger: new Logger({ enabled: false }),
-      listeners: [listener],
-    });
-
-    await server.start();
-    expect(listener.started).toBe(true);
-
-    await server.stop();
-    expect(listener.stopped).toBe(true);
-  });
-
-  it("expose le router", () => {
-    const server = new CoreServer({
-      storage: new StorageManager(),
-    });
-
-    const router = server.getRouter();
-    expect(router).toBeDefined();
-  });
-});

package/src/core/__tests__/event.normalizer.test.ts

@@ -1,56 +0,0 @@
-import { EventNormalizer } from "../event.normalizer";
-import { describe, it, expect, jest } from "@jest/globals";
-import { IdGenerator } from "../id-generator";
-
-describe("EventNormalizer.normalizeHttp", () => {
-  it("normalise correctement une requête HTTP", () => {
-    // Mock du timestamp
-    const fakeNow = 1234567890;
-    jest.spyOn(Date, "now").mockReturnValue(fakeNow);
-
-    // Mock de l'ID
-    jest.spyOn(IdGenerator, "generate").mockReturnValue("uuid-test");
-
-    const req = {
-      ip: "9.9.9.9",
-      method: "POST",
-      path: "/test",
-      headers: { "x-forwarded-for": "9.9.9.9" },
-      query: { a: "1" },
-      body: { hello: "world" },
-      raw: {}, // obligatoire
-    };
-
-    const event = EventNormalizer.normalizeHttp(req);
-
-    expect(event).toEqual({
-      id: "uuid-test",
-      type: "http",
-      timestamp: fakeNow,
-      sourceIp: "9.9.9.9",
-      request: {
-        method: "POST",
-        path: "/test",
-        headers: { "x-forwarded-for": "9.9.9.9" },
-        query: { a: "1" },
-        body: { hello: "world" },
-      },
-    });
-  });
-
-  it("retourne 'unknown' si aucune IP n'est trouvée", () => {
-    const req = {
-      ip: "",
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-      raw: {},
-    };
-
-    const event = EventNormalizer.normalizeHttp(req);
-
-    expect(event.sourceIp).toBe("unknown");
-  });
-});

package/src/core/__tests__/event.router.test.ts

@@ -1,89 +0,0 @@
-import {
-  AnyNormalizedEvent,
-  NormalizedHttpEvent,
-} from "../../types/event.types";
-import {
-  StorageListParams,
-  Storage,
-} from "../../storage-adapters/storage.interface";
-import { EventRouter } from "../event.router";
-import { EventNormalizer } from "../event.normalizer";
-import { describe, it, expect, jest } from "@jest/globals";
-
-class MockStorage implements Storage {
-  save = jest.fn<(event: AnyNormalizedEvent) => Promise<void>>();
-  getEvent = jest.fn<(id: string) => Promise<AnyNormalizedEvent | null>>();
-  listEvents =
-    jest.fn<(params: StorageListParams) => Promise<AnyNormalizedEvent[]>>();
-  deleteEvent = jest.fn<(id: string) => Promise<boolean>>();
-  clearEvents = jest.fn<() => Promise<void>>();
-  getStats =
-    jest.fn<() => Promise<{ total: number; byType: Record<string, number> }>>();
-  getAll = jest.fn<() => Promise<AnyNormalizedEvent[]>>();
-}
-
-describe("EventRouter", () => {
-  it("enregistre un événement HTTP normalisé", async () => {
-    const mockStorage = new MockStorage();
-
-    const fakeEvent: NormalizedHttpEvent = {
-      id: "123",
-      type: "http",
-      timestamp: 111,
-      sourceIp: "1.1.1.1",
-      request: {
-        method: "GET",
-        path: "/",
-        headers: {},
-        query: {},
-        body: {},
-      },
-    };
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
-
-    const router = new EventRouter(mockStorage);
-
-    const req = {
-      ip: "1.1.1.1",
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-      raw: {},
-    };
-
-    const result = await router.handleHttp(req);
-
-    expect(EventNormalizer.normalizeHttp).toHaveBeenCalledWith(req);
-    expect(mockStorage.save).toHaveBeenCalledWith(fakeEvent);
-    expect(result).toEqual(fakeEvent);
-  });
-
-  it("propagate une erreur si normalizeHttp throw", async () => {
-    const mockStorage = new MockStorage();
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockImplementation(() => {
-      throw new Error("Boom");
-    });
-
-    const router = new EventRouter(mockStorage);
-
-    await expect(router.handleHttp({} as any)).rejects.toThrow("Boom");
-    expect(mockStorage.save).not.toHaveBeenCalled();
-  });
-
-  it("propagate une erreur si storage.save throw", async () => {
-    const mockStorage = new MockStorage();
-
-    const fakeEvent = { id: "x", type: "http" } as any;
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
-    mockStorage.save.mockRejectedValue(new Error("DB error"));
-
-    const router = new EventRouter(mockStorage);
-
-    await expect(router.handleHttp({} as any)).rejects.toThrow("DB error");
-  });
-});

package/src/core/__tests__/logger.test.ts

@@ -1,32 +0,0 @@
-import { Logger, LogEntry } from "../../core/logger";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("Logger", () => {
-  it("appelle les hooks", () => {
-    const hook = jest.fn<(entry: LogEntry) => void>();
-    const logger = new Logger({ hooks: [hook], enabled: true });
-
-    logger.info("hello");
-
-    expect(hook).toHaveBeenCalled();
-    expect(hook.mock.calls[0][0].message).toBe("hello");
-  });
-
-  it("respecte le niveau de logs", () => {
-    const hook = jest.fn<(entry: LogEntry) => void>();
-    const logger = new Logger({ level: "warn", hooks: [hook] });
-
-    logger.info("should not log");
-    logger.error("should log");
-
-    expect(hook).toHaveBeenCalledTimes(1);
-    expect(hook.mock.calls[0][0].level).toBe("error");
-  });
-
-  it("crée un logger enfant avec contexte", () => {
-    const logger = new Logger({ context: "root" });
-    const child = logger.withContext("child");
-
-    expect(child).not.toBe(logger);
-  });
-});

package/src/core/__tests__/storage-manager.test.ts

@@ -1,74 +0,0 @@
-import { describe, test, expect } from "@jest/globals";
-import { StorageManager } from "../storage"; // si ton fichier s'appelle storage-manager.ts
-import { NormalizedHttpEvent } from "../../types/event.types";
-
-function makeHttpEvent(id: string): NormalizedHttpEvent {
-  return {
-    id,
-    type: "http",
-    timestamp: Date.now(),
-    sourceIp: "127.0.0.1",
-    request: {
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: "",
-    },
-  };
-}
-
-describe("StorageManager", () => {
-  test("save + getEvent", async () => {
-    const storage = new StorageManager();
-
-    const event = makeHttpEvent("1");
-    await storage.save(event);
-
-    const found = await storage.getEvent("1");
-    expect(found).not.toBeNull();
-    expect(found?.id).toBe("1");
-  });
-
-  test("listEvents returns events", async () => {
-    const storage = new StorageManager();
-
-    await storage.save(makeHttpEvent("1"));
-
-    const list = await storage.listEvents({});
-    expect(list.length).toBe(1);
-  });
-
-  test("deleteEvent removes event", async () => {
-    const storage = new StorageManager();
-
-    await storage.save(makeHttpEvent("1"));
-
-    let list = await storage.listEvents({});
-    expect(list.length).toBe(1);
-
-    await storage.deleteEvent("1");
-
-    list = await storage.listEvents({});
-    expect(list.length).toBe(0);
-  });
-
-  test("clearEvents empties storage", async () => {
-    const storage = new StorageManager();
-
-    await storage.save(makeHttpEvent("1"));
-    await storage.clearEvents();
-
-    const list = await storage.listEvents({});
-    expect(list.length).toBe(0);
-  });
-
-  test("getStats returns correct structure", async () => {
-    const storage = new StorageManager();
-
-    const stats = await storage.getStats();
-
-    expect(stats.total).toBe(0);
-    expect(stats.byType).toEqual({});
-  });
-});

package/src/core/event.normalizer.ts

@@ -1,167 +0,0 @@
-import {
-  RawEvent,
-  RawDnsEvent,
-  RawSmtpEvent,
-  RawTcpEvent,
-  RawSsrfEvent,
-  RawWebhookEvent,
-  RawWebSocketEvent,
-  RawApiEvent,
-  NormalizedHttpEvent,
-  NormalizedDnsEvent,
-  NormalizedSmtpEvent,
-  NormalizedTcpEvent,
-  NormalizedSsrfEvent,
-  NormalizedWebhookEvent,
-  NormalizedWebSocketEvent,
-  NormalizedApiEvent,
-} from "../types/event.types";
-
-import { IdGenerator } from "./id-generator";
-
-export class EventNormalizer {
-  //
-  // -------------------------
-  // DNS
-  // -------------------------
-  //
-  static normalizeDns(event: RawDnsEvent): NormalizedDnsEvent {
-    return {
-      id: IdGenerator.generate(),
-      type: "dns",
-      timestamp: Date.now(),
-      ip: event.ip ?? "",
-      query: event.query ?? "",
-      recordType: event.recordType ?? "",
-      raw: event.raw,
-    };
-  }
-
-  //
-  // -------------------------
-  // HTTP
-  // -------------------------
-  //
-  static normalizeHttp(event: RawEvent): NormalizedHttpEvent {
-    const sourceIp = event.ip && event.ip.trim() !== "" ? event.ip : "unknown";
-
-    return {
-      id: IdGenerator.generate(),
-      type: "http",
-      timestamp: Date.now(),
-      sourceIp,
-      request: {
-        method: event.method,
-        path: event.path,
-        headers: event.headers,
-        query: event.query,
-        body: event.body,
-      },
-    };
-  }
-
-  //
-  // -------------------------
-  // SMTP
-  // -------------------------
-  //
-  static normalizeSmtp(event: RawSmtpEvent): NormalizedSmtpEvent {
-    return {
-      id: IdGenerator.generate(),
-      type: "smtp",
-      timestamp: Date.now(),
-      ip: event.ip ?? "",
-      from: event.from ?? "",
-      to: event.to ?? [],
-      subject: event.subject ?? "",
-      body: event.body ?? "",
-      raw: event.raw,
-    };
-  }
-
-  //
-  // -------------------------
-  // TCP
-  // -------------------------
-  //
-  static normalizeTcp(event: RawTcpEvent): NormalizedTcpEvent {
-    return {
-      id: IdGenerator.generate(),
-      type: "tcp",
-      timestamp: Date.now(),
-      ip: event.ip ?? "",
-      port: event.port ?? 0,
-      data: event.data ?? "",
-      raw: event.raw,
-    };
-  }
-
-  //
-  // -------------------------
-  // SSRF
-  // -------------------------
-  //
-  static normalizeSsrf(raw: RawSsrfEvent): NormalizedSsrfEvent {
-    return {
-      id: IdGenerator.generate(),
-      type: "ssrf",
-      timestamp: Date.now(),
-      sourceIp: raw.ip,
-      request: {
-        method: raw.method,
-        path: raw.path,
-        headers: raw.headers,
-        query: raw.query,
-      },
-    };
-  }
-
-  //
-  // -------------------------
-  // WEBHOOK
-  // -------------------------
-  //
-  static normalizeWebhook(raw: RawWebhookEvent): NormalizedWebhookEvent {
-    return {
-      id: IdGenerator.generate(),
-      type: "webhook",
-      timestamp: Date.now(),
-      sourceIp: raw.ip,
-      headers: raw.headers,
-      body: raw.body,
-    };
-  }
-
-  //
-  // -------------------------
-  // WEBSOCKET
-  // -------------------------
-  //
-  static normalizeWebSocket(raw: RawWebSocketEvent): NormalizedWebSocketEvent {
-    return {
-      id: IdGenerator.generate(),
-      type: "websocket",
-      timestamp: Date.now(),
-      sourceIp: raw.ip,
-      message: raw.message,
-    };
-  }
-
-  //
-  // -------------------------
-  // API  (NOUVEAU)
-  // -------------------------
-  //
-  static normalizeApi(raw: RawApiEvent): NormalizedApiEvent {
-    return {
-      id: IdGenerator.generate(),
-      type: "api",
-      timestamp: Date.now(),
-      sourceIp: raw.ip,
-      request: {
-        body: raw.body,
-      },
-      raw: raw.raw,
-    };
-  }
-}

package/src/core/event.router.ts

@@ -1,13 +0,0 @@
-import { EventNormalizer } from "./event.normalizer";
-import { Storage } from "../storage-adapters/storage.interface";
-import { RawEvent, NormalizedHttpEvent } from "../types/event.types";
-
-export class EventRouter {
-  constructor(private storage: Storage) {}
-
-  async handleHttp(event: RawEvent): Promise<NormalizedHttpEvent> {
-    const normalized = EventNormalizer.normalizeHttp(event);
-    await this.storage.save(normalized);
-    return normalized;
-  }
-}

package/src/core/http/__tests__/adapter-node.test.ts

@@ -1,52 +0,0 @@
-import { NodeAdapter } from "../adapter-node";
-import { MiddlewarePipeline } from "../middleware";
-import { Router } from "../router";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect, jest } from "@jest/globals";
-import * as Build from "../buildRequest";
-
-describe("NodeAdapter.handle", () => {
-  it("appelle le handler quand la route match", async () => {
-    const router = new Router();
-    const pipeline = new MiddlewarePipeline();
-
-    // mock buildRequest
-    const buildRequestMock = jest
-      .spyOn(Build, "buildRequest")
-      .mockImplementation(
-        (raw: any, params?: Record<string, string>) =>
-          new Request({
-            method: "GET",
-            path: "/test",
-            headers: {},
-            params: params ?? {},
-          }),
-      );
-
-    const handler = jest.fn();
-
-    router.match = jest.fn(() => ({
-      handler,
-      params: { id: "42" },
-      middlewares: [],
-    })) as any;
-
-    pipeline.run = jest.fn(async () => {}) as any;
-
-    const res = {
-      writableEnded: false,
-      setHeader: jest.fn(),
-      end: jest.fn(),
-      statusCode: 200,
-    };
-
-    const adapter = new NodeAdapter(router, pipeline);
-
-    await adapter.handle({ url: "/test", method: "GET", headers: {} }, res);
-
-    expect(handler).toHaveBeenCalled();
-    expect(pipeline.run).toHaveBeenCalled();
-    expect(buildRequestMock).toHaveBeenCalledTimes(2);
-  });
-});

package/src/core/http/__tests__/body-parser-multipart.test.ts

@@ -1,41 +0,0 @@
-import { bodyParserMultipart } from "../middleware";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect } from "@jest/globals";
-
-describe("bodyParserMultipart", () => {
-  it("parse un champ texte et un fichier", async () => {
-    const boundary = "----1234";
-
-    const raw = {
-      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
-      [Symbol.asyncIterator]: async function* () {
-        yield Buffer.from(
-          `--${boundary}\r\n` +
-            `Content-Disposition: form-data; name="username"\r\n\r\n` +
-            `jeremy\r\n` +
-            `--${boundary}\r\n` +
-            `Content-Disposition: form-data; name="file"; filename="test.txt"\r\n` +
-            `Content-Type: text/plain\r\n\r\n` +
-            `Hello world\r\n` +
-            `--${boundary}--`,
-        );
-      },
-    };
-
-    const req = new Request({
-      method: "POST",
-      path: "/upload",
-      headers: raw.headers,
-      raw,
-    });
-
-    const res = new Response({});
-
-    await bodyParserMultipart(req, res);
-
-    expect(req.form?.username).toBe("jeremy");
-    expect(req.files?.[0].filename).toBe("test.txt");
-    expect(req.files?.[0].data.toString()).toBe("Hello world");
-  });
-});