pwn 0.5.620 → 0.5.621

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

@@ -3,20 +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 (identical shape to PWN::SDR::Decoder::Flex):
-      #   GQRX 48 kHz s16le UDP audio → sox → 22 050 Hz → multimon-ng.
-      #
-      # 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>
-      #
-      # Each line is parsed into { protocol, baud, address/capcode, function,
-      # function_desc, type, type_desc, message } and JSON-logged.
+      # 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)',
@@ -24,73 +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
 
-          # -e  hide empty messages
-          # -u  heuristically prune unlikely decodes (cuts BCH false-positives)
-          # -p  emit partially received messages (still useful intel)
-          # -f alpha  force Alpha framing when function bits are ambiguous —
-          #           mirrors the behaviour operators expect from Flex ALN.
-          decode_cmd = 'multimon-ng -q -t raw -e -u -p -f alpha ' \
-                       '-a POCSAG512 -a POCSAG1200 -a POCSAG2400 -'
+            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
 
-          PWN::SDR::Decoder::Base.run_pipeline(
-            freq_obj: freq_obj,
-            protocol: 'POCSAG',
-            required_bins: %w[sox multimon-ng],
-            decode_cmd: decode_cmd,
-            line_match: /^POCSAG(?:512|1200|2400):/,
-            parser: proc { |line| parse_line(line: line) }
-          )
+          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
+
+            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
+
+                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
+          flush.call
+          tail_from = [bits.length - 576, 0].max
+          bits[tail_from..] || []
+        end
 
-        public_class_method def self.parse_line(opts = {})
-          line = opts[:line].to_s
-          out  = { protocol: 'POCSAG', raw_inspected: line.inspect }
+        # 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
 
-          if (m = line.match(/^POCSAG(\d+):/))
-            out[:baud] = m[1].to_i
-          end
-          if (m = line.match(/Address:\s*(\d+)/i))
-            out[:address] = m[1].to_i
-            out[:capcode] = m[1].rjust(7, '0')
+        # 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[:type_payload] = m[2].to_s.gsub(/<[A-Z]{2,4}>/, '').strip
-            out[:message]      = out[:type_payload]
+          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.strip
+        end
 
-          bits = []
-          bits << "POCSAG#{out[:baud]}" if out[:baud]
-          bits << "RIC=#{out[:capcode]}" if out[:capcode]
-          bits << "F#{out[:function]}(#{out[:function_desc]})" if out[:function]
-          bits << "#{out[:type]}: #{out[:message]}" if out[:type]
-          out[:summary] = bits.join(' ')
-          out
+        # 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>
@@ -102,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

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'shellwords'
-
 module PWN
   module SDR
     module Decoder
-      # RFID decoder covering LF (125/134 kHz), HF (13.56 MHz) and UHF
-      # (860–960 MHz EPC Gen2). Near-field ASK/load-modulation is not
-      # recoverable from GQRX audio, so this drives a Proxmark3 (LF/HF) via
-      # `pm3 -c '...'` or `nfc-list` (HF), and `rtl_433` in flex/analyzer mode
-      # for UHF backscatter — whichever tool is present.
+      # 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(
@@ -18,30 +18,24 @@ 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])
-
-          direct_cmd, bins, proto =
-            if hz < 1_000_000
-              ["pm3 -c 'lf search'", %w[pm3], 'RFID-LF']
-            elsif hz.between?(13_000_000, 14_000_000)
-              if PWN::SDR::Decoder::Base.bin_available?(bin: 'pm3')
-                ["pm3 -c 'hf search'", %w[pm3], 'RFID-HF']
-              else
-                ['nfc-list -v', %w[nfc-list], 'RFID-HF']
-              end
-            else
-              ["rtl_433 -f #{hz} -A -F json", %w[rtl_433], 'RFID-UHF']
-            end
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          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: proto,
-            required_bins: bins,
-            direct_cmd: direct_cmd,
-            line_match: /(UID|EPC|TAG|ATQA|SAK|EM4|HID|ISO|Chipset|"model")/i,
-            parser: proc { |line| parse_line(line: line) }
+            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
 
