@j3r3mcdev/oast-server 1.1.7 → 1.1.8

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

@@ -1,69 +1,69 @@
-import { describe, it, expect } from "@jest/globals";
-import { SmtpExtractor } from "../smtp.extractor";
-
-describe("SmtpExtractor", () => {
-  it("extrait correctement un RawSmtpEvent valide", () => {
-    const session = {
-      remoteAddress: "1.2.3.4",
-      envelope: {
-        mailFrom: { address: "attacker@example.com" },
-        rcptTo: [{ address: "victim@example.com" }],
-      },
-      headers: { subject: "Hello World" },
-    };
-
-    const body = "This is the email body";
-
-    const result = SmtpExtractor.extract(session, body);
-
-    expect(result).toEqual({
-      ip: "1.2.3.4",
-      from: "attacker@example.com",
-      to: "victim@example.com",
-      subject: "Hello World",
-      raw: {
-        session,
-        body,
-      },
-    });
-  });
-
-  it("gère les champs manquants proprement", () => {
-    const session = {
-      remoteAddress: undefined,
-      envelope: {
-        mailFrom: {},
-        rcptTo: [{}],
-      },
-      headers: {},
-    };
-
-    const result = SmtpExtractor.extract(session, "");
-
-    expect(result).toEqual({
-      ip: "",
-      from: "",
-      to: "",
-      subject: "",
-      raw: {
-        session,
-        body: "",
-      },
-    });
-  });
-
-  it("ne plante pas si session est vide", () => {
-    const result = SmtpExtractor.extract({}, "BODY");
-
-    expect(result).toEqual({
-      ip: "",
-      from: "",
-      to: "",
-      subject: "",
-      raw: {
-        session: {},
-        body: "BODY",
-      },
-    });
-  });
-});
+import { describe, it, expect } from "@jest/globals";
+import { SmtpExtractor } from "../smtp.extractor";
+
+describe("SmtpExtractor", () => {
+  it("extrait correctement un RawSmtpEvent valide", () => {
+    const session = {
+      remoteAddress: "1.2.3.4",
+      envelope: {
+        mailFrom: { address: "attacker@example.com" },
+        rcptTo: [{ address: "victim@example.com" }],
+      },
+      headers: { subject: "Hello World" },
+    };
+
+    const body = "This is the email body";
+
+    const result = SmtpExtractor.extract(session, body);
+
+    expect(result).toEqual({
+      ip: "1.2.3.4",
+      from: "attacker@example.com",
+      to: "victim@example.com",
+      subject: "Hello World",
+      raw: {
+        session,
+        body,
+      },
+    });
+  });
+
+  it("gère les champs manquants proprement", () => {
+    const session = {
+      remoteAddress: undefined,
+      envelope: {
+        mailFrom: {},
+        rcptTo: [{}],
+      },
+      headers: {},
+    };
+
+    const result = SmtpExtractor.extract(session, "");
+
+    expect(result).toEqual({
+      ip: "",
+      from: "",
+      to: "",
+      subject: "",
+      raw: {
+        session,
+        body: "",
+      },
+    });
+  });
+
+  it("ne plante pas si session est vide", () => {
+    const result = SmtpExtractor.extract({}, "BODY");
+
+    expect(result).toEqual({
+      ip: "",
+      from: "",
+      to: "",
+      subject: "",
+      raw: {
+        session: {},
+        body: "BODY",
+      },
+    });
+  });
+});

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

