pwn 0.5.620 → 0.5.621

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

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require 'shellwords'
-
 module PWN
   module SDR
     module Decoder
-      # ADS-B (Automatic Dependent Surveillance – Broadcast) decoder for
-      # aircraft transponder squitters on 1090 MHz (Mode-S / ES) and 978 MHz
-      # (UAT). 2 Mbit/s PPM cannot be recovered from GQRX audio, so this
-      # module drives `dump1090` (or `dump978-fa`) directly against the SDR
-      # and structures each SBS-1/BaseStation CSV line it emits on stdout.
+      # Pure-Ruby ADS-B (1090 MHz Mode-S / 978 MHz UAT) activity detector.
+      #
+      # Mode-S Extended Squitter is 2 Mbit/s PPM with 8/120 μs frames on a
+      # 2 MHz-wide channel — physically unrecoverable from GQRX's 48 kHz
+      # demodulated-audio tap. Rather than shell out to `dump1090`, this
+      # module runs Base.run_detector to characterise squitter density
+      # (bursts/sec, peak dBFS, floor) natively in Ruby. `parse_line` is
+      # retained for offline SBS-1 CSV analysis.
       module ADSB
         SBS_FIELDS = %i[
           msg_type tx_type session_id aircraft_id icao24 flight_id
@@ -25,28 +26,13 @@ module PWN
 
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
-          raise 'ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
-
-          hz   = PWN::SDR.hz_to_i(freq: freq_obj[:freq])
-          gain = (freq_obj[:rf_gain] || 40).to_s.to_f
-          uat  = hz.between?(977_000_000, 979_000_000)
-
-          direct_cmd =
-            if uat && PWN::SDR::Decoder::Base.bin_available?(bin: 'dump978-fa')
-              "bash -c #{Shellwords.escape("dump978-fa --sdr driver=rtlsdr --sdr-gain #{gain} --raw-stdout 2>/dev/null | uat2text")}"
-            elsif PWN::SDR::Decoder::Base.bin_available?(bin: 'dump1090-fa')
-              "dump1090-fa --device-type rtlsdr --gain #{gain} --net-sbs-stdout --quiet"
-            else
-              "dump1090 --gain #{gain} --net-sbs-stdout --quiet"
-            end
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          hz  = PWN::SDR.hz_to_i(freq: freq_obj[:freq])
+          uat = hz.between?(977_000_000, 979_000_000)
+          PWN::SDR::Decoder::Base.run_detector(
             freq_obj: freq_obj,
             protocol: uat ? 'ADSB-UAT978' : 'ADSB-1090ES',
-            required_bins: uat ? %w[dump978-fa uat2text] : %w[dump1090],
-            direct_cmd: direct_cmd,
-            line_match: /^(MSG,|-|\+)/,
-            parser: proc { |line| parse_line(line: line) }
+            note: '2 Mbit/s PPM squitters exceed the 48 kHz audio-tap Nyquist limit; native mode reports squitter-burst density only. Feed captured SBS-1 CSV to .parse_line for full field decode.',
+            describe: proc { |b| { modulation: 'PPM', frame_len_us: 120, classification: b[:duration_ms] < 5 ? 'squitter' : 'interrogation-train' } }
           )
         end
 
@@ -60,7 +46,6 @@ module PWN
           f   = line.split(',', -1)
           out = { protocol: 'ADSB' }
           SBS_FIELDS.each_with_index { |k, i| out[k] = f[i] unless f[i].to_s.empty? }
-
           bits = []
           bits << "ICAO=#{out[:icao24]}" if out[:icao24]
           bits << "CS=#{out[:callsign].to_s.strip}" if out[:callsign]
@@ -81,15 +66,11 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts "USAGE:
+          puts "USAGE (ruby-native detector, no external binaries):
             #{self}.decode(
               freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
             )
 
-            NOTE: Requires `dump1090` (1090 MHz Mode-S/ES) or
-                  `dump978-fa` + `uat2text` (978 MHz UAT). Owns the SDR
-                  directly — set freq_obj[:sdr_args] if GQRX has device 0.
-
             #{self}.parse_line(line: 'MSG,3,1,1,ABCDEF,1,...')
 
             #{self}.authors

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

@@ -1,16 +1,100 @@
 # frozen_string_literal: true
 
-require 'shellwords'
-
 module PWN
   module SDR
     module Decoder
-      # NOAA APT (Automatic Picture Transmission) decoder for the 137 MHz
-      # polar-orbiting weather satellites (NOAA-15/18/19). APT is a 2400 Hz
-      # AM subcarrier inside a 34 kHz-wide FM downlink; GQRX's UDP audio is
-      # recorded to a WAV, then handed to `noaa-apt` (or `satdump`) to render
-      # the two-channel visible/IR image strip.
+      # Pure-Ruby NOAA APT (Automatic Picture Transmission) decoder for the
+      # 137 MHz polar-orbiting weather satellites (NOAA-15/18/19).
+      #
+      # APT is a 2400 Hz AM subcarrier inside a ~34 kHz-wide FM downlink
+      # carrying two 909-pixel image channels at 2 lines/second (4160
+      # words/line). This module envelope-demodulates the 2400 Hz carrier
+      # from GQRX's 48 kHz UDP audio, resamples to 4160 words/sec, aligns
+      # each line on the 7-pulse Sync-A pattern, and appends the resulting
+      # 8-bit greyscale rows to a Netpbm PGM (P5) file — all in Ruby.
+      # No `sox`, no `noaa-apt`.
       module APT
