pwn 0.5.620 → 0.5.621

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

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'shellwords'
-
 module PWN
   module SDR
     module Decoder
-      # Iridium L-band (1.616–1.6265 GHz) burst decoder. Drives gr-iridium's
-      # `iridium-extractor` against the SDR to demodulate 25 kbit/s DE-QPSK
-      # simplex/duplex bursts, then pipes them through iridium-toolkit's
-      # `iridium-parser.py` for frame classification (IRA/IBC/IDA/ISY/VOC/...).
+      # Pure-Ruby Iridium L-band burst detector.
+      #
+      # Iridium simplex/duplex bursts are 25 kbit/s DE-QPSK across
+      # 1616–1626.5 MHz. Native mode reports burst count/duration/energy
+      # per channel. `parse_line` retained for offline iridium-toolkit
+      # text analysis.
       module Iridium
         # Supported Method Parameters::
         # PWN::SDR::Decoder::Iridium.decode(
@@ -17,24 +17,12 @@ 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
-          sdr_args = (freq_obj[:sdr_args] || 'rtl=0').to_s
-
-          inner = "iridium-extractor -D 4 --multi-frame -c #{hz} -r 2000000 " \
-                  "-g #{gain} -o - #{Shellwords.escape(sdr_args)} 2>/dev/null " \
-                  '| iridium-parser.py --harder /dev/stdin'
-          direct_cmd = "bash -c #{Shellwords.escape(inner)}"
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_detector(
             freq_obj: freq_obj,
             protocol: 'IRIDIUM',
-            required_bins: %w[iridium-extractor iridium-parser.py],
-            direct_cmd: direct_cmd,
-            line_match: /^(IRA|IBC|IDA|ISY|ITL|MSG|VOC|RAW):/,
-            parser: proc { |line| parse_line(line: line) }
+            note: '25 kbit/s DE-QPSK — native mode reports burst timing/energy only.',
+            threshold: 7.0,
+            describe: proc { |b| { modulation: 'DE-QPSK', symbol_rate: 25_000, classification: b[:duration_ms] < 10 ? 'simplex-burst' : 'duplex-frame' } }
           )
         end
 
@@ -62,14 +50,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 `iridium-extractor` (gr-iridium) and
-                  `iridium-parser.py` (iridium-toolkit). Owns the SDR.
-
             #{self}.parse_line(line: 'IRA: sat:23 beam:14 pos=(+32.1/-097.0) ...')
 
             #{self}.authors

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

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'shellwords'
 
 module PWN
   module SDR
     module Decoder
-      # LoRa / LoRaWAN CSS decoder for the 433 / 868 / 902–928 MHz ISM
-      # allocations. Chirp-spread-spectrum needs raw I/Q, so this drives
-      # `rtl_433` (which ships a native LoRa demod, protocol #264) directly.
-      # Emits one JSON line per decoded uplink containing SF/BW/CR, DevAddr,
-      # FCnt, and raw PHYPayload hex.
+      # Pure-Ruby LoRa / LoRaWAN CSS activity detector.
+      #
+      # LoRa is chirp-spread-spectrum over 125/250/500 kHz — recoverable
+      # only from raw I/Q at ≥250 ksps, not from a 48 kHz audio tap.
+      # Native mode reports chirp-burst duration/energy (from which SF
+      # can be estimated). `parse_line` retained for offline JSON analysis.
       module LoRa
         # Supported Method Parameters::
         # PWN::SDR::Decoder::LoRa.decode(
