@j3r3mcdev/oast-server 1.1.1 → 1.1.2

package/dist/core/__tests__/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/storage-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/event.normalizer.d.ts

@@ -0,0 +1,10 @@
+import { RawEvent, RawDnsEvent, RawSmtpEvent, RawTcpEvent, RawSsrfEvent, NormalizedHttpEvent, NormalizedDnsEvent, NormalizedSmtpEvent, NormalizedTcpEvent, NormalizedSsrfEvent, NormalizedWebhookEvent, RawWebhookEvent, NormalizedWebSocketEvent, RawWebSocketEvent } from "../types/event.types";
+export declare class EventNormalizer {
+    static normalizeDns(event: RawDnsEvent): NormalizedDnsEvent;
+    static normalizeHttp(event: RawEvent): NormalizedHttpEvent;
+    static normalizeSmtp(event: RawSmtpEvent): NormalizedSmtpEvent;
+    static normalizeTcp(event: RawTcpEvent): NormalizedTcpEvent;
+    static normalizeSsrf(raw: RawSsrfEvent): NormalizedSsrfEvent;
+    static normalizeWebhook(raw: RawWebhookEvent): NormalizedWebhookEvent;
+    static normalizeWebSocket(raw: RawWebSocketEvent): NormalizedWebSocketEvent;
+}

package/dist/core/event.router.d.ts

@@ -0,0 +1,7 @@
+import { Storage } from "../storage-adapters/storage.interface";
+import { RawEvent, NormalizedHttpEvent } from "../types/event.types";
+export declare class EventRouter {
+    private storage;
+    constructor(storage: Storage);
+    handleHttp(event: RawEvent): Promise<NormalizedHttpEvent>;
+}

package/dist/core/http/__tests__/adapter-node.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/compile-path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/middleware-pipeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/request.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/response.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/router-match.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/adapter-node.d.ts

@@ -0,0 +1,8 @@
+import { MiddlewarePipeline } from "./middleware";
+import { Router } from "./router";
+export declare class NodeAdapter {
+    private router;
+    private pipeline;
+    constructor(router: Router, pipeline: MiddlewarePipeline);
+    handle(req: any, res: any): Promise<void>;
+}

package/dist/core/http/buildRequest.d.ts

@@ -0,0 +1,2 @@
+import { Request } from "./request";
+export declare function buildRequest(raw: any, params?: Record<string, string>): Request;

package/dist/core/http/compile-path.d.ts

@@ -0,0 +1,13 @@
+export declare function compilePath(path: string): ({
+    type: string;
+    value: string;
+    name?: undefined;
+} | {
+    type: string;
+    name: string;
+    value?: undefined;
+} | {
+    type: string;
+    value?: undefined;
+    name?: undefined;
+})[];

package/dist/core/http/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: any;
+    constructor(status: number, code: string, message: string, details?: any);
+}
+export declare class ErrorHandler {
+    static handle(err: unknown, res: any): void;
+}

package/dist/core/http/http-server.d.ts

@@ -0,0 +1,7 @@
+import { Router } from "./router";
+export declare class HttpServer {
+    private router;
+    private server;
+    constructor(router: Router);
+    start(port: number): void;
+}

package/dist/core/http/middleware.d.ts

@@ -0,0 +1,12 @@
+import { Request } from "./request";
+import { Response } from "./response";
+export type Middleware = (req: Request, res: Response, next: () => Promise<void>) => Promise<void> | void;
+export declare class MiddlewarePipeline {
+    private middlewares;
+    use(mw: Middleware): this;
+    run(req: Request, res: Response): Promise<void>;
+}
+export declare function bodyParserJson(req: Request, res: Response): Promise<void>;
+export declare function bodyParserRaw(req: Request, res: Response): Promise<void>;
+export declare function bodyParserText(req: Request, res: Response): Promise<void>;
+export declare function bodyParserMultipart(req: Request, res: Response): Promise<void>;

package/dist/core/http/request.d.ts

@@ -0,0 +1,35 @@
+export interface RequestContext {
+    [key: string]: any;
+}
+export declare class Request {
+    readonly method: string;
+    readonly path: string;
+    readonly headers: Record<string, string>;
+    readonly query: Record<string, string | string[]>;
+    readonly params: Record<string, string>;
+    body: any;
+    bodyRaw?: Buffer;
+    bodyText?: string;
+    files?: Array<{
+        fieldname: string;
+        filename: string;
+        contentType: string;
+        data: Buffer;
+    }>;
+    form?: Record<string, string>;
+    readonly ip: string;
+    readonly raw: any;
+    readonly context: RequestContext;
+    constructor(options: {
+        method: string;
+        path: string;
+        headers: Record<string, string>;
+        query?: Record<string, string | string[]>;
+        params?: Record<string, string>;
+        body?: any;
+        ip?: string;
+        raw?: any;
+        context?: RequestContext;
+    });
+    header(name: string): string | undefined;
+}