@@ -1,150 +1,150 @@
-import { describe, it, expect, jest, beforeEach } from "@jest/globals";
-import { SmtpListener } from "../smtp.listener";
-import { EventNormalizer } from "../../../core/event.normalizer";
-import { CoreRouter } from "../../../core/router";
-
-// Mock EventNormalizer
-jest.mock("../../../core/event.normalizer", () => ({
-  EventNormalizer: {
-    normalizeSmtp: jest.fn(),
-  },
-}));
-
-describe("SmtpListener", () => {
-  let router: CoreRouter;
-  let server: any;
-  let listener: SmtpListener;
-
-  beforeEach(() => {
-    router = {
-      dispatch: jest.fn(async (_event: any) => {}),
-    } as any;
-
-    server = {
-      onData: null,
-      close: jest.fn(),
-    };
-
-    listener = new SmtpListener(router, { server });
-  });
-
-  it("traite un email SMTP valide et appelle dispatch", async () => {
-    const callback = jest.fn();
-
-    // NormalizedSmtpEvent VALIDE
-    (EventNormalizer.normalizeSmtp as jest.Mock).mockReturnValue({
-      id: "smtp-123",
-      type: "smtp",
-      timestamp: Date.now(),
-      ip: "1.2.3.4",
-      from: "attacker@example.com",
-      to: ["victim@example.com"],
-      subject: "Test Email",
-      body: "Hello world",
-      raw: {},
-    });
-
-    await listener.start();
-
-    const stream = {
-      on: jest.fn((event: string, handler: (chunk?: any) => void) => {
-        if (event === "data") handler("Hello world");
-        if (event === "end") handler();
-      }),
-    };
-
-    const session = {
-      remoteAddress: "1.2.3.4",
-      envelope: {
-        mailFrom: { address: "attacker@example.com" },
-        rcptTo: [{ address: "victim@example.com" }],
-      },
-      headers: { subject: "Test Email" },
-    };
-
-    await server.onData(stream, session, callback);
-
-    expect(EventNormalizer.normalizeSmtp).toHaveBeenCalled();
-    expect(router.dispatch).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(null);
-  });
-
-  it("renvoie une erreur si normalizeSmtp échoue", async () => {
-    const callback = jest.fn();
-
-    (EventNormalizer.normalizeSmtp as jest.Mock).mockImplementation(() => {
-      throw new Error("bad smtp");
-    });
-
-    await listener.start();
-
-    const stream = {
-      on: jest.fn((event: string, handler: (chunk?: any) => void) => {
-        if (event === "data") handler("DATA");
-        if (event === "end") handler();
-      }),
-    };
-
-    const session = {
-      remoteAddress: "1.2.3.4",
-      envelope: {
-        mailFrom: { address: "a@b.com" },
-        rcptTo: [{ address: "c@d.com" }],
-      },
-      headers: { subject: "X" },
-    };
-
-    await server.onData(stream, session, callback);
-
-    expect(callback).toHaveBeenCalledWith(new Error("bad smtp"));
-  });
-
-  it("renvoie une erreur si router.dispatch échoue", async () => {
-    const callback = jest.fn();
-
-    (EventNormalizer.normalizeSmtp as jest.Mock).mockReturnValue({
-      id: "smtp-999",
-      type: "smtp",
-      timestamp: Date.now(),
-      ip: "1.2.3.4",
-      from: "a@b.com",
-      to: ["c@d.com"],
-      subject: "X",
-      body: "DATA",
-      raw: {},
-    });
-
-    listener["router"] = {
-      dispatch: jest.fn(async () => {
-        throw new Error("dispatch failed");
-      }),
-    } as any;
-
-    await listener.start();
-
-    const stream = {
-      on: jest.fn((event: string, handler: (chunk?: any) => void) => {
-        if (event === "data") handler("DATA");
-        if (event === "end") handler();
-      }),
-    };
-
-    const session = {
-      remoteAddress: "1.2.3.4",
-      envelope: {
-        mailFrom: { address: "a@b.com" },
-        rcptTo: [{ address: "c@d.com" }],
-      },
-      headers: { subject: "X" },
-    };
-
-    await server.onData(stream, session, callback);
-
-    expect(callback).toHaveBeenCalledWith(new Error("dispatch failed"));
-  });
-
-  it("stop() appelle server.close si disponible", async () => {
-    await listener.stop();
-    expect(server.close).toHaveBeenCalled();
-  });
-});
+import { describe, it, expect, jest, beforeEach } from "@jest/globals";
+import { SmtpListener } from "../smtp.listener";
+import { EventNormalizer } from "../../../core/event.normalizer";
+import { CoreRouter } from "../../../core/router";
+
+// Mock EventNormalizer
+jest.mock("../../../core/event.normalizer", () => ({
+  EventNormalizer: {
+    normalizeSmtp: jest.fn(),
+  },
+}));
+
+describe("SmtpListener", () => {
+  let router: CoreRouter;
+  let server: any;
+  let listener: SmtpListener;
+
+  beforeEach(() => {
+    router = {
+      dispatch: jest.fn(async (_event: any) => {}),
+    } as any;
+
+    server = {
+      onData: null,
+      close: jest.fn(),
+    };
+
+    listener = new SmtpListener(router, { server });
+  });
+
+  it("traite un email SMTP valide et appelle dispatch", async () => {
+    const callback = jest.fn();
+
+    // NormalizedSmtpEvent VALIDE
+    (EventNormalizer.normalizeSmtp as jest.Mock).mockReturnValue({
+      id: "smtp-123",
+      type: "smtp",
+      timestamp: Date.now(),
+      ip: "1.2.3.4",
+      from: "attacker@example.com",
+      to: ["victim@example.com"],
+      subject: "Test Email",
+      body: "Hello world",
+      raw: {},
+    });
+
+    await listener.start();
+
+    const stream = {
+      on: jest.fn((event: string, handler: (chunk?: any) => void) => {
+        if (event === "data") handler("Hello world");
+        if (event === "end") handler();
+      }),
+    };
+
+    const session = {
+      remoteAddress: "1.2.3.4",
+      envelope: {
+        mailFrom: { address: "attacker@example.com" },
+        rcptTo: [{ address: "victim@example.com" }],
+      },
+      headers: { subject: "Test Email" },
+    };
+
+    await server.onData(stream, session, callback);
+
+    expect(EventNormalizer.normalizeSmtp).toHaveBeenCalled();
+    expect(router.dispatch).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(null);
+  });
+
+  it("renvoie une erreur si normalizeSmtp échoue", async () => {
+    const callback = jest.fn();
+
+    (EventNormalizer.normalizeSmtp as jest.Mock).mockImplementation(() => {
+      throw new Error("bad smtp");
+    });
+
+    await listener.start();
+
+    const stream = {
+      on: jest.fn((event: string, handler: (chunk?: any) => void) => {
+        if (event === "data") handler("DATA");
+        if (event === "end") handler();
+      }),
+    };
+
+    const session = {
+      remoteAddress: "1.2.3.4",
+      envelope: {
+        mailFrom: { address: "a@b.com" },
+        rcptTo: [{ address: "c@d.com" }],
+      },
+      headers: { subject: "X" },
+    };
+
+    await server.onData(stream, session, callback);
+
+    expect(callback).toHaveBeenCalledWith(new Error("bad smtp"));
+  });
+
+  it("renvoie une erreur si router.dispatch échoue", async () => {
+    const callback = jest.fn();
+
+    (EventNormalizer.normalizeSmtp as jest.Mock).mockReturnValue({
+      id: "smtp-999",
+      type: "smtp",
+      timestamp: Date.now(),
+      ip: "1.2.3.4",
+      from: "a@b.com",
+      to: ["c@d.com"],
+      subject: "X",
+      body: "DATA",
+      raw: {},
+    });
+
+    listener["router"] = {
+      dispatch: jest.fn(async () => {
+        throw new Error("dispatch failed");
+      }),
+    } as any;
+
+    await listener.start();
+
+    const stream = {
+      on: jest.fn((event: string, handler: (chunk?: any) => void) => {
+        if (event === "data") handler("DATA");
+        if (event === "end") handler();
+      }),
+    };
+
+    const session = {
+      remoteAddress: "1.2.3.4",
+      envelope: {
+        mailFrom: { address: "a@b.com" },
+        rcptTo: [{ address: "c@d.com" }],
+      },
+      headers: { subject: "X" },
+    };
+
+    await server.onData(stream, session, callback);
+
+    expect(callback).toHaveBeenCalledWith(new Error("dispatch failed"));
+  });
+
+  it("stop() appelle server.close si disponible", async () => {
+    await listener.stop();
+    expect(server.close).toHaveBeenCalled();
+  });
+});