@@ -19,22 +19,17 @@ 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])
-          sdr_args = freq_obj[:sdr_args].to_s
-
-          cmd = ['rtl_433', '-f', hz.to_s, '-s', '1024k',
-                 '-R', '264', '-F', 'json', '-M', 'level']
-          cmd.push('-d', sdr_args) unless sdr_args.empty?
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_detector(
             freq_obj: freq_obj,
             protocol: 'LoRa',
-            required_bins: %w[rtl_433],
-            direct_cmd: Shellwords.join(cmd),
-            line_match: /^\s*{/,
-            parser: proc { |line| parse_line(line: line) }
+            note: 'CSS over 125–500 kHz — native mode reports chirp bursts and estimates SF from duration.',
+            threshold: 8.0,
+            describe: proc { |b|
+              # Preamble ≈ 8 symbols; T_sym = 2^SF / BW. Assume BW=125k.
+              t_sym_ms = b[:duration_ms] / 20.0
+              sf_est = t_sym_ms.positive? ? Math.log2(t_sym_ms * 125).round.clamp(6, 12) : nil
+              { modulation: 'CSS', bw_khz_assumed: 125, sf_estimate: sf_est }.compact
+            }
           )
         end
 
@@ -69,13 +64,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 `rtl_433` >= 23.x (native LoRa demod). Owns SDR.
-
             #{self}.parse_line(line: '{\"model\":\"LoRa\",\"sf\":7,\"bw\":125,...}')
 
             #{self}.authors

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

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-require 'shellwords'
-
 module PWN
   module SDR
     module Decoder
-      # LTE / UMTS / CDMA / PCS / AWS wideband cellular cell-search decoder.
+      # Pure-Ruby LTE / UMTS / CDMA cellular activity detector.
       #
-      # 1.4–20 MHz OFDMA/WCDMA cannot be recovered from GQRX audio; this
-      # module drives srsRAN's `cell_search` (or `LTE-Cell-Scanner`'s
-      # `CellSearch`) directly against the SDR to enumerate physical cells:
-      # EARFCN, PCI, CP type, RSRP/RSRQ, PSS/SSS correlation.
+      # 1.4–20 MHz OFDMA/WCDMA is far beyond a 48 kHz audio tap and beyond
+      # interpreted Ruby's real-time I/Q throughput. Native mode reports
+      # channel occupancy / power only. `parse_line` retained for offline
+      # cell_search / CellSearch text analysis.
       module LTE
         # Supported Method Parameters::
         # PWN::SDR::Decoder::LTE.decode(
@@ -19,33 +17,17 @@ 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
-          sdr_args = (freq_obj[:sdr_args] || 'driver=rtlsdr').to_s
-
-          direct_cmd =
-            if PWN::SDR::Decoder::Base.bin_available?(bin: 'cell_search')
-              # srsRAN cell_search takes a band number; fall back to explicit
-              # DL frequency via -s/-e range when unavailable.
-              "cell_search -a #{Shellwords.escape(sdr_args)} -g #{gain} -s #{hz} -e #{hz}"
-            else
-              "CellSearch -s #{hz / 1_000_000.0} -e #{hz / 1_000_000.0} -g #{gain}"
-            end
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_detector(
             freq_obj: freq_obj,
             protocol: 'LTE',
-            required_bins: %w[cell_search],
-            direct_cmd: direct_cmd,
-            line_match: /(CELL|PCI|EARFCN|Found|RSRP|CID)/i,
-            parser: proc { |line| parse_line(line: line) }
+            note: 'OFDMA (1.4–20 MHz, 15 kHz subcarriers) — native mode reports channel occupancy only.',
+            threshold: 4.0,
+            describe: proc { |_b| { modulation: 'OFDMA', subcarrier_khz: 15 } }
           )
         end
 
         # Supported Method Parameters::
-        # PWN::SDR::Decoder::LTE.parse_line(line: 'Found CELL ... PCI: 123 ... PRB: 50 ... -85.0 dBm')
+        # PWN::SDR::Decoder::LTE.parse_line(line: 'Found CELL ... PCI: 123 ...')
 
         public_class_method def self.parse_line(opts = {})
           line = opts[:line].to_s
@@ -69,14 +51,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 srsRAN `cell_search` (or LTE-Cell-Scanner
-                  `CellSearch`). Owns the SDR — set freq_obj[:sdr_args].
-
             #{self}.parse_line(line: 'Found CELL 739.0 MHz, EARFCN=5110, PCI=123, 50 PRB, -85.2 dBm')
 
             #{self}.authors

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

@@ -3,11 +3,93 @@
 module PWN
   module SDR
     module Decoder
-      # CW / Morse decoder for the amateur CW sub-bands (cw20/cw40/cw80,
-      # amateur_30m). GQRX's CW demodulator produces a ~700 Hz sidetone in the
-      # 48 kHz UDP audio stream; multimon-ng's MORSE_CW demod recovers the
-      # dit/dah timing and prints decoded characters one line at a time.
+      # Pure-Ruby CW / Morse decoder for the amateur CW sub-bands.
+      #
+      # GQRX's CW/USB demodulator produces a ~600–800 Hz sidetone in the
+      # 48 kHz UDP audio stream. This module envelope-detects the tone
+      # with a state-preserving single-pole low-pass, adaptively
+      # thresholds it into on/off runs, classifies each run as dit / dah
+      # / char-gap / word-gap by timing, and looks the resulting `.-`
+      # sequences up in DSP::MORSE_TABLE. No `multimon-ng`, no `sox`.
       module Morse
+        # Stateful, streaming CW demodulator fed by Base.run_native.
+        class Demod
+          def initialize(rate: 48_000)
+            @rate    = rate
+            # single-pole low-pass on |x|; τ ≈ 5 ms
+            @env_a   = Math.exp(-1.0 / (rate * 0.005))
+            @env     = 0.0
+            @floor   = 0.0
+            @peak    = 0.0
+            @state   = :off
+            @run     = 0
+            @dit     = rate * 60 / 1000 # seed 60 ms (≈ 20 WPM)
+            @sym     = +''
+            @word    = +''
+          end
+
+          def feed(samples, &)
+            samples.each do |x|
+              @env = (@env_a * @env) + ((1.0 - @env_a) * x.abs)
+              # slow trackers for adaptive threshold (attack fast, decay slow)
+              @peak  = @env > @peak ? ((@peak * 0.7) + (@env * 0.3)) : (@peak * 0.9999)
+              @floor = @env < @floor ? @env : ((@floor * 0.9999) + (@env * 0.0001))
+              thresh = @floor + ((@peak - @floor) * 0.4)
+              on = @env > thresh && (@peak - @floor) > 0.01
+              if on == (@state == :on)
+                @run += 1
+              else
+                classify_run(&)
+                @state = on ? :on : :off
+                @run   = 1
+              end
+            end
+            return unless @state == :off && @run > 5 * @dit && !(@sym.empty? && @word.empty?)
+
+            flush_char
+            flush_word(&)
+          end
+
+          private
+
+          def classify_run(&)
+            return if @run < @rate / 500 # <2 ms glitch
+
+            if @state == :on
+              @dit = ((@dit * 3) + @run) / 4 if @run < @dit * 1.5 && @run > @rate / 200
+              @sym << (@run > 2 * @dit ? '-' : '.')
+            else
+              return if @sym.empty? && @word.empty?
+
+              if @run > 5 * @dit
+                flush_char
+                flush_word(&)
+              elsif @run > 2 * @dit
+                flush_char
+              end
+            end
+          end
+
+          def flush_char
+            return if @sym.empty?
+
+            @word << (PWN::SDR::Decoder::DSP::MORSE_TABLE[@sym] || '_')
+            @sym = +''
+          end
+
+          def flush_word
+            return if @word.empty?
+
+            out = { protocol: 'MORSE-CW', text: @word.dup }
+            if (m = @word.match(/\b([A-Z0-9]{1,3}\d[A-Z]{1,4})\b/))
+              out[:callsign] = m[1]
+            end
+            out[:summary] = "CW #{@word}"[0, 120]
+            yield out
+            @word = +''
+          end
+        end
+
         # Supported Method Parameters::
         # PWN::SDR::Decoder::Morse.decode(
         #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
@@ -15,28 +97,20 @@ module PWN
 
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_native(
             freq_obj: freq_obj,
             protocol: 'MORSE-CW',
-            required_bins: %w[sox multimon-ng],
-            decode_cmd: 'multimon-ng -q -t raw -a MORSE_CW -',
-            line_match: /\S/,
-            parser: proc { |line| parse_line(line: line) }
+            demod: Demod.new
           )
         end
 
         # Supported Method Parameters::
-        # PWN::SDR::Decoder::Morse.parse_line(line: 'CQ CQ DE W1AW')
+        # h = PWN::SDR::Decoder::Morse.decode_string(pattern: '.- -...')
 
-        public_class_method def self.parse_line(opts = {})
-          line = opts[:line].to_s.gsub(/^MORSE(?:_CW)?:\s*/i, '').strip
-          out  = { protocol: 'MORSE-CW', text: line }
-          if (m = line.match(/\b([A-Z0-9]{1,3}\d[A-Z]{1,4})\b/))
-            out[:callsign] = m[1]
-          end
-          out[:summary] = "CW #{line}"[0, 120]
-          out
+        public_class_method def self.decode_string(opts = {})
+          pattern = opts[:pattern].to_s
+          txt = pattern.strip.split(/\s+/).map { |s| PWN::SDR::Decoder::DSP::MORSE_TABLE[s] || '_' }.join
+          { protocol: 'MORSE-CW', text: txt, summary: "CW #{txt}" }
         end
 
         # Author(s):: 0day Inc. <support@0dayinc.com>
@@ -48,12 +122,12 @@ 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'
             )
 