+        WORDS_PER_LINE = 4160
+        LINES_PER_SEC  = 2
+        WORD_RATE      = WORDS_PER_LINE * LINES_PER_SEC # 8320 Hz
+        # Sync-A: 7 cycles of 1040 Hz square = 1 1 0 0 repeated 7 times
+        SYNC_A = ([1, 1, 0, 0] * 7).freeze
+
+        # Streaming APT demodulator fed by Base.run_native.
+        class Demod
+          def initialize(rate: 48_000, out_path: nil)
+            @rate     = rate
+            @carrier  = 2400.0
+            @env_win  = (rate / @carrier).round # ≈20 samples per cycle
+            @stamp    = Time.now.strftime('%Y%m%d_%H%M%S')
+            @pgm_path = out_path || "/tmp/apt_#{@stamp}.pgm"
+            @rows     = []
+            @word_buf = []
+            @minv     = 1.0
+            @maxv     = 0.0
+          end
+
+          def feed(samples, &)
+            env   = PWN::SDR::Decoder::DSP.envelope(samples: samples, window: @env_win)
+            words = PWN::SDR::Decoder::DSP.resample(samples: env, src_rate: @rate, dst_rate: WORD_RATE)
+            @word_buf.concat(words)
+            extract_lines(&)
+          end
+
+          private
+
+          def extract_lines
+            while @word_buf.length >= WORDS_PER_LINE * 2
+              off = sync_offset(@word_buf[0, WORDS_PER_LINE])
+              @word_buf.shift(off) if off.positive?
+              break if @word_buf.length < WORDS_PER_LINE
+
+              row = @word_buf.shift(WORDS_PER_LINE)
+              lo, hi = row.minmax
+              @minv = lo if lo < @minv
+              @maxv = hi if hi > @maxv
+              @rows << row
+              write_pgm if (@rows.length % 20).zero?
+              yield(
+                protocol: 'NOAA-APT',
+                lines: @rows.length,
+                seconds: @rows.length / LINES_PER_SEC,
+                pgm: @pgm_path,
+                summary: "APT line #{@rows.length} (#{@rows.length / LINES_PER_SEC}s) → #{@pgm_path}"
+              )
+            end
+          end
+
+          def sync_offset(row)
+            mid = row.sum / row.length
+            best_off = 0
+            best_cor = -1.0
+            (0..(row.length - SYNC_A.length)).each do |o|
+              cor = 0.0
+              SYNC_A.each_with_index do |s, i|
+                cor += (row[o + i] - mid) * (s.zero? ? -1.0 : 1.0)
+              end
+              if cor > best_cor
+                best_cor = cor
+                best_off = o
+              end
+            end
+            best_off
+          end
+
+          def write_pgm
+            span = @maxv - @minv
+            span = 1.0 if span <= 0
+            File.open(@pgm_path, 'wb') do |f|
+              f.write("P5\n#{WORDS_PER_LINE} #{@rows.length}\n255\n")
+              @rows.each do |row|
+                bytes = row.map { |v| (((v - @minv) / span) * 255).clamp(0, 255).round }
+                f.write(bytes.pack('C*'))
+              end
+            end
+          end
+        end
+
         # Supported Method Parameters::
         # PWN::SDR::Decoder::APT.decode(
         #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
@@ -18,35 +102,11 @@ module PWN
 
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
-          raise 'ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
-
-          stamp   = Time.now.strftime('%Y%m%d_%H%M%S')
-          wav_out = "/tmp/apt_#{stamp}.wav"
-          png_out = "/tmp/apt_#{stamp}.png"
-
-          # Record 11 025 Hz WAV (noaa-apt's native rate) until [ENTER],
-          # emitting a heartbeat line per second so the spinner stays live,
-          # then decode to PNG on exit.
-          inner = 'sox -t raw -e signed-integer -b 16 -r 22050 -c 1 - ' \
-                  "-t wav -r 11025 #{Shellwords.escape(wav_out)} & SOXPID=$!; " \
-                  'trap "kill $SOXPID 2>/dev/null" EXIT INT TERM; ' \
-                  'while kill -0 $SOXPID 2>/dev/null; do ' \
-                  "echo APT_REC seconds=$SECONDS file=#{wav_out}; sleep 1; done"
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_native(
             freq_obj: freq_obj,
             protocol: 'NOAA-APT',
-            required_bins: %w[sox noaa-apt],
-            decode_cmd: "bash -c #{Shellwords.escape(inner)}",
-            line_match: /^APT_REC/,
-            parser: proc { |line| { protocol: 'NOAA-APT', wav: wav_out, png: png_out, summary: line.strip } }
+            demod: Demod.new
           )
-
-          return unless File.exist?(wav_out) && File.size(wav_out).positive?
-
-          system('noaa-apt', wav_out, '-o', png_out)
-
-          puts "[*] APT image written: #{png_out}" if File.exist?(png_out)
         end
 
         # Author(s):: 0day Inc. <support@0dayinc.com>
@@ -58,13 +118,14 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts "USAGE:
+          puts "USAGE (ruby-native, no external binaries):
             #{self}.decode(
               freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
             )
 
-            NOTE: Requires `sox` and `noaa-apt`. Set GQRX to FM, ~34 kHz BW.
-                  Records the pass to /tmp/apt_<ts>.wav, decodes to PNG on exit.
+            NOTE: Set GQRX to WFM (mono), ~34 kHz filter. Writes an 8-bit
+                  greyscale Netpbm P5 image to /tmp/apt_<ts>.pgm every 10 s
+                  of received pass. Both A/B channels are in one strip.
 
             #{self}.authors
           "