pwn 0.5.729 → 0.5.731

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '04697e334aa79768d74f64b19c7e90c8a8b0372899abdf68d83bcfd4f2dcf96b'
-  data.tar.gz: 8e8934c327d039dbfaad46d62837d1e6241af718b915deba0ed3aac240ded64b
+  metadata.gz: fba7b3d4693ca9b846825957a7bde24e2a1cd6fd18577666cac32f3abfc0fcb2
+  data.tar.gz: a1ea687f125fb659f363d7195ac4f32f332918b7707ecf1aa78acafa653eff36
 SHA512:
-  metadata.gz: 68965dcb416fa10c340a8aaa4345409313f8949de2ea17529fbe570b35022e0eaa782639941f5d1ed873542dc6d1432a20372c0c16c1365ff32c199635829921
-  data.tar.gz: cb5176d386d0d26308ad52ac292714ddb11134fe384cf994ce275326a6d6dffbfa628f5616af99b7f6d44c9cf7df0add18a4f4d9669805e85278851da1b32a17
+  metadata.gz: 50cd5f5f05075760b364ef46dc82ff469d1698bbaf724880563f97793108437fcfbbc441e2283817ce10b44c46f36566b6254f36879be66f67432cdeecc8c57a
+  data.tar.gz: 2085d58ae27b634c5d0893ab0c30f428e9442a15695721a4e45d3c923cbbaa67eb95d35e578bb07d1e1b6253be089ac2c833381ba839adf406c2137229063cd3

data/Gemfile

@@ -50,9 +50,9 @@ gem 'libusb', '0.8.0'
 gem 'luhn', '3.0.0'
 gem 'mail', '2.9.1'
 gem 'mcp', '1.5.1'
-gem 'meshtastic', '0.0.175'
+gem 'meshtastic', '0.0.176'
 gem 'metasm', '1.0.6'
-gem 'mongo', '2.25.0'
+gem 'mongo', '2.26.0'
 gem 'msfrpc-client', '1.1.2'
 gem 'netaddr', '2.0.6'
 gem 'net-ldap', '0.20.0'
@@ -81,7 +81,7 @@ gem 'rmagick', '7.1.4'
 gem 'rqrcode', '3.2.0'
 gem 'rspec', '3.13.2'
 gem 'rtesseract', '3.1.4'
-gem 'rubocop', '1.90.0'
+gem 'rubocop', '1.91.0'
 gem 'rubocop-rake', '0.7.1'
 gem 'rubocop-rspec', '3.10.2'
 gem 'ruby-audio', '1.6.1'

data/documentation/Contributing.md

@@ -60,6 +60,67 @@ An already-true `stop:` callback raises cancellation before spawning either clie
 Invalid inputs still raise `ArgumentError`; native decoding never silently falls
 back to another decoder or a detector.
 
