pwn 0.5.739 → 0.5.741

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

@@ -2,6 +2,8 @@
 
 require 'spec_helper'
 require 'tmpdir'
+require 'open3'
+require 'fileutils'
 
 describe PWN::Plugins::AFLplusplus do
   it 'should display information for authors' do
@@ -19,4 +21,42 @@ describe PWN::Plugins::AFLplusplus do
       expect(stats[:execs_per_sec] || stats['execs_per_sec']).to eq('1234.5')
     end
   end
+
+  it 'builds an AFL dictionary from interesting binary strings' do
+    Dir.mktmpdir('pwn-fuzz-dict-') do |dir|
+      src = File.join(dir, 't.c')
+      bin = File.join(dir, 't')
+      File.write(src, "#include <stdio.h>\nint main(void) { puts(\"https://fuzz.example/token\"); return 0; }\n")
+      out, status = Open3.capture2e('cc', '-O0', '-o', bin, src)
+      expect(status.success?).to eq(true), out
+      dict = described_class.dictionary_from_binary(path: bin)
+      blob = Array(dict[:tokens] || dict).join("\n")
+      expect(blob).to include('https://fuzz.example/token')
+    end
+  end
+
+  it 'dedups crashes by backtrace hash and hands unique ones to RE triage' do
+    Dir.mktmpdir('pwn-fuzz-dedup-') do |dir|
+      crashes = File.join(dir, 'crashes')
+      FileUtils.mkdir_p(crashes)
+      File.binwrite(File.join(crashes, 'id:000000,sig:11'), 'AAAA')
+      File.binwrite(File.join(crashes, 'id:000001,sig:11'), 'BBBB')
+      File.binwrite(File.join(crashes, 'id:000002,sig:11'), 'CCCC')
+      reports = {
+        'AAAA' => { signal: 'SIGSEGV', pc: '0x401136', fault_addr: '0x401136', backtrace: [{ func: 'vuln' }] },
+        'BBBB' => { signal: 'SIGSEGV', pc: '0x401136', fault_addr: '0x401136', backtrace: [{ func: 'vuln' }] },
+        'CCCC' => { signal: 'SIGABRT', pc: '0x401200', fault_addr: '0x0', backtrace: [{ func: 'abort' }] }
+      }
+      allow(PWN::Plugins::GDBMI).to receive(:run_to_crash) do |opts|
+        reports.fetch(opts[:stdin].to_s)
+      end
+      allow(PWN::Plugins::BinaryParser).to receive(:triage).and_return(file_type: 'elf', protections: { nx: true })
+      allow(PWN::Plugins::ExploitDev).to receive(:from_crash).and_return(offset: 64)
+      row = described_class.crash_triage(out_dir: dir, target: '/bin/true', handoff: true)
+      expect(row[:unique].length).to eq(2)
+      expect(row[:triaged].length).to eq(2)
+      expect(row[:triaged]).to all(include(:backtrace_hash, :crash, :binary_triage))
+      expect(row[:pipeline]).to eq('pwn-re-003')
+    end
+  end
 end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+require 'json'
+require 'tmpdir'
+
+describe PWN::Plugins::AISandbox 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 'denies rm -rf /tmp/fake_root in strict mode without touching disk' do
+    root = '/tmp/fake_root'
+    FileUtils.mkdir_p(root)
+    marker = File.join(root, 'keep')
+    File.write(marker, 'safe')
+    begin
+      out = described_class.exec(kind: :shell, payload: 'rm -rf /tmp/fake_root', mode: 'strict')
+      expect(out[:error].to_s).to match(/sandbox violation/i)
+      expect(File.file?(marker)).to be true
+    ensure
+      FileUtils.rm_rf(root)
+    end
+  end
+
+  it 'denies FileUtils.rm_rf("/tmp/fake_root") in strict mode without touching disk' do
+    root = '/tmp/fake_root'
+    FileUtils.mkdir_p(root)
+    marker = File.join(root, 'keep')
+    File.write(marker, 'safe')
+    begin
+      out = described_class.exec(kind: :ruby, payload: "FileUtils.rm_rf('/tmp/fake_root')", mode: 'strict')
+      expect(out[:error].to_s).to match(/sandbox violation/i)
+      expect(File.file?(marker)).to be true
+    ensure
+      FileUtils.rm_rf(root)
+    end
+  end
+end

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

@@ -12,6 +12,120 @@ describe PWN::Plugins::ArtifactRegistry do
     expect(described_class).to respond_to :help
   end
 