package/dist/core/http/response.d.ts

@@ -0,0 +1,17 @@
+export declare class Response {
+    private _status;
+    private _headers;
+    private _sent;
+    private _raw;
+    constructor(raw: any);
+    status(code: number): this;
+    header(name: string, value: string): this;
+    json(data: any): void;
+    text(data: string): void;
+    send(data: any): void;
+    stream(readable: NodeJS.ReadableStream): void;
+    sse(): void;
+    write(data: string): void;
+    end(): void;
+    private ensureNotSent;
+}

package/dist/core/http/router.d.ts

@@ -0,0 +1,28 @@
+import { Middleware } from "./middleware";
+export declare class Router {
+    private routes;
+    /**
+     * Enregistre une route avec middlewares optionnels :
+     * router.get("/x", mw1, mw2, handler)
+     */
+    register(method: string, path: string, ...middlewaresAndHandler: any[]): void;
+    /**
+     * Trouve la route et extrait les params
+     */
+    match(method: string, urlPath: string): {
+        handler: Function;
+        middlewares: Middleware[];
+        params: Record<string, string>;
+    } | null;
+    /**
+     * Ton moteur de matching existant — inchangé
+     */
+    private matchSegments;
+    get(path: string, ...middlewaresAndHandler: any[]): void;
+    post(path: string, ...middlewaresAndHandler: any[]): void;
+    put(path: string, ...middlewaresAndHandler: any[]): void;
+    delete(path: string, ...middlewaresAndHandler: any[]): void;
+    patch(path: string, ...middlewaresAndHandler: any[]): void;
+    options(path: string, ...middlewaresAndHandler: any[]): void;
+    head(path: string, ...middlewaresAndHandler: any[]): void;
+}

package/dist/core/id-generator.d.ts