+### Optional Liquid and radare2 integration tests
+
+Native Liquid DSP examples and the real radare2 JSON replay are also explicit
+opt-ins, even when the backends happen to be installed. The default gate excludes
+`liquid_integration` and `radare2_integration` metadata rather than marking tests
+pending. Liquid interface checks, missing-library errors, pure-Ruby DSP fallback,
+radare2 argument validation, and binutils fallback coverage still run by default.
+The binary fallback tests require the existing binutils tools and `/bin/true`.
+
+```bash
+PWN_TEST_LIQUID=1 bundle exec rspec spec/lib/pwn/ffi/liquid_spec.rb
+PWN_TEST_RADARE2=1 bundle exec rspec spec/lib/pwn/plugins/binary_analysis_spec.rb
+# Enable both in the full gate:
+PWN_TEST_LIQUID=1 PWN_TEST_RADARE2=1 bundle exec rake
+```
+
+Liquid opt-in requires the liquid-dsp shared library (`libliquid`) visible to the
+dynamic loader. Radare2 opt-in requires `r2` and a C compiler named `cc` on PATH.
+The radare2 example compiles a small unstripped C fixture in a temporary directory,
+checks real JSON disassembly for its known `main` symbol, and removes the fixture
+afterward. It does not assume the host's stripped `/bin/true` has a discoverable
+`main`. Opt-in runs fail with installation guidance when a prerequisite is absent;
+they never skip or accept a degraded backend as native success. The tests install
+nothing and require no radio hardware or network access.
+
+### Optional FFTW, Volk, and SDR shared-library tests
+
+The default gate also excludes real FFTW/Volk computations and radio-library
+integration checks, regardless of what is installed. Missing-library behavior,
+mocked device inventory and stream lifecycle tests, and Ruby DSP fallbacks run
+without these shared libraries and produce no pending examples.
+
+| Environment opt-in | RSpec metadata | Loader prerequisite / coverage |
+| --- | --- | --- |
+| `PWN_TEST_FFTW=1` | `fftw_integration` | `libfftw3f`; native impulse FFT |
+| `PWN_TEST_VOLK=1` | `volk_integration` | `libvolk`; native conversion, accumulation, DSP dispatch |
+| `PWN_TEST_RTL_SDR=1` | `rtl_sdr_integration` | `librtlsdr`; binding resolution only, no USB scan |
+| `PWN_TEST_ADALM_PLUTO=1` | `adalm_pluto_integration` | Compatible `libiio`; library version only |
+| `PWN_TEST_SOAPY_SDR=1` | `soapy_sdr_integration` | `libSoapySDR`; library/API version only |
+| `PWN_TEST_HACK_RF=1` | `hack_rf_integration` | `libhackrf`; library version only |
+
+For example:
+
+```bash
+PWN_TEST_FFTW=1 bundle exec rspec spec/lib/pwn/ffi/fftw_spec.rb
+PWN_TEST_VOLK=1 bundle exec rspec spec/lib/pwn/ffi/volk_spec.rb spec/lib/pwn/sdr/decoder/dsp_spec.rb
+PWN_TEST_ADALM_PLUTO=1 bundle exec rspec spec/lib/pwn/ffi/adalm_pluto_spec.rb
+PWN_TEST_LIQUID=1 bundle exec rspec spec/lib/pwn/ffi/liquid_spec.rb spec/lib/pwn/sdr/decoder/dsp_spec.rb
+```
+
+Each opt-in fails with installation guidance if its library cannot load. Native
+DSP integration tests assert real backend dispatch, not just a matching fallback.
+None of these library opt-ins opens, tunes, receives from, or transmits through a
+radio. Pluto URI discovery is mocked, including scan cleanup.
+
+Actual RTL-SDR USB enumeration has a separate `rtl_sdr_hardware` tag, enabled
+only by `PWN_TEST_RTL_SDR_HARDWARE=1`. It requires a connected RTL-SDR and USB
+permissions, and fails on an empty inventory. Do not enable it in unattended
+upgrade gates; library opt-ins do not enable hardware tests. It performs inventory
+only, not tuning or reception. The test suite installs no dependencies.
+
 ## Adding a plugin
 
 1. `lib/pwn/plugins/my_thing.rb` following the conventions above.

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.729'
+  VERSION = '0.5.731'
 end

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

@@ -101,15 +101,57 @@ RSpec.describe 'PWN::AI::Agent::Verification' do
     expect(report[:status]).to eq(:fail)
   end
 
