pwn 0.5.618 → 0.5.620

data/lib/pwn/ai/agent/tools/mistakes.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'pwn/ai/agent/registry'
+require 'pwn/ai/agent/mistakes'
+
+# Expose the negative-feedback ledger to the model so it can inspect its
+# own recurring failure patterns, RECORD mistakes it recognises
+# semantically (not just tool-dispatch errors), and — critically — RESOLVE
+# them with an explicit fix, which is then re-injected into every future
+# system prompt as an actionable "do THIS instead" lesson AND handed
+# straight back inline on the next recurrence via
+# Mistakes.correction_hint.
+
+PWN::AI::Agent::Registry.register(
+  name: 'mistakes_list',
+  toolset: 'learning',
+  schema: {
+    name: 'mistakes_list',
+    description: 'List recorded failure fingerprints from ~/.pwn/mistakes.json ' \
+                 '(signature, tool, normalised error, count, first/last seen, ' \
+                 'resolved, fix). Sorted by recurrence count. These are the ' \
+                 'specific mistakes the agent keeps making — inspect before ' \
+                 'attempting the same tool again, and call mistakes_resolve ' \
+                 'once a working alternative is found.',
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: { type: 'integer', default: 20 },
+        unresolved_only: { type: 'boolean', default: true }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Mistakes) },
+  handler: lambda { |args|
+    PWN::AI::Agent::Mistakes.top(
+      limit: args[:limit] || 20,
+      unresolved_only: args.key?(:unresolved_only) ? args[:unresolved_only] : true
+    )
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'mistakes_record',
+  toolset: 'learning',
+  schema: {
+    name: 'mistakes_record',
+    description: 'Proactively fingerprint a mistake YOU just made (wrong ' \
+                 'assumption, wrong file edited, bad approach, hallucinated ' \
+                 'API) so the negative-feedback loop captures failures that ' \
+                 'are NOT tool-dispatch errors. The (tool, error) pair is ' \
+                 'normalised and its cross-session count incremented; once ' \
+                 'count ≥ 3 it is flagged [REPEATING] in every future system ' \
+                 'prompt. Follow up with mistakes_resolve when you find the fix.',
+    parameters: {
+      type: 'object',
+      properties: {
+        tool: {
+          type: 'string',
+          description: 'Component / area the mistake was in (e.g. "assumption", "shell", "pwn_eval", "plan", a module name).'
+        },
+        error: { type: 'string', description: 'What went wrong, in your own words.' },
+        args: { type: 'string', description: 'Optional sample of the input that triggered it.' }
+      },
+      required: %w[tool error]
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Mistakes) },
+  handler: lambda { |args|
+    sid = (PWN::Env.dig(:ai, :session_id) if defined?(PWN::Env))
+    PWN::AI::Agent::Mistakes.record(
+      tool: args[:tool], error: args[:error], args: args[:args],
+      session_id: sid, source: :model
+    )
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'mistakes_resolve',
+  toolset: 'learning',
+  schema: {
+    name: 'mistakes_resolve',
+    description: 'Mark a recorded mistake as RESOLVED and attach the fix ' \
+                 '(what to do INSTEAD). The fix is (a) promoted to a ' \
+                 'PWN::Memory :lesson so every future run sees "AVOID X — ' \
+                 'FIX: Y" in its system prompt, AND (b) handed straight back ' \
+                 'inline via correction_hint the next time that signature ' \
+                 'recurs. If the same signature recurs after resolution it is ' \
+                 'automatically re-opened and tagged [REGRESSED]. Call this ' \
+                 'the moment you find a working alternative to a ' \
+                 'previously-failing approach.',
+    parameters: {
+      type: 'object',
+      properties: {
+        signature: { type: 'string', description: 'Mistake signature from mistakes_list / KNOWN MISTAKES block / correction_hint.' },
+        fix: { type: 'string', description: 'What to do instead next time.' }
+      },
+      required: %w[signature fix]
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Mistakes) },
+  handler: lambda { |args|
+    PWN::AI::Agent::Mistakes.resolve(signature: args[:signature], fix: args[:fix])
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'mistakes_reset',
+  toolset: 'learning',
+  schema: {
+    name: 'mistakes_reset',
+    description: 'Wipe ~/.pwn/mistakes.json (all recorded failure fingerprints ' \
+                 'and their fixes). Use only when moving to a new host/engagement ' \
+                 'where prior failure patterns no longer apply. IRREVERSIBLE — ' \
+                 'must pass confirm:true.',
+    parameters: {
+      type: 'object',
+      properties: {
+        confirm: { type: 'boolean', description: 'Must be true to actually reset.' }
+      },
+      required: %w[confirm]
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Mistakes) },
+  handler: lambda { |args|
+    raise ArgumentError, 'refusing to reset mistakes without confirm:true' unless args[:confirm] == true
+
+    before = PWN::AI::Agent::Mistakes.load.keys.length
+    PWN::AI::Agent::Mistakes.reset
+    { reset: true, mistakes_cleared: before, file: PWN::AI::Agent::Mistakes::MISTAKES_FILE }
+  }
+)

data/lib/pwn/ai/agent.rb

@@ -25,6 +25,7 @@ module PWN
       autoload :Loop,          'pwn/ai/agent/loop'
       autoload :Metrics,       'pwn/ai/agent/metrics'
       autoload :Learning,      'pwn/ai/agent/learning'
+      autoload :Mistakes,      'pwn/ai/agent/mistakes'
       autoload :Extrospection, 'pwn/ai/agent/extrospection'
       autoload :Introspection, 'pwn/ai/agent/introspection'
       autoload :Swarm,         'pwn/ai/agent/swarm'

data/lib/pwn/plugins/jira_data_center.rb

@@ -522,7 +522,7 @@ module PWN
               if elem.is_a?(Hash)
                 # Retain common identifier keys; if none present keep full hash
                 keys_to_keep = %i[id key name value]
-                elem.keys.any? { |kk| keys_to_keep.include?(kk) } ? elem.slice(*keys_to_keep) : elem
+                elem.keys.intersect?(keys_to_keep) ? elem.slice(*keys_to_keep) : elem
               else
                 elem
               end
@@ -530,7 +530,7 @@ module PWN
           when Hash
             keys_to_keep = %i[id key name value]
             filtered_fields[k] =
-              if v.keys.any? { |kk| keys_to_keep.include?(kk) }
+              if v.keys.intersect?(keys_to_keep)
                 v.slice(*keys_to_keep)
               else
                 v

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module PWN
+  module SDR
+    module Decoder
+      # ADS-B (Automatic Dependent Surveillance – Broadcast) decoder for
+      # aircraft transponder squitters on 1090 MHz (Mode-S / ES) and 978 MHz
+      # (UAT). 2 Mbit/s PPM cannot be recovered from GQRX audio, so this
+      # module drives `dump1090` (or `dump978-fa`) directly against the SDR
+      # and structures each SBS-1/BaseStation CSV line it emits on stdout.
+      module ADSB
+        SBS_FIELDS = %i[
+          msg_type tx_type session_id aircraft_id icao24 flight_id
+          date_gen time_gen date_log time_log callsign altitude_ft
+          ground_speed_kt track_deg lat lon vertical_rate_fpm squawk
+          alert emergency spi on_ground
+        ].freeze
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::ADSB.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]
+          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] || 40).to_s.to_f
+          uat  = hz.between?(977_000_000, 979_000_000)
+
+          direct_cmd =
+            if uat && PWN::SDR::Decoder::Base.bin_available?(bin: 'dump978-fa')
+              "bash -c #{Shellwords.escape("dump978-fa --sdr driver=rtlsdr --sdr-gain #{gain} --raw-stdout 2>/dev/null | uat2text")}"
+            elsif PWN::SDR::Decoder::Base.bin_available?(bin: 'dump1090-fa')
+              "dump1090-fa --device-type rtlsdr --gain #{gain} --net-sbs-stdout --quiet"
+            else
+              "dump1090 --gain #{gain} --net-sbs-stdout --quiet"
+            end
+
+          PWN::SDR::Decoder::Base.run_pipeline(
+            freq_obj: freq_obj,
+            protocol: uat ? 'ADSB-UAT978' : 'ADSB-1090ES',
+            required_bins: uat ? %w[dump978-fa uat2text] : %w[dump1090],
+            direct_cmd: direct_cmd,
+            line_match: /^(MSG,|-|\+)/,
+            parser: proc { |line| parse_line(line: line) }
+          )
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::ADSB.parse_line(line: 'MSG,3,1,1,ABCDEF,...')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          return { protocol: 'ADSB-UAT', summary: line.strip } unless line.start_with?('MSG,')
+
+          f   = line.split(',', -1)
+          out = { protocol: 'ADSB' }
+          SBS_FIELDS.each_with_index { |k, i| out[k] = f[i] unless f[i].to_s.empty? }
+
+          bits = []
+          bits << "ICAO=#{out[:icao24]}" if out[:icao24]
+          bits << "CS=#{out[:callsign].to_s.strip}" if out[:callsign]
+          bits << "ALT=#{out[:altitude_ft]}ft" if out[:altitude_ft]
+          bits << "POS=#{out[:lat]},#{out[:lon]}" if out[:lat] && out[:lon]
+          bits << "GS=#{out[:ground_speed_kt]}kt" if out[:ground_speed_kt]
+          bits << "SQK=#{out[:squawk]}" if out[:squawk]
+          out[:summary] = "ADSB #{bits.join(' ')}".strip
+          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:
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            NOTE: Requires `dump1090` (1090 MHz Mode-S/ES) or
+                  `dump978-fa` + `uat2text` (978 MHz UAT). Owns the SDR
+                  directly — set freq_obj[:sdr_args] if GQRX has device 0.
+
+            #{self}.parse_line(line: 'MSG,3,1,1,ABCDEF,1,...')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module PWN
+  module SDR
+    module Decoder
+      # NOAA APT (Automatic Picture Transmission) decoder for the 137 MHz
+      # polar-orbiting weather satellites (NOAA-15/18/19). APT is a 2400 Hz
+      # AM subcarrier inside a 34 kHz-wide FM downlink; GQRX's UDP audio is
+      # recorded to a WAV, then handed to `noaa-apt` (or `satdump`) to render
+      # the two-channel visible/IR image strip.
+      module APT
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::APT.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]
+          raise 'ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
+
+          stamp   = Time.now.strftime('%Y%m%d_%H%M%S')
+          wav_out = "/tmp/apt_#{stamp}.wav"
+          png_out = "/tmp/apt_#{stamp}.png"
+
+          # Record 11 025 Hz WAV (noaa-apt's native rate) until [ENTER],
+          # emitting a heartbeat line per second so the spinner stays live,
+          # then decode to PNG on exit.
+          inner = 'sox -t raw -e signed-integer -b 16 -r 22050 -c 1 - ' \
+                  "-t wav -r 11025 #{Shellwords.escape(wav_out)} & SOXPID=$!; " \
+                  'trap "kill $SOXPID 2>/dev/null" EXIT INT TERM; ' \
+                  'while kill -0 $SOXPID 2>/dev/null; do ' \
+                  "echo APT_REC seconds=$SECONDS file=#{wav_out}; sleep 1; done"
+
+          PWN::SDR::Decoder::Base.run_pipeline(
+            freq_obj: freq_obj,
+            protocol: 'NOAA-APT',
+            required_bins: %w[sox noaa-apt],
+            decode_cmd: "bash -c #{Shellwords.escape(inner)}",
+            line_match: /^APT_REC/,
+            parser: proc { |line| { protocol: 'NOAA-APT', wav: wav_out, png: png_out, summary: line.strip } }
+          )
+
+          return unless File.exist?(wav_out) && File.size(wav_out).positive?
+
+          system('noaa-apt', wav_out, '-o', png_out)
+
+          puts "[*] APT image written: #{png_out}" if File.exist?(png_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:
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            NOTE: Requires `sox` and `noaa-apt`. Set GQRX to FM, ~34 kHz BW.
+                  Records the pass to /tmp/apt_<ts>.wav, decodes to PNG on exit.
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module PWN
+  module SDR
+    module Decoder
+      # Bluetooth Classic (BR/EDR) & BLE advertising decoder for 2.402–2.480 GHz.
+      #
+      # 1 Mbit/s GFSK with 79 (BR/EDR) or 40 (BLE) FHSS channels cannot be
+      # recovered from GQRX audio. This module drives an Ubertooth One via
+      # `ubertooth-rx` (LAP/UAP discovery) or `ubertooth-btle -f -p` (BLE
+      # advertising follow) directly and structures each output line.
+      module Bluetooth
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::Bluetooth.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]
+          raise 'ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
+
+          ble = freq_obj[:ble] || freq_obj[:mode].to_s.casecmp('ble').zero?
+          direct_cmd = ble ? 'ubertooth-btle -f -p' : 'ubertooth-rx -z'
+
+          PWN::SDR::Decoder::Base.run_pipeline(
+            freq_obj: freq_obj,
+            protocol: ble ? 'BLE' : 'BT-BR/EDR',
+            required_bins: [ble ? 'ubertooth-btle' : 'ubertooth-rx'],
+            direct_cmd: direct_cmd,
+            line_match: /(LAP|AdvA|ADV_|SCAN_|BD_ADDR|systime)/i,
+            parser: proc { |line| parse_line(line: line) }
+          )
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::Bluetooth.parse_line(line: 'systime=... LAP=9e8b33 ...')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'Bluetooth' }
+          out[:lap]      = ::Regexp.last_match(1) if line =~ /LAP[=: ]([0-9a-fA-F]{6})/
+          out[:uap]      = ::Regexp.last_match(1) if line =~ /UAP[=: ]([0-9a-fA-F]{2})/
+          out[:bd_addr]  = ::Regexp.last_match(1) if line =~ /(?:AdvA|BD_ADDR)[=: ]([0-9a-fA-F:]{12,17})/
+          out[:pdu_type] = ::Regexp.last_match(1) if line =~ /\b(ADV_\w+|SCAN_\w+|CONNECT_REQ)\b/
+          out[:channel]  = ::Regexp.last_match(1) if line =~ /ch[=: ]?(\d{1,2})\b/i
+          out[:rssi]     = ::Regexp.last_match(1) if line =~ /rssi[=: ]?(-?\d+)/i
+          out[:summary]  = "BT #{out.values_at(:pdu_type, :bd_addr, :lap).compact.join(' ')}".strip
+          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:
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            NOTE: Requires an Ubertooth One and `ubertooth-rx` /
+                  `ubertooth-btle`. Set freq_obj[:ble] = true for BLE mode.
+
+            #{self}.parse_line(line: 'systime=... ch=37 LAP=9e8b33 ...')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module PWN
+  module SDR
+    module Decoder
+      # DECT (Digital Enhanced Cordless Telecommunications) decoder for the
+      # 1.880–1.900 GHz (EU) / 1.920–1.930 GHz (US DECT-6.0) allocation.
+      # 1.152 Mbit/s GFSK across 10 TDMA carriers requires raw I/Q; this
+      # module drives gr-dect2's `dect_cli` (or the `re-DECTed` toolkit)
+      # directly and structures each RFPI/PP scan line.
+      module DECT
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::DECT.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]
+          raise 'ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
+
+          hz = PWN::SDR.hz_to_i(freq: freq_obj[:freq])
+          # DECT carriers are 1.728 MHz apart; ch0 = 1 897.344 MHz (EU).
+          ch = ((1_897_344_000 - hz) / 1_728_000.0).round.clamp(0, 9)
+
+          direct_cmd =
+            if PWN::SDR::Decoder::Base.bin_available?(bin: 'dect_cli')
+              "dect_cli -s #{ch}"
+            else
+              "dectrx -c #{ch}"
+            end
+
+          PWN::SDR::Decoder::Base.run_pipeline(
+            freq_obj: freq_obj,
+            protocol: 'DECT',
+            required_bins: %w[dect_cli],
+            direct_cmd: direct_cmd,
+            line_match: /(RFPI|FP|PP|slot|carrier|RSSI)/i,
+            parser: proc { |line| parse_line(line: line) }
+          )
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::DECT.parse_line(line: 'RFPI: 01 23 45 67 89 slot 4 carrier 3 RSSI -55')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'DECT' }
+          out[:rfpi]    = ::Regexp.last_match(1).delete(' ') if line =~ /RFPI[:=]?\s*((?:[0-9A-Fa-f]{2}\s*){5})/
+          out[:slot]    = ::Regexp.last_match(1) if line =~ /slot\s*(\d+)/i
+          out[:carrier] = ::Regexp.last_match(1) if line =~ /carrier\s*(\d+)/i
+          out[:rssi]    = ::Regexp.last_match(1) if line =~ /RSSI[:=]?\s*(-?\d+)/i
+          out[:role]    = ::Regexp.last_match(1) if line =~ /\b(FP|PP)\b/
+          out[:summary] = "DECT RFPI=#{out[:rfpi]} slot=#{out[:slot]} carrier=#{out[:carrier]}"
+          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:
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            NOTE: Requires gr-dect2's `dect_cli` (or re-DECTed `dectrx`).
+                  Owns the SDR directly.
+
+            #{self}.parse_line(line: 'RFPI: 01 23 45 67 89 slot 4 carrier 3')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module PWN
+  module SDR
+    module Decoder
+      # GNSS / GPS L1-C/A (1575.42 MHz) & L2C (1227.60 MHz) decoder. BPSK/DSSS
+      # at 1.023 / 10.23 Mcps needs raw I/Q, so this drives `gnss-sdr` (or
+      # `rtl_gps`) directly and structures the PVT / NMEA lines it emits
+      # (satellite PRNs acquired, C/N0, computed position fix, UTC time).
+      module GPS
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::GPS.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]
+          raise 'ERROR: :freq_obj is required' unless freq_obj.is_a?(Hash)
+
+          conf = (freq_obj[:gnss_conf] || '/usr/share/gnss-sdr/conf/gnss-sdr_GPS_L1_rtlsdr_realtime.conf').to_s
+          direct_cmd = "gnss-sdr --config_file=#{Shellwords.escape(conf)}"
+
+          PWN::SDR::Decoder::Base.run_pipeline(
+            freq_obj: freq_obj,
+            protocol: 'GPS',
+            required_bins: %w[gnss-sdr],
+            direct_cmd: direct_cmd,
+            line_match: /(PVT|Position|PRN|Tracking|\$G[PN])/,
+            parser: proc { |line| parse_line(line: line) }
+          )
+        end
+
+        # Supported Method Parameters::
+        # PWN::SDR::Decoder::GPS.parse_line(line: 'Position at ... Lat = 32.7 [deg], Long = -97.1 ...')
+
+        public_class_method def self.parse_line(opts = {})
+          line = opts[:line].to_s
+          out  = { protocol: 'GPS' }
+          out[:prn]  = ::Regexp.last_match(1) if line =~ /PRN[ =]?(\d{1,2})/
+          out[:cn0]  = ::Regexp.last_match(1) if line =~ /CN0[ =]?([\d.]+)/i
+          out[:lat]  = ::Regexp.last_match(1) if line =~ /Lat(?:itude)?\s*=\s*(-?[\d.]+)/i
+          out[:lon]  = ::Regexp.last_match(1) if line =~ /Long(?:itude)?\s*=\s*(-?[\d.]+)/i
+          out[:alt]  = ::Regexp.last_match(1) if line =~ /Height\s*=\s*(-?[\d.]+)/i
+          out[:utc]  = ::Regexp.last_match(1) if line =~ /UTC\s*=?\s*([\d:.-]+T?[\d:.]*)/
+          out[:nmea] = line if line.start_with?('$G')
+          out[:summary] = if out[:lat]
+                            "GPS FIX #{out[:lat]},#{out[:lon]} alt=#{out[:alt]}m"
+                          elsif out[:prn]
+                            "GPS PRN#{out[:prn]} CN0=#{out[:cn0]}"
+                          else
+                            "GPS #{line[0, 100]}"
+                          end
+          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:
+            #{self}.decode(
+              freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq'
+            )
+
+            NOTE: Requires `gnss-sdr` and an active-antenna-biased front end.
+                  Override the receiver config via freq_obj[:gnss_conf].
+
+            #{self}.parse_line(line: 'Position ... Lat = 32.7 Long = -97.1 Height = 210')
+
+            #{self}.authors
+          "
+        end
+      end
+    end
+  end
+end