pwn 0.5.613 → 0.5.617

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'