pwn 0.5.739 → 0.5.741

data/lib/pwn/ai/agent/task_dag.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+require 'fileutils'
+require 'time'
+require 'securerandom'
+
+module PWN
+  module AI
+    module Agent
+      # Planner/executor split: YAML task DAGs with per-step checkpoints.
+      module TaskDAG
+        ROOT = File.join(Dir.home, '.pwn', 'runs')
+
+        public_class_method def self.required_bins
+          []
+        end
+
+        # Emit a YAML-serializable DAG with zero tool side effects.
+        public_class_method def self.plan(opts = {})
+          request = opts[:request].to_s
+          raise 'ERROR: request is required' if request.strip.empty?
+
+          steps = Array(opts[:steps])
+          steps = infer_steps(request: request) if steps.empty?
+          {
+            version: 1,
+            request: request,
+            steps: steps.map { |step| normalize_step(step: step) }
+          }
+        end
+
+        # Run an approved DAG; completed checkpoints are skipped on resume.
+        public_class_method def self.execute(opts = {})
+          root = opts[:root] || ROOT
+          run_id = (opts[:run_id] || SecureRandom.hex(8)).to_s
+          dir = File.join(root, run_id)
+          FileUtils.mkdir_p(dir)
+          dag = load_dag(opts.merge(dir: dir))
+          File.write(File.join(dir, 'dag.yaml'), YAML.dump(JSON.parse(JSON.generate(dag)))) unless File.file?(File.join(dir, 'dag.yaml'))
+          File.write(File.join(dir, 'run_id'), run_id)
+          done = load_done(dir: dir)
+          steps = Array(dag['steps'] || dag[:steps]).map { |step| normalize_step(step: step) }
+          results = []
+          remaining = steps.reject { |step| done[step['id']] }
+          until remaining.empty?
+            ready = remaining.select { |step| Array(step['dependencies']).all? { |need| done[need] } }
+            raise ArgumentError, 'task DAG deadlock or missing dependencies' if ready.empty?
+
+            ready.each do |step|
+              remaining.delete(step)
+              row = run_step(step: step, dir: dir)
+              done[step['id']] = true
+              results << row
+              persist_checkpoint(dir: dir, step: step, row: row)
+              return { run_id: run_id, dir: dir, results: results, halted: step['id'] } if opts[:halt_after].to_s == step['id']
+            end
+          end
+          { run_id: run_id, dir: dir, results: results, ok: results.all? { |row| row[:ok] != false } }
+        end
+
+        # Resume a checkpointed run, skipping completed steps.
+        public_class_method def self.resume(opts = {})
+          execute(opts)
+        end
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        public_class_method def self.help
+          puts "USAGE:
+            # List host binaries this module expects to be installed.
+            #{self}.required_bins
+
+            # Emit a YAML-serializable DAG with zero tool side effects.
+            #{self}.plan(
+              request: 'required - operator request to decompose',
+              steps: 'optional - Array of step hashes; inferred from the request when omitted'
+            )
+
+            # Run an approved DAG; completed checkpoints are skipped on resume.
+            #{self}.execute(
+              dag: 'optional - Hash DAG; required unless path or run_id is set',
+              path: 'optional - YAML DAG path',
+              run_id: 'optional - existing run to resume; generated when omitted',
+              root: 'optional - runs directory; defaults to ~/.pwn/runs',
+              halt_after: 'optional - step id used by tests to stop after a checkpoint'
+            )
+
+            # Resume a checkpointed run, skipping completed steps.
+            #{self}.resume(
+              run_id: 'required - run id previously returned by execute',
+              root: 'optional - runs directory; defaults to ~/.pwn/runs'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
+        end
+
+        private_class_method def self.infer_steps(opts = {})
+          parts = opts[:request].to_s.split(/\s+then\s+|;\s*|\n+/i).map(&:strip).reject(&:empty?)
+          parts = [opts[:request].to_s.strip] if parts.empty?
+          prev = nil
+          parts.each_with_index.map do |clause, idx|
+            id = "s#{idx + 1}"
+            tool, args = map_clause(clause: clause)
+            step = {
+              'id' => id,
+              'tool' => tool,
+              'args' => args,
+              'side_effect' => side_effect_tier(tool: tool, args: args),
+              'dependencies' => prev ? [prev] : []
+            }
+            prev = id
+            step
+          end
+        end
+
+        private_class_method def self.map_clause(opts = {})
+          clause = opts[:clause].to_s
+          case clause
+          when /\bnmap\b|\bnmap_scan\b/i
+            ['nmap_scan', { 'xml' => clause }]
+          when /\bnuclei\b/i
+            ['nuclei_scan', { 'target' => clause }]
+          when /\b(pwn_eval|ruby)\b/i
+            ['pwn_eval', { 'code' => clause }]
+          else
+            ['shell', { 'command' => clause }]
+          end
+        end
+
+        private_class_method def self.side_effect_tier(opts = {})
+          tool = opts[:tool].to_s
+          args = opts[:args] || {}
+          payload = args['command'] || args[:command] || args['code'] || args[:code] || JSON.generate(args)
+          kind = PWN::Plugins::AISandbox.classify(payload: payload, side_effect: opts[:side_effect])
+          case kind.to_s
+          when 'write' then 'destructive'
+          when 'network' then 'active_scan'
+          else
+            tool.match?(/scan|nuclei|nmap|fuzz/) ? 'active_scan' : 'read_only'
+          end
+        end
+
+        private_class_method def self.normalize_step(opts = {})
+          step = opts[:step]
+          step = step.transform_keys(&:to_s) if step.is_a?(Hash)
+          raise ArgumentError, 'each step needs id, tool, and args' unless step.is_a?(Hash)
+
+          args = step['args'] || {}
+          args = args.transform_keys(&:to_s) if args.is_a?(Hash)
+          {
+            'id' => step['id'].to_s,
+            'tool' => step['tool'].to_s,
+            'args' => args,
+            'side_effect' => (step['side_effect'] || side_effect_tier(tool: step['tool'], args: args)).to_s,
+            'dependencies' => Array(step['dependencies']).map(&:to_s)
+          }
+        end
+
+        private_class_method def self.load_dag(opts = {})
+          if opts[:dag]
+            dag = opts[:dag]
+            return dag.transform_keys(&:to_s) if dag.is_a?(Hash)
+
+            return dag
+          end
+          path = opts[:path].to_s
+          path = File.join(opts[:dir], 'dag.yaml') if path.empty?
+          raise 'ERROR: dag, path, or an existing run is required' unless File.file?(path)
+
+          YAML.safe_load_file(path)
+        end
+
+        private_class_method def self.load_done(opts = {})
+          path = File.join(opts[:dir], 'checkpoints.jsonl')
+          return {} unless File.file?(path)
+
+          File.readlines(path).each_with_object({}) do |line, acc|
+            row = JSON.parse(line)
+            acc[row['id']] = true if row['status'] == 'completed'
+          rescue JSON::ParserError
+            next
+          end
+        end
+
+        private_class_method def self.persist_checkpoint(opts = {})
+          path = File.join(opts[:dir], 'checkpoints.jsonl')
+          rec = { id: opts[:step]['id'], status: 'completed', at: Time.now.utc.iso8601, result: opts[:row] }
+          File.open(path, 'a') do |file|
+            file.flock(File::LOCK_EX)
+            file.puts(JSON.generate(rec))
+            file.flush
+            file.fsync
+          end
+        end
+
+        private_class_method def self.run_step(opts = {})
+          step = opts[:step]
+          PWN::AI::Agent::Registry.discover
+          raw = PWN::AI::Agent::Dispatch.call(
+            tool_call: { function: { name: step['tool'], arguments: JSON.generate(step['args']) } },
+            scope_path: File.join(opts[:dir], 'absent.yaml')
+          )
+          body = JSON.parse(raw, symbolize_names: true)
+          result = body[:result] || body
+          ok = !result.is_a?(Hash) || result[:error].nil?
+          { id: step['id'], ok: ok, result: result }
+        rescue StandardError => e
+          { id: step['id'], ok: false, error: "#{e.class}: #{e.message}" }
+        end
+      end
+    end
+  end
+end