@@ -0,0 +1,3 @@
+export declare class IdGenerator {
+    static generate(): string;
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,29 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export interface LoggerOptions {
+    level?: LogLevel;
+    context?: string;
+    enabled?: boolean;
+    hooks?: Array<(entry: LogEntry) => void>;
+}
+export interface LogEntry {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    context?: string;
+    data?: any;
+}
+export declare class Logger {
+    private level;
+    private context?;
+    private enabled;
+    private hooks;
+    constructor(options?: LoggerOptions);
+    private shouldLog;
+    private emit;
+    debug(msg: string, data?: any): void;
+    info(msg: string, data?: any): void;
+    warn(msg: string, data?: any): void;
+    error(msg: string, data?: any): void;
+    fatal(msg: string, data?: any): void;
+    withContext(context: string): Logger;
+}

package/dist/core/router.d.ts

@@ -0,0 +1,16 @@
+import { Storage } from "../storage-adapters/storage.interface";
+import { Logger } from "./logger";
+import { AnyNormalizedEvent } from "../types/event.types";
+export type RouterHook = (event: AnyNormalizedEvent) => void | Promise<void>;
+export interface RouterOptions {
+    logger?: Logger;
+    hooks?: RouterHook[];
+}
+export declare class CoreRouter {
+    private storage;
+    private logger;
+    private hooks;
+    constructor(storage: Storage, options?: RouterOptions);
+    dispatch(event: AnyNormalizedEvent): Promise<void>;
+    addHook(hook: RouterHook): void;
+}

package/dist/core/server.d.ts

@@ -0,0 +1,25 @@
+import { Logger } from "./logger";
+import { CoreRouter } from "./router";
+import { StorageManager } from "./storage";
+import { Listener } from "../listeners/listener.interface";
+export interface CoreServerOptions {
+    logger?: Logger;
+    storage?: StorageManager;
+    listeners?: Listener[];
+}
+export declare class CoreServer {
+    private logger;
+    private storage;
+    private router;
+    private listeners;
+    constructor(options?: CoreServerOptions);
+    getRouter(): CoreRouter;
+    getStorage(): StorageManager;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Méthode appelée par CoreRouter après chaque event normalisé.
+     * Permet de diffuser l’event aux listeners SSE (ApiListener).
+     */
+    broadcast(event: any): void;
+}

package/dist/core/storage.d.ts

@@ -0,0 +1,24 @@
+import { Storage } from "../storage-adapters/storage.interface";
+import { AnyNormalizedEvent } from "../types/event.types";
+import { Logger } from "./logger";
+export declare class StorageManager implements Storage {
+    private events;
+    private logger;
+    constructor(options?: {
+        logger?: Logger;
+    });
+    save(event: AnyNormalizedEvent): Promise<void>;
+    getEvent(id: string): Promise<AnyNormalizedEvent | null>;
+    listEvents(params: {
+        type?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<AnyNormalizedEvent[]>;
+    getAll(): Promise<AnyNormalizedEvent[]>;
+    deleteEvent(id: string): Promise<boolean>;
+    clearEvents(): Promise<void>;
+    getStats(): Promise<{
+        total: number;
+        byType: Record<string, number>;
+    }>;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.controller.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.routes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.sse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/api.controllers.d.ts

@@ -0,0 +1,9 @@
+import { ServerResponse } from "http";
+import { StorageManager } from "../../core/storage";
+export declare class ApiController {
+    static listEvents(url: URL, res: ServerResponse, storage: StorageManager): Promise<void>;
+    static getEvent(id: string, res: ServerResponse, storage: StorageManager): Promise<void>;
+    static deleteAll(res: ServerResponse, storage: StorageManager): Promise<void>;
+    static deleteOne(id: string, res: ServerResponse, storage: StorageManager): Promise<void>;
+    static stats(res: ServerResponse, storage: StorageManager): Promise<void>;
+}

package/dist/listeners/api/api.extractor.d.ts

@@ -0,0 +1,5 @@
+import { IncomingMessage } from "http";
+import { RawEvent } from "../../types/event.types";
+export declare class ApiExtractor {
+    static extract(req: IncomingMessage): Promise<RawEvent>;
+}

package/dist/listeners/api/api.listener.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from "../../core/logger";
+import { StorageManager } from "../../core/storage";
+export interface ApiListenerOptions {
+    port: number;
+    logger?: Logger;
+}
+export declare class ApiListener {
+    private storage;
+    private options;
+    private logger;
+    private server;
+    private sse;
+    constructor(storage: StorageManager, options: ApiListenerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    broadcastEvent(event: any): void;
+}

package/dist/listeners/api/api.routes.d.ts

@@ -0,0 +1,5 @@
+import { IncomingMessage, ServerResponse } from "http";
+import { Logger } from "../../core/logger";
+import { StorageManager } from "../../core/storage";
+import { ApiSse } from "./api.sse";
+export declare function handleApiRequest(req: IncomingMessage, res: ServerResponse, storage: StorageManager, sse: ApiSse, logger: Logger): Promise<void>;

package/dist/listeners/api/api.sse.d.ts

@@ -0,0 +1,10 @@
+import { ServerResponse } from "http";
+import { Logger } from "../../core/logger";
+export declare class ApiSse {
+    private logger;
+    private clients;
+    constructor(logger: Logger);
+    handle(res: ServerResponse): void;
+    broadcast(event: any): void;
+    closeAll(): void;
+}

package/dist/listeners/dns/__tests__/dns.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/dns/dns.extractor.d.ts

@@ -0,0 +1,8 @@
+export declare class DnsExtractor {
+    static extract(packet: any): {
+        ip: any;
+        query: any;
+        type: any;
+        raw: any;
+    };
+}

package/dist/listeners/dns/dns.listener.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from "../../core/logger";
+import { CoreRouter } from "../../core/router";
+export interface DnsListenerOptions {
+    server: any;
+    logger?: Logger;
+}
+export declare class DnsListener {
+    private router;
+    private options;
+    private logger;
+    constructor(router: CoreRouter, options: DnsListenerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleQuery;
+}

package/dist/listeners/http/__tests__/http.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/http/__tests__/http.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/http/http.extractor.d.ts

@@ -0,0 +1,11 @@
+export declare class HttpExtractor {
+    static extract(req: any): {
+        ip: any;
+        method: any;
+        path: any;
+        headers: any;
+        query: any;
+        body: any;
+        raw: any;
+    };
+}

package/dist/listeners/http/http.listener.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from "../../core/logger";
+import { CoreRouter } from "../../core/router";
+export interface HttpListenerOptions {
+    port: number;
+    logger?: Logger;
+}
+export declare class HttpListener {
+    private router;
+    private options;
+    private server?;
+    private logger;
+    constructor(router: CoreRouter, options: HttpListenerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private readBody;
+}

package/dist/listeners/listener.interface.d.ts

@@ -0,0 +1,4 @@
+export interface Listener {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/listeners/smtp/__tests__/smtp.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/smtp/__tests__/smtp.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/smtp/smtp.extractor.d.ts

@@ -0,0 +1,12 @@
+export declare class SmtpExtractor {
+    static extract(session: any, body: string): {
+        ip: any;
+        from: any;
+        to: any;
+        subject: any;
+        raw: {
+            session: any;
+            body: string;
+        };
+    };
+}

package/dist/listeners/smtp/smtp.listener.d.ts

@@ -0,0 +1,13 @@
+import { CoreRouter } from "../../core/router";
+import { Logger } from "../../core/logger";
+export declare class SmtpListener {
+    private router;
+    private server;
+    private logger;
+    constructor(router: CoreRouter, options: {
+        server: any;
+        logger?: Logger;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/listeners/ssrf/__tests__/ssrf.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/ssrf/__tests__/ssrf.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/ssrf/__tests__/ssrf.listener.test.js

@@ -14,10 +14,8 @@ globals_1.jest.mock("../../../core/event.normalizer");
     let router;
     let port;
     let listener;
-    (0, globals_1.beforeEach)(() => {
-        router = {
-            dispatch: globals_1.jest.fn(),
-        };
+    (0, globals_1.beforeEach)((done) => {
+        router = { dispatch: globals_1.jest.fn() };
         port = 12000 + Math.floor(Math.random() * 2000);
         ssrf_extractor_1.SsrfExtractor.extract.mockReturnValue({
             ip: "1.2.3.4",
@@ -40,6 +38,8 @@ globals_1.jest.mock("../../../core/event.normalizer");
             },
         });
         listener = new ssrf_listener_1.SsrfListener(router, port);
+        // 🔥 On attend que le serveur soit prêt
+        listener["server"].on("listening", done);
     });
     (0, globals_1.afterEach)(() => {
         listener.stop();
@@ -49,18 +49,6 @@ globals_1.jest.mock("../../../core/event.normalizer");
             const req = http_1.default.request({ hostname: "localhost", port, path: "/ssrf", method: "GET" }, (res) => {
                 (0, globals_1.expect)(res.statusCode).toBe(200);
                 (0, globals_1.expect)(router.dispatch).toHaveBeenCalledTimes(1);
-                (0, globals_1.expect)(router.dispatch).toHaveBeenCalledWith({
-                    id: "123",
-                    type: "ssrf",
-                    timestamp: 111,
-                    sourceIp: "1.2.3.4",
-                    request: {
-                        method: "GET",
-                        path: "/ssrf",
-                        headers: {},
-                        query: {},
-                    },
-                });
                 resolve();
             });
             req.end();

package/dist/listeners/ssrf/ssrf.extractor.d.ts

@@ -0,0 +1,10 @@
+export declare class SsrfExtractor {
+    static extract(req: any): {
+        ip: any;
+        method: any;
+        path: any;
+        headers: any;
+        query: any;
+        raw: any;
+    };
+}

package/dist/listeners/ssrf/ssrf.listener.d.ts

@@ -0,0 +1,8 @@
+import { CoreRouter } from "../../core/router";
+export declare class SsrfListener {
+    private router;
+    private server;
+    private logger;
+    constructor(router: CoreRouter, port: number);
+    stop(): void;
+}

package/dist/listeners/tcp/tcp.extractor.d.ts

@@ -0,0 +1,4 @@
+import { RawTcpEvent, NormalizedTcpEvent } from "../../types/event.types";
+export declare class TcpExtractor {
+    static normalize(raw: RawTcpEvent): NormalizedTcpEvent;
+}

package/dist/listeners/tcp/tcp.listener.d.ts

@@ -0,0 +1,18 @@
+import { Listener } from "../listener.interface";
+import { CoreRouter } from "../../core/router";
+import { StorageManager } from "../../core/storage";
+import { Logger } from "../../core/logger";
+export interface TcpListenerOptions {
+    port: number;
+    logger?: Logger;
+}
+export declare class TcpListener implements Listener {
+    private router;
+    private storage;
+    private options;
+    private server;
+    private logger;
+    constructor(router: CoreRouter, storage: StorageManager, options: TcpListenerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/listeners/webhook/__tests__/webhook.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/webhook/__tests__/webhook.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/webhook/webhook.extractor.d.ts

@@ -0,0 +1,8 @@
+export declare class WebhookExtractor {
+    static extract(req: any, body: any): {
+        ip: any;
+        headers: any;
+        body: any;
+        raw: any;
+    };
+}

package/dist/listeners/webhook/webhook.listener.d.ts

@@ -0,0 +1,8 @@
+import { CoreRouter } from "../../core/router";
+export declare class WebhookListener {
+    private router;
+    private server;
+    private logger;
+    constructor(router: CoreRouter, port: number);
+    stop(): void;
+}

package/dist/listeners/websocket/__tests__/websocket.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/websocket/__tests__/websocket.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/websocket/websocket.extractor.d.ts

@@ -0,0 +1,10 @@
+export declare class WebSocketExtractor {
+    static extract(ws: any, req: any, message: string): {
+        ip: any;
+        message: string;
+        raw: {
+            ws: any;
+            req: any;
+        };
+    };
+}