@j3r3mcdev/oast-server 1.0.0

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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,147 @@
+import {
+  RawEvent,
+  RawDnsEvent,
+  RawSmtpEvent,
+  RawTcpEvent,
+  RawSsrfEvent,
+  NormalizedHttpEvent,
+  NormalizedDnsEvent,
+  NormalizedSmtpEvent,
+  NormalizedTcpEvent,
+  NormalizedSsrfEvent,
+  NormalizedWebhookEvent,
+  RawWebhookEvent,
+  NormalizedWebSocketEvent,
+  RawWebSocketEvent,
+} 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,
+    };
+  }
+}

package/src/core/event.router.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,41 @@
+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");
+  });
+});

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

@@ -0,0 +1,28 @@
+import { bodyParserRaw } from "../middleware";
+import { Request } from "../request";
+import { Response } from "../response";
+import { describe, it, expect } from "@jest/globals";
+
+describe("bodyParserRaw", () => {
+  it("lit le body brut", async () => {
+    const raw = {
+      headers: { "content-type": "application/octet-stream" },
+      [Symbol.asyncIterator]: async function* () {
+        yield Buffer.from([1, 2, 3, 4]);
+      },
+    };
+
+    const req = new Request({
+      method: "POST",
+      path: "/",
+      headers: raw.headers,
+      raw,
+    });
+
+    const res = new Response({});
+
+    await bodyParserRaw(req, res);
+
+    expect(req.bodyRaw).toEqual(Buffer.from([1, 2, 3, 4]));
+  });
+});

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

@@ -0,0 +1,28 @@
+import { bodyParserText } from "../middleware";
+import { Request } from "../request";
+import { Response } from "../response";
+import { describe, it, expect } from "@jest/globals";
+
+describe("bodyParserText", () => {
+  it("lit le body text", async () => {
+    const raw = {
+      headers: { "content-type": "text/plain" },
+      [Symbol.asyncIterator]: async function* () {
+        yield Buffer.from("Hello world");
+      },
+    };
+
+    const req = new Request({
+      method: "POST",
+      path: "/",
+      headers: raw.headers,
+      raw,
+    });
+
+    const res = new Response({});
+
+    await bodyParserText(req, res);
+
+    expect(req.bodyText).toBe("Hello world");
+  });
+});

package/src/core/http/__tests__/compile-path.test.ts

@@ -0,0 +1,39 @@
+import { compilePath } from "../compile-path";
+import { describe, it, expect } from "@jest/globals";
+
+describe("compilePath", () => {
+  it("compile un chemin simple avec segment statique", () => {
+    const result = compilePath("/tasks");
+
+    expect(result).toEqual([{ type: "static", value: "tasks" }]);
+  });
+
+  it("compile un chemin avec paramètre", () => {
+    const result = compilePath("/tasks/:id");
+
+    expect(result).toEqual([
+      { type: "static", value: "tasks" },
+      { type: "param", name: "id" },
+    ]);
+  });
+
+  it("compile un chemin avec paramètre", () => {
+    const result = compilePath("/tasks/:id");
+
+    expect(result).toEqual([
+      { type: "static", value: "tasks" },
+      { type: "param", name: "id" },
+    ]);
+  });
+
+  it("compile un chemin complexe avec static, param et wildcard", () => {
+    const result = compilePath("/a/:b/*/c");
+
+    expect(result).toEqual([
+      { type: "static", value: "a" },
+      { type: "param", name: "b" },
+      { type: "wildcard" },
+      { type: "static", value: "c" },
+    ]);
+  });
+});

package/src/core/http/__tests__/middleware-pipeline.test.ts

@@ -0,0 +1,51 @@
+import { MiddlewarePipeline } from "../../http/middleware";
+import { Request } from "../../http/request";
+import { Response } from "../../http/response";
+import { describe, it, expect, jest } from "@jest/globals";
+
+describe("MiddlewarePipeline", () => {
+  it("exécute les middlewares dans l'ordre", async () => {
+    const pipeline = new MiddlewarePipeline();
+
+    const calls: string[] = [];
+
+    pipeline.use(async (req, res, next) => {
+      calls.push("mw1");
+      await next();
+    });
+
+    pipeline.use(async (req, res, next) => {
+      calls.push("mw2");
+      await next();
+    });
+
+    const req = new Request({ method: "GET", path: "/", headers: {} });
+    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
+
+    await pipeline.run(req, res);
+
+    expect(calls).toEqual(["mw1", "mw2"]);
+  });
+
+  it("arrête la chaîne si next() n'est pas appelé", async () => {
+    const pipeline = new MiddlewarePipeline();
+
+    const calls: string[] = [];
+
+    pipeline.use(async () => {
+      calls.push("mw1");
+      // pas de next()
+    });
+
+    pipeline.use(async () => {
+      calls.push("mw2");
+    });
+
+    const req = new Request({ method: "GET", path: "/", headers: {} });
+    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
+
+    await pipeline.run(req, res);
+
+    expect(calls).toEqual(["mw1"]);
+  });
+});

package/src/core/http/__tests__/request.test.ts

@@ -0,0 +1,34 @@
+import { Request } from "../request";
+import { describe, it, expect } from "@jest/globals";
+
+describe("Request", () => {
+  it("crée une requête immuable avec les bonnes propriétés", () => {
+    const req = new Request({
+      method: "GET",
+      path: "/test",
+      headers: { "content-type": "application/json" },
+      query: { a: "1" },
+      params: { id: "123" },
+      body: { x: 1 },
+      ip: "127.0.0.1",
+    });
+
+    expect(req.method).toBe("GET");
+    expect(req.path).toBe("/test");
+    expect(req.headers["content-type"]).toBe("application/json");
+    expect(req.query.a).toBe("1");
+    expect(req.params.id).toBe("123");
+    expect(req.body.x).toBe(1);
+    expect(req.ip).toBe("127.0.0.1");
+  });
+
+  it("retourne un header via header()", () => {
+    const req = new Request({
+      method: "GET",
+      path: "/",
+      headers: { "x-test": "ok" },
+    });
+
+    expect(req.header("x-test")).toBe("ok");
+  });
+});

package/src/core/http/__tests__/response.test.ts

@@ -0,0 +1,35 @@
+import { Response } from "../../http/response";
+import { describe, it, expect, jest } from "@jest/globals";
+
+describe("Response", () => {
+  it("enregistre le status et les headers", () => {
+    const raw = {
+      setHeader: jest.fn(),
+      end: jest.fn(),
+    };
+
+    const res = new Response(raw);
+
+    res.status(201).header("x-test", "ok").send("hello");
+
+    expect(raw.setHeader).toHaveBeenCalledWith("x-test", "ok");
+    expect(raw.end).toHaveBeenCalledWith("hello");
+  });
+
+  it("envoie du JSON", () => {
+    const raw = {
+      setHeader: jest.fn(),
+      end: jest.fn(),
+    };
+
+    const res = new Response(raw);
+
+    res.json({ a: 1 });
+
+    expect(raw.setHeader).toHaveBeenCalledWith(
+      "content-type",
+      "application/json",
+    );
+    expect(raw.end).toHaveBeenCalledWith(JSON.stringify({ a: 1 }));
+  });
+});