pwn 0.5.615 → 0.5.618

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

@@ -3,213 +3,112 @@
 module PWN
   module SDR
     module Decoder
-      # SDR Decoder for GSM signals.
+      # GSM (2G) broadcast-channel decoder.
+      #
+      # GSM is 270.833 kbit/s GMSK — it CANNOT be recovered from GQRX's 48 kHz
+      # demodulated-audio UDP tap. This module therefore drives the SDR
+      # directly via `grgsm_livemon_headless` (from gr-gsm) which publishes
+      # decoded Um bursts as GSMTAP on udp/4729, then reads them back with
+      # `tshark` for structured field extraction (MCC/MNC/LAC/CI/ARFCN, paging
+      # IMSIs/TMSIs, System Information messages, etc.).
+      #
+      # Interface matches PWN::SDR::Decoder::Flex / ::RDS so the GQRX
+      # dispatcher (`decoder: :gsm`) works uniformly.
       module GSM
-        POWER_THRESHOLD = 0.1
-        SLEEP_INTERVAL = 0.1
-        HEADER_SIZE = 44
-        BURST_DURATION_SEC = 0.000577
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::GSM.decode(
+        #   freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+        # )
 
-        # TSC 0 binary sequence (26 bits): 00100101110000101010011011
-        TSC_0 = [0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1].freeze
-
-        # Starts the live decoding thread.
-        public_class_method def self.start(opts = {})
-          freq_obj = opts[:freq_obj]
-          raise ':ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
-
-          gqrx_sock = freq_obj[:gqrx_sock]
-          freq = freq_obj[:freq]
-          bandwidth = freq_obj[:bandwidth].to_i
-          record_path = freq_obj[:record_path]
-
-          sleep 0.1 until File.exist?(record_path)
-
-          header = File.binread(record_path, HEADER_SIZE)
-          raise 'Invalid WAV header' unless header.start_with?('RIFF') && header.include?('WAVE')
-
-          bytes_read = HEADER_SIZE
-
-          puts "GSM Decoder started for freq: #{freq}, bandwidth: #{bandwidth}"
-
-          Thread.new do
-            loop do
-              current_size = File.size(record_path)
-              if current_size > bytes_read
-                new_bytes = current_size - bytes_read
-                # Ensure full I/Q pairs (8 bytes)
-                new_bytes -= new_bytes % 8
-                data = File.binread(record_path, new_bytes, bytes_read)
-                process_chunk(
-                  data: data,
-                  bandwidth: bandwidth,
-                  freq: freq
-                )
-                bytes_read = current_size
-              end
-
-              sleep SLEEP_INTERVAL
-            end
-          rescue StandardError => e
-            puts "Decoder error: #{e.message}"
-          ensure
-            cleanup(record_path: record_path)
-          end
-        end
-
-        # Stops the decoding thread.
-        public_class_method def self.stop(opts = {})
+        public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
           raise 'ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
 
-          decoder_thread = freq_obj[:decoder_thread]
-          decoder_thread.kill if decoder_thread.is_a?(Thread)
+          hz   = PWN::SDR.hz_to_i(freq: freq_obj[:freq])
+          gain = (freq_obj[:rf_gain] || 40).to_s.to_f
+
+          tshark_fields = %w[
+            frame.time
+            gsmtap.arfcn
+            gsmtap.chan_type
+            gsm_a.imsi
+            gsm_a.tmsi
+            e212.mcc
+            e212.mnc
+            gsm_a.lac
+            gsm_a.bssmap.cell_ci
+            gsm_a.dtap.msg_rr_type
+          ]
+
+          direct_cmd = "sh -c 'grgsm_livemon_headless -f #{hz} -g #{gain} >/dev/null 2>&1 & " \
+                       'LMPID=$!; trap "kill $LMPID 2>/dev/null" EXIT; sleep 2; ' \
+                       'tshark -i lo -l -Y gsmtap -T fields -E separator=\| ' \
+                       "#{tshark_fields.map { |f| "-e #{f}" }.join(' ')}'"
+
+          PWN::SDR::Decoder::Base.run_pipeline(
+            freq_obj: freq_obj,
+            protocol: 'GSM',
+            required_bins: %w[grgsm_livemon_headless tshark],
+            direct_cmd: direct_cmd,
+            line_match: /\S/,
+            parser: proc { |line| parse_line(line: line) }
+          )
         end
 
-        class << self
-          private
-
-          def process_chunk(opts = {})
-            data = opts[:data]
-            bandwidth = opts[:bandwidth]
-            freq = opts[:freq]
-            raise ':ERROR: :data, :bandwidth, and :freq are required' unless data && bandwidth && freq
-
-            samples = data.unpack('f< *')
-            return if samples.length.odd? # Skip incomplete
-
-            complex_samples = []
-            (0...samples.length).step(2) do |i|
-              complex_samples << Complex(samples[i], samples[i + 1])
-            end
-
-            window_size = [(bandwidth * BURST_DURATION_SEC).round, complex_samples.length].min
-            return if window_size <= 0
-
-            # Simplified power on sliding windows
-            powers = []
-            complex_samples.each_cons(window_size) do |window|
-              power = window.map { |c| c.abs**2 }.sum / window_size
-              powers << power
-            end
-
-            max_power = powers.max
-            return unless max_power > POWER_THRESHOLD
-
-            # Demod the entire chunk (assume burst-aligned roughly)
-            bits = demod_gmsk(complex_samples)
-            # Synchronize via TSC correlation
-            sync_offset = find_tsc_offset(bits, TSC_0)
-            return unless sync_offset >= 0
-
-            # Extract data bits from normal burst structure
-            burst_start = sync_offset - 58 # TSC starts at symbol 58 (0-index)
-            return unless burst_start >= 0 && burst_start + 148 <= bits.length
-
-            data_bits = extract_data_bits(bits, burst_start)
-            puts "Burst synchronized at offset #{sync_offset} for #{freq} Hz (power: #{max_power.round(4)})"
-            decode_imsi(
-              data_bits: data_bits,
-              freq: freq
-            )
-          end
-
-          def demod_gmsk(complex_samples)
-            return [] if complex_samples.length < 2
-
-            bits = []
-            (1...complex_samples.length).each do |i|
-              prod = complex_samples[i] * complex_samples[i - 1].conj
-              # Sign of imaginary part for quadrature differential
-              bit = (prod.imag >= 0 ? 0 : 1) # Or adjust polarity
-              bits << bit
-            end
-            bits
-          end
-
-          def find_tsc_offset(bits, tsc)
-            max_corr = -1
-            best_offset = -1
-            tsc_length = tsc.length # 26
-            (0...(bits.length - tsc_length + 1)).each do |offset|
-              window = bits[offset, tsc_length]
-              corr = window.zip(tsc).count { |b1, b2| b1 == b2 }
-              if corr > max_corr
-                max_corr = corr
-                best_offset = offset
-              end
-            end
-            # Threshold: e.g., >20 matches for good sync
-            max_corr > 20 ? best_offset : -1
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::GSM.parse_line(line: 'ts|arfcn|chan|imsi|tmsi|mcc|mnc|lac|ci|rr')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          f = line.split('|', -1)
+          out = {
+            protocol: 'GSM',
+            arfcn: f[1],
+            chan_type: f[2],
+            imsi: f[3],
+            tmsi: f[4],
+            mcc: f[5],
+            mnc: f[6],
+            lac: f[7],
+            cell_id: f[8],
+            rr_msg_type: f[9]
+          }.reject { |_, v| v.to_s.empty? }
+
+          if out[:imsi].to_s.length.between?(14, 16)
+            out[:imsi_mcc]  = out[:imsi][0, 3]
+            out[:imsi_mnc]  = out[:imsi][3, 3]
+            out[:imsi_msin] = out[:imsi][6..]
           end
 
-          # Extract 114 data bits from normal burst (ignoring tails/guard)
-          def extract_data_bits(bits, burst_start)
-            data1_start = burst_start + 2
-            data2_start = burst_start + 88 # After TSC 26 + data1 57 = 85, +3? Wait, structure: tail2(0-1), data(2-58), tsc(59-84), data(85-141), tail(142-143)
-            data1 = bits[data1_start, 57]
-            data2 = bits[data2_start, 57]
-            data1 + data2
-          end
-
-          def decode_imsi(opts = {})
-            data_bits = opts[:data_bits]
-            freq = opts[:freq]
-            raise ':ERROR: :data_bits and :freq are required' unless data_bits && freq
-
-            # Simplified "IMSI extraction": Interpret first ~60 bits as packed digits (4 bits per digit, BCD-like).
-            # In reality: Deinterleave (over bursts), Viterbi decode convolutional code (polys G0=10011b, G1=11011b),
-            # CRC check, parse L3 message (e.g., Paging Req Type 1 has IMSI IE at specific offset, packed BCD).
-            # Here: Raw data bits to 15-digit IMSI (first 60 bits -> 15 nibbles).
-            return unless data_bits.length >= 60
-
-            imsi_digits = []
-            data_bits[0, 60].each_slice(4) do |nibble|
-              digit = nibble.join.to_i(2)
-              imsi_digits << (digit % 10) # Mod 10 for digit-like, or keep as is for hex
-            end
-
-            # Format as 3(MCC)+3(MNC)+9(MSIN)
-            mcc = imsi_digits[0, 3].join
-            mnc = imsi_digits[3, 3].join
-            msin = imsi_digits[6, 9].join
-            imsi = "#{mcc.ljust(3, '0')}#{mnc.ljust(3, '0')}#{msin.ljust(9, '0')}"
-
-            puts "Decoded IMSI: #{imsi} at #{freq} Hz"
-            # TODO: Integrate full L3 parser (e.g., from ruby-gsm gem or custom).
-          end
-
-          def cleanup(opts = {})
-            record_path = opts[:record_path]
-            raise ':ERROR: :record_path is required' unless record_path
-
-            return unless File.exist?(record_path)
-
-            File.delete(record_path)
-            puts "Cleaned up recording: #{record_path}"
-          end
+          summary_bits = []
+          summary_bits << "ARFCN=#{out[:arfcn]}" if out[:arfcn]
+          summary_bits << "MCC/MNC=#{out[:mcc]}/#{out[:mnc]}" if out[:mcc]
+          summary_bits << "LAC=#{out[:lac]} CI=#{out[:cell_id]}" if out[:lac]
+          summary_bits << "IMSI=#{out[:imsi]}" if out[:imsi]
+          summary_bits << "TMSI=#{out[:tmsi]}" if out[:tmsi]
+          out[:summary] = "GSM #{summary_bits.join(' ')}".strip
+          out
         end
 
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
-          "AUTHOR(S):
-            0day Inc. <support@0dayinc.com>
-          "
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
         end
 
         # Display Usage for this Module
 
         public_class_method def self.help
           puts "USAGE:
-            gsm_decoder_thread = PWN::SDR::Decoder::GSM.start(
-              freq_obj: 'required - freq_obj returned from PWN::SDR::Receiver::GQRX.init_freq method'
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
             )
 
-            # To stop the decoder thread:
-            PWN::SDR::Decoder::GSM.stop(
-              freq_obj: 'required - freq_obj returned from PWN::SDR::Receiver::GQRX.init_freq method'
-            )
+            NOTE: Requires `grgsm_livemon_headless` (gr-gsm) and `tshark`.
+                  GSM cannot be decoded from GQRX's 48 kHz audio tap; this
+                  module drives the SDR directly and reads GSMTAP on lo:4729.
+
+            #{self}.parse_line(line: 'ts|arfcn|chan|imsi|tmsi|mcc|mnc|lac|ci|rr')
 
             #{self}.authors
           "

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

@@ -1,244 +1,87 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'open3'
-require 'tty-spinner'
-require 'io/wait'
-
 module PWN
   module SDR
     module Decoder
-      # POCSAG Decoder Module for Pagers
+      # POCSAG (CCIR Radiopaging Code No. 1) decoder for pager networks.
+      #
+      # 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.
       module POCSAG
+        FUNCTION_DESC = {
+          0 => 'Numeric (Tone/A)',
+          1 => 'Tone only (B)',
+          2 => 'Tone only (C)',
+          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
+
         # Supported Method Parameters::
-        # pocsag_resp = PWN::SDR::Decoder::POCSAG.decode(
-        #   freq_obj: 'required - GQRX socket object returned from #connect method'
+        # 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]
-          gqrx_sock = freq_obj[:gqrx_sock]
-          udp_ip    = freq_obj[:udp_ip]    || '127.0.0.1'
-          udp_port  = freq_obj[:udp_port]  || 7355
-
-          freq_obj.delete(:gqrx_sock)
-
-          skip_freq_char = "\n"
-
-          puts JSON.pretty_generate(freq_obj)
-          puts 'Press [ENTER] to Continue to next frequency...'
-
-          # Spinner setup with dynamic terminal width awareness
-          spinner = TTY::Spinner.new(
-            '[:spinner] :status',
-            format: :arrow_pulse,
-            clear: true,
-            hide_cursor: true
-          )
-
-          spinner_overhead = 12
-          max_title_length = [TTY::Screen.width - spinner_overhead, 50].max
-
-          initial_title = "INFO: Decoding #{self.to_s.split('::').last} on udp://#{udp_ip}:#{udp_port} ..."
-          initial_title = initial_title[0...max_title_length] if initial_title.length > max_title_length
-          spinner.update(status: initial_title)
-          spinner.auto_spin
 
-          skip_freq = false
-
-          # === Replace netcat with PWN::Plugins::Sock.listen ===
-          udp_listener = PWN::SDR::GQRX.listen_udp(
-            udp_ip: udp_ip,
-            udp_port: udp_port
+          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) }
           )
