pwn 0.5.728 → 0.5.731

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0018be9794020a4b996e0d67a076e2741ca124d475f1439a047a77ecc0667d9d'
-  data.tar.gz: 46eae2746ab67af7ace35e7dc4caa6e09897a187ec7295a6fe5b103a33262722
+  metadata.gz: fba7b3d4693ca9b846825957a7bde24e2a1cd6fd18577666cac32f3abfc0fcb2
+  data.tar.gz: a1ea687f125fb659f363d7195ac4f32f332918b7707ecf1aa78acafa653eff36
 SHA512:
-  metadata.gz: dd8e061914bb0941234e210a8ea346d4f11dbd0babcd5137e93fe529b094826459b469f6cfb5d2e8cabdc306bbb8471df5703275035a9e8d27fc36352b50ec84
-  data.tar.gz: 4f361334ec04c20998333623be5c2d5b97ab27189dc52f1d4fda470ff40e743c38f58b1ae37b85244557a1f7eaf93954abd3baafdcb96c8bc8d57eb4fc71ff98
+  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

@@ -30,6 +30,97 @@ rake            # rubocop + rspec - must be zero offenses
 
 (`rvmsudo rake` on multi-user RVM installs.)
 
+### Optional native decoder integration tests
+
+The default `bundle exec rake` does not require `proxmark3` or `rtl_433`.
+Ruby EM4100/Acurite decoding, native input validation, missing-executable errors,
+and cancellation-before-spawn tests always run. Only real native file replays
+are excluded with RSpec metadata (`proxmark3_integration`, `rtl433_integration`),
+not marked pending or silently passed inside examples.
+
+After installing the optional clients, explicitly enable their fixture tests:
+
+```bash
+PWN_TEST_PROXMARK3=1 bundle exec rspec spec/lib/pwn/sdr/decoder/rfid_spec.rb
+PWN_TEST_RTL433=1 bundle exec rspec spec/lib/pwn/sdr/decoder/rtl433_spec.rb
+# Enable both in the full gate:
+PWN_TEST_PROXMARK3=1 PWN_TEST_RTL433=1 bundle exec rake
+```
+
+These tests use committed offline amplitude/IQ captures, not RF hardware.
+Opt-in runs fail if their client is unavailable or cannot decode the reference;
+installed versions can differ in supported protocols and output. Fixture provenance
+and tested versions are recorded in `spec/fixtures/sdr/rfid/README.md` and
+`spec/fixtures/sdr/rtl433/README.md`. Neither client is installed by the test suite.
+
+At runtime, `RFID.decode(mode: :fdxb_pm3, ...)` and
+`RTL433.decode(mode: :native, ...)` raise an actionable `IOError` when their
+executable is missing, suggesting installation or an explicit `executable:` path.
+An already-true `stop:` callback raises cancellation before spawning either client.
+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/sdr/decoder/rfid.rb

@@ -191,12 +191,19 @@ module PWN
           data = File.read(path)
           raise ArgumentError, 'PM3 file must contain signed integer amplitude samples' unless data.lines.all? { |line| line.strip.match?(/\A-?\d+\z/) }
 
+          raise IOError, 'proxmark3 replay cancelled' if opts[:stop]&.call
+
           Tempfile.create(['pwn-fdxb-', '.pm3']) do |trace|
             Tempfile.create('pwn-fdxb-output-') do |output|
               trace.write(data)
               trace.flush
-              pid = Process.spawn(opts.fetch(:executable, 'proxmark3').to_s, '--incognito', '-c',
-                                  "data load -f #{trace.path}; lf fdxb demod", in: File::NULL, out: output, err: output)
+              executable = opts.fetch(:executable, 'proxmark3').to_s
+              begin
+                pid = Process.spawn(executable, '--incognito', '-c',
+                                    "data load -f #{trace.path}; lf fdxb demod", in: File::NULL, out: output, err: output)
+              rescue Errno::ENOENT
+                raise IOError, "proxmark3 executable #{executable.inspect} not found; install the optional proxmark3 client or set executable: to its path"
+              end
               deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + duration
               begin
                 loop do
