pwn 0.5.618 → 0.5.621

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

@@ -3,19 +3,21 @@
 module PWN
   module SDR
     module Decoder
-      # POCSAG (CCIR Radiopaging Code No. 1) decoder for pager networks.
+      # Pure-Ruby POCSAG (CCIR Radiopaging Code No. 1) decoder.
       #
-      # Pipeline: GQRX UDP audio → sox 48k→22.05k → multimon-ng POCSAG512/1200/2400.
-      #
-      # multimon-ng emits lines of the form:
-      #   POCSAG1200: Address:  123456  Function: 3  Alpha:   FIRE ALARM ZONE 4
-      #   POCSAG512:  Address:  000042  Function: 0  Numeric: 5551234
-      #   POCSAG2400: Address:  987654  Function: 1  Skyper:  ...
-      #   POCSAG1200: Address:  123456  Function: 2  Alpha:   <partial><EOT>
-      #
-      # This module parses those into { protocol, baud, address, function,
-      # function_desc, type, type_desc, message } and JSON-logs each page.
+      # GQRX supplies NBFM-discriminator audio on its 48 kHz UDP tap; for a
+      # 2-FSK pager channel that is already an NRZ baseband whose sign
+      # encodes the bit. This module NRZ-slices at 512/1200/2400 baud,
+      # locks onto the 32-bit Frame Sync Codeword (0x7CD215D8), then walks
+      # each 8-frame batch of BCH(31,21)+parity codewords, extracting
+      # address (RIC/capcode + function bits) and message codewords
+      # (numeric BCD or 7-bit ASCII). No `multimon-ng`, no `sox`.
       module POCSAG