-  it 'executes opt-in test commands with bounded duration and treats timeouts as unknown' do
-    opts = { request: 'Run tests', requirements: ['Run tests'], root: @root, allow_commands: true, timeout: 0.2 }
-    check = { requirement: 'Run tests', kind: :command, argv: [RbConfig.ruby, '-e', 'puts "verified"'], expected: "verified\n" }
-    expect(PWN::AI::Agent::Verification.run(opts.merge(checks: [check]))[:status]).to eq(:pass)
-    check[:argv] = [RbConfig.ruby, '-e', 'exit 1']
-    expect(PWN::AI::Agent::Verification.run(opts.merge(checks: [check]))[:status]).to eq(:fail)
-    check[:argv] = [RbConfig.ruby, '-e', 'sleep 10']
-    expect(PWN::AI::Agent::Verification.run(opts.merge(checks: [check]))[:status]).to eq(:unknown)
-    expect(PWN::AI::Agent::Verification.run(opts.merge(allow_commands: false, checks: [check]))[:status]).to eq(:unknown)
+  it 'executes opt-in test commands with a bounded budget that allows interpreter startup' do
+    report = PWN::AI::Agent::Verification.run(
+      request: 'Run tests', requirements: ['Run tests'], root: @root, allow_commands: true, timeout: 10,
+      checks: [{ requirement: 'Run tests', kind: :command, argv: [RbConfig.ruby, '-e', 'puts "verified"'], expected: "verified\n" }]
+    )
+    expect(report[:status]).to eq(:pass)
+    expect(report[:checks].first).to include(passed: true, exit_code: 0, evidence: Digest::SHA256.hexdigest("verified\n"))
+  end
+
+  it 'allows simulated slow interpreter startup within the successful command budget' do
+    # Loading a startup file before -e models a slower host without mocking the runner.
+    startup = File.join(@root, 'startup.rb')
+    File.write(startup, 'sleep 0.3')
+    report = PWN::AI::Agent::Verification.run(
+      request: 'Run tests', requirements: ['Run tests'], root: @root, allow_commands: true, timeout: 10,
+      checks: [{ requirement: 'Run tests', kind: :command, argv: [RbConfig.ruby, '-r', startup, '-e', 'puts "verified"'], expected: "verified\n" }]
+    )
+    expect(report[:status]).to eq(:pass)
+    expect(report[:checks].first).to include(passed: true, exit_code: 0, evidence: Digest::SHA256.hexdigest("verified\n"))
+  end
+
+  it 'reports an actual unsuccessful command exit as failure' do
+    report = PWN::AI::Agent::Verification.run(
+      request: 'Run tests', requirements: ['Run tests'], root: @root, allow_commands: true, timeout: 10,
+      checks: [{ requirement: 'Run tests', kind: :command, argv: [RbConfig.ruby, '-e', 'exit 1'] }]
+    )
+    expect(report[:status]).to eq(:fail)
+    expect(report[:checks].first).to include(passed: false, exit_code: 1)
+  end
+
+  it 'bounds an unfinished command and reports a timeout as unknown, not failure or success' do
+    # This command cannot finish within the deadline, regardless of startup speed.
+    report = Timeout.timeout(5) do
+      PWN::AI::Agent::Verification.run(
+        request: 'Run tests', requirements: ['Run tests'], root: @root, allow_commands: true, timeout: 0.2,
+        checks: [{ requirement: 'Run tests', kind: :command, argv: [RbConfig.ruby, '-e', 'sleep 60'] }]
+      )
+    end
+    expect(report[:status]).to eq(:unknown)
+    expect(report[:checks].first).to include(passed: nil, evidence: 'unavailable', error: 'Timeout::Error')
+    expect(report[:checks].first).not_to have_key(:exit_code)
+  end
+
+  it 'does not spawn test commands without explicit opt-in' do
+    expect(Open3).not_to receive(:popen3)
+    report = PWN::AI::Agent::Verification.run(
+      request: 'Run tests', requirements: ['Run tests'], root: @root, allow_commands: false,
+      checks: [{ requirement: 'Run tests', kind: :command, argv: [RbConfig.ruby, '-e', 'puts "verified"'] }]
+    )
+    expect(report[:status]).to eq(:unknown)
+    expect(report[:checks].first).to include(passed: nil, error: 'ArgumentError')
   end
 
   it 'attributes a checked artifact only to its last observed writer rather than a later noop' do

data/spec/lib/pwn/ffi/adalm_pluto_spec.rb

@@ -3,6 +3,12 @@
 require 'spec_helper'
 
 describe PWN::FFI::AdalmPluto do
+  it 'handles a missing shared library without native calls' do
+    allow(described_class).to receive(:available?).and_return(false)
+    expect(described_class.info).to include(available: false)
+    expect(described_class.list_uris).to eq([])
+  end
+
   it 'waits for a cancelled refill to return before destroying its buffer' do
     handle = { buffer: FFI::MemoryPointer.new(:char, 4) }
     entered = Queue.new
@@ -62,8 +68,8 @@ describe PWN::FFI::AdalmPluto do
     expect(PWN::FFI::AdalmPluto).to respond_to :available?
   end
 
-  it 'should report library info when libiio is present' do
-    skip 'libiio not installed' unless PWN::FFI::AdalmPluto.available?
+  it 'should report library info', :adalm_pluto_integration do
+    expect(described_class.available?).to be(true), 'Install compatible libiio and make it visible to the dynamic loader (PWN_TEST_ADALM_PLUTO=1).'
 
     info = PWN::FFI::AdalmPluto.info
     expect(info[:available]).to eq(true)
@@ -71,15 +77,23 @@ describe PWN::FFI::AdalmPluto do
     expect(info[:minor]).to be_a(Integer)
   end
 