@@ -303,6 +310,7 @@ module PWN
             # file: explicit .pm3 signed integer AMPLITUDE trace, not SDR IQ; no hardware access.
             # Valid CRC16 required. Returns national/country ID, animal and data-block flags.
             # executable: 'proxmark3'; duration: 30s deadline; stop: callable; output/on_frame/log_file.
+            # Missing executable raises IOError with install/path guidance; already-stopped replay never spawns.
             # PM3 mode is finite offline replay; no ISO14443/ISO15693/EPC Gen2 coverage.
             # carrier_hz: 125000 default; clocks_per_bit: 64 default, or 32/16.
             # threshold: 0.5 default, normalized envelope amplitude; tune to the received levels.

data/lib/pwn/sdr/decoder/rtl433.rb

@@ -206,10 +206,14 @@ module PWN
             command.push('-R', '0')
             ids.each { |id| command.push('-R', id.to_s) }
           end
+          raise IOError, 'rtl_433 replay cancelled' if opts[:stop]&.call
+
           count = 0
           output = opts.fetch(:output, $stdout)
           deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + duration
+          started = false
           Open3.popen3(*command) do |input, stdout, stderr, worker|
+            started = true
             input.close
             buffers = { stdout => +'', stderr => +'' }
             errors = +''
@@ -269,6 +273,10 @@ module PWN
             end
           end
           { protocol: 'RTL433', mode: :native, backend: 'rtl_433', frames: count, source: path }
+        rescue Errno::ENOENT
+          raise unless started == false
+
+          raise IOError, "rtl_433 executable #{command.first.inspect} not found; install the optional rtl_433 package or set executable: to its path"
         end
 
         public_class_method def self.detect(opts = {})
@@ -333,6 +341,7 @@ module PWN
             # Native mode is finite FILE replay only: file required, no auto RF/config loading.
             # Native options: format: :cu8/:cs16/:cf32, protocols: [positive native IDs],
             # executable: 'rtl_433', duration: 30 seconds (deadline), stop: callable.
+            # Missing executable raises IOError with install/path guidance; already-stopped replay never spawns.
             # Output is per-device native JSON, device_protocol preserves native numeric ID.
             # Individual sensors/integrity depend on installed version; mic absent means not-reported.
             # sample_rate: 250000 default, >=20000; threshold: 0.5 normalized envelope amplitude.

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.728'
+  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/lib/pwn/sdr/decoder/rfid_spec.rb

@@ -3,7 +3,28 @@
 require 'spec_helper'
 
 describe PWN::SDR::Decoder::RFID do
