pwn 0.5.618 → 0.5.621

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # 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(
+        #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+        # )
+
+        public_class_method def self.decode(opts = {})
+          freq_obj = opts[:freq_obj]
+          PWN::SDR::Decoder::Base.run_detector(
+            freq_obj: freq_obj,
+            protocol: 'IRIDIUM',
+            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
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::Iridium.parse_line(line: 'IRA: sat:23 beam:14 ...')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'IRIDIUM' }
+          out[:frame_type] = ::Regexp.last_match(1) if line =~ /^([A-Z]{3}):/
+          out[:sat]        = ::Regexp.last_match(1) if line =~ /sat:(\d+)/
+          out[:beam]       = ::Regexp.last_match(1) if line =~ /beam:(\d+)/
+          out[:pos]        = ::Regexp.last_match(1) if line =~ /pos=\(([^)]+)\)/
+          out[:ra_id]      = ::Regexp.last_match(1) if line =~ /ric:(\d+)/
+          out[:summary]    = "IRIDIUM #{out[:frame_type]} sat=#{out[:sat]} beam=#{out[:beam]}"
+          out.compact
+        end
+
+        # Author(s):: 0day Inc. <support@0dayinc.com>
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        # Display Usage for this Module
+
+        public_class_method def self.help
+          puts "USAGE (ruby-native detector, no external binaries):
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            #{self}.parse_line(line: 'IRA: sat:23 beam:14 pos=(+32.1/-097.0) ...')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PWN
+  module SDR
+    module Decoder
+      # 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(
+        #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+        # )
+
+        public_class_method def self.decode(opts = {})
+          freq_obj = opts[:freq_obj]
+          PWN::SDR::Decoder::Base.run_detector(
+            freq_obj: freq_obj,
+            protocol: 'LoRa',
+            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
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::LoRa.parse_line(line: '{"model":"LoRa",...}')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          h = begin
+            JSON.parse(line, symbolize_names: true)
+          rescue StandardError
+            { unparsed: line }
+          end
+          out = { protocol: 'LoRa' }.merge(h)
+          bits = []
+          bits << "SF#{out[:sf]}" if out[:sf]
+          bits << "BW#{out[:bw]}" if out[:bw]
+          bits << "CR#{out[:cr]}" if out[:cr]
+          bits << "DevAddr=#{out[:devaddr] || out[:id]}" if out[:devaddr] || out[:id]
+          bits << "FCnt=#{out[:fcnt]}" if out[:fcnt]
+          bits << "len=#{out[:len] || (out[:data].to_s.length / 2)}" if out[:len] || out[:data]
+          out[:summary] = "LoRa #{bits.join(' ')}".strip
+          out
+        end
+
+        # Author(s):: 0day Inc. <support@0dayinc.com>
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        # Display Usage for this Module
+
+        public_class_method def self.help
+          puts "USAGE (ruby-native detector, no external binaries):
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            #{self}.parse_line(line: '{\"model\":\"LoRa\",\"sf\":7,\"bw\":125,...}')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # Pure-Ruby LTE / UMTS / CDMA cellular activity detector.
+      #
+      # 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(
+        #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+        # )
+
+        public_class_method def self.decode(opts = {})
+          freq_obj = opts[:freq_obj]
+          PWN::SDR::Decoder::Base.run_detector(
+            freq_obj: freq_obj,
+            protocol: 'LTE',
+            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 ...')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'LTE' }
+          out[:earfcn] = ::Regexp.last_match(1) if line =~ /EARFCN[:= ]+(\d+)/i
+          out[:pci]    = ::Regexp.last_match(1) if line =~ /(?:PCI|N_id_cell|Id)[:= ]+(\d{1,3})/i
+          out[:prb]    = (::Regexp.last_match(1) || ::Regexp.last_match(2)) if line =~ /(?:PRB[:= ]+(\d+)|(\d+)\s*PRB)/i
+          out[:cp]     = ::Regexp.last_match(1) if line =~ /\b(Normal|Extended)\b\s*CP/i
+          out[:rsrp]   = ::Regexp.last_match(1) if line =~ /(-?\d+(?:\.\d+)?)\s*dBm/
+          out[:freq_mhz] = ::Regexp.last_match(1) if line =~ /(\d{3,4}\.\d)\s*MHz/
+          out[:summary] = "LTE PCI=#{out[:pci]} EARFCN=#{out[:earfcn]} PRB=#{out[:prb]} RSRP=#{out[:rsrp]}dBm"
+          out.compact
+        end
+
+        # Author(s):: 0day Inc. <support@0dayinc.com>
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        # Display Usage for this Module
+
+        public_class_method def self.help
+          puts "USAGE (ruby-native detector, no external binaries):
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            #{self}.parse_line(line: 'Found CELL 739.0 MHz, EARFCN=5110, PCI=123, 50 PRB, -85.2 dBm')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # 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'
+        # )
+
+        public_class_method def self.decode(opts = {})
+          freq_obj = opts[:freq_obj]
+          PWN::SDR::Decoder::Base.run_native(
+            freq_obj: freq_obj,
+            protocol: 'MORSE-CW',
+            demod: Demod.new
+          )
+        end
+
+        # Supported Method Parameters::
+        # h = PWN::SDR::Decoder::Morse.decode_string(pattern: '.- -...')
+
+        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>
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        # Display Usage for this Module
+
+        public_class_method def self.help
+          puts "USAGE (ruby-native, no external binaries):
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            #{self}.decode_string(pattern: '.- -...')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # 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(
+        #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+        # )
+
+        public_class_method def self.decode(opts = {})
+          freq_obj = opts[:freq_obj]
+          PWN::SDR::Decoder::Base.run_detector(
+            freq_obj: freq_obj,
+            protocol: 'P25',
+            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
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::P25.parse_line(line: 'Sync: +P25p1 NAC: 293 src: 1234 tg: 5678')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'P25' }
+          out[:nac]       = ::Regexp.last_match(1) if line =~ /NAC:\s*([0-9A-Fa-f]+)/
+          out[:talkgroup] = ::Regexp.last_match(1) if line =~ /(?:TGID|tg[: ])\s*(\d+)/i
+          out[:radio_id]  = ::Regexp.last_match(1) if line =~ /(?:RID|src[: ])\s*(\d+)/i
+          out[:duid]      = ::Regexp.last_match(1) if line =~ /DUID:\s*(\S+)/
+          out[:sync]      = ::Regexp.last_match(1) if line =~ /Sync:\s*(\S+)/
+          out[:summary]   = "P25 NAC=#{out[:nac]} TG=#{out[:talkgroup]} RID=#{out[:radio_id]}".squeeze(' ')
+          out.compact
+        end
+
+        # Author(s):: 0day Inc. <support@0dayinc.com>
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        # Display Usage for this Module
+
+        public_class_method def self.help
+          puts "USAGE (ruby-native detector, no external binaries):
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            #{self}.parse_line(line: 'Sync: +P25p1 NAC: 293 src: 1234 tg: 5678')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # 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'
+        # )
+
+        public_class_method def self.decode(opts = {})
+          freq_obj = opts[:freq_obj]
+          PWN::SDR::Decoder::Base.run_native(
+            freq_obj: freq_obj,
+            protocol: 'PAGER',
+            demod: Demod.new
+          )
+        end
+
+        # Author(s):: 0day Inc. <support@0dayinc.com>
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        # Display Usage for this Module
+
+        public_class_method def self.help
+          puts "USAGE (ruby-native, no external binaries):
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            NOTE: Runs the native POCSAG (512/1200/2400) and FLEX (1600)
+                  demodulators in parallel on the same GQRX NBFM audio tap.
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end