+  describe 'spill' do
+    before do
+      @artifact_dir = Dir.mktmpdir
+      stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(@artifact_dir, 'artifacts'))
+    end
+
+    after do
+      FileUtils.remove_entry(@artifact_dir)
+    end
+
+    it 'stores exact bytes privately under a session and short digest' do
+      bytes = "\x00\xffhello".b
+      stored = described_class.spill(bytes: bytes, session_id: 'session-1')
+      expect(stored).to include(handle: "session-1/#{Digest::SHA256.hexdigest(bytes)[0, 8]}.bin", bytes: bytes.bytesize, sha256: Digest::SHA256.hexdigest(bytes))
+      expect(File.binread(stored[:path])).to eq(bytes)
+      expect(File.stat(stored[:path]).mode & 0o777).to eq(0o600)
+      expect(File.stat(File.dirname(stored[:path])).mode & 0o777).to eq(0o700)
+      expect(File.stat(described_class::ROOT).mode & 0o777).to eq(0o700)
+      expect(described_class.spill(bytes: bytes, session_id: 'session-1')).to eq(stored)
+    end
+
+    it 'pages 50 MiB losslessly with bounded reads and a streaming digest' do
+      bytes = (0..255).to_a.pack('C*') * (50 * 1024 * 1024 / 256)
+      stored = described_class.spill(bytes: bytes, session_id: 'large')
+      expected = Digest::SHA256.hexdigest(bytes)
+      digest = Digest::SHA256.new
+      offset = 0
+      pages = 0
+      loop do
+        page = described_class.read_page(handle: stored[:handle], offset: offset, length: 1_000_000)
+        expect(page[:bytes]).to be <= 2048
+        expect(page).to include(handle: stored[:handle], total_bytes: bytes.bytesize, encoding: 'base64', mode: 'base64')
+        decoded = Base64.strict_decode64(page[:body])
+        digest.update(decoded)
+        offset = page[:next_offset]
+        pages += 1
+        break if page[:eof]
+      end
+      expect(offset).to eq(bytes.bytesize)
+      expect(digest.hexdigest).to eq(expected)
+      puts "artifact paging verified: bytes=#{offset} pages=#{pages} sha256=#{digest.hexdigest}"
+    end
+
+    it 'preserves split UTF-8 bytes, explicit encodings, refs and EOF metadata' do
+      stored = described_class.spill(bytes: 'éabc', session_id: 'text')
+      first = described_class.read_page(handle: stored[:handle], length: 1)
+      expect(Base64.strict_decode64(first[:body])).to eq("\xc3".b)
+      expect(described_class.read_page(ref: stored[:path], offset: 2, length: 99, max_length: 2)).to include(body: 'ab', bytes: 2, eof: false, next_offset: 4)
+      expect(described_class.read_page(path: stored[:path], mode: 'hex', length: 2)).to include(hex: 'c3a9', body: 'c3a9')
+      expect(described_class.read_page(path: stored[:path], mode: 'base64', offset: 99)).to include(body: '', bytes: 0, eof: true, next_offset: 99)
+      expect { described_class.read_page(handle: '../text/12345678.bin') }.to raise_error(ArgumentError)
+      expect { described_class.read_page(path: stored[:path], offset: -1) }.to raise_error(ArgumentError)
+      expect { described_class.read_page(path: stored[:path], sha256: 'bad') }.to raise_error(/sha256 mismatch/)
+    end
+
+    it 'bounds get reads rather than loading the entire file' do
+      stored = described_class.spill(bytes: 'x' * 100_000, session_id: 'get')
+      expect(File).to receive(:binread).with(stored[:path], 65_536).and_call_original
+      expect(described_class.get(path: stored[:path])[:body].bytesize).to eq(65_536)
+    end
+
+    it 'greps complete lines across page boundaries with bounded previews and resumable byte offsets' do
+      bytes = "first\n#{'x' * 2046}BOUNDARY#{'y' * 2_100_000}\nlast\xff\n".b
+      stored = described_class.spill(bytes: bytes, session_id: 'grep')
+      first = described_class.grep(handle: stored[:handle], regex: 'x', limit: 1)
+      expect(first[:matches].first).to include(offset: 6, fragment_offset: 6, bytes: 2048, continued: true)
+      expect(first).to include(next_offset: bytes.index('last'), eof: false, semantics: 'binary_lines')
+      offsets = []
+      cursor = 0
+      loop do
+        result = described_class.grep(handle: stored[:handle], regex: 'last', offset: cursor)
+
+        offsets.concat(result[:matches].map { |match| match[:offset] })
+        expect(result[:next_offset]).to be > cursor
+        cursor = result[:next_offset]
+        break if result[:eof]
+      end
+      expect(offsets).to eq([bytes.index('last')])
+      boundary = described_class.grep(handle: stored[:handle], regex: 'BOUNDARY')
+      expect(boundary[:matches].first[:offset]).to eq(bytes.index('BOUNDARY'))
+      bounded = described_class.grep(handle: stored[:handle], regex: 'BOUNDARY', max_bytes: 32)
+      expect(bounded[:matches].first[:text]).to include('BOUNDARY')
+      expect(bounded[:matches].sum { |hit| hit[:bytes] }).to be <= 32
+      last = described_class.grep(path: stored[:path], regex: 'last', offset: bytes.index('last'))
+      expect(Base64.strict_decode64(last[:matches].first[:text])).to eq("last\xff\n".b)
+    end
+
+    it 'caps grep match counts and regex runtime and rejects invalid regexes' do
+      stored = described_class.spill(bytes: "hit\n" * 100, session_id: 'grep-limit')
+      allow(Regexp).to receive(:new).and_call_original
+      expect(Regexp).to receive(:new).with('hit'.b, Regexp::NOENCODING, timeout: 0.05).and_call_original
+      result = described_class.grep(handle: stored[:handle], regex: 'hit', limit: 999)
+      expect(result[:matches].length).to eq(50)
+      expect(result[:next_offset]).to eq(200)
+      expect { described_class.grep(handle: stored[:handle], regex: '[') }.to raise_error(RegexpError)
+      expect { described_class.grep(handle: stored[:handle], regex: 'hit', offset: -1) }.to raise_error(ArgumentError)
+    end
+
+    it 'interrupts expensive regexes on a giant unterminated line' do
+      stored = described_class.spill(bytes: "#{'a' * 2047}!", session_id: 'timeout')
+      expect { described_class.grep(handle: stored[:handle], regex: '(a+)\\1+$') }.to raise_error(Regexp::TimeoutError)
+    end
+
+    it 'rejects traversal, symlink directories, and short digest collisions' do
+      expect { described_class.spill(bytes: 'x', session_id: '../escape') }.to raise_error(ArgumentError)
+      stored = described_class.spill(bytes: 'x', session_id: 'safe')
+      File.binwrite(stored[:path], 'different')
+      expect { described_class.spill(bytes: 'x', session_id: 'safe') }.to raise_error(/collision/)
+      expect(File.binread(stored[:path])).to eq('different')
+      File.symlink(File.dirname(stored[:path]), File.join(described_class::ROOT, 'link'))
+      expect { described_class.spill(bytes: 'x', session_id: 'link') }.to raise_error(/symlink/)
+    end
+  end
+
   it 'lists artifacts for a session id' do
     Dir.mktmpdir do |dir|
       stub_const('PWN::Plugins::ArtifactRegistry::ROOT', dir)