-  it 'decodes independent ISO11784/11785 FDX-B amplitude captures with the native offline client' do
+  it 'reports an actionable missing native executable without emitting frames' do
+    Dir.mktmpdir('pwn-missing-backend-') do |dir|
+      executable = File.join(dir, 'proxmark3')
+      frames = []
+      output = StringIO.new
+      expect do
+        described_class.decode(mode: :fdxb_pm3, file: 'spec/fixtures/sdr/rfid/fdxb_animal.pm3',
+                               executable: executable, output: output, on_frame: ->(frame) { frames << frame })
+      end.to raise_error(IOError, /proxmark3.*not found.*install.*executable:/i)
+      expect(frames).to be_empty
+      expect(output.string).to be_empty
+    end
+  end
+
+  it 'cancels an already stopped native replay before spawning' do
+    expect(Process).not_to receive(:spawn)
+    expect do
+      described_class.decode(mode: :fdxb_pm3, file: 'spec/fixtures/sdr/rfid/fdxb_animal.pm3', stop: -> { true })
+    end.to raise_error(IOError, /cancelled/)
+  end
+
+  it 'decodes independent ISO11784/11785 FDX-B amplitude captures with the native offline client', :proxmark3_integration do
     %w[animal extended].each do |variant|
       frames = []
       result = described_class.decode(mode: :fdxb_pm3, file: "spec/fixtures/sdr/rfid/fdxb_#{variant}.pm3",
@@ -17,12 +38,16 @@ describe PWN::SDR::Decoder::RFID do
     end
   end
 
-  it 'rejects automatic RF and emits no identity for an incomplete native amplitude trace' do
+  it 'rejects automatic RF and supports cancellation without the native client' do
     allow(PWN::SDR::Decoder::Base).to receive(:run_iq).and_raise('unexpected automatic RF')
     expect { described_class.decode(mode: :fdxb_pm3) }.to raise_error(ArgumentError, /explicit/)
     path = 'spec/fixtures/sdr/rfid/fdxb_animal.pm3'
     expect { described_class.decode(mode: :fdxb_pm3, file: path, source: :rtl_sdr) }.to raise_error(ArgumentError, /live/)
     expect { described_class.decode(mode: :fdxb_pm3, file: path, stop: -> { true }) }.to raise_error(IOError, /cancelled/)
+  end
+
+  it 'emits no identity for an incomplete native amplitude trace', :proxmark3_integration do
+    path = 'spec/fixtures/sdr/rfid/fdxb_animal.pm3'
     Tempfile.create(['fdxb-short-', '.pm3']) do |file|
       file.write(File.readlines(path).first(100).join)
       file.flush

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

@@ -3,6 +3,27 @@
 require 'spec_helper'
 
 describe PWN::SDR::Decoder::RTL433 do
+  it 'reports an actionable missing native executable without emitting frames' do
+    Dir.mktmpdir('pwn-missing-backend-') do |dir|
+      executable = File.join(dir, 'rtl_433')
+      frames = []
+      output = StringIO.new
+      expect do
+        described_class.decode(mode: :native, file: 'spec/fixtures/sdr/rtl433/toyota.cu8',
+                               executable: executable, output: output, on_frame: ->(frame) { frames << frame })
+      end.to raise_error(IOError, /rtl_433.*not found.*install.*executable:/i)
+      expect(frames).to be_empty
+      expect(output.string).to be_empty
+    end
+  end
+
+  it 'cancels an already stopped native replay before spawning' do
+    expect(Open3).not_to receive(:popen3)
+    expect do
+      described_class.decode(mode: :native, file: 'spec/fixtures/sdr/rtl433/toyota.cu8', stop: -> { true })
+    end.to raise_error(IOError, /cancelled/)
+  end
+
   it 'decodes six real over-air Acurite packets with payloads matching the upstream reference' do
     demod = described_class::AcuriteIQ.new(rate: 250_000)
     frames = []
@@ -30,7 +51,7 @@ describe PWN::SDR::Decoder::RTL433 do
     expect { described_class.decode(mode: :all) }.to raise_error(ArgumentError, /mode/)
   end
 
-  it 'replays OOK and FSK native catalogue decoders against published captures' do
+  it 'replays OOK and FSK native catalogue decoders against published captures', :rtl433_integration do
     %w[acurite_th_609_001 wh31 toyota].each do |name|
       frames = []
       result = described_class.decode(mode: :native, file: "spec/fixtures/sdr/rtl433/#{name}.cu8",
@@ -44,7 +65,7 @@ describe PWN::SDR::Decoder::RTL433 do
     end
   end
 
-  it 'requires explicit native files, validates formats and supports native protocol selection' do
+  it 'requires explicit native files and validates formats and protocol selection without the native client' do
     allow(PWN::SDR::Decoder::Base).to receive(:run_iq).and_raise('unexpected automatic RF')
     expect { described_class.decode(mode: :native) }.to raise_error(ArgumentError, /explicit file/)
     path = 'spec/fixtures/sdr/rtl433/toyota.cu8'
@@ -52,6 +73,10 @@ describe PWN::SDR::Decoder::RTL433 do
     expect { described_class.decode(mode: :native, file: path, source: :rtl_sdr) }.to raise_error(ArgumentError, /live source/)
     expect { described_class.decode(mode: :native, file: path, protocols: [0]) }.to raise_error(ArgumentError, /protocol/)
     expect { described_class.decode(mode: :native, file: path, stop: -> { true }) }.to raise_error(IOError, /cancelled/)
+  end
+
+  it 'supports native protocol selection', :rtl433_integration do
+    path = 'spec/fixtures/sdr/rtl433/toyota.cu8'
     expect(described_class.decode(mode: :native, file: path, protocols: [11], output: StringIO.new)[:frames]).to eq(0)
     expect(described_class.decode(mode: :native, file: path, protocols: [88], output: StringIO.new)[:frames]).to eq(1)
   end

data/spec/spec_helper.rb

@@ -19,6 +19,14 @@ Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |f| require f }
 # ─────────────────────────────────────────────────────────────────────────────
 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.728
+  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