-            #{self}.parse_line(line: 'CQ CQ DE W1AW W1AW K')
+            #{self}.decode_string(pattern: '.- -...')
 
             #{self}.authors
           "

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

@@ -3,10 +3,14 @@
 module PWN
   module SDR
     module Decoder
-      # APCO Project 25 (P25) Phase-1 C4FM decoder for the 700/800 MHz
-      # public-safety allocations. GQRX supplies NBFM-discriminator audio via
-      # the UDP tap; `dsd` (Digital Speech Decoder) recovers the C4FM symbol
-      # stream and prints trunking-control frames (NAC, TGID, RID, DUID, ...).
+      # Pure-Ruby APCO Project 25 Phase-1 C4FM activity detector.
+      #
+      # P25 is 4800 sym/s 4-level FSK with 1/2-rate trellis + RS + IMBE
+      # vocoder. Full symbol recovery, deinterleave, FEC and voice decode
+      # is out of scope for a portable pure-Ruby implementation; this
+      # module instead characterises C4FM keying activity (talkgroup key-
+      # ups, control-channel duty cycle) natively via Base.run_detector.
+      # `parse_line` is retained for offline dsd-format log analysis.
       module P25
         # Supported Method Parameters::
         # PWN::SDR::Decoder::P25.decode(
@@ -15,17 +19,18 @@ module PWN
 
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
-
-          # dsd expects 48 kHz s16le on stdin — bypass Base's 22 050 Hz resample
-          # by asking for 48 000 (sox becomes a passthrough / format guard).
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_detector(
             freq_obj: freq_obj,
             protocol: 'P25',
-            required_bins: %w[sox dsd],
-            resample_hz: 48_000,
-            decode_cmd: 'dsd -q -i - -o /dev/null -f1',
-            line_match: /(NAC|TGID|TG:|RID|src:|P25|Sync:)/i,
-            parser: proc { |line| parse_line(line: line) }
+            note: 'C4FM 4-FSK + trellis/RS/IMBE — native mode reports key-up bursts (duration/peak/duty) only. Feed captured dsd text to .parse_line for NAC/TG/RID.',
+            threshold: 6.0,
+            describe: proc { |b|
+              kind = if b[:duration_ms] > 1500 then 'voice-superframe'
+                     elsif b[:duration_ms] > 150 then 'LDU/HDU'
+                     else 'TSBK/control'
+                     end
+              { modulation: 'C4FM', symbol_rate: 4800, classification: kind }
+            }
           )
         end
 
