neuralos 3.2.13 → 3.2.15

package/plugins/mitmproxy-bridge/index.mjs

@@ -0,0 +1,256 @@
+/**
+ * mitmproxy-bridge — mitmproxy traffic capture for RTerm.
+ *
+ * Two use modes:
+ *   1. Agent self-inspection — capture what the LLM actually sends over the
+ *      wire (verify no secrets leak in prompts, inspect provider requests).
+ *   2. Authorized interception — capture traffic on hosts you administer,
+ *      following the APerf deploy pattern (run on the RTerm host as a sidecar).
+ *
+ * Pure + injectable: process spawning and file reads are injected; command
+ * building, flow parsing, and secret detection are pure and fully testable.
+ */
+
+// --- Pure: build the mitmdump command line ---
+
+export function buildMitmCommand(opts) {
+  const {
+    mode = 'regular',        // regular | reverse
+    listenPort = 8080,
+    upstreamTarget,          // for reverse mode: the upstream host:port
+    flowsFile,               // where to write the flow file
+    filterExpr,              // optional mitmproxy filter expression
+    extraArgs = [],
+  } = opts || {}
+
+  if (!flowsFile) throw new Error('buildMitmCommand needs flowsFile')
+  const args = ['mitmdump']
+
+  if (mode === 'reverse') {
+    if (!upstreamTarget) throw new Error('reverse mode needs upstreamTarget')
+    args.push('--mode', `reverse:${upstreamTarget}`)
+  } else {
+    args.push('--mode', 'regular')
+  }
+  args.push('--listen-port', String(listenPort))
+  args.push('-w', flowsFile)
+  if (filterExpr) args.push('--set', `flow_detail=0`, '--set', `intercept=${filterExpr}`)
+  for (const a of extraArgs) args.push(String(a))
+  return { cmd: 'mitmdump', args }
+}
+
+// --- Pure: parse a mitmproxy flows file (JSON lines from mitmdump --flow-detail) ---
+
+/**
+ * Parse mitmproxy flow records (the JSON array/dump format) into a compact
+ * summary: per-host request counts, methods, status codes, and content types.
+ */
+export function parseFlows(rawFlows) {
+  const summary = {
+    total: 0,
+    byHost: {},
+    byStatus: {},
+    requests: [],
+  }
+
+  let flows = rawFlows
+  if (typeof rawFlows === 'string') {
+    try { flows = JSON.parse(rawFlows) } catch { return { ...summary, error: 'unparseable flows' } }
+  }
+  if (!Array.isArray(flows)) return { ...summary, error: 'flows is not an array' }
+
+  for (const f of flows) {
+    const host = String(f?.request?.host ?? f?.host ?? 'unknown')
+    const method = String(f?.request?.method ?? f?.method ?? '?')
+    const status = f?.response?.status_code ?? f?.status_code
+    const path = String(f?.request?.path ?? f?.path ?? '')
+    const contentType = String(f?.response?.headers?.['content-type'] ?? '')
+
+    summary.total += 1
+    const byHost = summary.byHost[host] || (summary.byHost[host] = { count: 0, methods: {} })
+    byHost.count += 1
+    byHost.methods[method] = (byHost.methods[method] || 0) + 1
+
+    const statusKey = status !== undefined && status !== null ? String(status) : 'no-response'
+    summary.byStatus[statusKey] = (summary.byStatus[statusKey] || 0) + 1
+
+    if (summary.requests.length < 100) {
+      summary.requests.push({ host, method, path: path.slice(0, 120), status: statusKey, contentType: contentType.slice(0, 60) })
+    }
+  }
+
+  return summary
+}
+
+// --- Pure: detect secret-looking content in captured request bodies ---
+
+const SECRET_PATTERNS = [
+  { re: /\bsk-[A-Za-z0-9]{20,}/g, name: 'openai-style-key' },
+  { re: /\bghp_[A-Za-z0-9]{30,}/g, name: 'github-token' },
+  { re: /\bAKIA[A-Z0-9]{16}\b/g, name: 'aws-access-key' },
+  { re: /\bxox[baprs]-[A-Za-z0-9-]{10,}/g, name: 'slack-token' },
+  // JWT: header/payload/signature. Real JWT headers are commonly exactly 20
+  // chars total (17 after the "eyJ" prefix) — {17,} catches those; {20,} was
+  // an FN that missed short-header JWTs.
+  { re: /\beyJ[A-Za-z0-9_-]{17,}\.eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}\b/g, name: 'jwt' },
+  { re: /\b(?:password|passwd|pwd|secret|token|api[_-]?key)\s*[:=]\s*['"]?[^\s'"]{8,}/gi, name: 'credential-assignment' },
+]
+
+export function detectSecrets(text) {
+  const findings = []
+  if (!text || typeof text !== 'string') return findings
+  for (const { re, name } of SECRET_PATTERNS) {
+    const matches = text.match(re)
+    if (matches) {
+      findings.push({
+        kind: name,
+        count: matches.length,
+        // redact: show only a prefix so the secret itself never lands in output
+        preview: matches[0].slice(0, 8) + '…',
+      })
+    }
+  }
+  return findings
+}
+
+// --- Pure: which hosts are allowed to be intercepted ---
+
+export function isHostAllowed(host, allowlist) {
+  if (!Array.isArray(allowlist) || allowlist.length === 0) return false
+  const h = String(host || '').toLowerCase()
+  return allowlist.some((a) => {
+    const pat = String(a || '').toLowerCase()
+    if (pat === h) return true
+    // allow "*.example.com" style suffix matching
+    if (pat.startsWith('*.')) return h.endsWith(pat.slice(1))
+    return false
+  })
+}
+
+// --- Plugin entry ---
+
+export function register(ctx) {
+  const { registerTool, registerPanel, log, spawnProcess } = ctx
+
+  let mitmChild = null
+  let lastSummary = null
+
+  registerTool({
+    name: 'mitm_start',
+    description: 'Start a mitmproxy capture. Mode "regular" listens as an HTTP proxy on listenPort; mode "reverse" forwards to upstreamTarget. Flows are written to a file for later analysis. Only start captures for hosts you are authorized to intercept.',
+    params: {
+      mode: { type: 'string', description: '"regular" (proxy) or "reverse" (forward to upstreamTarget)' },
+      listenPort: { type: 'number', description: 'Port to listen on (default 8080)' },
+      upstreamTarget: { type: 'string', description: 'For reverse mode: host:port to forward to' },
+      allowlist: { type: 'array', description: 'Hosts/patterns authorized for interception, e.g. ["api.example.com", "*.internal"]' },
+    },
+    handler: async (params) => {
+      if (typeof spawnProcess !== 'function') {
+        return { error: 'mitmproxy-bridge requires process spawning, which is not available in this RTerm build.' }
+      }
+      if (mitmChild) {
+        return { error: 'A mitmproxy capture is already running. Stop it with mitm_stop first.' }
+      }
+
+      const mode = params?.mode === 'reverse' ? 'reverse' : 'regular'
+      if (mode === 'reverse' && !params?.upstreamTarget) {
+        return { error: 'reverse mode needs upstreamTarget (host:port).' }
+      }
+      // Governance: an allowlist must be provided — no unbounded interception.
+      const allowlist = Array.isArray(params?.allowlist) ? params.allowlist : []
+      if (mode === 'reverse' && allowlist.length === 0) {
+        return { error: 'reverse mode requires an allowlist of authorized hosts. Unbounded interception is not permitted.' }
+      }
+
+      const fs = await import('node:fs')
+      const os = await import('node:os')
+      const path = await import('node:path')
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mitm-rterm-'))
+      const flowsFile = path.join(dir, 'flows.mitm')
+
+      let plan
+      try {
+        plan = buildMitmCommand({
+          mode,
+          listenPort: params?.listenPort,
+          upstreamTarget: params?.upstreamTarget,
+          flowsFile,
+        })
+      } catch (e) {
+        return { error: e?.message ?? String(e) }
+      }
+
+      log(`[mitmproxy] starting ${mode} capture on :${params?.listenPort ?? 8080} → ${flowsFile}`)
+      try {
+        mitmChild = spawnProcess(plan.cmd, plan.args, { stdio: 'pipe', detached: false })
+      } catch (e) {
+        return { error: `failed to spawn mitmdump: ${e?.message ?? e}. Is mitmproxy installed (pip install mitmproxy / brew install mitmproxy)?` }
+      }
+      if (!mitmChild) return { error: 'spawnProcess returned no child process' }
+
+      return {
+        started: true,
+        mode,
+        listenPort: params?.listenPort ?? 8080,
+        flowsFile,
+        note: mode === 'regular'
+          ? 'Configure clients to use this host as HTTP proxy. Stop with mitm_stop.'
+          : `Point clients at :${params?.listenPort ?? 8080}; traffic forwards to ${params?.upstreamTarget}. Stop with mitm_stop.`,
+      }
+    },
+  })
+
+  registerTool({
+    name: 'mitm_stop',
+    description: 'Stop the running mitmproxy capture and summarize the captured flows.',
+    params: {},
+    handler: async () => {
+      if (!mitmChild) return { error: 'No mitmproxy capture is running.' }
+      try { mitmChild.kill?.() } catch { /* ignore */ }
+      mitmChild = null
+      return { stopped: true }
+    },
+  })
+
+  registerTool({
+    name: 'mitm_flows',
+    description: 'Summarize captured flows from a mitmproxy flow dump: per-host counts, methods, status codes, and secret detection on request bodies. Use mitmdump -nr <flowsFile> --flow-detail 3 to export, or pass pre-parsed flows.',
+    params: {
+      flows: { type: 'array', description: 'Pre-parsed flow records [{request:{host,method,path}, response:{status_code}}]' },
+    },
+    handler: async (params) => {
+      const flows = Array.isArray(params?.flows) ? params.flows : []
+      if (flows.length === 0) {
+        return { error: 'No flows given. Export flows from the capture first (mitmdump -nr <file>) and pass the parsed records.' }
+      }
+      const summary = parseFlows(flows)
+
+      // Secret scan across request paths + any body text present in the records.
+      const textBlob = flows
+        .map((f) => `${f?.request?.path ?? ''} ${typeof f?.request?.body === 'string' ? f.request.body : ''}`)
+        .join('\n')
+        .slice(0, 200_000)
+      const secrets = detectSecrets(textBlob)
+
+      lastSummary = { summary, secrets }
+      log(`[mitmproxy] summarized ${summary.total} flows across ${Object.keys(summary.byHost).length} host(s); ${secrets.length} secret pattern(s) found`)
+      return { summary, secrets }
+    },
+  })
+
+  registerPanel({
+    name: 'mitmproxy-flows',
+    title: 'Traffic Capture',
+    render: async () => {
+      if (!lastSummary) return '<div class="panel-section"><h3>Traffic Capture</h3><p>No flows analyzed yet. Use mitm_start / mitm_flows.</p></div>'
+      const hostRows = Object.entries(lastSummary.summary.byHost)
+        .slice(0, 10)
+        .map(([h, s]) => `<tr><td>${h}</td><td>${s.count}</td></tr>`)
+        .join('')
+      return `<div class="panel-section"><h3>Traffic Capture — ${lastSummary.summary.total} flows</h3>
+        <table><tr><th>host</th><th>requests</th></tr>${hostRows}</table>
+        ${lastSummary.secrets.length ? `<p class="warn">⚠ ${lastSummary.secrets.length} secret pattern(s) detected</p>` : '<p>No secrets detected</p>'}
+      </div>`
+    },
+  })
+}

package/plugins/mitmproxy-bridge/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "mitmproxy-bridge",
+  "version": "1.0.0",
+  "description": "mitmproxy traffic capture for RTerm — agent self-inspection (what the LLM sends over the wire) and authorized interception on administered hosts. Flow summaries + secret-pattern detection on captured bodies.",
+  "entry": "index.mjs",
+  "tools": [
+    "mitm_start",
+    "mitm_stop",
+    "mitm_flows"
+  ],
+  "panels": [
+    "mitmproxy-flows"
+  ],
+  "permissions": [
+    "spawnProcess"
+  ]
+}