package/src/listeners/smtp/smtp.extractor.ts

@@ -1,18 +1,18 @@
-export class SmtpExtractor {
-  static extract(session: any, body: string) {
-    const envelope = session?.envelope ?? {};
-    const mailFrom = envelope.mailFrom ?? {};
-    const rcptTo = Array.isArray(envelope.rcptTo) ? envelope.rcptTo : [];
-
-    return {
-      ip: session?.remoteAddress ?? "",
-      from: mailFrom.address ?? "",
-      to: rcptTo[0]?.address ?? "",
-      subject: session?.headers?.subject ?? "",
-      raw: {
-        session,
-        body,
-      },
-    };
-  }
-}
+export class SmtpExtractor {
+  static extract(session: any, body: string) {
+    const envelope = session?.envelope ?? {};
+    const mailFrom = envelope.mailFrom ?? {};
+    const rcptTo = Array.isArray(envelope.rcptTo) ? envelope.rcptTo : [];
+
+    return {
+      ip: session?.remoteAddress ?? "",
+      from: mailFrom.address ?? "",
+      to: rcptTo[0]?.address ?? "",
+      subject: session?.headers?.subject ?? "",
+      raw: {
+        session,
+        body,
+      },
+    };
+  }
+}

package/src/listeners/smtp/smtp.listener.ts