@@ -53,13 +58,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 `dsd`. Set GQRX demod to Narrow FM, ~12.5 kHz.
-
             #{self}.parse_line(line: 'Sync: +P25p1 NAC: 293 src: 1234 tg: 5678')
 
             #{self}.authors

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

@@ -3,12 +3,24 @@
 module PWN
   module SDR
     module Decoder
-      # Combined pager decoder for the mixed-protocol `pager_all` band plan.
-      #
-      # Runs multimon-ng with FLEX + FLEX_NEXT + POCSAG512/1200/2400 enabled
-      # simultaneously and dispatches each output line to the appropriate
-      # per-protocol parser (::Flex-style or ::POCSAG.parse_line).
+      # Pure-Ruby combined pager decoder for the mixed-protocol `pager_all`
+      # band plan. Feeds every incoming 48 kHz audio chunk to BOTH the
+      # native POCSAG and FLEX demodulators concurrently; whichever locks
+      # emits messages. No `multimon-ng`, no `sox`.
       module Pager
+        # Composite demodulator wrapping POCSAG::Demod + Flex::Demod.
+        class Demod
+          def initialize(rate: 48_000)
+            @pocsag = PWN::SDR::Decoder::POCSAG::Demod.new(rate: rate)
+            @flex   = PWN::SDR::Decoder::Flex::Demod.new(rate: rate)
+          end
+
+          def feed(samples, &)
+            @pocsag.feed(samples.dup, &)
+            @flex.feed(samples, &)
+          end
+        end
+
         # Supported Method Parameters::
         # PWN::SDR::Decoder::Pager.decode(
         #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