@@ -28,7 +142,8 @@ describe PWN::Plugins::ArtifactRegistry do
       src = File.join(dir, 'dump.txt')
       File.write(src, "nop\ncall system\nret\n")
       hits = described_class.read_page(path: src, grep: 'call.*system')
-      expect(hits[:matches].first[:text]).to include('call system')
+      expect(hits[:matches].first[:text]).to eq('call system')
+      expect(hits[:matches].first[:line]).to eq(2)
     end
   end
 

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

@@ -12,4 +12,16 @@ describe PWN::Plugins::Assembly do
     help_response = PWN::Plugins::Assembly
     expect(help_response).to respond_to :help
   end
+
+  it 'assemble and disassemble return structured engine output' do
+    asm = described_class.assemble(asm: "nop\nret", arch: 'x86_64')
+    expect(asm).to include(:bytes, :hex, :engine)
+    expect(asm[:bytes].bytesize).to be >= 2
+    expect(%w[keystone metasm]).to include(asm[:engine].to_s)
+    dis = described_class.disassemble(bytes: asm[:bytes], arch: 'x86_64')
+    expect(dis[:insns]).to be_an(Array)
+    blob = dis[:insns].map { |row| "#{row[:mnemonic]} #{row[:op_str]}" }.join(' ')
+    expect(blob).to match(/nop/i)
+    expect(%w[capstone metasm]).to include(dis[:engine].to_s)
+  end
 end

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

@@ -12,4 +12,19 @@ describe PWN::Plugins::BasicAuth do
     help_response = PWN::Plugins::BasicAuth
     expect(help_response).to respond_to :help
   end
+
+  it 'offers recon loot when a service prompts for auth' do
+    Dir.mktmpdir('pwn-basic-auth-') do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      PWN::Plugins::Vault.ingest(
+        text: "username=admin\npassword=hunter2\n",
+        host: 'app.example.test',
+        source: 'recon',
+        where: 'banner:80',
+        engagement: 'lab'
+      )
+      encoded = described_class.encode(host: 'app.example.test', engagement: 'lab', service: 'http')
+      expect(described_class.decode(base64_str: encoded)).to eq('admin:hunter2')
+    end
+  end
 end

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

@@ -25,11 +25,68 @@ describe PWN::Plugins::BinaryParser do
     skip 'no ELF on PATH' unless path
     Dir.mktmpdir do |dir|
       allow(Dir).to receive(:home).and_return(dir)
