fase(6): fuzzing module complete

dist/modules/fuzzing/domain/entities/FuzzResult.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzResult = void 0;
+const Entity_1 = require("../../../../shared/domain/Entity");
+class FuzzResult extends Entity_1.Entity {
+    static create(props, id) {
+        return new FuzzResult({ ...props, detectedAt: new Date() }, id);
+    }
+    static reconstitute(props, id) {
+        return new FuzzResult(props, id);
+    }
+    get sessionId() { return this.props.sessionId; }
+    get stateId() { return this.props.stateId; }
+    get selector() { return this.props.selector; }
+    get payload() { return this.props.payload; }
+    get strategy() { return this.props.strategy; }
+    get anomalyType() { return this.props.anomalyType; }
+    get severity() { return this.props.severity; }
+    get description() { return this.props.description; }
+    get detectedAt() { return this.props.detectedAt; }
+}
+exports.FuzzResult = FuzzResult;

dist/modules/fuzzing/domain/entities/FuzzSession.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzSession = void 0;
+const AggregateRoot_1 = require("../../../../shared/domain/AggregateRoot");
+const Result_1 = require("../../../../shared/domain/Result");
+const FuzzIntensity_1 = require("../value-objects/FuzzIntensity");
+const Seed_1 = require("../value-objects/Seed");
+const FuzzStarted_1 = require("../events/FuzzStarted");
+const FuzzCompleted_1 = require("../events/FuzzCompleted");
+const VulnerabilityDetected_1 = require("../events/VulnerabilityDetected");
+class FuzzSession extends AggregateRoot_1.AggregateRoot {
+    constructor(props, id) {
+        super(props, id);
+    }
+    static reconstitute(props, id) {
+        return new FuzzSession(props, id);
+    }
+    static create(request) {
+        let intensity;
+        try {
+            intensity = FuzzIntensity_1.FuzzIntensity.fromString(request.intensity);
+        }
+        catch (e) {
+            return (0, Result_1.Err)(e.message);
+        }
+        let seed;
+        try {
+            seed = Seed_1.Seed.create(request.seed);
+        }
+        catch (e) {
+            return (0, Result_1.Err)(e.message);
+        }
+        const props = {
+            crawlSessionId: request.crawlSessionId,
+            intensity,
+            seed,
+            status: 'running',
+            actionsExecuted: 0,
+            vulnerabilitiesFound: 0,
+            startedAt: new Date(),
+        };
+        const session = new FuzzSession(props);
+        session.addDomainEvent(new FuzzStarted_1.FuzzStarted(session.id.toString(), {
+            crawlSessionId: request.crawlSessionId,
+            intensity: request.intensity,
+            seed: request.seed,
+        }));
+        return (0, Result_1.Ok)(session);
+    }
+    get crawlSessionId() { return this.props.crawlSessionId; }
+    get intensity() { return this.props.intensity; }
+    get seed() { return this.props.seed; }
+    get status() { return this.props.status; }
+    get actionsExecuted() { return this.props.actionsExecuted; }
+    get vulnerabilitiesFound() { return this.props.vulnerabilitiesFound; }
+    get startedAt() { return this.props.startedAt; }
+    get completedAt() { return this.props.completedAt; }
+    recordVulnerability(result) {
+        this.props = {
+            ...this.props,
+            actionsExecuted: this.props.actionsExecuted + 1,
+            vulnerabilitiesFound: this.props.vulnerabilitiesFound + 1,
+        };
+        this.addDomainEvent(new VulnerabilityDetected_1.VulnerabilityDetected(this.id.toString(), {
+            crawlSessionId: this.props.crawlSessionId,
+            stateId: result.stateId,
+            anomalyType: result.anomalyType,
+            severity: result.severity,
+            selector: result.selector,
+            payload: result.payload,
+            strategy: result.strategy,
+        }));
+    }
+    incrementActions() {
+        this.props = { ...this.props, actionsExecuted: this.props.actionsExecuted + 1 };
+    }
+    complete() {
+        this.props = { ...this.props, status: 'completed', completedAt: new Date() };
+        this.addDomainEvent(new FuzzCompleted_1.FuzzCompleted(this.id.toString(), {
+            crawlSessionId: this.props.crawlSessionId,
+            actionsExecuted: this.props.actionsExecuted,
+            vulnerabilitiesFound: this.props.vulnerabilitiesFound,
+        }));
+    }
+    fail(reason) {
+        this.props = { ...this.props, status: 'failed', completedAt: new Date() };
+        this.addDomainEvent(new FuzzCompleted_1.FuzzCompleted(this.id.toString(), {
+            crawlSessionId: this.props.crawlSessionId,
+            actionsExecuted: this.props.actionsExecuted,
+            vulnerabilitiesFound: this.props.vulnerabilitiesFound,
+            failed: true,
+            reason,
+        }));
+    }
+}
+exports.FuzzSession = FuzzSession;