@@ -16,42 +28,13 @@ module PWN
 
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
-
-          decode_cmd = 'multimon-ng -q -t raw -e -u -p ' \
-                       '-a FLEX -a FLEX_NEXT ' \
-                       '-a POCSAG512 -a POCSAG1200 -a POCSAG2400 -'
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_native(
             freq_obj: freq_obj,
             protocol: 'PAGER',
-            required_bins: %w[sox multimon-ng],
-            decode_cmd: decode_cmd,
-            line_match: /^(FLEX|POCSAG)/,
-            parser: proc { |line| parse_line(line: line) }
+            demod: Demod.new
           )
         end
 
-        # Supported Method Parameters::
-        # PWN::SDR::Decoder::Pager.parse_line(line: 'FLEX|... or POCSAG1200: ...')
-
-        public_class_method def self.parse_line(opts = {})
-          line = opts[:line].to_s
-          return PWN::SDR::Decoder::POCSAG.parse_line(line: line) if line.start_with?('POCSAG')
-
-          # FLEX / FLEX_NEXT — pipe- or space-delimited (see ::Flex for format).
-          delim  = line.start_with?('FLEX: ') ? ' ' : '|'
-          parts  = line.split(delim)
-          proto  = line.start_with?('FLEX_NEXT') ? 'FLEX_NEXT' : 'FLEX'
-          types  = %w[ALN BIN HEX NUM TON TONE UNK]
-          t_idx  = parts.index { |p| types.include?(p) }
-          out    = { protocol: proto, raw_inspected: line.inspect }
-          out[:capcode]      = parts.find { |p| p.match?(/^\[?\d{7,10}\]?$/) }
-          out[:type]         = t_idx ? parts[t_idx] : nil
-          out[:type_payload] = t_idx ? parts[(t_idx + 1)..].join(delim) : nil
-          out[:summary]      = "#{proto} RIC=#{out[:capcode]} #{out[:type]}: #{out[:type_payload]}"
-          out.compact
-        end
-
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
@@ -61,12 +44,13 @@ 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'
             )
 
-            #{self}.parse_line(line: 'FLEX|3200|...|ALN|MESSAGE')
+            NOTE: Runs the native POCSAG (512/1200/2400) and FLEX (1600)
+                  demodulators in parallel on the same GQRX NBFM audio tap.
 
             #{self}.authors
           "