-  it 'should list URIs (possibly empty) when libiio is present' do
-    skip 'libiio not installed' unless PWN::FFI::AdalmPluto.available?
-
-    # Restrict to usb,local so libiio does not attempt mDNS/DNS-SD (avahi)
-    # discovery during the test suite — avoids the noisy
-    #   "ERROR: Unable to create Avahi DNS-SD client :Daemon not running"
-    # C-level stderr write on hosts where avahi-daemon is not running.
-    list = PWN::FFI::AdalmPluto.list_uris(backends: 'usb,local')
-    expect(list).to be_a(Array)
+  it 'maps URIs and releases the mocked scan without hardware discovery' do
+    allow(described_class).to receive(:available?).and_return(true)
+    scan = FFI::MemoryPointer.new(:char)
+    entry = FFI::MemoryPointer.new(:char)
+    entries = FFI::MemoryPointer.new(:pointer)
+    entries.write_pointer(entry)
+    expect(described_class).to receive(:iio_create_scan_context).with('usb,local', 0).and_return(scan)
+    expect(described_class).to receive(:iio_scan_context_get_info_list) do |context, output|
+      expect(context).to eq(scan)
+      output.write_pointer(entries)
+      1
+    end
+    allow(described_class).to receive(:iio_context_info_get_uri).with(entry).and_return('usb:mock')
+    allow(described_class).to receive(:iio_context_info_get_description).with(entry).and_return('Mock Pluto')
+    expect(described_class).to receive(:iio_context_info_list_free).with(entries)
+    expect(described_class).to receive(:iio_scan_context_destroy).with(scan)
+    expect(described_class.list_uris(backends: 'usb,local')).to eq([{ uri: 'usb:mock', description: 'Mock Pluto' }])
   end
 
   it 'should appear in PWN::FFI.backends' do

data/spec/lib/pwn/ffi/fftw_spec.rb

@@ -3,6 +3,11 @@
 require 'spec_helper'
 
 describe PWN::FFI::FFTW do
+  it 'handles a missing shared library without native calls' do
+    allow(described_class).to receive(:available?).and_return(false)
+    expect { described_class.rfft(samples: [1.0]) }.to raise_error(RuntimeError, /libfftw3f not available/)
+  end
+
   it 'should display information for authors' do
     expect(PWN::FFI::FFTW).to respond_to :authors
   end
@@ -15,8 +20,8 @@ describe PWN::FFI::FFTW do
     expect(PWN::FFI::FFTW).to respond_to :available?
   end
 
-  it 'should compute an rfft impulse response when libfftw3f is present' do
-    skip 'libfftw3f not installed' unless PWN::FFI::FFTW.available?
+  it 'should compute an rfft impulse response', :fftw_integration do
+    expect(described_class.available?).to be(true), 'Install libfftw3f and make it visible to the dynamic loader (PWN_TEST_FFTW=1).'
 
     spec = PWN::FFI::FFTW.rfft(samples: [1.0, 0, 0, 0, 0, 0, 0, 0])
     expect(spec.length).to eq(5) # n/2+1

data/spec/lib/pwn/ffi/hack_rf_spec.rb

@@ -3,6 +3,12 @@
 require 'spec_helper'
 
 describe PWN::FFI::HackRF do
+  it 'handles a missing shared library without native calls' do
+    allow(described_class).to receive(:available?).and_return(false)
+    expect(described_class.info).to include(available: false)
+    expect { described_class.open }.to raise_error(RuntimeError, /libhackrf not available/)
+  end
+
   it 'releases the GVL while native stop waits for callbacks' do
     source = File.read(File.expand_path('../../../../lib/pwn/ffi/hack_rf.rb', __dir__))
     expect(source).to match(/attach_function :hackrf_stop_rx, \[:pointer\], :int, blocking: true/)
@@ -51,8 +57,8 @@ describe PWN::FFI::HackRF do
     expect(PWN::FFI::HackRF).to respond_to :available?
   end
 
-  it 'should report library info when libhackrf is present' do
-    skip 'libhackrf not installed' unless PWN::FFI::HackRF.available?
+  it 'should report library info', :hack_rf_integration do
+    expect(described_class.available?).to be(true), 'Install libhackrf and make it visible to the dynamic loader (PWN_TEST_HACK_RF=1).'
 
     info = PWN::FFI::HackRF.info
     expect(info[:available]).to eq(true)

data/spec/lib/pwn/ffi/liquid_spec.rb

@@ -15,17 +15,33 @@ describe PWN::FFI::Liquid do
     expect(PWN::FFI::Liquid).to respond_to :available?
   end
 
-  it 'should resample at half rate when libliquid is present' do
-    skip 'libliquid not installed' unless PWN::FFI::Liquid.available?
+  it 'rejects native DSP calls when libliquid is unavailable' do
+    allow(described_class).to receive(:available?).and_return(false)
+    expect { described_class.resample(samples: [0.0], rate: 0.5) }.to raise_error(RuntimeError, /libliquid not available/)
+    expect { described_class.freq_demod(iq: [1.0, 0.0]) }.to raise_error(RuntimeError, /libliquid not available/)
+  end
+
+  it 'keeps DSP resampling functional when libliquid is unavailable' do
+    allow(described_class).to receive(:available?).and_return(false)
+    allow(PWN::SDR::Decoder::DSP).to receive(:native).and_return(true)
+    expect(described_class).not_to receive(:resample)
+    result = PWN::SDR::Decoder::DSP.resample(samples: [0.0, 1.0, 2.0, 3.0], src_rate: 4, dst_rate: 2)
+    expect(result).to eq([0.0, 2.0])
+  end
 
