pwn 0.5.737 → 0.5.739

data/spec/lib/pwn/ai/agent/registry_spec.rb

@@ -47,6 +47,56 @@ describe PWN::AI::Agent::Registry do
     expect(names.length).to eq(described_class::CORE_TOOLS.length)
   end
 
+  it 'advertises the MCP broker for a named backend in the normal core-only prompt path' do
+    described_class.discover
+    request = 'Use combo.nation to inspect the menu catalog'
+    enabled = PWN::AI::Agent::Loop.send(:default_interactive_toolsets, request: request)
+    expect(PWN::AI::MCP::ComboNation).not_to receive(:connect)
+    definitions = described_class.definitions(core_only: true, relevance: request, enabled: enabled)
+    tool = definitions.find { |row| row.dig(:function, :name) == 'mcp' }
+    expect(tool).not_to be_nil
+    expect(tool.dig(:function, :description)).to include('combo_nation', 'PWN::AI::MCP::ComboNation', 'menu_catalog')
+  end
+
+  it 'routes MCP names and capabilities without relying on keyword rank or changing unrelated core prompts' do
+    described_class.discover
+    allow(described_class).to receive(:router_enabled?).and_return(true)
+    ['PWN::AI::MCP::ComboNation', 'combo_nation', 'ComboNation', 'combo.nation', 'menu_dial_calibration', 'MCP backends'].each do |query|
+      [true, false].each do |core_only|
+        names = described_class.definitions(core_only: core_only, relevance: query, top_k: 0).map { |row| row.dig(:function, :name) }
+        expect(names).to include('mcp')
+      end
+    end
+    names = described_class.definitions(core_only: true, relevance: 'inspect a local Ruby file').map { |row| row.dig(:function, :name) }
+    expect(names).to eq(described_class::CORE_TOOLS)
+  end
+
+  it 'discovers another MCP client from its metadata and respects explicit toolset exclusion' do
+    described_class.discover
+    client = Module.new
+    %i[connect disconnect list_tools call_tool].each { |method| client.define_singleton_method(method) { |_| {} } }
+    client.const_set(:TOOLS, %w[inspect_widget])
+    stub_const('PWN::AI::MCP::WidgetLab', client)
+    expect(client).not_to receive(:connect)
+    %w[widget_lab inspect_widget].each do |query|
+      tools = described_class.definitions(core_only: true, relevance: query)
+      mcp = tools.find { |row| row.dig(:function, :name) == 'mcp' }
+      expect(mcp.dig(:function, :description)).to include('widget_lab', 'inspect_widget')
+      expect(described_class.definitions(core_only: true, relevance: query, enabled: [])).to eq([])
+      names = described_class.definitions(core_only: true, relevance: query, enabled: ['pwn']).map { |row| row.dig(:function, :name) }
+      expect(names).not_to include('mcp')
+    end
+    expect(described_class.lookup(name: 'mcp').schema[:description]).not_to include('WidgetLab')
+  end
+
+  it 'does not let MCP relevance bypass a failed availability check' do
+    described_class.discover
+    entry = described_class.lookup(name: 'mcp')
+    allow(entry.check).to receive(:call).and_return(false)
+    tools = described_class.definitions(core_only: true, relevance: 'combo.nation')
+    expect(tools.map { |row| row.dig(:function, :name) }).not_to include('mcp')
+  end
+
   it 'applies observed shell and Ruby prerequisites to the existing core tools' do
     described_class.discover
     context = { environment: :local, capabilities: { shell: false, ruby: false } }

data/spec/lib/pwn/ai/agent/tools/mcp_spec.rb

@@ -51,6 +51,37 @@ describe 'PWN::AI::Agent::Tools mcp' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'mcp').toolset).to eq('mcp')
   end
 