dist/modules/fuzzing/domain/events/FuzzCompleted.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzCompleted = void 0;
+const crypto_1 = require("crypto");
+class FuzzCompleted {
+    constructor(aggregateId, payload) {
+        this.aggregateId = aggregateId;
+        this.payload = payload;
+        this.eventId = (0, crypto_1.randomUUID)();
+        this.eventName = 'fuzz.completed';
+        this.occurredOn = new Date();
+    }
+}
+exports.FuzzCompleted = FuzzCompleted;

dist/modules/fuzzing/domain/events/FuzzStarted.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzStarted = void 0;
+const crypto_1 = require("crypto");
+class FuzzStarted {
+    constructor(aggregateId, payload) {
+        this.aggregateId = aggregateId;
+        this.payload = payload;
+        this.eventId = (0, crypto_1.randomUUID)();
+        this.eventName = 'fuzz.started';
+        this.occurredOn = new Date();
+    }
+}
+exports.FuzzStarted = FuzzStarted;

dist/modules/fuzzing/domain/events/VulnerabilityDetected.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VulnerabilityDetected = void 0;
+const crypto_1 = require("crypto");
+class VulnerabilityDetected {
+    constructor(aggregateId, payload) {
+        this.aggregateId = aggregateId;
+        this.payload = payload;
+        this.eventId = (0, crypto_1.randomUUID)();
+        this.eventName = 'fuzz.vulnerability_detected';
+        this.occurredOn = new Date();
+    }
+}
+exports.VulnerabilityDetected = VulnerabilityDetected;

dist/modules/fuzzing/domain/ports/IFuzzerEngine.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

dist/modules/fuzzing/domain/value-objects/FuzzIntensity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzIntensity = void 0;
+const ValueObject_1 = require("../../../../shared/domain/ValueObject");
+class FuzzIntensity extends ValueObject_1.ValueObject {
+    static low() { return new FuzzIntensity({ value: 'low' }); }
+    static medium() { return new FuzzIntensity({ value: 'medium' }); }
+    static high() { return new FuzzIntensity({ value: 'high' }); }
+    static fromString(s) {
+        if (!FuzzIntensity.LEVELS.includes(s)) {
+            throw new Error(`Invalid intensity: ${s}. Must be one of: ${FuzzIntensity.LEVELS.join(', ')}`);
+        }
+        return new FuzzIntensity({ value: s });
+    }
+    get value() { return this.props.value; }
+}
+exports.FuzzIntensity = FuzzIntensity;
+FuzzIntensity.LEVELS = ['low', 'medium', 'high'];

dist/modules/fuzzing/domain/value-objects/FuzzPayload.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzPayload = void 0;
+const ValueObject_1 = require("../../../../shared/domain/ValueObject");
+class FuzzPayload extends ValueObject_1.ValueObject {
+    static create(value, strategy) {
+        return new FuzzPayload({ value, strategy });
+    }
+    get value() { return this.props.value; }
+    get strategy() { return this.props.strategy; }
+}
+exports.FuzzPayload = FuzzPayload;

dist/modules/fuzzing/domain/value-objects/FuzzStrategy.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzStrategy = void 0;
+const ValueObject_1 = require("../../../../shared/domain/ValueObject");
+class FuzzStrategy extends ValueObject_1.ValueObject {
+    static empty() { return new FuzzStrategy({ value: 'empty' }); }
+    static oversized() { return new FuzzStrategy({ value: 'oversized' }); }
+    static specialChars() { return new FuzzStrategy({ value: 'special_chars' }); }
+    static typeMismatch() { return new FuzzStrategy({ value: 'type_mismatch' }); }
+    static boundary() { return new FuzzStrategy({ value: 'boundary' }); }
+    static fromString(s) {
+        if (!FuzzStrategy.ALL.includes(s)) {
+            throw new Error(`Invalid fuzz strategy: ${s}`);
+        }
+        return new FuzzStrategy({ value: s });
+    }
+    get value() { return this.props.value; }
+}
+exports.FuzzStrategy = FuzzStrategy;
+FuzzStrategy.ALL = ['empty', 'oversized', 'special_chars', 'type_mismatch', 'boundary'];

dist/modules/fuzzing/domain/value-objects/Seed.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Seed = void 0;
+const ValueObject_1 = require("../../../../shared/domain/ValueObject");
+class Seed extends ValueObject_1.ValueObject {
+    static create(value) {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`Seed must be a non-negative integer, got: ${value}`);
+        }
+        return new Seed({ value });
+    }
+    static fromTimestamp() {
+        return new Seed({ value: Date.now() });
+    }
+    get value() { return this.props.value; }
+}
+exports.Seed = Seed;