-      first = described_class.triage(path: path)
+      stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(dir, 'artifacts'))
+      first = described_class.triage(path: path, session_id: 'fixture')
       expect(first).to include(:format, :arch, :protections, :sha256, :sections)
       expect(first[:cached]).to be false
-      second = described_class.triage(path: path)
+      second = described_class.triage(path: path, session_id: 'fixture')
       expect(second[:cached]).to be true
     end
   end
+
+  it 'surfaces mitigations and attack surface for a stripped ELF in one JSON artifact' do
+    Dir.mktmpdir('pwn-triage-') do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(dir, 'artifacts'))
+      source = File.join(dir, 'fixture.c')
+      path = File.join(dir, 'fixture')
+      File.write(source, <<~C)
+        #include <stdio.h>
+        int main(void) {
+          puts("https://example.test/api");
+          puts("/var/lib/pwn/keys");
+          puts("BEGIN RSA PRIVATE KEY");
+          printf("%s %n\\n", "fmt");
+          return 0;
+        }
+      C
+      out, status = Open3.capture2e('cc', '-O0', '-g', '-fstack-protector-all', '-o', path, source)
+      expect(status.success?).to eq(true), out
+      Open3.capture2e('strip', '--strip-all', path)
+      row = described_class.triage(path: path, session_id: 'fixture')
+      expect(row[:file_type] || row[:format]).to match(/elf/i)
+      expect(row[:arch].to_s).not_to be_empty
+      expect(row[:linking].to_s).to match(/dynamic|static/)
+      expect(row[:protections]).to include(:nx, :pie, :relro, :canary, :cfi)
+      expect(row[:protections].values).to all(satisfy { |value| [true, false].include?(value) || value.is_a?(String) })
+      expect(row[:stripped]).to eq(true)
+      expect(Array(row[:imports]).any? { |name| name.to_s.include?('puts') || name.to_s.include?('printf') || name.to_s.include?('libc') }).to eq(true)
+      strings = row[:interesting_strings]
+      blob = JSON.generate(strings)
+      expect(blob).to include('https://example.test/api')
+      expect(blob).to match(%r{/var/lib/pwn/keys})
+      expect(blob).to include('%n')
+      expect(row[:entropy]).to be_a(Hash)
+      expect(row[:entropy].keys).not_to be_empty
+      expect(row[:packer]).to include(:packed, :indicators)
+      expect(row[:handle].to_s).to match(%r{\Afixture/[0-9a-f]{8}\.bin\z})
+      stored = JSON.parse(File.binread(row[:artifact][:path] || File.join(dir, 'artifacts', row[:handle])), symbolize_names: true)
+      expect(stored[:sha256]).to eq(row[:sha256])
+      expect(stored[:protections]).to include(:canary)
+    end
+  end
+
+  it 'elf_resolve maps symbols, GOT, and PLT on a compiled ELF' do
+    Dir.mktmpdir('pwn-elf-resolve-') do |dir|
+      src = File.join(dir, 't.c')
+      path = File.join(dir, 't')
+      File.write(src, "#include <stdio.h>\n#include <stdlib.h>\nint main(void) { puts(\"hi\"); if (0) system(\"x\"); return 0; }\n")
+      out, status = Open3.capture2e('cc', '-O0', '-no-pie', '-o', path, src)
+      expect(status.success?).to eq(true), out
+      row = described_class.elf_resolve(path: path)
+      expect(row[:plt].keys.map(&:to_s)).to include('puts')
+      expect(row[:got].keys.map(&:to_s)).to include('puts')
+      expect(row[:symbols]['main'] || row[:symbols][:main]).to be_a(Integer)
+    end
+  end
 end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tmpdir'
+require 'open3'
 
 describe PWN::Plugins::ExploitDev do
   it 'should display information for authors' do
@@ -43,4 +45,46 @@ describe PWN::Plugins::ExploitDev do
     expect(row).to include(:path)
     expect(row[:symbols]).to be_a(Hash)
   end