+        end
 
-          # Combined processing pipeline: sox → multimon-ng
-          decode_cmd = '
-            sox -t raw -e signed-integer -b 16 -r 48000 -c 1 - \
-                -t raw -e signed-integer -b 16 -r 22050 -c 1 - | \
-            multimon-ng -t raw \
-              -a POCSAG512 \
-              -a POCSAG1200 \
-              -a POCSAG2400 \
-              -
-          '
-
-          mm_stdin, mm_stdout, mm_stderr, mm_wait_thr = Open3.popen3(decode_cmd)
-
-          current_title = 'Waiting for data frames...'
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::POCSAG.parse_line(line: 'POCSAG1200: Address: ...')
 
-          # Thread: read from UDP listener and feed to sox|multimon pipeline
-          receiver_thread = Thread.new do
-            begin
-              loop do
-                data, _sender = udp_listener.recv(4096)
-                next unless data.to_s.bytesize.positive?
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'POCSAG' }
 
-                mm_stdin.write(data)
-                mm_stdin.flush rescue nil
-              end
-            rescue IOError, Errno::EPIPE, EOFError, Errno::ECONNRESET
-              # normal exit path when shutting down
-            end
+          if (m = line.match(/^POCSAG(\d+):/))
+            out[:baud] = m[1].to_i
           end