+  before(:each, :liquid_integration) do
+    expect(described_class.available?).to be(true),
+                                          'PWN_TEST_LIQUID=1 requires liquid-dsp: install libliquid and make it visible to the dynamic loader. ' \
+                                          "Load error: #{described_class.load_error}"
+  end
+
+  it 'should resample at half rate with libliquid', :liquid_integration do
     samples = Array.new(64) { |i| Math.sin(2 * Math::PI * i / 16.0) }
     out = PWN::FFI::Liquid.resample(samples: samples, rate: 0.5)
     expect(out.length).to be_between(24, 40)
   end
 
-  it 'should FM-demod a complex tone when libliquid is present' do
-    skip 'libliquid not installed' unless PWN::FFI::Liquid.available?
-
+  it 'should FM-demod a complex tone with libliquid', :liquid_integration do
     iq = []
     phase = 0.0
     dphi = 2 * Math::PI * 0.05

data/spec/lib/pwn/ffi/rtl_sdr_spec.rb

@@ -3,6 +3,12 @@
 require 'spec_helper'
 
 describe PWN::FFI::RTLSdr do
+  it 'handles a missing shared library without native calls' do
+    allow(described_class).to receive(:available?).and_return(false)
+    expect { described_class.list_devices }.to raise_error(RuntimeError, /librtlsdr not available/)
+    expect { described_class.open }.to raise_error(RuntimeError, /librtlsdr not available/)
+  end
+
   it 'releases the GVL during native reads so DSP workers can run' do
     source = File.read(File.expand_path('../../../../lib/pwn/ffi/rtl_sdr.rb', __dir__))
     declaration = source[/attach_function :rtlsdr_read_sync,.*?(?=attach_function)/m]
@@ -31,10 +37,27 @@ describe PWN::FFI::RTLSdr do
     expect(PWN::FFI::RTLSdr).to respond_to :available?
   end
 
-  it 'should list devices (possibly empty) when librtlsdr is present' do
-    skip 'librtlsdr not installed' unless PWN::FFI::RTLSdr.available?
+  it 'maps device inventory using mocked USB calls' do
+    allow(described_class).to receive(:available?).and_return(true)
+    allow(described_class).to receive(:rtlsdr_get_device_count).and_return(1)
+    allow(described_class).to receive(:rtlsdr_get_device_name).with(0).and_return('Mock tuner')
+    expect(described_class).to receive(:rtlsdr_get_device_usb_strings) do |index, manufacturer, product, serial|
+      expect(index).to eq(0)
+      manufacturer.write_string('Test')
+      product.write_string('SDR')
+      serial.write_string('123')
+      0
+    end
+    expect(described_class.list_devices).to eq([{ index: 0, name: 'Mock tuner', manufacturer: 'Test', product: 'SDR', serial: '123' }])
+  end
+
+  it 'loads the native inventory and read bindings without scanning USB', :rtl_sdr_integration do
+    expect(described_class.available?).to be(true), 'Install librtlsdr and make it visible to the dynamic loader (PWN_TEST_RTL_SDR=1).'
+    expect(described_class).to respond_to(:rtlsdr_get_device_count, :rtlsdr_read_sync)
+  end
 
-    list = PWN::FFI::RTLSdr.list_devices
-    expect(list).to be_a(Array)
+  it 'lists a connected RTL-SDR', :rtl_sdr_hardware do
+    expect(described_class.available?).to be(true), 'Install librtlsdr before enabling PWN_TEST_RTL_SDR_HARDWARE=1.'
+    expect(described_class.list_devices).not_to be_empty, 'Connect an RTL-SDR with USB permissions before enabling PWN_TEST_RTL_SDR_HARDWARE=1.'
   end
 end

data/spec/lib/pwn/ffi/soapy_sdr_spec.rb

@@ -3,6 +3,12 @@
 require 'spec_helper'
 
 describe PWN::FFI::SoapySDR do