+
+  it 'gadgets returns queryable records parsed from ropper/rp-style output' do
+    allow(PWN::Plugins::ROP).to receive(:gadgets).and_return(
+      backend: 'ropper',
+      gadgets: [
+        { address: 0x40101a, gadget: 'pop rdi; ret', regs_clobbered: %w[rdi rsp rip] },
+        { address: 0x40101c, gadget: 'ret', regs_clobbered: %w[rsp rip] }
+      ]
+    )
+    row = described_class.gadgets(path: '/bin/true', filter: 'pop rdi')
+    expect(row[:gadgets]).to be_an(Array)
+    expect(row[:gadgets]).to all(include(:address, :gadget))
+    expect(row[:gadgets].map { |g| g[:gadget] }).to include(a_string_matching(/pop rdi/i))
+  end
+
+  it 'ret2libc builds a packed chain from ELF resolve + pop rdi' do
+    Dir.mktmpdir('pwn-ret2libc-') do |dir|
+      src = File.join(dir, 'vuln.c')
+      bin = File.join(dir, 'vuln')
+      File.write(src, <<~C)
+        #include <stdio.h>
+        #include <stdlib.h>
+        #include <unistd.h>
+        char cmd[] = "echo RET2LIBC_OK";
+        void keep(void) { __asm__ volatile("pop %rdi; ret"); }
+        int main(int argc, char **argv) {
+          char buf[64];
+          (void)argv;
+          if (argc > 100) { system(cmd); keep(); }
+          read(0, buf, 256);
+          return 0;
+        }
+      C
+      out, status = Open3.capture2e('cc', '-O0', '-fno-stack-protector', '-no-pie', '-o', bin, src)
+      expect(status.success?).to eq(true), out
+      chain = described_class.ret2libc(path: bin, offset: 72, extra: 'cmd')
+      expect(chain[:payload].bytesize).to be > 72
+      expect(chain[:system]).to be_a(Integer)
+      expect(chain[:binsh] || chain[:arg]).to be_a(Integer)
+      expect(chain[:pop_rdi]).to be_a(Integer)
+    end
+  end
 end

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

@@ -8,6 +8,7 @@ RSpec.describe PWN::Plugins::Findings do
     @dir = Dir.mktmpdir
     allow(Dir).to receive(:home).and_return(@dir)
     stub_const('PWN::Plugins::Findings::FILE', File.join(@dir, 'findings.jsonl'))
+    stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(@dir, 'artifacts'))
     @evidence = File.join(@dir, 'response.txt')
     File.write(@evidence, 'Local fixture returned the reproducible response.')
   end
@@ -30,6 +31,56 @@ RSpec.describe PWN::Plugins::Findings do
     expect(described_class.report(engagement_id: 'other')).to eq([])
   end
 
+  it 'persists directed enables links and replaces outgoing links durably' do
+    target = described_class.record_structured(finding)
+    source = described_class.record_structured(finding.merge(enables: [target[:id]]))
+    expect(target[:enables]).to eq([])
+    expect(described_class.report.find { |row| row[:id] == source[:id] }[:enables]).to eq([target[:id]])
+    expect(described_class.link(id: source[:id], enables: [])[:enables]).to eq([])
+    expect(described_class.report.find { |row| row[:id] == source[:id] }[:enables]).to eq([])
+  end
+
+  it 'rejects invalid outgoing links and cycles including legacy incoming links without mutation' do
+    a = described_class.record_structured(finding)
+    b = described_class.record_structured(finding.merge(attack_chain_refs: [a[:id]]))
+    other = described_class.record_structured(finding.merge(engagement_id: 'other'))
+    before = File.read(described_class::FILE)
+    [nil, 'bad', [123], ['missing'], [a[:id]], [b[:id], b[:id]], [other[:id]]].each do |enables|
+      expect { described_class.link(id: a[:id], enables: enables) }.to raise_error(ArgumentError)
+    end
+    expect { described_class.link(id: b[:id], enables: [a[:id]]) }.to raise_error(ArgumentError, /cycle/)
+    expect { described_class.record_structured(finding.merge(enables: [b[:id]], attack_chain_refs: [b[:id]])) }.to raise_error(ArgumentError, /cycle/)
+    expect { described_class.record_structured(finding.merge(enables: [other[:id]])) }.to raise_error(ArgumentError, /engagement/)
+    expect { described_class.record_structured(finding.merge(enables: [b[:id], b[:id]])) }.to raise_error(ArgumentError, /duplicate/)
+    expect(File.read(described_class::FILE)).to eq(before)
+  end
+
+  it 'treats empty and default engagement identifiers as the same graph scope' do
+    a = described_class.record_structured(finding.merge(engagement_id: ''))
+    b = described_class.record_structured(finding.merge(engagement_id: 'default', enables: [a[:id]]))
+    c = described_class.record_structured(finding.merge(engagement_id: 'default', attack_chain_refs: [a[:id]]))
+    expect(c[:attack_chain_refs]).to eq([a[:id]])
+    expect(b[:enables]).to eq([a[:id]])
+    expect { described_class.link(id: a[:id], enables: [b[:id]]) }.to raise_error(ArgumentError, /cycle/)
+  end
+
+  it 'links artifact handles to durable evidence hashes, reproduction steps and severity justification' do
+    stored = PWN::Plugins::ArtifactRegistry.spill(bytes: "crash\x00\xff".b, session_id: 'fixture')
+    args = finding.except(:evidence_paths).merge(
+      artifact_handles: [{ handle: stored[:handle], kind: 'crash', label: 'crash.bin' }],
+      severity_justification: 'The fixture leaks data without authentication; no integrity or availability impact demonstrated.',
+      reproduction_steps: ['Start the local fixture.', 'Run the supplied PoC and compare its output.']
+    )
+    row = described_class.record_structured(args)
+    expect(row[:severity_justification]).to eq(args[:severity_justification])
+    expect(row[:reproduction_steps]).to eq(args[:reproduction_steps])
+    evidence = row.fetch(:evidence_artifacts).first
+    expect(evidence).to include(handle: stored[:handle], path: stored[:path], sha256: stored[:sha256], kind: 'crash')
+    expect(File.binread(evidence[:stored])).to eq("crash\x00\xff".b)
+    expect(described_class.report.first[:evidence_artifacts]).to eq(row[:evidence_artifacts])
+    expect(row[:verification_status]).to eq('not_executed')
+  end
+
   it 'flags removed evidence and rejects malformed metrics with trailing tokens' do
     described_class.record_structured(finding)
     File.delete(@evidence)