@@ -69,14 +63,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: LF/HF need a Proxmark3 (`pm3`) or libnfc reader; UHF uses
-                  `rtl_433 -A`. Band chosen automatically from freq_obj[:freq].
-
             #{self}.parse_line(line: 'UID: 04 A1 B2 C3 D4 E5 F6  SAK: 08  Mifare Classic 1K')
 
             #{self}.authors

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

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'shellwords'
 
 module PWN
   module SDR
     module Decoder
-      # Generic ISM/keyfob/sensor decoder backed by `rtl_433`.
+      # Pure-Ruby ISM/keyfob/sensor activity detector for the 315 / 390 /
+      # 433.92 / 868 / 915 MHz device zoo.
       #
-      # Covers the OOK/ASK/FSK device zoo on 300–315 / 390 / 433.92 / 868 /
-      # 902–928 MHz: car/garage keyfobs, TPMS, weather stations, utility
-      # meters, doorbells, alarm PIRs, etc. rtl_433 owns the SDR directly and
-      # emits one JSON object per decoded frame (`-F json`), which this module
-      # merges verbatim into the freq_obj log line.
+      # 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(
@@ -21,24 +23,18 @@ 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]
-          sdr_args = freq_obj[:sdr_args].to_s
-
-          cmd = ['rtl_433', '-f', hz.to_s, '-F', 'json', '-M', 'level', '-M', 'protocol']
-          cmd.push('-g', gain.to_s) if gain
-          cmd.push('-d', sdr_args) unless sdr_args.empty?
-          direct_cmd = Shellwords.join(cmd)
-
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_detector(
             freq_obj: freq_obj,
-            protocol: 'RTL433',
-            required_bins: %w[rtl_433],
-            direct_cmd: direct_cmd,
-            line_match: /^\s*{/,
-            parser: proc { |line| parse_line(line: line) }
+            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
 
@@ -53,7 +49,6 @@ module PWN
             { unparsed: line }
           end
           out = { protocol: 'RTL433' }.merge(h)
-
           bits = []
           bits << out[:model].to_s if out[:model]
           bits << "id=#{out[:id]}" if out[:id]
@@ -75,15 +70,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`. Owns the SDR directly (pass
-                  freq_obj[:sdr_args] like ':1' or 'driver=hackrf' to select
-                  a device other than the one GQRX is holding).
-
             #{self}.parse_line(line: '{\"model\":\"Acurite-Tower\",\"id\":1234,...}')
 
             #{self}.authors

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

@@ -3,11 +3,102 @@
 module PWN
   module SDR
     module Decoder
-      # RTTY (Radioteletype, ITA2/Baudot) decoder for the amateur RTTY
-      # sub-bands (rtty20/rtty40/rtty80). GQRX supplies FM-demodulated audio
-      # containing the classic 170 Hz-shift 45.45-baud mark/space tones;
-      # `minimodem` recovers the 5-bit Baudot stream and prints ASCII.
+      # 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'
@@ -15,32 +106,13 @@ module PWN
 
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
-
-          # minimodem reads s16le mono from stdin at the rate we hand it; keep
-          # sox at 22 050 Hz (Base default) and tell minimodem the same.
-          PWN::SDR::Decoder::Base.run_pipeline(
+          PWN::SDR::Decoder::Base.run_native(
             freq_obj: freq_obj,
             protocol: 'RTTY',
-            required_bins: %w[sox minimodem],
-            decode_cmd: 'minimodem --rx --quiet --rtty -R 22050 -f -',
-            line_match: /\S/,
-            parser: proc { |line| parse_line(line: line) }
+            demod: Demod.new
           )
         end
 
-        # Supported Method Parameters::
-        # PWN::SDR::Decoder::RTTY.parse_line(line: 'RYRYRY DE W1AW')
-
-        public_class_method def self.parse_line(opts = {})
-          line = opts[:line].to_s.strip
-          out  = { protocol: 'RTTY', text: line }
-          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}"[0, 120]
-          out
-        end
-
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
@@ -50,12 +122,13 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts "USAGE:
+          puts "USAGE (ruby-native 2-FSK ITA2, no external binaries):
             #{self}.decode(
               freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
             )
 
-            #{self}.parse_line(line: 'RYRYRY CQ CQ DE W1AW')
+            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
           "