+  it 'handles a missing shared library without native calls' do
+    allow(described_class).to receive(:available?).and_return(false)
+    expect(described_class.info).to include(available: false)
+    expect { described_class.make(args: 'driver=mock') }.to raise_error(RuntimeError, /libSoapySDR not available/)
+  end
+
   it 'reports close failure and retains the stream for cleanup retry' do
     handle = { device: :device, stream: :stream }
     allow(described_class).to receive(:SoapySDRDevice_deactivateStream).and_return(0)
@@ -39,8 +45,8 @@ describe PWN::FFI::SoapySDR do
     expect(PWN::FFI::SoapySDR).to respond_to :available?
   end
 
-  it 'should report API info when libSoapySDR is present' do
-    skip 'libSoapySDR not installed' unless PWN::FFI::SoapySDR.available?
+  it 'should report API info', :soapy_sdr_integration do
+    expect(described_class.available?).to be(true), 'Install libSoapySDR and make it visible to the dynamic loader (PWN_TEST_SOAPY_SDR=1).'
 
     info = PWN::FFI::SoapySDR.info
     expect(info[:available]).to eq(true)

data/spec/lib/pwn/ffi/volk_spec.rb

@@ -3,6 +3,12 @@
 require 'spec_helper'
 
 describe PWN::FFI::Volk do
+  it 'handles a missing shared library without native calls' do
+    allow(described_class).to receive(:available?).and_return(false)
+    expect { described_class.unpack_s16le(data: '') }.to raise_error(RuntimeError, /libvolk not available/)
+    expect { described_class.accumulate(samples: []) }.to raise_error(RuntimeError, /libvolk not available/)
+  end
+
   it 'should display information for authors' do
     expect(PWN::FFI::Volk).to respond_to :authors
   end
@@ -15,8 +21,8 @@ describe PWN::FFI::Volk do
     expect(PWN::FFI::Volk).to respond_to :available?
   end
 
-  it 'should unpack s16le to unit-range floats when libvolk is present' do
-    skip 'libvolk not installed' unless PWN::FFI::Volk.available?
+  it 'should unpack s16le to unit-range floats', :volk_integration do
+    expect(described_class.available?).to be(true), 'Install libvolk and make it visible to the dynamic loader (PWN_TEST_VOLK=1).'
 
     raw = [0, 16_384, -16_384, 32_767].pack('s<*')
     out = PWN::FFI::Volk.unpack_s16le(data: raw)
@@ -27,8 +33,8 @@ describe PWN::FFI::Volk do
     expect(out[3]).to be_within(1e-3).of(1.0)
   end
 