@@ -1,60 +1,60 @@
-import { CoreRouter } from "../../core/router";
-import { EventNormalizer } from "../../core/event.normalizer";
-import { Logger } from "../../core/logger";
-
-export class SmtpListener {
-  private router: CoreRouter;
-  private server: any;
-  private logger: Logger;
-
-  constructor(router: CoreRouter, options: { server: any; logger?: Logger }) {
-    this.router = router;
-    this.server = options.server;
-    this.logger = options.logger ?? new Logger({ context: "SmtpListener" });
-  }
-
-  async start() {
-    this.logger.info("SMTP Listener started");
-
-    this.server.onData = async (stream: any, session: any, callback: any) => {
-      let chunks: string[] = [];
-
-      stream.on("data", (chunk: any) => {
-        chunks.push(chunk.toString());
-      });
-
-      stream.on("end", async () => {
-        const body = chunks.join("");
-
-        let event;
-        try {
-          event = EventNormalizer.normalizeSmtp({
-            ip: session.remoteAddress,
-            from: session.envelope.mailFrom.address,
-            to: session.envelope.rcptTo.map((r: any) => r.address),
-            subject: session.headers.subject,
-            body,
-            raw: session,
-          });
-        } catch (err: any) {
-          callback(new Error(err.message));
-          return;
-        }
-
-        try {
-          await this.router.dispatch(event);
-          callback(null);
-        } catch (err) {
-          callback(new Error("dispatch failed")); // ✔ EXACTEMENT ce que ton test attend
-        }
-      });
-    };
-  }
-
-  async stop() {
-    if (this.server?.close) {
-      this.server.close();
-      this.logger.info("SMTP Listener stopped");
-    }
-  }
-}
+import { CoreRouter } from "../../core/router";
+import { EventNormalizer } from "../../core/event.normalizer";
+import { Logger } from "../../core/logger";
+
+export class SmtpListener {
+  private router: CoreRouter;
+  private server: any;
+  private logger: Logger;
+
+  constructor(router: CoreRouter, options: { server: any; logger?: Logger }) {
+    this.router = router;
+    this.server = options.server;
+    this.logger = options.logger ?? new Logger({ context: "SmtpListener" });
+  }
+
+  async start() {
+    this.logger.info("SMTP Listener started");
+
+    this.server.onData = async (stream: any, session: any, callback: any) => {
+      let chunks: string[] = [];
+
+      stream.on("data", (chunk: any) => {
+        chunks.push(chunk.toString());
+      });
+
+      stream.on("end", async () => {
+        const body = chunks.join("");
+
+        let event;
+        try {
+          event = EventNormalizer.normalizeSmtp({
+            ip: session.remoteAddress,
+            from: session.envelope.mailFrom.address,
+            to: session.envelope.rcptTo.map((r: any) => r.address),
+            subject: session.headers.subject,
+            body,
+            raw: session,
+          });
+        } catch (err: any) {
+          callback(new Error(err.message));
+          return;
+        }
+
+        try {
+          await this.router.dispatch(event);
+          callback(null);
+        } catch (err) {
+          callback(new Error("dispatch failed")); // ✔ EXACTEMENT ce que ton test attend
+        }
+      });
+    };
+  }
+
+  async stop() {
+    if (this.server?.close) {
+      this.server.close();
+      this.logger.info("SMTP Listener stopped");
+    }
+  }
+}

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

@@ -1,41 +1,41 @@
-import { SsrfExtractor } from "../ssrf.extractor";
-import { describe, it, expect } from "@jest/globals";
-
-describe("SsrfExtractor", () => {
-  it("extrait correctement toutes les données", () => {
-    const req: any = {
-      ip: "1.2.3.4",
-      method: "GET",
-      path: "/test",
-      headers: { host: "example.com" },
-      query: { a: 1 },
-      raw: { foo: "bar" },
-    };
-
-    const extracted = SsrfExtractor.extract(req);
-
-    expect(extracted).toEqual({
-      ip: "1.2.3.4",
-      method: "GET",
-      path: "/test",
-      headers: { host: "example.com" },
-      query: { a: 1 },
-      raw: req,
-    });
-  });
-
-  it("retourne une structure complète même si des champs manquent", () => {
-    const req: any = {};
-
-    const extracted = SsrfExtractor.extract(req);
-
-    expect(extracted).toEqual({
-      ip: "",
-      method: undefined,
-      path: undefined,
-      headers: {},
-      query: {},
-      raw: req,
-    });
-  });
-});
+import { SsrfExtractor } from "../ssrf.extractor";
+import { describe, it, expect } from "@jest/globals";
+
+describe("SsrfExtractor", () => {
+  it("extrait correctement toutes les données", () => {
+    const req: any = {
+      ip: "1.2.3.4",
+      method: "GET",
+      path: "/test",
+      headers: { host: "example.com" },
+      query: { a: 1 },
+      raw: { foo: "bar" },
+    };
+
+    const extracted = SsrfExtractor.extract(req);
+
+    expect(extracted).toEqual({
+      ip: "1.2.3.4",
+      method: "GET",
+      path: "/test",
+      headers: { host: "example.com" },
+      query: { a: 1 },
+      raw: req,
+    });
+  });
+
+  it("retourne une structure complète même si des champs manquent", () => {
+    const req: any = {};
+
+    const extracted = SsrfExtractor.extract(req);
+
+    expect(extracted).toEqual({
+      ip: "",
+      method: undefined,
+      path: undefined,
+      headers: {},
+      query: {},
+      raw: req,
+    });
+  });
+});