@@ -38,6 +89,50 @@ RSpec.describe PWN::Plugins::Findings do
     expect { described_class.record_structured(finding.merge(cvss_vector: finding[:cvss_vector].sub('AV:N', 'AV:N:extra'))) }.to raise_error(ArgumentError, /cvss_vector/)
   end
 
+  it 'detects tampering of the durable copy even when the original evidence still matches' do
+    row = described_class.record_structured(finding)
+    stored = row[:evidence_artifacts].first[:stored]
+    File.binwrite(stored, 'corrupted stored bytes')
+    expect(described_class.evidence_verify(engagement_id: 'fixture')).to include(ok: false, mismatches: include(stored))
+  end
+
+  it 'refuses a symlink masquerading as a durable evidence copy' do
+    sha = Digest::SHA256.file(@evidence).hexdigest
+    stored = File.join(@dir, '.pwn', 'engagements', 'fixture', 'evidence', sha)
+    FileUtils.mkdir_p(File.dirname(stored))
+    File.symlink(@evidence, stored)
+    expect { described_class.record_structured(finding) }.to raise_error(ArgumentError, /symlink/)
+    expect(described_class.report).to eq([])
+  end
+
+  it 'rejects invalid, missing, symlinked or changed handles without recording a finding' do
+    artifact = PWN::Plugins::ArtifactRegistry.spill(bytes: 'original', session_id: 'fixture')
+    args = finding.except(:evidence_paths).merge(artifact_handles: [artifact[:handle]], severity_justification: 'Read-only exposure.')
+    ['../fixture/00000000.bin', 'fixture/00000000.bin', "#{artifact[:handle]}\n"].each do |handle|
+      expect { described_class.record_structured(args.merge(artifact_handles: [handle])) }.to raise_error(ArgumentError, /handle/)
+    end
+    File.unlink(artifact[:path])
+    File.symlink(@evidence, artifact[:path])
+    expect { described_class.record_structured(args) }.to raise_error(ArgumentError, /symlink/)
+    File.unlink(artifact[:path])
+    File.binwrite(artifact[:path], 'changed')
+    expect { described_class.record_structured(args) }.to raise_error(ArgumentError, /digest mismatch/)
+    expect(described_class.report).to eq([])
+  end
+
+  it 'accepts legacy full hash handles and preserves an expected digest supplied with a descriptor' do
+    artifact = PWN::Plugins::ArtifactRegistry.put(bytes: 'puts :fixture')
+    args = finding.except(:evidence_paths).merge(artifact_handles: [artifact[:sha256]], severity_justification: 'Read-only exposure.')
+    row = described_class.record_structured(args)
+    expect(row[:evidence_artifacts].first).to include(handle: artifact[:sha256], sha256: artifact[:sha256])
+    descriptor = { handle: artifact[:handle], sha256: '0' * 64 }
+    expect { described_class.record_structured(args.merge(artifact_handles: [descriptor])) }.to raise_error(ArgumentError, /sha256 mismatch/)
+    expect { described_class.record_structured(args.merge(severity_justification: ' ')) }.to raise_error(ArgumentError, /severity_justification/)
+    [[], [''], 'run a command', [123]].each do |steps|
+      expect { described_class.record_structured(args.merge(reproduction_steps: steps)) }.to raise_error(ArgumentError, /reproduction_steps/)
+    end
+  end
+
   it 'rejects a score inconsistent with the vector and unsafe engagement paths' do
     expect { described_class.record_structured(finding.merge(cvss_score: 9.8)) }.to raise_error(ArgumentError, /cvss_score/)
     expect { described_class.record_structured(finding.merge(engagement_id: '../escape')) }.to raise_error(ArgumentError, /engagement_id/)
@@ -78,11 +173,111 @@ RSpec.describe PWN::Plugins::Findings do
     File.write(response, "HTTP/1.1 200 OK\n\nuid=0(root) fixture")
     verified = described_class.verify(id: row[:id], kind: 'http', request_path: request, response_path: response, impact: 'uid=0')
     expect(verified[:verification_status]).to eq('reproduced')