package/plugins/netexec-bridge/index.d.mts

@@ -0,0 +1,28 @@
+// netexec-bridge plugin type declarations
+export function register(ctx: any): void
+export function buildNetexecCommand(opts: {
+  protocol: string
+  targets: string
+  action: string
+  extraArgs?: string[]
+  username?: string
+  passwordRef?: string
+  domain?: string
+  timeoutSec?: number
+}): { cmd: string; args: string[] }
+export function validateTargets(targets: string | null | undefined, allowlist: string[] | null | undefined): { ok: boolean; reason?: string; targets?: string[] }
+export function parseNetexecOutput(raw: string | null | undefined): {
+  hosts: Array<{ ip: string; hostname: string; status: string; detail?: string }>
+  authSuccess: Array<{ protocol: string; ip: string; port: number; hostname: string; detail: string; pwned: boolean }>
+  authFailed: Array<{ protocol: string; ip: string; port: number; hostname: string; detail: string }>
+  errors: string[]
+  raw: string
+}
+export function buildSprayPlan(opts: {
+  targets: string
+  usernames: string[]
+  attemptsPerUser?: number
+  delayMs?: number
+  jitterMs?: number
+}): { targets: string; steps: Array<{ username: string; attempt: number; waitBeforeMs: number }>; totalAttempts: number; note: string }
+export default any

package/plugins/netexec-bridge/index.mjs

@@ -0,0 +1,325 @@
+/**
+ * netexec-bridge — NetExec external attack-simulation for RTerm.
+ *
+ * Complements rmagent (which watches FROM the boxes) by testing FROM the
+ * outside: credential validation, SMB/LDAP enumeration, spray simulation.
+ * The purple-team loop: NetExec stages an external attack, rmagent's attest
+ * must catch the resulting 4625s — the drill then scores both halves.
+ *
+ * GOVERNANCE (non-negotiable):
+ *   - Target allowlist required on every call. No unbounded scanning.
+ *   - Targets must be hosts the operator administers (same rule as rmagent).
+ *   - Credential sprays are rate-limited and jittered by default.
+ *   - The plugin never stores credentials; they resolve from the vault/env.
+ *
+ * Pure + injectable: process spawning injected; command building and output
+ * parsing are pure and fully testable.
+ */
+
+// --- Pure: build the netexec command line ---
+
+export function buildNetexecCommand(opts) {
+  const {
+    protocol,        // smb | ldap | winrm | mssql | ssh | ftp | rdp | wmi
+    targets,         // string: CIDR, range, or comma-separated hosts
+    action,          // netexec subcommand: users, groups, shares, --sam, etc.
+    extraArgs = [],
+    username,
+    passwordRef,     // vault key — never the password itself
+    domain,
+    timeoutSec = 120,
+  } = opts || {}
+
+  if (!protocol) throw new Error('buildNetexecCommand needs a protocol (smb, ldap, winrm, ...)')
+  if (!targets) throw new Error('buildNetexecCommand needs targets')
+  if (!action) throw new Error('buildNetexecCommand needs an action')
+
+  const args = ['netexec', protocol, String(targets)]
+  if (username) args.push('-u', String(username))
+  // password resolves at runtime from the vault — we pass an env var name
+  if (passwordRef) args.push('-p', `env:${passwordRef}`)
+  if (domain) args.push('-d', String(domain))
+  args.push('--timeout', String(timeoutSec))
+  const actionStr = String(action)
+  if (actionStr.startsWith('--')) args.push(actionStr)
+  else args.push(actionStr)
+  for (const a of extraArgs) args.push(String(a))
+
+  return { cmd: 'netexec', args }
+}
+
+// --- Pure: validate targets against the authorized allowlist ---
+
+export function validateTargets(targets, allowlist) {
+  if (!targets || typeof targets !== 'string') {
+    return { ok: false, reason: 'targets must be a string (CIDR, range, or comma-separated hosts)' }
+  }
+  if (!Array.isArray(allowlist) || allowlist.length === 0) {
+    return { ok: false, reason: 'an authorized target allowlist is required — unbounded scanning is not permitted' }
+  }
+
+  const requested = targets.split(',').map((t) => t.trim()).filter(Boolean)
+  const allowedSet = new Set(allowlist.map((a) => String(a).trim()))
+  const denied = []
+
+  for (const t of requested) {
+    // exact host match
+    if (allowedSet.has(t)) continue
+    // CIDR membership: allowlist entry is a CIDR and target is a bare IP
+    const inCidr = allowlist.some((a) => {
+      const cidr = String(a).trim()
+      if (!cidr.includes('/')) return false
+      return ipInCidr(t, cidr)
+    })
+    if (inCidr) continue
+    denied.push(t)
+  }
+
+  if (denied.length > 0) {
+    return { ok: false, reason: `target(s) not in the authorized allowlist: ${denied.join(', ')}` }
+  }
+  return { ok: true, targets: requested }
+}
+
+function ipInCidr(ip, cidr) {
+  const [base, bitsStr] = cidr.split('/')
+  const bits = Number(bitsStr)
+  if (!Number.isInteger(bits) || bits < 0 || bits > 32) return false
+  const toInt = (s) => {
+    const parts = s.split('.').map(Number)
+    if (parts.length !== 4 || parts.some((p) => !Number.isInteger(p) || p < 0 || p > 255)) return null
+    return ((parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]) >>> 0
+  }
+  const ipInt = toInt(ip)
+  const baseInt = toInt(base)
+  if (ipInt === null || baseInt === null) return false
+  if (bits === 0) return true
+  const mask = (0xFFFFFFFF << (32 - bits)) >>> 0
+  return (ipInt & mask) === (baseInt & mask)
+}
+
+// --- Pure: parse netexec output ---
+
+/**
+ * netexec prints lines like:
+ *   SMB  192.168.1.10  445  HOSTNAME  [+] hostname\user (Pwn3d!)
+ *   SMB  192.168.1.11  445  HOSTNAME2 [-] hostname\user:BADPW
+ * Parse into hosts + auth results.
+ */
+export function parseNetexecOutput(raw) {
+  const result = {
+    hosts: [],
+    authSuccess: [],
+    authFailed: [],
+    errors: [],
+    raw: typeof raw === 'string' ? raw.slice(0, 5000) : '',
+  }
+
+  if (typeof raw !== 'string') return result
+  const lines = raw.split('\n')
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+
+    // Host status line: PROTOCOL  ip  port  hostname  [status]
+    const m = trimmed.match(/^(\w+)\s+(\S+)\s+(\d+)\s+(\S+)\s+(.*)$/)
+    if (!m) {
+      if (/error|failed to|traceback/i.test(trimmed)) result.errors.push(trimmed.slice(0, 200))
+      continue
+    }
+
+    const [, proto, ip, port, hostname, rest] = m
+    const entry = { protocol: proto, ip, port: Number(port), hostname, detail: rest.slice(0, 200) }
+
+    if (/\[\+\]/.test(rest)) {
+      result.authSuccess.push({ ...entry, pwned: /\(Pwn3d!?\)/.test(rest) })
+      result.hosts.push({ ip, hostname, status: 'auth-ok' })
+    } else if (/\[-\]/.test(rest)) {
+      result.authFailed.push(entry)
+      result.hosts.push({ ip, hostname, status: 'auth-failed' })
+    } else if (/\[\*\]/.test(rest)) {
+      result.hosts.push({ ip, hostname, status: 'info', detail: rest.slice(0, 120) })
+    } else {
+      result.hosts.push({ ip, hostname, status: 'unknown' })
+    }
+  }
+
+  return result
+}
+
+// --- Pure: build a spray plan (rate-limited, jittered) ---
+
+export function buildSprayPlan(opts) {
+  const {
+    targets,
+    usernames,       // array of usernames to try
+    attemptsPerUser = 1,
+    delayMs = 5000,  // between attempts — slow by default
+    jitterMs = 2000,
+  } = opts || {}
+
+  if (!Array.isArray(usernames) || usernames.length === 0) {
+    throw new Error('buildSprayPlan needs usernames')
+  }
+  if (!targets) throw new Error('buildSprayPlan needs targets')
+
+  const plan = []
+  for (const user of usernames) {
+    for (let i = 0; i < Math.max(1, attemptsPerUser); i++) {
+      const jitter = Math.floor(Math.random() * Math.max(0, jitterMs))
+      plan.push({
+        username: String(user),
+        attempt: i + 1,
+        waitBeforeMs: delayMs + jitter,
+      })
+    }
+  }
+  return {
+    targets: String(targets),
+    steps: plan,
+    totalAttempts: plan.length,
+    note: `Spray plan: ${plan.length} attempt(s) across ${usernames.length} user(s), ≥${delayMs}ms between attempts (jitter ${jitterMs}ms). This is a SLOW spray by design — verify rmagent attest catches the 4625s.`,
+  }
+}
+
+// --- Plugin entry ---
+
+export function register(ctx) {
+  const { registerTool, registerTrigger, registerPanel, log, spawnProcess } = ctx
+
+  let lastResult = null
+
+  const runNetexec = async (plan) => {
+    if (typeof spawnProcess !== 'function') {
+      return { error: 'netexec-bridge requires process spawning, which is not available in this RTerm build.' }
+    }
+    return await new Promise((resolve) => {
+      let stdout = ''
+      let stderr = ''
+      let child
+      try {
+        child = spawnProcess(plan.cmd, plan.args, { stdio: 'pipe' })
+      } catch (e) {
+        resolve({ error: `failed to spawn netexec: ${e?.message ?? e}. Install with: pip install netexec` })
+        return
+      }
+      if (!child || typeof child.on !== 'function') {
+        resolve({ error: 'spawnProcess returned no child process' })
+        return
+      }
+      let settled = false
+      const settle = (v) => { if (!settled) { settled = true; resolve(v) } }
+      child.stdout?.on?.('data', (d) => { stdout += String(d) })
+      child.stderr?.on?.('data', (d) => { stderr += String(d) })
+      child.on('error', (e) => settle({ error: `netexec spawn error: ${e?.message ?? e}` }))
+      child.on('close', (code) => settle({ code, stdout, stderr }))
+      const t = setTimeout(() => {
+        try { child.kill?.() } catch { /* ignore */ }
+        settle({ error: 'netexec timed out', stdout, stderr })
+      }, 300_000)
+      child.on('close', () => clearTimeout(t))
+    })
+  }
+
+  registerTool({
+    name: 'netexec_check',
+    description: 'Run a NetExec check against authorized targets (credential validation, enumeration). Targets MUST be in the authorized allowlist — the same hosts you administer. Results parse into per-host auth outcomes; successful auths are findings.',
+    params: {
+      protocol: { type: 'string', description: 'smb | ldap | winrm | mssql | ssh | ftp | rdp | wmi' },
+      targets: { type: 'string', description: 'Target hosts (comma-separated IPs or a CIDR). Must be within the authorized allowlist.' },
+      action: { type: 'string', description: 'NetExec action: users, groups, shares, --sam, --users, etc.' },
+      allowlist: { type: 'array', description: 'Authorized target hosts/CIDRs. REQUIRED — no unbounded scanning.' },
+      username: { type: 'string', description: 'Username to test' },
+      passwordRef: { type: 'string', description: 'Vault key holding the password (never the password itself)' },
+      domain: { type: 'string', description: 'Optional domain' },
+    },
+    handler: async (params) => {
+      const { protocol, targets, action } = params || {}
+      const allowlist = Array.isArray(params?.allowlist) ? params.allowlist : []
+
+      // Governance gate FIRST.
+      const check = validateTargets(targets, allowlist)
+      if (!check.ok) {
+        return { error: `Authorization failed: ${check.reason}. Only test hosts you administer.` }
+      }
+
+      let plan
+      try {
+        plan = buildNetexecCommand({
+          protocol, targets, action,
+          username: params?.username,
+          passwordRef: params?.passwordRef,
+          domain: params?.domain,
+        })
+      } catch (e) {
+        return { error: e?.message ?? String(e) }
+      }
+
+      log(`[netexec] ${protocol} ${action} against ${check.targets.length} authorized target(s)`)
+      const run = await runNetexec(plan)
+      if (run?.error) return { error: run.error, stderr: run.stderr?.slice(0, 400) }
+
+      const parsed = parseNetexecOutput(run.stdout)
+      lastResult = parsed
+
+      log(`[netexec] ${parsed.hosts.length} host(s), ${parsed.authSuccess.length} auth success, ${parsed.authFailed.length} auth failed`)
+      return {
+        hosts: parsed.hosts,
+        authSuccess: parsed.authSuccess,
+        authFailed: parsed.authFailed,
+        errors: parsed.errors,
+        note: parsed.authSuccess.length > 0
+          ? '⚠ Successful authentication found — treat as a finding and verify rmagent attest saw the corresponding logons.'
+          : 'No successful authentications.',
+      }
+    },
+  })
+
+  registerTool({
+    name: 'netexec_spray_plan',
+    description: 'Build a rate-limited, jittered credential-spray plan (does NOT execute it). Returns the step schedule to review before running via netexec_check. Slow by design so rmagent attest can catch the 4625 pattern.',
+    params: {
+      targets: { type: 'string', description: 'Target hosts (must be authorized)' },
+      usernames: { type: 'array', description: 'Usernames to try' },
+      attemptsPerUser: { type: 'number', description: 'Attempts per username (default 1)' },
+    },
+    handler: async (params) => {
+      try {
+        const plan = buildSprayPlan({
+          targets: params?.targets,
+          usernames: params?.usernames,
+          attemptsPerUser: params?.attemptsPerUser,
+        })
+        return plan
+      } catch (e) {
+        return { error: e?.message ?? String(e) }
+      }
+    },
+  })
+
+  registerTrigger({
+    name: 'netexec_auth_success',
+    description: 'Fires when a NetExec check finds a successful authentication on an authorized target. Use for incident + rmagent correlation playbooks.',
+    match: (event) => {
+      if (event?.source !== 'netexec') return false
+      return Array.isArray(event?.authSuccess) && event.authSuccess.length > 0
+    },
+    action: 'run-playbook',
+  })
+
+  registerPanel({
+    name: 'netexec-results',
+    title: 'NetExec',
+    render: async () => {
+      if (!lastResult) return '<div class="panel-section"><h3>NetExec</h3><p>No check run yet. Use netexec_check.</p></div>'
+      const rows = lastResult.hosts.slice(0, 15)
+        .map((h) => `<tr><td>${h.ip}</td><td>${h.hostname}</td><td>${h.status}</td></tr>`)
+        .join('')
+      return `<div class="panel-section"><h3>NetExec — ${lastResult.hosts.length} host(s)</h3>
+        <table><tr><th>ip</th><th>hostname</th><th>status</th></tr>${rows}</table>
+        ${lastResult.authSuccess.length ? `<p class="warn">⚠ ${lastResult.authSuccess.length} successful auth(s)</p>` : ''}
+      </div>`
+    },
+  })
+}

package/plugins/netexec-bridge/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "netexec-bridge",
+  "version": "1.0.0",
+  "description": "NetExec external attack-simulation for RTerm — credential validation, SMB/LDAP enumeration, and rate-limited spray simulation against authorized targets. Complements rmagent (inside view) with the outside view; closes the purple-team loop.",
+  "entry": "index.mjs",
+  "tools": [
+    "netexec_check",
+    "netexec_spray_plan"
+  ],
+  "triggers": [
+    "netexec_auth_success"
+  ],
+  "panels": [
+    "netexec-results"
+  ],
+  "permissions": [
+    "spawnProcess",
+    "readLedger:incidents"
+  ]
+}

package/plugins/promptfoo-redteam/index.d.mts

@@ -0,0 +1,15 @@
+// promptfoo-redteam plugin type declarations
+export function register(ctx: any): void
+export function buildPromptfooConfig(opts: {
+  providers: Array<{ name: string; model: string; baseUrl?: string; apiKeyRef?: string }>
+  tests: Array<{ vars: { prompt: string }; assert?: any[] }>
+  description?: string
+}): { description: string; prompts: string[]; providers: any[]; tests: any[] }
+export function builtinRedteamTests(): Array<{ description: string; vars: { prompt: string }; assert: any[] }>
+export function parsePromptfooResults(raw: unknown): {
+  summary: { total: number; passed: number; failed: number; errors: number; byProvider: Record<string, { total: number; passed: number; failed: number }> }
+  findings: Array<{ severity: string; category: string; provider: string; test: string; score: number; message: string }>
+  error?: string
+}
+export function redteamVerdict(summary: { total: number; passed?: number; failed?: number; errors?: number } | null | undefined): string
+export default any