+  it 'dispatches the broker advertised for a combo.nation prompt and preserves menu IDs across calls' do
+    registry = PWN::AI::Agent::Registry
+    tools = registry.definitions(core_only: true, relevance: 'Inspect combo.nation menus')
+    schema = tools.find { |tool| tool.dig(:function, :name) == 'mcp' }
+    expect(schema).not_to be_nil
+    fake = start_fake_server
+    # Only replace process spawning; exercise the real protocol client, broker,
+    # schema validation and Dispatch with JSON arguments as returned by a model.
+    allow(PWN::AI::MCP::ComboNation).to receive(:connect).and_wrap_original do |method, opts|
+      expect(opts[:allow_hardware]).not_to eq(true)
+      method.call(opts.merge(reader: fake[:reader], writer: fake[:writer], timeout: 2))
+    end
+    calls = [
+      { action: 'list_tools', backend: 'combo_nation' },
+      { action: 'call_tool', backend: 'combo_nation', name: 'menu_guess', arguments: { option: '5.10' } }
+    ]
+    results = calls.map do |args|
+      JSON.parse(PWN::AI::Agent::Dispatch.call(
+                   scope_policy: { enabled: false },
+                   tool_call: { id: 'mcp-test', type: 'function', function: { name: schema.dig(:function, :name), arguments: JSON.generate(args) } }
+                 ))
+    end
+    expect(results.first.dig('result', 'tools').map { |tool| tool['name'] }).to include('menu_catalog')
+    expect(results.last.dig('result', 'parsed', 'arguments')).to eq('option' => '5.10')
+    expect(results.last.dig('result', 'allow_hardware')).to eq(false)
+    expect(PWN::AI::MCP::ComboNation).to have_received(:connect).once
+  ensure
+    PWN::AI::MCP.reset!
+    fake[:thread].join(2) if fake
+  end
+
   it 'lists MCP backends and drives combo.nation tools through Dispatch-shaped args' do
     entry = PWN::AI::Agent::Registry.lookup(name: 'mcp')
     listed = entry.handler.call(action: 'backends')

data/spec/lib/pwn/ai/agent/tools/sbom_scan_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'PWN::AI::Agent::Tools sbom_scan' do
+  it 'registers sbom_scan' do
+    load '/opt/pwn/lib/pwn/ai/agent/tools/sbom_scan.rb'
+    expect(PWN::AI::Agent::Registry.lookup(name: 'sbom_scan')).not_to be_nil
+  end
+end

data/spec/lib/pwn/corpus_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+
+describe PWN::Corpus do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'resolves a named builtin corpus from cache' do
+    Dir.mktmpdir('corpus') do |dir|
+      stub_const('PWN::Corpus::ROOT', dir)
+      path = described_class.get(name: :fuzz_short, offline: true)
+      expect(File.read(path)).to include('../')
+      expect(described_class.get(name: :fuzz_short, offline: true)).to eq(path)
+    end
+  end
+end

data/spec/lib/pwn/engagement_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+
+describe PWN::Engagement do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'persists host state and requires override for out-of-scope targets' do
+    Dir.mktmpdir('eng') do |dir|
+      stub_const('PWN::AI::Agent::Engagement::ROOT', dir)
+      stub_const('PWN::AI::Agent::Engagement::ACTIVE_FILE', File.join(dir, 'active'))
+      described_class.open(name: 'lab', scope_cidrs: ['10.0.0.0/8'])
+      described_class.record_host(host: '10.1.2.3', ports: [22], notes: ['ssh'])
+      expect(described_class.hosts.values.first[:ports]).to include(22)
+      expect(described_class.warn_unless_in_scope(host: '8.8.8.8')[:override_required]).to eq(true)
+      described_class.record_host(host: '8.8.8.8', ports: [53], override: true)
+      expect(described_class.hosts.values.map { |row| row[:host] }).to include('8.8.8.8')
+    end
+  end
+end