-
-          # Thread: read decoded output from multimon-ng and display it
-          decoder_thread = Thread.new do
-            # buffer = +''
-            buffer = ''
-
-            valid_types = %w[ALN BIN HEX NUM TON TONE UNK]
-            loop do
-              begin
-                chunk = mm_stdout.readpartial(4096)
-                # buffer << chunk
-                buffer = "#{buffer}#{chunk}"
-
-                while (line = buffer.slice!(/^.*\n/))
-                  line = line.chomp
-                  next if line.empty? || !line.start_with?('POCSAG')
-
-                  decoded_at = Time.now.strftime('%Y-%m-%d %H:%M:%S%z')
-                  dec_msg = { decoded_at: decoded_at }
-                  dec_msg[:raw_inspected] = line.inspect
-
-                  protocol = line[0..8]
-                  protocol = line[0..9] unless protocol == 'POCSAG512'
-                  dec_msg[:protocol] = protocol
-
-                  # ────────────────────────────── Detect format ──────────────────────────────
-                  # Sometimes POCSAG is space delimited, sometimes pipe delimited
-                  # FLEX_NEXT appears to always be pipe delimited
-
-                  delimiter = '|'
-                  space_delim = false
-                  if line.start_with?('FLEX: ')
-                    delimiter = ' '
-                    space_delim = true
-                  end
-
-                  flex_pipe_delim = false
-                  flex_pipe_delim = true if line.start_with?('FLEX|')
-
-                  parts = line.split(delimiter)
-
-                  # protocol index already used
-                  idx_already_used = [0]
-                  target_parts_idx = 1
-                  target_parts_idx += 1 if flex_pipe_delim
-                  target_parts_idx += 2 if space_delim
-                  dec_msg[:speed] = parts[target_parts_idx] if parts[target_parts_idx]
-                  idx_already_used.push(target_parts_idx)
-
-                  target_parts_idx += 2
-                  dec_msg[:capcode] = parts[target_parts_idx] if parts[target_parts_idx]
-                  idx_already_used.push(target_parts_idx)
-
-                  target_parts_idx -= 1
-                  dec_msg[:capcode_loc] = parts[target_parts_idx] if parts[target_parts_idx]
-                  idx_already_used.push(target_parts_idx)
-
-                  while target_parts_idx < parts.size
-                    if idx_already_used.include?(target_parts_idx)
-                      target_parts_idx += 1
-                      next
-                    end
-
-                    key = parts[target_parts_idx]
-                    key = 'long_sequence_number' if key == 'LS'
-
-                    if key && valid_types.include?(key)
-                      dec_msg[:type] = key
-
-                      dec_msg[:type_desc] = case key
-                                            when 'ALN'
-                                              'Human-readable text'
-                                            when 'BIN'
-                                              'Binary / data payload (typically 32 bit words)'
-                                            when 'HEX'
-                                              'Raw hex representation of data'
-                                            when 'NUM'
-                                              'Numbers only'
-                                            when 'TON', 'TONE'
-                                              'Just alert tone, no message'
-                                            when 'UNK'
-                                              'Decoded but type unknown / unsupported format'
-                                            end
-
-                      target_parts_idx += 1
-                      payload_parts = parts[target_parts_idx..]
-                      dec_msg[:type_payload] = payload_parts.join(delimiter)
-
-                      break
-                    else
-                      target_parts_idx += 1
-                      dec_msg[key] = parts[target_parts_idx] if parts[target_parts_idx]
-                    end
-
-                    idx_already_used.push(target_parts_idx)
-                    target_parts_idx += 1
-                  end
-
-                  final_msg = freq_obj.merge(dec_msg)
-                  puts JSON.pretty_generate(final_msg)
-                  # TODO: Append dec_msg to a log file in a better way
-                  flex_log_file = "/tmp/flex_decoder_#{Time.now.strftime('%Y%m%d')}.log"
-                  File.open(flex_log_file, 'a') do |f|
-                    f.puts("#{JSON.generate(final_msg)},")
-                  end
-                end
-              rescue EOFError, IOError
-                break
-              end
-            end
+          if (m = line.match(/Address:\s*(\d+)/i))
+            out[:address] = m[1].to_i
+            out[:capcode] = m[1]
           end