+        FSC       = 0x7CD215D8
+        IDLE_CW   = 0x7A89C197
+        BAUDS     = [1200, 512, 2400].freeze
+        BCD_TABLE = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', 'U', ' ', '-', ')', '('].freeze
+
         FUNCTION_DESC = {
           0 => 'Numeric (Tone/A)',
           1 => 'Tone only (B)',
@@ -23,59 +25,173 @@ module PWN
           3 => 'Alphanumeric (D)'
         }.freeze
 
-        TYPE_DESC = {
-          'Alpha' => 'Alphanumeric text (7-bit ASCII)',
-          'Numeric' => 'Numeric-only (BCD)',
-          'Skyper' => 'Skyper network encoded',
-          'Tone' => 'Tone-only alert (no message body)'
-        }.freeze
+        # Streaming POCSAG demodulator fed by Base.run_native.
+        class Demod
+          def initialize(rate: 48_000)
+            @rate  = rate
+            @buf   = []
+            @baud  = nil
+            @inv   = false
+            @carry_bits = []
+          end
 
-        # Supported Method Parameters::
-        # PWN::SDR::Decoder::POCSAG.decode(
-        #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
-        # )
+          def feed(samples, &)
+            @buf.concat(samples)
+            max = (@rate * 3.5).to_i
+            @buf.shift(@buf.length - max) if @buf.length > max
+            return if @buf.length < @rate # need ≥1 s to lock
 
-        public_class_method def self.decode(opts = {})
-          freq_obj = opts[:freq_obj]
+            try_lock unless @baud
+            return unless @baud
 
-          PWN::SDR::Decoder::Base.run_pipeline(
-            freq_obj: freq_obj,
-            protocol: 'POCSAG',
-            required_bins: %w[sox multimon-ng],
-            decode_cmd: 'multimon-ng -q -t raw -e -u -p ' \
-                        '-a POCSAG512 -a POCSAG1200 -a POCSAG2400 -f auto -',
-            line_match: /^POCSAG(?:512|1200|2400):/,
-            parser: proc { |line| parse_line(line: line) }
-          )
+            bits = PWN::SDR::Decoder::DSP.nrz_slice(samples: @buf, rate: @rate, baud: @baud, invert: @inv)
+            @buf.clear
+            bits = @carry_bits + bits
+            @carry_bits = POCSAG.decode_bits(bits: bits, baud: @baud, &)
+          end
+
+          private
+
+          # Try each baud × polarity until FSC (≤2 bit errors) is found.
+          def try_lock
+            hit = BAUDS.product([false, true]).find do |bd, inv|
+              bits = PWN::SDR::Decoder::DSP.nrz_slice(samples: @buf, rate: @rate, baud: bd, invert: inv)
+              PWN::SDR::Decoder::DSP.find_sync(bits: bits, pattern: FSC, width: 32, max_err: 2)
+            end
+            @baud, @inv = hit if hit
+          end
         end
 
         # Supported Method Parameters::
-        # PWN::SDR::Decoder::POCSAG.parse_line(line: 'POCSAG1200: Address: ...')
+        # carry = PWN::SDR::Decoder::POCSAG.decode_bits(bits: [...], baud: 1200) { |msg| ... }
+        # Returns the trailing (unconsumed) bits so the caller can prepend
+        # them to the next chunk for streaming continuity.
+
+        public_class_method def self.decode_bits(opts = {})
+          bits = opts[:bits] || []
+          baud = opts[:baud]
+          i = 0
+          pending = nil
+          flush = proc do
+            yield assemble(pending: pending, baud: baud) if pending && block_given?
+            pending = nil
+          end
+          loop do
+            idx = PWN::SDR::Decoder::DSP.find_sync(bits: bits, pattern: FSC, width: 32, max_err: 2, from: i)
+            break unless idx
 
-        public_class_method def self.parse_line(opts = {})
-          line = opts[:line].to_s
-          out  = { protocol: 'POCSAG' }
+            i = idx + 32
+            # One batch = 8 frames × 2 codewords × 32 bits = 512 bits
+            8.times do |frame|
+              2.times do
+                break if i + 32 > bits.length
 
-          if (m = line.match(/^POCSAG(\d+):/))
-            out[:baud] = m[1].to_i
+                cw = PWN::SDR::Decoder::DSP.bits_to_int(bits: bits[i, 32])
+                i += 32
+                next if [IDLE_CW, FSC].include?(cw)
+
+                if cw.nobits?(0x80000000)
+                  flush.call
+                  addr18 = (cw >> 13) & 0x3FFFF
+                  func   = (cw >> 11) & 0x3
+                  ric    = (addr18 << 3) | frame
+                  pending = { ric: ric, func: func, msg_words: [] }
+                elsif pending
+                  pending[:msg_words] << ((cw >> 11) & 0xFFFFF)
+                end
+              end
+            end
           end
-          if (m = line.match(/Address:\s*(\d+)/i))
-            out[:address] = m[1].to_i
-            out[:capcode] = m[1]
+          flush.call
+          tail_from = [bits.length - 576, 0].max
+          bits[tail_from..] || []
+        end
+
+        # Supported Method Parameters::
+        # h = PWN::SDR::Decoder::POCSAG.assemble(pending: {ric:,func:,msg_words:}, baud: 1200)
+
+        public_class_method def self.assemble(opts = {})
+          pending = opts[:pending]
+          baud    = opts[:baud]
+          return {} unless pending
+
+          words = pending[:msg_words] || []
+          func  = pending[:func]
+          type, text =
+            if words.empty?
+              ['Tone', nil]
+            elsif func == 3
+              ['Alpha', alpha_decode(words: words)]
+            else
+              ['Numeric', numeric_decode(words: words)]
+            end
+          out = {
+            protocol: 'POCSAG',
+            baud: baud,
+            address: pending[:ric],
+            capcode: pending[:ric].to_s.rjust(7, '0'),
+            function: func,
+            function_desc: FUNCTION_DESC[func] || 'Unknown',
+            type: type,
+            message: text
+          }.compact
+          summary = ["POCSAG#{baud}", "RIC=#{out[:capcode]}", "F#{func}(#{out[:function_desc]})"]
+          summary << "#{type}: #{text}" if text
+          out[:summary] = summary.join(' ')
+          out
+        end
+
+        # Supported Method Parameters::
+        # str = PWN::SDR::Decoder::POCSAG.numeric_decode(words: [Integer, ...])
+
+        public_class_method def self.numeric_decode(opts = {})
+          words = opts[:words] || []
+          out = +''
+          words.each do |w|
+            5.times do |d|
+              nib = (w >> (16 - (d * 4))) & 0xF
+              # POCSAG BCD nibbles are bit-reversed within each 4-bit group
+              rev = ((nib & 1) << 3) | ((nib & 2) << 1) | ((nib & 4) >> 1) | ((nib & 8) >> 3)
+              out << BCD_TABLE[rev]
+            end
           end
-          if (m = line.match(/Function:\s*(\d+)/i))
-            fn = m[1].to_i
-            out[:function]      = fn
-            out[:function_desc] = FUNCTION_DESC[fn] || 'Unknown'
+          out.gsub(/ +$/, '')
+        end
+
+        # Supported Method Parameters::
+        # str = PWN::SDR::Decoder::POCSAG.alpha_decode(words: [Integer, ...])
+
+        public_class_method def self.alpha_decode(opts = {})
+          words = opts[:words] || []
+          bitstream = []
+          words.each do |w|
+            19.downto(0) { |b| bitstream << ((w >> b) & 1) }
           end
-          if (m = line.match(/\b(Alpha|Numeric|Skyper|Tone):\s*(.*)$/i))
-            type = m[1].capitalize
-            out[:type]      = type
-            out[:type_desc] = TYPE_DESC[type] || 'Unknown'
-            out[:message]   = m[2].to_s.gsub(/<[A-Z]{2,3}>/, '').strip
+          out = +''
+          bitstream.each_slice(7) do |ch|
+            break if ch.length < 7
+
+            # 7-bit ASCII, LSB first within each character
+            code = ch.each_with_index.sum { |b, i| b << i }
+            next if code.zero? || code == 0x03 || code == 0x17
+
+            out << (code.between?(0x20, 0x7E) ? code.chr : '.')
           end
-          out[:summary] = "POCSAG#{out[:baud]} RIC=#{out[:capcode]} F#{out[:function]} #{out[:type]}: #{out[:message]}"
-          out
+          out.strip
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::POCSAG.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: 'POCSAG',
+            demod: Demod.new
+          )
         end
 
         # Author(s):: 0day Inc. <support@0dayinc.com>