data/spec/lib/pwn/plugins/debugger_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+describe PWN::Plugins::Debugger do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'recovers a cyclic offset without parsing gdb text' do
+    pattern = described_class.cyclic(length: 200)
+    slice = pattern[80, 4]
+    expect(described_class.cyclic_find(value: slice, length: 200)).to eq(80)
+    expect(described_class.to_pwntools_offsets(value: slice, length: 200)[:offset]).to eq(80)
+  end
+
+  it 'parses MI register values into a hash' do
+    row = described_class.send(:parse_mi, raw: '^done,register-values=[{number="16",name="rip",value="0x41414141"}]')
+    expect(row[:ok]).to eq(true)
+    expect(row[:registers]['rip']).to eq('0x41414141')
+  end
+end

data/spec/lib/pwn/plugins/handler_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'socket'
+
+describe PWN::Plugins::Handler do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'generates a reverse shell payload without Metasploit' do
+    row = described_class.generate(kind: 'rev_sh', host: '127.0.0.1', port: 4444)
+    expect(row[:payload]).to include('127.0.0.1')
+    expect(row[:payload]).to include('4444')
+  end
+
+  it 'generates bind python and powershell payloads' do
+    expect(described_class.generate(kind: 'bind_python', port: 5555)[:payload]).to include('5555')
+    expect(described_class.generate(kind: 'bind_powershell', port: 5555)[:payload]).to include('GetStream')
+  end
+end

data/spec/lib/pwn/plugins/redb_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+describe PWN::Plugins::REDB do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'answers who calls strcpy from cache on a second open' do
+    Dir.mktmpdir('redb') do |dir|
+      stub_const('PWN::Plugins::REDB::ROOT', File.join(dir, 'redb'))
+      src = File.join(dir, 'x.c')
+      bin = File.join(dir, 'x')
+      File.write(src, "#include <string.h>\nvoid caller(void){ char b[8]; strcpy(b, \"x\"); }\nint main(void){ caller(); return 0; }\n")
+      system('cc', '-O0', '-g', '-fno-builtin', '-fno-inline', '-o', bin, src)
+      described_class.open(bin: bin)
+      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      described_class.open(bin: bin)
+      xrefs = described_class.xrefs_to(bin: bin, sym: 'strcpy')
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+      expect(elapsed).to be < 1.0
+      expect(xrefs).to be_an(Array)
+      expect(xrefs.map { |row| row['dst'] || row[:dst] }).to include('strcpy')
+    end
+  end
+end

data/spec/lib/pwn/plugins/repl_spec.rb

@@ -8,12 +8,18 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       described_class,
       described_class::ASM,
       described_class::AI,
-      described_class::IRC,
       described_class::Mesh,
       described_class::Vault
     ].map { |mod| File.read(mod.method(:add_commands).source_location.first) }.uniq.join("\n")
   end
 
+  it 'does not register pwn-irc or define REPL::IRC' do
+    described_class.add_commands
+    expect(Pry::Commands.find_command('pwn-irc')).to be_nil
+    expect(defined?(PWN::Plugins::REPL::IRC)).to be_nil
+    expect(PWN::Plugins::IRC).to be_a(Module)
+  end
+
   describe 'ai.memory pinned engagement block' do
     it 'handles dotted commands locally in AI mode and registers the Pry command' do
       described_class.add_commands

data/spec/lib/pwn/plugins/sbom_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Plugins::SBOM do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'normalizes grype JSON into package/cve rows' do
+    json = { 'matches' => [{ 'artifact' => { 'name' => 'openssl', 'version' => '1.1.1' },
+                             'vulnerability' => { 'id' => 'CVE-2024-0001', 'severity' => 'HIGH', 'fix' => { 'versions' => ['1.1.1w'] } } }] }
+    allow(Open3).to receive(:capture2).and_return([JSON.generate(json), instance_double(Process::Status, success?: true)])
+    allow(PWN::Plugins::PreflightChecker).to receive(:bin?).and_return(true)
+    out = described_class.scan(path_or_image: '/tmp/lock', engine: 'grype')
+    expect(out[:vulns].first).to include(package: 'openssl', cve: 'CVE-2024-0001', severity: 'high', fix_version: '1.1.1w')
+  end
+end