-
-          loop do
-            spinner.update(status: current_title)
-
-            # Non-blocking ENTER check to exit gracefully
-            next unless $stdin.wait_readable(0)
-
-            begin
-              char = $stdin.read_nonblock(1)
-              next unless char == skip_freq_char
-
-              skip_freq = true
-              puts "\n[!] ENTER pressed → stopping decoder..."
-
-              break
-            rescue IO::WaitReadable, EOFError
-              # ignore
-            end
-
-            break if skip_freq
+          if (m = line.match(/Function:\s*(\d+)/i))
+            fn = m[1].to_i
+            out[:function]      = fn
+            out[:function_desc] = FUNCTION_DESC[fn] || 'Unknown'
           end
-
-          spinner.success('Decoding stopped')
-        rescue StandardError => e
-          spinner.error("Decoding failed: #{e.message}") if defined?(spinner)
-          raise
-        ensure
-          # Cleanup
-          [receiver_thread, decoder_thread].each do |thread|
-            thread.kill if thread.alive?
+          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
           end
-
-          [mm_stdin, mm_stdout, mm_stderr].each { |io| io.close rescue nil }
-
-          mm_wait_thr&.value rescue nil
-
-          PWN::SDR::GQRX.disconnect_udp(udp_listener: udp_listener) if defined?(udp_listener) && udp_listener
-
-          spinner.stop if defined?(spinner) && spinner
+          out[:summary] = "POCSAG#{out[:baud]} RIC=#{out[:capcode]} F#{out[:function]} #{out[:type]}: #{out[:message]}"
+          out
         end
 
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
-          "AUTHOR(S):
-            0day Inc. <support@0dayinc.com>
-          "
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
         end
 
         # Display Usage for this Module
@@ -246,9 +89,11 @@ module PWN
         public_class_method def self.help
           puts "USAGE:
             #{self}.decode(
-              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq method'
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
             )
 
+            #{self}.parse_line(line: 'POCSAG1200: Address: 123456 Function: 3 Alpha: HELLO')
+
             #{self}.authors
           "
         end

data/lib/pwn/sdr/decoder.rb

@@ -7,6 +7,7 @@ module PWN
   module SDR
     # Deocder Module for SDR signals.
     module Decoder
+      autoload :Base, 'pwn/sdr/decoder/base'
       autoload :Flex, 'pwn/sdr/decoder/flex'
       autoload :GSM, 'pwn/sdr/decoder/gsm'
       autoload :POCSAG, 'pwn/sdr/decoder/pocsag'