@@ -87,12 +203,18 @@ 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: 'POCSAG1200: Address: 123456 Function: 3 Alpha: HELLO')
+            #{self}.decode_bits(bits: [0,1,...], baud: 1200) { |msg| ... }
+            #{self}.assemble(pending: {ric:, func:, msg_words:[]}, baud: 1200)
+            #{self}.numeric_decode(words: [Integer, ...])
+            #{self}.alpha_decode(words: [Integer, ...])
+
+            NOTE: Set GQRX to Narrow FM. Baud (512/1200/2400) and NRZ
+                  polarity are auto-detected from the FSC 0x7CD215D8.
 
             #{self}.authors
           "

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # Pure-Ruby RFID activity detector for LF (125/134 kHz), HF
+      # (13.56 MHz) and UHF (860–960 MHz EPC Gen2).
+      #
+      # Near-field ASK/load-modulation on LF/HF requires an inductive
+      # coupler (not an SDR antenna); UHF backscatter is 40–640 kbps ASK.
+      # Native mode reports reader-carrier presence and tag-response
+      # bursts by band. `parse_line` retained for offline text analysis.
+      module RFID
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::RFID.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]
+          hz = PWN::SDR.hz_to_i(freq: freq_obj[:freq])
+          band = if hz < 1_000_000 then 'LF'
+                 elsif hz.between?(13_000_000, 14_000_000) then 'HF'
+                 else 'UHF'
+                 end
+          PWN::SDR::Decoder::Base.run_detector(
+            freq_obj: freq_obj,
+            protocol: "RFID-#{band}",
+            note: 'Native mode reports reader-carrier and tag-backscatter bursts by band.',
+            threshold: 6.0,
+            describe: proc { |b|
+              kind = case band
+                     when 'LF'  then b[:duration_ms] > 100 ? 'reader-CW' : 'EM4x/HID-response'
+                     when 'HF'  then b[:duration_ms] > 5   ? 'ISO14443-REQA/frame' : 'ISO15693-slot'
+                     else            b[:duration_ms] > 20  ? 'reader-Query' : 'EPC-backscatter'
+                     end
+              { band: band, modulation: 'ASK/load-mod', classification: kind }
+            }
+          )
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::RFID.parse_line(line: 'UID: 04 A1 B2 C3 D4 E5 F6')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'RFID' }
+          out[:uid]  = ::Regexp.last_match(1).delete(' ') if line =~ /UID[:=]?\s*((?:[0-9A-Fa-f]{2}\s*){4,10})/
+          out[:epc]  = ::Regexp.last_match(1) if line =~ /EPC[:=]?\s*([0-9A-Fa-f]+)/
+          out[:atqa] = ::Regexp.last_match(1) if line =~ /ATQA[:=]?\s*([0-9A-Fa-f ]+)/
+          out[:sak]  = ::Regexp.last_match(1) if line =~ /SAK[:=]?\s*([0-9A-Fa-f]+)/
+          out[:tag]  = ::Regexp.last_match(1) if line =~ /(EM4\w+|HID\w*|Mifare\w*|NTAG\w*|ISO\s?\d+)/i
+          out[:summary] = "RFID #{out[:tag]} UID=#{out[:uid] || out[:epc]}".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: 'UID: 04 A1 B2 C3 D4 E5 F6  SAK: 08  Mifare Classic 1K')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PWN
+  module SDR
+    module Decoder
+      # Pure-Ruby ISM/keyfob/sensor activity detector for the 315 / 390 /
+      # 433.92 / 868 / 915 MHz device zoo.
+      #
+      # The upstream `rtl_433` binary carries ~250 device-specific protocol
+      # dissectors; re-implementing that library is out of scope. This
+      # module instead characterises OOK/ASK/FSK bursts natively (count,
+      # duration, gap, peak dBFS) — enough to fingerprint a keyfob press,
+      # a periodic weather-station beacon, or a TPMS chirp — without
+      # invoking any external binary. `parse_line` still accepts rtl_433
+      # `-F json` output for offline analysis.
+      module RTL433
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::RTL433.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: 'ISM-433',
+            note: 'Native OOK/FSK burst characteriser (no rtl_433 binary). Feed captured `rtl_433 -F json` lines to .parse_line for per-device decode.',
+            threshold: 10.0,
+            describe: proc { |b|
+              kind = if b[:duration_ms] < 20 then 'keyfob/OOK-short'
+                     elsif b[:duration_ms] < 120 then 'sensor/OOK-packet'
+                     else 'FSK-continuous'
+                     end
+              { modulation: 'OOK/ASK/FSK', classification: kind }
+            }
+          )
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::RTL433.parse_line(line: '{"time":"...","model":"..."}')
+
+        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: 'RTL433' }.merge(h)
+          bits = []
+          bits << out[:model].to_s if out[:model]
+          bits << "id=#{out[:id]}" if out[:id]
+          bits << "ch=#{out[:channel]}" if out[:channel]
+          bits << "code=#{out[:code]}" if out[:code]
+          bits << "cmd=#{out[:cmd] || out[:button]}" if out[:cmd] || out[:button]
+          bits << "temp=#{out[:temperature_C]}C" if out[:temperature_C]
+          bits << "rssi=#{out[:rssi]}" if out[:rssi]
+          out[:summary] = bits.empty? ? line[0, 120] : bits.join(' ')
+          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\":\"Acurite-Tower\",\"id\":1234,...}')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # Pure-Ruby RTTY (Radioteletype, ITA2/Baudot) decoder.
+      #
+      # Amateur RTTY is 45.45 baud 2-FSK with a 170 Hz shift; on USB the
+      # convention is mark ≈ 2125 Hz, space ≈ 2295 Hz in the demodulated
+      # audio. This module runs a per-symbol Goertzel on both tones,
+      # frames 1-start / 5-data / 1.5-stop asynchronously, and decodes
+      # ITA2 via DSP::BAUDOT_LTRS/FIGS. No `minimodem`, no `sox`.
+      module RTTY
+        # Streaming 2-FSK Baudot demodulator fed by Base.run_native.
+        class Demod
+          def initialize(rate: 48_000, baud: 45.45, mark_hz: 2125.0, space_hz: 2295.0)
+            @rate     = rate
+            @baud     = baud
+            @mark_hz  = mark_hz
+            @space_hz = space_hz
+            @spb      = rate / baud
+            @buf      = []
+            @figs     = false
+            @line     = +''
+            @idle_bits = 0
+          end
+
+          def feed(samples, &)
+            @buf.concat(samples)
+            # keep at most ~2 s of audio buffered
+            @buf.shift(@buf.length - (@rate * 2)) if @buf.length > @rate * 2
+            demod_buffer(&)
+          end
+
+          private
+
+          def bit_at(offset)
+            a = offset.floor
+            b = (offset + @spb).floor
+            win = @buf[a...b]
+            pm = PWN::SDR::Decoder::DSP.goertzel(samples: win, rate: @rate, freq: @mark_hz)
+            ps = PWN::SDR::Decoder::DSP.goertzel(samples: win, rate: @rate, freq: @space_hz)
+            pm >= ps ? 1 : 0
+          end
+
+          # Async framing: idle = mark(1), start bit = space(0), 5 data bits
+          # LSB-first, ≥1 stop bit = mark(1).
+          def demod_buffer(&)
+            char_span = (@spb * 7.5).ceil
+            pos = 0.0
+            while @buf.length - pos > char_span
+              if bit_at(pos) == 1
+                pos += @spb
+                @idle_bits += 1
+                flush_line(&) if @idle_bits > 20 && !@line.empty?
+                next
+              end
+              @idle_bits = 0
+              # start bit found — sample 5 data bits at their centres
+              data = Array.new(5) { |i| bit_at(pos + (@spb * (i + 1))) }
+              stop = bit_at(pos + (@spb * 6))
+              pos += @spb * 7.5
+              next unless stop == 1
+
+              handle_code(data.each_with_index.sum { |b, i| b << i }, &)
+            end
+            consumed = pos.floor
+            @buf.shift(consumed) if consumed.positive?
+          end
+
+          def handle_code(code, &)
+            case code
+            when 31 then @figs = false
+            when 27 then @figs = true
+            else
+              tbl = @figs ? PWN::SDR::Decoder::DSP::BAUDOT_FIGS : PWN::SDR::Decoder::DSP::BAUDOT_LTRS
+              c = tbl[code]
+              return unless c
+
+              if ["\n", "\r"].include?(c)
+                flush_line(&)
+              else
+                @line << c
+                flush_line(&) if @line.length >= 80
+              end
+            end
+          end
+
+          def flush_line
+            return if @line.strip.empty?
+
+            out = { protocol: 'RTTY', baud: @baud, shift_hz: (@space_hz - @mark_hz).round, text: @line.dup }
+            if (m = @line.match(/\bDE\s+([A-Z0-9]{1,3}\d[A-Z]{1,4})\b/))
+              out[:callsign] = m[1]
+            end
+            out[:summary] = "RTTY #{@line.strip}"[0, 120]
+            yield out
+            @line = +''
+          end
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::RTTY.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: 'RTTY',
+            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 2-FSK ITA2, no external binaries):
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            NOTE: Set GQRX to USB, tune so mark≈2125 Hz / space≈2295 Hz in
+                  the audio passband. 45.45 baud, 170 Hz shift, 1N5+1.5.
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module PWN
+  module SDR
+    module Decoder
+      # Pure-Ruby 802.11 (WiFi) activity detector.
+      #
+      # 20+ MHz OFDM cannot be demodulated in interpreted Ruby in real
+      # time. Native mode reports channel occupancy/duty and maps
+      # freq_obj to a WLAN channel number. `parse_line` retained for
+      # offline pipe-delimited tshark-fields analysis.
+      module WiFi
+        TSHARK_FIELDS = %w[
+          frame.time_relative wlan.fc.type_subtype wlan.bssid wlan.sa
+          wlan.da wlan_radio.channel wlan_radio.signal_dbm wlan.ssid
+        ].freeze
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::WiFi.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]
+          hz  = PWN::SDR.hz_to_i(freq: freq_obj[:freq])
+          mhz = (hz / 1_000_000.0).round
+          ch  = case mhz
+                when 2412..2472 then ((mhz - 2412) / 5) + 1
+                when 2484       then 14
+                when 5000..5900 then (mhz - 5000) / 5
+                else 0
+                end
+          PWN::SDR::Decoder::Base.run_detector(
+            freq_obj: freq_obj,
+            protocol: 'WiFi-802.11',
+            note: '20+ MHz OFDM — native mode reports channel occupancy/duty only.',
+            threshold: 6.0,
+            describe: proc { |b| { modulation: 'OFDM', channel: ch, mhz: mhz, airtime_ms: b[:duration_ms] } }
+          )
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::WiFi.parse_line(line: 't|subtype|bssid|sa|da|ch|rssi|ssid')
+
+        public_class_method def self.parse_line(opts = {})
+          f = opts[:line].to_s.split('|', -1)
+          out = {
+            protocol: 'WiFi', subtype: f[1], bssid: f[2], sa: f[3], da: f[4],
+            channel: f[5], rssi_dbm: f[6], ssid: f[7]
+          }.reject { |_, v| v.to_s.empty? }
+          out[:summary] = "WiFi ch#{out[:channel]} #{out[:bssid]} '#{out[:ssid]}' #{out[:rssi_dbm]}dBm"
+          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: '0.1|8|aa:bb:..|aa:bb:..|ff:ff:..|6|-42|linksys')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end