-  it 'should accumulate floats when libvolk is present' do
-    skip 'libvolk not installed' unless PWN::FFI::Volk.available?
+  it 'should accumulate floats', :volk_integration do
+    expect(described_class.available?).to be(true), 'Install libvolk and make it visible to the dynamic loader (PWN_TEST_VOLK=1).'
 
     sum = PWN::FFI::Volk.accumulate(samples: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
     expect(sum).to be_within(1e-4).of(36.0)

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

@@ -5,20 +5,50 @@ require 'tmpdir'
 require 'digest'
 
 describe 'normalized binary analysis' do
-  it 'executes the actual radare2 read-only JSON interfaces when installed' do
-    require 'pwn/plugins/radare2'
-    skip 'r2 unavailable' unless PWN::Plugins::BinaryAnalysis.available?(name: 'r2')
-    result = PWN::Plugins::Radare2.analyze_all(path: '/bin/true')
-    expect(result[:backend]).to eq('radare2')
-    expect(result[:functions]).not_to be_empty
-    expect(PWN::Plugins::Radare2.list_functions(path: '/bin/true')[:data]).not_to be_empty
-    expect(PWN::Plugins::Radare2.disasm_function(path: '/bin/true', function: 'main')[:data]).to include('ops')
-    expect(PWN::Plugins::Radare2.xrefs(path: '/bin/true', addr: 'main')[:data]).to be_a(Array)
-    expect(PWN::Plugins::Radare2.strings(path: '/bin/true')[:data]).not_to be_empty
-    expect(PWN::Plugins::Radare2.imports(path: '/bin/true')[:data]).not_to be_empty
+  it 'executes the actual radare2 read-only JSON interfaces on a controlled binary', :radare2_integration do
+    expect(PWN::Plugins::BinaryAnalysis.available?(name: 'r2')).to be(true),
+                                                                   'PWN_TEST_RADARE2=1 requires radare2: install r2 and add it to PATH.'
+    expect(PWN::Plugins::BinaryAnalysis.available?(name: 'cc')).to be(true),
+                                                                   'PWN_TEST_RADARE2=1 requires a C compiler: install cc and add it to PATH.'
+
+    Dir.mktmpdir('pwn-radare2-spec-') do |dir|
+      path = File.join(dir, 'fixture')
+      source = File.join(dir, 'fixture.c')
+      File.write(source, "#include <stdio.h>\nint main(void) { return puts(\"pwn radare2 fixture\") < 0; }\n")
+      output, status = Open3.capture2e('cc', '-O0', '-g', '-o', path, source, chdir: dir)
+      expect(status.success?).to be(true), "Unable to compile radare2 fixture with cc: #{output}"
+      sha = Digest::SHA256.file(path).hexdigest
+
+      result = PWN::Plugins::Radare2.analyze_all(path: path)
+      expect(result).to include(backend: 'radare2', status: 'ok', sha256: sha)
+      expect(result[:functions]).not_to be_empty
+      expect(PWN::Plugins::Radare2.list_functions(path: path)[:data]).not_to be_empty
+      disassembly = PWN::Plugins::Radare2.disasm_function(path: path, function: 'main')
+      expect(disassembly).to include(backend: 'radare2', status: 'ok')
+      expect(disassembly[:data]).to include('ops')
+      expect(disassembly[:data]['ops']).not_to be_empty
+      xrefs = PWN::Plugins::Radare2.xrefs(path: path, addr: 'main')
+      expect(xrefs).to include(backend: 'radare2', status: 'ok')
+      expect(xrefs[:data]).to be_a(Array)
+      expect(PWN::Plugins::Radare2.strings(path: path)[:data]).not_to be_empty
+      expect(PWN::Plugins::Radare2.imports(path: path)[:data]).not_to be_empty
+      expect(Digest::SHA256.file(path).hexdigest).to eq(sha)
+    end
+  end
+
+  it 'rejects command injection without requiring a native backend' do
+    expect(PWN::Plugins::BinaryAnalysis).not_to receive(:run)
     expect { PWN::Plugins::Radare2.disasm_function(path: '/bin/true', function: 'main;!id') }.to raise_error(ArgumentError)
   end
 
+  it 'falls back deterministically when radare2 is unavailable' do
+    allow(PWN::Plugins::BinaryAnalysis).to receive(:available?).with(name: 'r2').and_return(false)
+    result = PWN::Plugins::Radare2.analyze_all(path: '/bin/true')
+    expect(result).to include(backend: 'binutils', status: 'degraded')
+    expect(result[:strings]).not_to be_empty
+    expect(result[:warnings]).not_to be_empty
+  end
+
   it 'reports an honest Ghidra fallback and uses the requested hash cache directory' do
     Dir.mktmpdir do |dir|
       result = PWN::Plugins::GhidraHeadless.analyze(path: '/bin/true', backend: 'binutils', cache_dir: dir)

data/spec/lib/pwn/sdr/decoder/dsp_spec.rb

@@ -29,33 +29,58 @@ describe PWN::SDR::Decoder::DSP do
     PWN::SDR::Decoder::DSP.native = was
   end
 
-  it 'should unpack s16le via Volk when available' do
-    skip 'libvolk not installed' unless PWN::FFI.available?(mod: :Volk)
-
+  it 'should unpack s16le via Volk', :volk_integration do
     was = PWN::SDR::Decoder::DSP.native
+    expect(PWN::FFI.available?(mod: :Volk)).to be(true), 'Install libvolk and make it visible to the dynamic loader (PWN_TEST_VOLK=1).'
     PWN::SDR::Decoder::DSP.native = true
     raw = [0, 16_384, -16_384, 32_767].pack('s<*')
+    native_out = PWN::FFI::Volk.unpack_s16le(data: raw)
+    expect(PWN::FFI::Volk).to receive(:unpack_s16le).with(data: raw).and_call_original
     out = PWN::SDR::Decoder::DSP.unpack_s16le(data: raw)
+    expect(out).to eq(native_out)
     expect(out[1]).to be_within(1e-3).of(0.5)
   ensure
     PWN::SDR::Decoder::DSP.native = was
   end
 
-  it 'should resample pure-ruby and liquid paths to comparable length' do
-    samples = Array.new(200) { |i| Math.sin(2 * Math::PI * i / 40.0) }
+  it 'falls back to Ruby unpacking with native enabled but Volk absent' do
+    was = described_class.native
+    described_class.native = true
+    allow(PWN::FFI).to receive(:available?).with(mod: :Volk).and_return(false)
+    expect(PWN::FFI::Volk).not_to receive(:unpack_s16le)
+    raw = [0, 16_384, -16_384, 32_767].pack('s<*')
+    expect(described_class.unpack_s16le(data: raw)).to eq([0.0, 0.5, -0.5, 32_767 / 32_768.0])
+  ensure
+    described_class.native = was
+  end
 
-    was = PWN::SDR::Decoder::DSP.native
-    PWN::SDR::Decoder::DSP.native = false
-    ruby_out = PWN::SDR::Decoder::DSP.resample(samples: samples, src_rate: 48_000, dst_rate: 24_000)
+  it 'falls back to Ruby resampling with native enabled but Liquid absent' do
+    was = described_class.native
+    samples = Array.new(200) { |i| Math.sin(2 * Math::PI * i / 40.0) }
+    described_class.native = false
+    ruby_out = described_class.resample(samples: samples, src_rate: 48_000, dst_rate: 24_000)
     expect(ruby_out.length).to eq(100)
 
-    if PWN::FFI.available?(mod: :Liquid)
-      PWN::SDR::Decoder::DSP.native = true
-      liq_out = PWN::SDR::Decoder::DSP.resample(samples: samples, src_rate: 48_000, dst_rate: 24_000)
-      # multi-stage resampler length can differ by a few samples due to delay
-      expect(liq_out.length).to be_between(90, 120)
-    end
+    allow(PWN::FFI).to receive(:available?).with(mod: :Liquid).and_return(false)
+    expect(PWN::FFI::Liquid).not_to receive(:resample)
+    described_class.native = true
+    expect(described_class.resample(samples: samples, src_rate: 48_000, dst_rate: 24_000)).to eq(ruby_out)
   ensure
-    PWN::SDR::Decoder::DSP.native = was
+    described_class.native = was
+  end
+
+  it 'resamples using Liquid to a comparable length', :liquid_integration do
+    was = described_class.native
+    expect(PWN::FFI.available?(mod: :Liquid)).to be(true), 'Install libliquid and make it visible to the dynamic loader (PWN_TEST_LIQUID=1).'
+    samples = Array.new(200) { |i| Math.sin(2 * Math::PI * i / 40.0) }
+    described_class.native = true
+    native_out = PWN::FFI::Liquid.resample(samples: samples, rate: 0.5)
+    expect(PWN::FFI::Liquid).to receive(:resample).with(samples: samples, rate: 0.5).and_call_original
+    liq_out = described_class.resample(samples: samples, src_rate: 48_000, dst_rate: 24_000)
+    expect(liq_out).to eq(native_out)
+    # Multi-stage resampler length can differ due to delay.
+    expect(liq_out.length).to be_between(90, 120)
+  ensure
+    described_class.native = was
   end
 end

data/spec/spec_helper.rb

@@ -21,6 +21,12 @@ RSpec.configure do |config|
   config.filter_run_excluding :local_embeddings unless ENV['PWN_TEST_EMBED_ENDPOINT'] && ENV['PWN_SQLITE_VEC_EXTENSION']
   config.filter_run_excluding :proxmark3_integration unless ENV['PWN_TEST_PROXMARK3'] == '1'
   config.filter_run_excluding :rtl433_integration unless ENV['PWN_TEST_RTL433'] == '1'
+  config.filter_run_excluding :liquid_integration unless ENV['PWN_TEST_LIQUID'] == '1'
+  config.filter_run_excluding :radare2_integration unless ENV['PWN_TEST_RADARE2'] == '1'
+  %w[fftw volk rtl_sdr adalm_pluto soapy_sdr hack_rf].each do |backend|
+    config.filter_run_excluding :"#{backend}_integration" unless ENV["PWN_TEST_#{backend.upcase}"] == '1'
+  end
+  config.filter_run_excluding :rtl_sdr_hardware unless ENV['PWN_TEST_RTL_SDR_HARDWARE'] == '1'
 
   next if ENV['PWN_SPEC_VERBOSE']
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.729
+  version: 0.5.731
 platform: ruby
 authors:
 - 0day Inc.
@@ -519,14 +519,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.175
+        version: 0.0.176
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.175
+        version: 0.0.176
 - !ruby/object:Gem::Dependency
   name: metasm
   requirement: !ruby/object:Gem::Requirement
@@ -547,14 +547,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.25.0
+        version: 2.26.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.25.0
+        version: 2.26.0
 - !ruby/object:Gem::Dependency
   name: msfrpc-client
   requirement: !ruby/object:Gem::Requirement
@@ -953,14 +953,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.90.0
+        version: 1.91.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.90.0
+        version: 1.91.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement