pwn 0.5.531 → 0.5.534

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'tty-spinner'
+require 'io/wait'
+
+module PWN
+  module SDR
+    module Decoder
+      # Flex Decoder Module for Pagers
+      module Flex
+        # Supported Method Parameters::
+        # pocsag_resp = PWN::SDR::Decoder::Flex.decode(
+        #   freq_obj: 'required - GQRX socket object returned from #connect method'
+        # )
+
+        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
+          )
+
+          # 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 FLEX \
+              -a FLEX_NEXT \
+              -
+          '
+
+          mm_stdin, mm_stdout, mm_stderr, mm_wait_thr = Open3.popen3(decode_cmd)
+
+          current_title = 'Waiting for data frames...'
+
+          # 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?
+
+                mm_stdin.write(data)
+                mm_stdin.flush rescue nil
+              end
+            rescue IOError, Errno::EPIPE, EOFError, Errno::ECONNRESET
+              # normal exit path when shutting down
+            end
+          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?('FLEX')
+
+                  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 = 'FLEX' unless protocol == 'FLEX_NEXT'
+                  dec_msg[:protocol] = protocol
+
+                  # ────────────────────────────── Detect format ──────────────────────────────
+                  # Sometimes Flex 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
+          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
+          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?
+          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
+        end
+
+        # Author(s):: 0day Inc. <support@0dayinc.com>
+
+        public_class_method def self.authors
+          "AUTHOR(S):
+            0day Inc. <support@0dayinc.com>
+          "
+        end
+
+        # Display Usage for this Module
+
+        public_class_method def self.help
+          puts "USAGE:
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq method'
+            )
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'open3'
 require 'tty-spinner'
+require 'io/wait'
 
 module PWN
   module SDR
@@ -16,91 +18,217 @@ module PWN
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
           gqrx_sock = freq_obj[:gqrx_sock]
-          record_path = freq_obj[:record_path]
-          freq_obj = freq_obj.dup
+          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 "\n*** Pager POCSAG Decoder ***"
-          puts 'Press [ENTER] to continue...'
-
-          # Toggle POCSAG off and on to reset the decoder
-          PWN::SDR::GQRX.cmd(
-            gqrx_sock: gqrx_sock,
-            cmd: 'U RECORD 0',
-            resp_ok: 'RPRT 0'
-          )
 
-          PWN::SDR::GQRX.cmd(
-            gqrx_sock: gqrx_sock,
-            cmd: 'U RECORD 1',
-            resp_ok: 'RPRT 0'
-          )
+          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] :decoding',
+            '[:spinner] :status',
             format: :arrow_pulse,
             clear: true,
             hide_cursor: true
           )
 
-          record_header_size = 44
-          wav_header = File.binread(record_path, record_header_size)
-          raise 'ERROR: WAV file header is invalid!' unless wav_header[0, 4] == 'RIFF' && wav_header[8, 4] == 'WAVE'
-
-          bytes_read = wav_header_size
-
-          # Conservative overhead for spinner animation, colors, and spacing
           spinner_overhead = 12
           max_title_length = [TTY::Screen.width - spinner_overhead, 50].max
 
-          initial_title = 'INFO: Decoding Pager POCSAG data...'
+          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(title: initial_title)
+          spinner.update(status: initial_title)
           spinner.auto_spin
 
-          last_resp = {}
+          skip_freq = false
 
-          loop do
-            current_wav_size = File.size?(record_path) ||= 0
-            pocsag_resp = {}
+          # === Replace netcat with PWN::Plugins::Sock.listen ===
+          udp_listener = PWN::SDR::GQRX.listen_udp(
+            udp_ip: udp_ip,
+            udp_port: udp_port
+          )
+
+          # 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)
 
-            # Only update when we have valid new data
-            if current_wav_size > bytes_read
-              new_bytes = current_wav_size - bytes_read
-              # Ensure full I/Q pairs (8 bytes each)
-              new_bytes -= new_bytes % 8
-              data = File.binread(record_path, new_bytes, bytes_read)
+          current_title = 'Waiting for data frames...'
 
-              msg = "DECODED DATA"
+          # 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?
 
-              spinner.update(decoding: msg)
-              last_resp = pocsag_resp.dup
+                mm_stdin.write(data)
+                mm_stdin.flush rescue nil
+              end
+            rescue IOError, Errno::EPIPE, EOFError, Errno::ECONNRESET
+              # normal exit path when shutting down
             end
+          end
+
+          # Thread: read decoded output from multimon-ng and display it
+          decoder_thread = Thread.new do
+            # buffer = +''
+            buffer = ''
 
-            # Non-blocking check for ENTER key to exit
-            if $stdin.wait_readable(0)
+            valid_types = %w[ALN BIN HEX NUM TON TONE UNK]
+            loop do
               begin
-                char = $stdin.read_nonblock(1)
-                break if char == skip_freq_char
-              rescue IO::WaitReadable, EOFError
-                # No-op
+                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
+          end
+
+          loop do
+            spinner.update(status: current_title)
 
-            sleep 0.01
+            # 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
           end
+
+          spinner.success('Decoding stopped')
         rescue StandardError => e
-          spinner.error('Decoding failed') if defined?(spinner)
-          raise e
+          spinner.error("Decoding failed: #{e.message}") if defined?(spinner)
+          raise
         ensure
-          File.unlink(record_path) if File.exist?(record_path)
-          PWN::SDR::GQRX.cmd(
-            gqrx_sock: gqrx_sock,
-            cmd: 'U RECORD 0',
-            resp_ok: 'RPRT 0'
-          )
+          # Cleanup
+          [receiver_thread, decoder_thread].each do |thread|
+            thread.kill if thread.alive?
+          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
         end

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

@@ -17,12 +17,12 @@ module PWN
           freq_obj = opts[:freq_obj]
           gqrx_sock = freq_obj[:gqrx_sock]
 
-          freq_obj = freq_obj.dup
+          # freq_obj = freq_obj.dup
           freq_obj.delete(:gqrx_sock)
           skip_freq_char = "\n"
           puts JSON.pretty_generate(freq_obj)
           puts "\n*** FM Radio RDS Decoder ***"
-          puts 'Press [ENTER] to continue...'
+          puts 'Press [ENTER] to continue to next frequency...'
 
           # Toggle RDS off and on to reset the decoder
           PWN::SDR::GQRX.cmd(
@@ -39,7 +39,7 @@ module PWN
 
           # Spinner setup with dynamic terminal width awareness
           spinner = TTY::Spinner.new(
-            '[:spinner] :decoding',
+            '[:spinner] :status',
             format: :arrow_pulse,
             clear: true,
             hide_cursor: true
@@ -88,7 +88,7 @@ module PWN
               rt_display = "#{rt_display[0...available_for_term]}..." if rt_display.length > available_for_term
 
               msg = "#{prefix}#{rt_display}"
-              spinner.update(decoding: msg)
+              spinner.update(status: msg)
               last_resp = rds_resp.dup
             end
 
@@ -108,6 +108,13 @@ module PWN
           spinner.error('Decoding failed') if defined?(spinner)
           raise e
         ensure
+          # Toggle RDS off and on to reset the decoder
+          PWN::SDR::GQRX.cmd(
+            gqrx_sock: gqrx_sock,
+            cmd: 'U RDS 0',
+            resp_ok: 'RPRT 0'
+          )
+
           spinner.stop if defined?(spinner) && spinner
         end
 

data/lib/pwn/sdr/decoder.rb

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

data/lib/pwn/sdr/frequency_allocation.rb

@@ -417,7 +417,7 @@ module PWN
             bandwidth: '16.000',
             precision: 4
           },
-          pager: {
+          pager_all: {
             ranges: [
               # Low-power / unlicensed / CB-related (very limited POCSAG usage)
               # RCRS channels (shared data/telemetry, occasional POCSAG)
@@ -449,6 +449,35 @@ module PWN
             ],
             demodulator_mode: :FM,
             bandwidth: '25.000',
+            precision: 4
+          },
+          pager_flex: {
+            ranges: [
+              # 900 MHz exclusive paging band (mostly FLEX, but some legacy POCSAG remains)
+              # Primary nationwide commercial paging band
+              { start_freq: '929.000.000', target_freq: '932.000.000' }
+            ],
+            demodulator_mode: :FM,
+            bandwidth: '20.000',
+            precision: 4,
+            decoder: :flex
+          },
+          pager_pocsag: {
+            ranges: [
+              # High-band VHF paging — most common for public-safety POCSAG today
+              # Classic VHF paging band (152/157/158 MHz very common)
+              { start_freq: '152.000.000', target_freq: '159.000.000' },
+
+              # UHF paging bands (hospital, on-site, restaurant/coaster pagers, some public safety)
+              # UHF low — occasional private systems
+              { start_freq: '400.000.000',  target_freq: '430.000.000' },
+              # UHF high — very common for local POCSAG (incl. 450–470 & 467.xxx for on-site)
+              { start_freq: '440.000.000',  target_freq: '470.000.000' },
+              # Classic UHF paging allocation (454/459 MHz pairs — many reallocated)
+              { start_freq: '454.000.000',  target_freq: '460.000.000' }
+            ],
+            demodulator_mode: :FM,
+            bandwidth: '12.500',
             precision: 4,
             decoder: :pocsag
           },