data/lib/pwn/ai/agent/tool_guard.rb

@@ -8,6 +8,8 @@ require 'time'
 require 'openssl'
 require 'uri'
 require 'base64'
+require 'ripper'
+require 'strscan'
 
 module PWN
   module AI
@@ -59,36 +61,155 @@ module PWN
         end
 
         public_class_method def self.placeholder?(opts = {})
-          return false if opts[:placeholder_ok] == true
-
-          raw = opts[:text].to_s.dup
-          s = raw.dup
-          s.gsub!(/<<[-~]?\s*(['"])(\w+)\1.*?^\2\s*$/m, ' ')
-          s.gsub!(/<<[-~]?\s*(\w+).*?^\1\s*$/m, ' ')
-          return true if s.lines.any? { |ln| ln.match?(/^\s*(?:\.{3}|…)\s*$/) }
-          return true if s.strip.match?(/\A\[\s*(?:\.{3}|…)\s*\]\z/)
-
-          s.gsub!(/'[^']*'/, "''")
-          s.gsub!(/"([^"\\]|\\.)*"/, '""')
-          PLACEHOLDER_RX.match?(s)
+          !placeholder_match(text: opts[:text], language: opts[:language], placeholder_ok: opts[:placeholder_ok]).nil?
+        end
+
+        public_class_method def self.placeholder_match(opts = {})
+          return nil if opts[:placeholder_ok] == true
+
+          raw = opts[:text].to_s.dup.force_encoding(Encoding::UTF_8)
+          return ruby_placeholder_match(text: raw) if opts[:language].to_s == 'ruby'
+
+          s = shell_code_surface(text: raw)
+          found = /(?:\A|[;\n|&()])\s*(?<token>\.{3}|…)\s*(?=\z|[;\n|&()])/.match(s) || /\A\s*\[\s*(?<token>\.{3}|…)\s*\]\s*\z/.match(s)
+          if found
+            index = found.begin(:token)
+            token = found[:token]
+          else
+            found = PLACEHOLDER_RX.match(s)
+            return nil unless found
+
+            token = found[0].strip
+            index = found.begin(0) + found[0].index(token)
+          end
+          offset = s[0...index].bytesize
+          { rule_id: 'payload.placeholder', match: raw.byteslice(offset, token.bytesize), offset: offset }
         rescue StandardError
-          false
+          nil
+        end
+
+        private_class_method def self.ruby_placeholder_match(opts = {})
+          raw = opts[:text]
+          # Parsed ranges and argument forwarding are real Ruby, not elision.
+          return nil if Ripper.sexp(raw)
+
+          lines = raw.lines
+          tokens = Ripper.lex(raw).reject { |_, type, _, _| %i[on_sp on_nl on_ignored_nl on_comment].include?(type) }
+          tokens.each_with_index do |(position, type, text, _), index|
+            next unless %i[on_op on_ident].include?(type)
+
+            marker = text if %w[... …].include?(text)
+            following = tokens[index, 4]
+            marker = '<3dots>' if following.map { |row| row[2] } == ['<', '3', 'dots', '>']
+            next unless marker
+
+            offset = lines.first(position[0] - 1).sum(&:bytesize) + position[1]
+            return { rule_id: 'payload.placeholder', match: marker, offset: offset }
+          end
+          nil
+        end
+
+        # Shlex-style word scanning with quote removal and queued heredocs.
+        # Mask literal bytes, retaining newlines and original byte positions.
+        private_class_method def self.shell_code_surface(opts = {})
+          raw = opts[:text].to_s
+          scanner = StringScanner.new(raw)
+          surface = raw.b.dup
+          pending = []
+          mask = lambda do |start, finish|
+            surface[start...finish] = raw.byteslice(start...finish).b.gsub(/[^\n]/n, '_')
+          end
+          until scanner.eos?
+            next if scanner.scan(/[ \t\r]+/)
+
+            if scanner.scan("\n")
+              pending.each do |delimiter, tabs|
+                until scanner.eos?
+                  start = scanner.pos
+                  line = scanner.scan(/[^\n]*(?:\n|\z)/)
+                  mask.call(start, scanner.pos)
+                  value = line.delete_suffix("\n")
+                  value = value.sub(/\A\t+/, '') if tabs
+                  break if value == delimiter
+                end
+              end
+              pending.clear
+            elsif scanner.peek(1) == '#'
+              start = scanner.pos
+              scanner.scan(/[^\n]*/)
+              mask.call(start, scanner.pos)
+            elsif scanner.peek(3) == '<<<'
+              start = scanner.pos
+              scanner.scan('<<<')
+              scanner.scan(/[ \t]*/)
+              shell_word(scanner: scanner)
+              mask.call(start, scanner.pos)
+            elsif scanner.peek(2) == '<<'
+              start = scanner.pos
+              operator = scanner.scan(/<<-?/)
+              scanner.scan(/[ \t]*/)
+              word = shell_word(scanner: scanner)
+              pending << [word[:text], operator == '<<-'] unless word[:text].empty?
+              mask.call(start, scanner.pos)
+            elsif scanner.scan(/[;|&()<>]/)
+              next
+            else
+              start = scanner.pos
+              word = shell_word(scanner: scanner)
+              mask.call(start, scanner.pos) if word[:quoted]
+            end
+          end
+          surface.force_encoding(raw.encoding)
+        end
+
+        private_class_method def self.shell_word(opts = {})
+          scanner = opts[:scanner]
+          text = +''
+          quoted = false
+          until scanner.eos? || scanner.peek(1).b.match?(/[\s;|&()<>]/n)
+            char = scanner.getch
+            if ["'", '"'].include?(char)
+              quoted = true
+              quote = char
+              until scanner.eos?
+                char = scanner.getch
+                break if char == quote
+
+                char = scanner.getch if char == '\\' && quote == '"' && !scanner.eos?
+                text << char
+              end
+            elsif char == '\\' && !scanner.eos?
+              quoted = true
+              text << scanner.getch
+            else
+              text << char
+            end
+          end
+          { text: text, quoted: quoted }
         end
 
         public_class_method def self.bashism?(opts = {})
+          !bashism_match(text: opts[:text]).nil?
+        end
+
+        public_class_method def self.bashism_match(opts = {})
           surface = shell_syntax_surface(text: opts[:text])
-          return false if surface.to_s.empty?
+          return nil if surface.to_s.empty?
 
-          surface = surface.gsub(/\$\{?RANDOM\}?\b/, '') if surface.match?(/\bRANDOM=/)
-          BASHISM_RX.match?(surface)
+          surface = surface.gsub(/\$\{?RANDOM\}?\b/) { |token| ' ' * token.length } if surface.match?(/\bRANDOM=/)
+          found = BASHISM_RX.match(surface)
+          return nil unless found
+
+          raw = opts[:text].to_s
+          { rule_id: 'payload.shell_syntax', match: raw[found.begin(0), found[0].length], offset: raw[0...found.begin(0)].bytesize }
         rescue StandardError
-          false
+          nil
         end
 
         public_class_method def self.shell_syntax_surface(opts = {})
           s = opts[:text].to_s.dup
-          s.gsub!(/<<[-~]?\s*(['"])(\w+)\1.*?^\2\s*$/m, ' ')
-          s.gsub!(/'[^']*'/, "''")
+          s.gsub!(/<<[-~]?\s*(['"])(\w+)\1.*?^\2\s*$/m) { |body| ' ' * body.length }
+          s.gsub!(/'[^']*'/) { |body| "'#{' ' * (body.length - 2)}'" }
           s
         end
 
@@ -217,13 +338,15 @@ module PWN
 
         public_class_method def self.invalid_payload(opts = {})
           hint = opts[:hint].to_s
-          tok = opts[:offending_token].to_s
+          tok = (opts[:match] || opts[:offending_token]).to_s
           text = opts[:text].to_s
           range = opts[:byte_range]
           if range.nil? && !tok.empty? && !text.empty?
-            idx = text.index(tok)
+            idx = opts[:offset] || text.b.index(tok.b)
             range = [idx, idx + tok.bytesize] if idx
           end
+          remedy = (opts[:remedy] || opts[:suggestion]).to_s
+          remedy = "Correct the payload before retrying. #{hint}" if remedy.empty?
           {
             stdout: '',
             stderr: hint,
@@ -231,10 +354,13 @@ module PWN
             error: 'invalid_payload',
             code: (opts[:code] || 'SYNTAX_DENY').to_s,
             rule_id: (opts[:rule_id] || 'payload').to_s,
+            match: tok.empty? ? nil : tok,
+            offset: range&.first,
+            remedy: remedy,
             offending_token: tok,
             byte_range: range,
             max_payload_bytes: MAX_PAYLOAD_BYTES,
-            suggestion: opts[:suggestion].to_s,
+            suggestion: remedy,
             hint: hint,
             shell: opts[:shell] || shell_name
           }
@@ -631,7 +757,15 @@ module PWN
             # Detect isolated ellipsis placeholders, not inline ranges or prose.
             #{self}.placeholder?(
               text: 'optional - command or payload text to inspect',
-              placeholder_ok: 'optional - true skips denial when the operator opts in'
+              placeholder_ok: 'optional - true skips denial when the operator opts in',
+              language: 'optional - ruby uses Ripper; shell (default) scans quotes and heredocs'
+            )
+
+            # Locate a rejected placeholder in the original decoded payload.
+            #{self}.placeholder_match(
+              text: 'optional - command or payload text to inspect',
+              placeholder_ok: 'optional - true returns no match for intentional literal content',
+              language: 'optional - ruby uses Ripper; shell (default) scans quotes and heredocs'
             )
 
             # Run bashism and return its result
@@ -639,6 +773,11 @@ module PWN
               text: 'optional - text value consumed by #bashism?'
             )
 
+            # Locate unsupported shell syntax in the original decoded payload.
+            #{self}.bashism_match(
+              text: 'optional - shell command to inspect for bash-only constructs'
+            )
+
             # Strip quoted heredocs and single-quoted strings before bash-syntax lint.
             #{self}.shell_syntax_surface(
               text: 'required - command string to lint'
@@ -693,7 +832,10 @@ module PWN
               offending_token: 'optional - exact rejected token span',
               suggestion: 'optional - how to rewrite the payload',
               text: 'optional - original payload used to compute byte_range',
-              byte_range: 'optional - [start, stop] byte offsets of the offending span'
+              byte_range: 'optional - [start, stop] byte offsets of the offending span',
+              match: 'optional - exact matched substring; alias for offending_token',
+              offset: 'optional - zero-based byte offset in the original decoded payload',
+              remedy: 'optional - sanctioned correction; alias for suggestion'
             )
 
             # Build a machine-readable guard denial (SCOPE_DENY, CANARY_DENY, ...).

data/lib/pwn/ai/agent/tools/artifacts.rb

@@ -38,32 +38,62 @@ PWN::AI::Agent::Registry.register(
   toolset: 'sessions',
   schema: {
     name: 'artifact_read',
-    description: 'Page an artifact as text/hex/base64 from offset.',
+    description: 'Read a bounded byte page. Use handle from a spilled tool result, offset and length; follow next_offset until eof. Handle pages default to lossless base64.',
     parameters: {
       type: 'object',
       properties: {
+        handle: { type: 'string' },
         path: { type: 'string' },
-        offset: { type: 'integer' },
-        length: { type: 'integer' },
+        offset: { type: 'integer', minimum: 0 },
+        length: { type: 'integer', minimum: 1 },
         mode: { type: 'string', description: 'text|hex|base64' },
         grep: { type: 'string' },
         ref: { type: 'string' },
         sha256: { type: 'string' }
       },
-      required: %w[path]
+      anyOf: [{ required: %w[handle] }, { required: %w[path] }, { required: %w[ref] }]
     }
   },
   handler: lambda { |args|
     PWN::Plugins::ArtifactRegistry.read_page(
+      handle: args[:handle] || args['handle'],
       path: args[:path] || args['path'] || args[:ref] || args['ref'],
       offset: args[:offset] || args['offset'],
       length: args[:length] || args['length'],
-      mode: args[:mode] || args['mode'],
+      max_length: PWN::AI::Agent::Result.page_length,
+      max_bytes: PWN::AI::Agent::Result.page_length,
+      mode: args[:mode] || args['mode'] || (args[:handle] || args['handle'] ? 'base64' : 'text'),
       grep: args[:grep] || args['grep'],
       sha256: args[:sha256] || args['sha256']
     )
   }
 )
+PWN::AI::Agent::Registry.register(
+  name: 'artifact_grep',
+  toolset: 'sessions',
+  schema: {
+    name: 'artifact_grep',
+    description: 'Search saved tool output by complete binary lines (first match per line, maximum line 64 MiB). Returns bounded previews and byte offsets; resume next_offset until eof, even after empty matches. Use artifact_read for exact bytes.',
+    parameters: {
+      type: 'object',
+      properties: {
+        handle: { type: 'string' },
+        regex: { type: 'string' },
+        offset: { type: 'integer', minimum: 0 }
+      },
+      required: %w[handle regex]
+    }
+  },
+  handler: lambda { |args|
+    PWN::Plugins::ArtifactRegistry.grep(
+      handle: args[:handle] || args['handle'],
+      regex: args[:regex] || args['regex'],
+      offset: args[:offset] || args['offset'],
+      limit: 1,
+      max_bytes: PWN::AI::Agent::Result.page_length
+    )
+  }
+)
 PWN::AI::Agent::Registry.register(
   name: 'artifact_put',
   toolset: 'sessions',

data/lib/pwn/ai/agent/tools/binary_triage.rb

@@ -7,14 +7,18 @@ PWN::AI::Agent::Registry.register(
   toolset: 'pwn',
   schema: {
     name: 'binary_triage',
-    description: 'Triage an ELF/PE/Mach-O binary (format, arch, imports, exports) and spill JSON to ~/.pwn/artifacts.',
+    description: 'Triage an ELF/PE/Mach-O binary into one JSON object: type, arch, linking, NX/PIE/RELRO/canary/CFI, imports/exports, interesting strings, section entropy, packer heuristics. Persists to the artifact store.',
     parameters: {
       type: 'object',
-      properties: { path: { type: 'string', description: 'Filesystem path of the binary.' } },
+      properties: {
+        path: { type: 'string', description: 'Filesystem path of the binary.' },
+        session_id: { type: 'string', description: 'Artifact session id (defaults to triage).' }
+      },
       required: %w[path]
     }
   },
   handler: lambda { |args|
-    PWN::Plugins::BinaryParser.triage(path: args[:path] || args['path'])
+    args = args.transform_keys(&:to_sym)
+    PWN::Plugins::BinaryParser.triage(path: args[:path], session_id: args[:session_id] || args[:session] || 'triage')
   }
 )

data/lib/pwn/ai/agent/tools/browser_goto.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'pwn/ai/agent/registry'
+
+PWN::AI::Agent::Registry.register(
+  name: 'browser_goto',
+  toolset: 'pwn',
+  schema: {
+    name: 'browser_goto',
+    description: 'Navigate a URL and optionally record screenshot, DOM snapshot, and HAR into the artifact store. When title is set, records a finding with pixel and HAR proof in the same call.',
+    parameters: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'HTTP(S) URL to open.' },
+        uri: { type: 'string' },
+        capture: { type: 'boolean', description: 'Spill screenshot, DOM, and HAR (defaults true when title is set).' },
+        title: { type: 'string', description: 'Finding title; records pixel and HAR proof without a second call.' },
+        severity: { type: 'string' },
+        session_id: { type: 'string' },
+        engagement_id: { type: 'string' },
+        html: { type: 'string', description: 'DOM HTML fixture when no live browser is open.' },
+        har: { type: 'string', description: 'HAR JSON fixture when no live capture proxy is attached.' },
+        screenshot: { type: 'string', description: 'PNG path used when no live screenshot is available.' },
+        label: { type: 'string' }
+      }
+    }
+  },
+  handler: lambda { |args|
+    args = args.transform_keys(&:to_sym)
+    PWN::Plugins::TransparentBrowser.goto(args)
+  }
+)

data/lib/pwn/ai/agent/tools/debug_lane.rb

@@ -26,6 +26,29 @@ PWN::AI::Agent::Registry.register(
     )
   }
 )
+PWN::AI::Agent::Registry.register(
+  name: 'gdb_run_to_crash',
+  toolset: 'pwn',
+  schema: {
+    name: 'gdb_run_to_crash',
+    description: 'Run a binary under gdb MI3 until crash and return {signal, pc, fault_addr, exploitability} plus ExploitDev offset from stdin/payload.',
+    parameters: {
+      type: 'object',
+      properties: {
+        binary: { type: 'string' },
+        bin: { type: 'string' },
+        stdin: { type: 'string', description: 'Crashing input bytes.' },
+        payload: { type: 'string' },
+        pwndbg: { type: 'boolean' }
+      },
+      anyOf: [{ required: %w[binary] }, { required: %w[bin] }]
+    }
+  },
+  handler: lambda { |args|
+    args = args.transform_keys(&:to_sym)
+    PWN::Plugins::GDBMI.run_to_crash(binary: args[:binary] || args[:bin], stdin: args[:stdin] || args[:payload], pwndbg: args[:pwndbg])
+  }
+)
 PWN::AI::Agent::Registry.register(
   name: 'binary_diff',
   toolset: 'pwn',