+    expect(verified[:evidence_artifacts].map { |artifact| artifact[:path] }).to include(request, response)
+    expect(verified[:evidence_artifacts].all? { |artifact| Digest::SHA256.file(artifact[:stored]).hexdigest == artifact[:sha256] }).to be(true)
     expect(described_class.report(engagement_id: 'fixture').first[:verification_status]).to eq('reproduced')
     File.write(response, "HTTP/1.1 403 Forbidden\n\ndenied")
     retest = described_class.retest(id: row[:id], kind: 'http', request_path: request, response_path: response, impact: 'uid=0')
     expect(retest[:verification_status]).to eq('fixed')
     expect(retest[:status]).to eq('closed')
+    responses = retest[:evidence_artifacts].select { |artifact| artifact[:path] == response }
+    expect(responses.map { |artifact| artifact[:sha256] }.uniq.length).to eq(2)
+  end
+
+  it 'persists path-scoped impact assessments with actual evidence and only consecutive directed edges' do
+    a = described_class.record_structured(finding.merge(title: 'SSRF', cwe: 'CWE-918'))
+    b = described_class.record_structured(finding.merge(title: 'Internal admin'))
+    c = described_class.record_structured(finding.merge(title: 'Command execution'))
+    d = described_class.record_structured(finding.merge(title: 'Alternate entry'))
+    ids = [a[:id], b[:id], c[:id]]
+    path = File.join(@dir, 'chain.txt')
+    text = "Fixture replay #{ids.join(' -> ')}: SSRF reaches internal admin and executes the fixture command."
+    File.write(path, text)
+    result = described_class.chain_impact(ids: ids, combined_impact_path: path, escalate: true, combined_severity: 'critical')
+    expect(result[:rationale]).to eq(text)
+    rows = described_class.report.to_h { |row| [row[:id], row] }
+    expect(rows[a[:id]][:enables]).to eq([b[:id]])
+    expect(rows[b[:id]][:enables]).to eq([c[:id]])
+    expect(rows[c[:id]][:attack_chain_refs]).to eq([])
+    assessment = rows[c[:id]].fetch(:chain_assessments).first
+    expect(assessment).to include(finding_ids: ids, combined_severity: 'critical', rationale: text,
+                                  reproduction_steps: [a[:poc], b[:poc], c[:poc]])
+    artifact = assessment[:evidence_artifacts].first
+    expect(artifact).to include(path: path, sha256: Digest::SHA256.file(path).hexdigest, size: File.size(path))
+    expect(File.read(artifact[:stored])).to eq(text)
+    alternate = File.join(@dir, 'alternate.txt')
+    File.write(alternate, "Fixture replay #{d[:id]} -> #{c[:id]} demonstrates read-only exposure, not command execution.")
+    described_class.chain_impact(ids: [d[:id], c[:id]], combined_impact_path: alternate, escalate: true, combined_severity: 'high',
+                                 severity_justification: 'Read-only internal exposure.', reproduction_steps: ['Replay alternate fixture.'])
+    described_class.chain_impact(ids: ids, combined_impact_path: path, escalate: true, combined_severity: 'critical',
+                                 severity_justification: 'Command execution proven in fixture.')
+    assessments = described_class.report.find { |row| row[:id] == c[:id] }[:chain_assessments]
+    expect(assessments.length).to eq(2)
+    expect(assessments.find { |item| item[:finding_ids] == ids }[:rationale]).to eq('Command execution proven in fixture.')
+    expect(assessments.find { |item| item[:finding_ids] == [d[:id], c[:id]] }).to include(combined_severity: 'high', reproduction_steps: ['Replay alternate fixture.'])
+    expect(described_class.chain_score(ids: ids)[:combined_severity]).to eq('critical')
+    expect(described_class.chain_score(ids: [d[:id], c[:id]])[:combined_severity]).to eq('high')
+    expect(described_class.chain_score(ids: [b[:id], c[:id]])[:combined_severity]).to eq('medium')
+    expect(described_class.chain_score(ids: ids.reverse)[:combined_severity]).to eq('medium')
+  end
+
+  it 'scores exact requested paths through the canonical graph without unrelated assessment uplift' do
+    a = described_class.record_structured(finding.merge(title: 'SSRF', cwe: 'CWE-918'))
+    b = described_class.record_structured(finding.merge(title: 'Internal admin'))
+    other = described_class.record_structured(finding.merge(title: 'Other entry'))
+    path = File.join(@dir, 'impact.txt')
+    text = "Fixture replay #{a[:id]} -> #{b[:id]} proves SSRF reaches internal admin and executes a command."
+    File.write(path, text)
+    described_class.chain_impact(ids: [a[:id], b[:id]], combined_impact_path: path, escalate: true, combined_severity: 'critical')
+    described_class.link(id: other[:id], enables: [b[:id]])
+    allow(PWN::Reports).to receive(:attack_chains).and_call_original
+    expect(PWN::Reports).to receive(:attack_chains).with(findings: array_including(hash_including(id: a[:id]), hash_including(id: b[:id]))).at_least(:once).and_call_original
+    score = described_class.chain_score(ids: [a[:id], b[:id]])
+    expect(score).to include(score: 'critical', combined_severity: 'critical', n: 2, rationale: text)
+    expect(score[:chains].first).to include(finding_ids: [a[:id], b[:id]], assessment_status: 'evidence_backed')
+    expect(described_class.chain_score(chain_refs: [other[:id], b[:id]])).to include(score: 'medium', n: 2)
+    expect(described_class.chain_score(ids: [b[:id]])).to include(score: 'medium', n: 1)
+    expect(described_class.chain_score(ids: ['missing'])).to include(score: 'info', n: 0)
+    expect(described_class.chain_score[:combined_severity]).to eq('critical')
+    expect(described_class.report.map { |row| row[:severity] }.uniq).to eq(['medium'])
+  end
+
+  it 'rejects invalid impact paths before changing any finding or evidence ledger' do
+    a = described_class.record_structured(finding)
+    b = described_class.record_structured(finding.merge(enables: [a[:id]]))
+    other = described_class.record_structured(finding.merge(engagement_id: 'other'))
+    path = File.join(@dir, 'chain.txt')
+    File.write(path, "Fixture replay #{a[:id]} #{b[:id]} #{other[:id]} includes all IDs but does not waive graph validation.")
+    before = File.read(described_class::FILE)
+    ledger = File.join(@dir, '.pwn', 'engagements', 'fixture', 'evidence.jsonl')
+    evidence_before = File.read(ledger)
+    [[a[:id], a[:id]], [a[:id], other[:id]], [a[:id], b[:id]], ['missing', a[:id]]].each do |ids|
+      expect { described_class.chain_impact(ids: ids, combined_impact_path: path) }.to raise_error(ArgumentError)
+    end
+    expect(File.read(described_class::FILE)).to eq(before)
+    expect(File.read(ledger)).to eq(evidence_before)
+  end
+
+  it 'rejects reverse links against legacy chain_refs and validates evidence before persisting impact' do
+    a = described_class.record_structured(finding)
+    legacy = described_class.record(title: 'Legacy child', severity: 'medium', engagement_id: 'fixture',
+                                    poc_artifacts: [@evidence], chain_refs: [a[:id]],
+                                    evidence: 'This local fixture is retained as the legacy finding evidence.')
+    expect { described_class.link(id: legacy[:id], enables: [a[:id]]) }.to raise_error(ArgumentError, /cycle/)
+    expect { described_class.link(id: 'missing', enables: []) }.to raise_error(ArgumentError, /existing/)
+    path = File.join(@dir, 'impact-validation.txt')
+    args = { ids: [a[:id], legacy[:id]], combined_impact_path: path, escalate: true, combined_severity: 'critical' }
+    before = File.read(described_class::FILE)
+    expect { described_class.chain_impact(args) }.to raise_error(ArgumentError, /readable/)
+    ['', 'A long evidence file that still fails to mention either finding ID.'].each do |text|
+      File.write(path, text)
+      expect { described_class.chain_impact(args) }.to raise_error(ArgumentError, /name every/)
+    end
+    File.write(path, "Fixture #{a[:id]} -> #{legacy[:id]} demonstrates reproducible combined impact.")
+    expect { described_class.chain_impact(args.merge(severity_justification: ' ')) }.to raise_error(ArgumentError, /severity_justification/)
+    expect { described_class.chain_impact(args.merge(reproduction_steps: [])) }.to raise_error(ArgumentError, /reproduction_steps/)
+    expect { described_class.chain_impact(args.merge(combined_severity: 'unknown')) }.to raise_error(ArgumentError, /combined_severity/)
+    expect(File.read(described_class::FILE)).to eq(before)
   end
 
   it 'rejects signature-only verification and requires combined-impact evidence to escalate a chain' do
@@ -97,7 +292,7 @@ RSpec.describe PWN::Plugins::Findings do
     File.write(impact, "Chaining #{parent[:id]} with #{child[:id]} yields account takeover on the fixture.")
     chained = described_class.chain_impact(ids: [parent[:id], child[:id]], combined_impact_path: impact, escalate: true, combined_severity: 'high')
     expect(chained[:combined_severity]).to eq('high')
-    expect(chained[:rationale]).to include('independently evidenced')
+    expect(chained[:rationale]).to eq(File.read(impact))
     gaps = described_class.issue_work_gaps(engagement_id: 'fixture')
     expect(gaps[:unverified]).to include(child[:id])
     expect(gaps[:unverified]).not_to include(parent[:id])