meshtastic 0.0.40 → 0.0.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dc432f90a8545cad1027f5514f0676a60d776f617db87b394436e1657693e98
-  data.tar.gz: 5a461b32da2516b164ab789f2a27653b5f46a4f7d36020ddca1ba161931162e0
+  metadata.gz: 3ffe0a1e8528090281aedce5b132f1f57aa82db0c8c46131cff53d00004e4dcd
+  data.tar.gz: 56bb82c58cdcbced0c401802180931aa4625e4314e4954ab30349811a614d399
 SHA512:
-  metadata.gz: 1094355139b2e703dda03bf60ff7034aeb94e1d7d335ba8cd73aae0d9c3bae4c64e61cfb3b8e2dcbdd8894174ab5e3f77b29fde04617fedc3f578b5e469a2678
-  data.tar.gz: d5677d5b337b4f1b8cbff41da88eafaeab8377f3235085f6ba2df384b7c19dd24cbece877d1d6c39f4cf3c4b9d6674f93ed6cb783bc62bd739e12379f3a8a552
+  metadata.gz: dd84aa7e0607992de00be53a0f8ccb2d69077004dd21ebc2838be38582064a797c0f13317c0abd375ab67199dd494640187895384ea74110c77c9b478a218654
+  data.tar.gz: a1135c741f44f38765421ea2020173b40395478fffdbb24da760d75f8483920f99cf2f0d110f7173fb9617e7522a644dc418f937aef79a35f1b04d89ed94737c

data/Gemfile

@@ -13,7 +13,7 @@ gemspec
 # to review these custom flags (e.g. pg, serialport, etc).
 gem 'bundler', '>=2.5.3'
 gem 'bundle-audit', '0.1.0'
-gem 'geocoder', '1.8.2'
+gem 'geocoder', '1.8.3'
 gem 'google-protobuf', '3.21.12'
 gem 'mqtt', '0.6.0'
 gem 'rake', '13.2.1'
@@ -21,6 +21,7 @@ gem 'rdoc', '6.6.3.1'
 gem 'rspec', '3.13.0'
 gem 'rubocop', '1.63.4'
 gem 'rubocop-rake', '0.6.0'
-gem 'rubocop-rspec', '2.29.1'
+gem 'rubocop-rspec', '2.29.2'
 gem 'rvm', '1.11.3.9'
+gem 'tty-prompt', '0.23.1'
 gem 'yard', '0.9.36'

data/lib/meshtastic/mqtt.rb

@@ -6,6 +6,7 @@ require 'json'
 require 'mqtt'
 require 'openssl'
 require 'securerandom'
+require 'tty-prompt'
 
 # Avoiding Namespace Collisions
 MQTTClient = MQTT::Client
@@ -42,16 +43,156 @@ module Meshtastic
       raise e
     end
 
+    # Supported Method Parameters::
+    # Meshtastic::MQQT.get_cipher_keys(
+    #  psks: 'required - hash of channel / pre-shared key value pairs'
+    #  )
+
+    private_class_method def self.get_cipher_keys(opts = {})
+      psks = opts[:psks]
+
+      psks.each_key do |key|
+        psk = psks[key]
+        padded_psk = psk.ljust(psk.length + ((4 - (psk.length % 4)) % 4), '=')
+        replaced_psk = padded_psk.gsub('-', '+').gsub('_', '/')
+        psks[key] = replaced_psk
+      end
+
+      psks
+    rescue StandardError => e
+      raise e
+    end
+
+    # Supported Method Parameters::
+    # Meshtastic::MQQT.recursively_decode_payloads(
+    #   object: 'required - object to recursively decode',
+    #   msg_type: 'required - message type (e.g. :TEXT_MESSAGE_APP)',
+    #   gps_metadata: 'optional - include GPS metadata in output (default: false)'
+    # )
+
+    private_class_method def self.recursively_decode_payloads(opts = {})
+      object = opts[:object]
+      msg_type = opts[:msg_type]
+      gps_metadata = opts[:gps_metadata]
+
+      # puts "OBJECT: #{object.inspect}"
+      object = Meshtastic::Data.decode(object).to_h if object.is_a?(String)
+
+      object.each do |key, value|
+        if value.is_a?(Hash)
+          # Recursive call if the value is a hash
+          recursively_decode_payloads(object: value)
+        elsif value.is_a?(Array)
+          # Process each element if it's an array
+          value.each do |item|
+            recursively_decode_payloads(object: item) if item.is_a?(Hash)
+          end
+        end
+        # Check if the key matches 'payload' and decode
+        case key
+        when :latitude_i
+          object[:latitude] = object[:latitude_i] * 0.0000001
+        when :longitude_i
+          object[:longitude] = object[:longitude_i] * 0.0000001
+        when :macaddr
+          object[key] = object[key].bytes.map { |byte| byte.to_s(16).rjust(2, '0') }.join(':')
+        when :payload
+          case msg_type
+          when :ADMIN_APP
+            decoder = Meshtastic::AdminMessage.decode(payload)
+          when :ATAK_FORWARDER, :ATAK_PLUGIN
+            decoder = Meshtastic::TAKPacket
+            # when :AUDIO_APP
+            # decoder = Meshtastic::Audio
+          when :DETECTION_SENSOR_APP
+            decoder = Meshtastic::DeviceState
+            # when :IP_TUNNEL_APP
+            # decoder = Meshtastic::IpTunnel
+          when :MAP_REPORT_APP
+            decoder = Meshtastic::MapReport
+            # when :MAX
+            # decoder = Meshtastic::Max
+          when :NEIGHBORINFO_APP
+            decoder = Meshtastic::NeighborInfo
+          when :NODEINFO_APP
+            decoder = Meshtastic::User
+          when :PAXCOUNTER_APP
+            decoder = Meshtastic::Paxcount
+          when :POSITION_APP
+            decoder = Meshtastic::Position
+            # when :PRIVATE_APP
+            # decoder = Meshtastic::Private
+          when :RANGE_TEST_APP
+            # Unsure if this is the correct protobuf object
+            decoder = Meshtastic::FromRadio
+          when :REMOTE_HARDWARE_APP
+            decoder = Meshtastic::HardwareMessage
+            # when :REPLY_APP
+            # decoder = Meshtastic::Reply
+          when :ROUTING_APP
+            decoder = Meshtastic::Routing
+          when :SERIAL_APP
+            decoder = Meshtastic::SerialConnectionStatus
+          when :SIMULATOR_APP
+            decoder = Meshtastic::Compressed
+          when :STORE_FORWARD_APP
+            decoder = Meshtastic::StoreAndForward
+          when :TEXT_MESSAGE_APP
+            # Unsure if this is the correct protobuf object
+            # decoder = Meshtastic::MqttClientProxyMessage
+            decoder = Meshtastic::Data
+          when :TELEMETRY_APP
+            decoder = Meshtastic::Telemetry
+          when :TRACEROUTE_APP
+            decoder = Meshtastic::RouteDiscovery
+          when :UNKNOWN_APP
+            decoder = Meshtastic::Data.decode
+          when :WAYPOINT_APP
+            decoder = Meshtastic::Waypoint
+            # when :ZPS_APP
+            # decoder = Meshtastic::Zps
+          else
+            puts "WARNING: Unknown message type: #{msg_type}"
+            decoder = Meshtastic::Data.decode
+          end
+
+          # begin
+          # # If the value is base64 encoded, base64 decode and then decode
+          #   base64_decoded_value = Base64.strict_decode64(value)
+          #   object[key] = decoder.decode(base64_decoded_value).to_h
+          # rescue ArgumentError => e
+          #   # Otherwise, just decode the value
+          object[key] = decoder.decode(value).to_h
+          # end
+
+        end
+
+        next unless gps_metadata && object[:latitude] && object[:longitude]
+
+        object[:gps_metadata] = gps_search(
+          lat: object[:latitude],
+          lon: object[:longitude]
+        ).first.data
+      end
+
+      object
+    rescue Google::Protobuf::ParseError
+      object
+    rescue StandardError => e
+      raise e
+    end
+
     # Supported Method Parameters::
     # Meshtastic::MQQT.subscribe(
     #   mqtt_obj: 'required - mqtt_obj returned from #connect method'
     #   root_topic: 'optional - root topic (default: msh)',
     #   region: 'optional - region e.g. 'US/VA', etc (default: US)',
     #   channel: 'optional - channel name e.g. "2/stat/#" (default: "2/e/LongFast/#")',
-    #   psk: 'optional - channel pre-shared key (default: AQ==)',
+    #   psks: 'optional - hash of :channel => psk key value pairs (default: { LongFast: "AQ==" })',
     #   qos: 'optional - quality of service (default: 0)',
     #   filter: 'optional - comma-delimited string(s) to filter on in message (default: nil)',
-    #   gps_metadata: 'optional - include GPS metadata in output (default: false)'
+    #   gps_metadata: 'optional - include GPS metadata in output (default: false)',
+    #   include_raw: 'optional - include raw packet data in output (default: false)'
     # )
 
     public_class_method def self.subscribe(opts = {})
@@ -60,34 +201,30 @@ module Meshtastic
       region = opts[:region] ||= 'US'
       channel = opts[:channel] ||= '2/e/LongFast/#'
       # TODO: Support Array of PSKs and attempt each until decrypted
-      psk = opts[:psk] ||= 'AQ=='
+
+      public_psk = '1PG7OiApB1nwvP+rz05pAQ=='
+      psks = opts[:psks] ||= { LongFast: public_psk }
+      raise 'ERROR: psks parameter must be a hash of :channel => psk key value pairs' unless psks.is_a?(Hash)
+
+      psks[:LongFast] = public_psk if psks[:LongFast] == 'AQ=='
+      psks = get_cipher_keys(psks: psks)
+
       qos = opts[:qos] ||= 0
       json = opts[:json] ||= false
       filter = opts[:filter]
       gps_metadata = opts[:gps_metadata] ||= false
+      include_raw = opts[:include_raw] ||= false
 
-      # TODO: Find JSON URI for this
+      # NOTE: Use MQTT Explorer for topic discovery
       full_topic = "#{root_topic}/#{region}/#{channel}"
       puts "Subscribing to: #{full_topic}"
       mqtt_obj.subscribe(full_topic, qos)
 
-      # Decrypt the message
-      # Our AES key is 128 or 256 bits, shared as part of the 'Channel' specification.
-
-      # Actual pre-shared key for LongFast channel
-      psk = '1PG7OiApB1nwvP+rz05pAQ==' if psk == 'AQ=='
-      padded_psk = psk.ljust(psk.length + ((4 - (psk.length % 4)) % 4), '=')
-      replaced_psk = padded_psk.gsub('-', '+').gsub('_', '/')
-      psk = replaced_psk
-      dec_psk = Base64.strict_decode64(psk)
-
-      # cipher = OpenSSL::Cipher.new('AES-256-CTR')
-      cipher = OpenSSL::Cipher.new('AES-128-CTR')
       filter_arr = filter.to_s.split(',').map(&:strip)
       mqtt_obj.get_packet do |packet_bytes|
-        # raw_packet = packet_bytes.to_s.b
+        raw_packet = packet_bytes.to_s.b if include_raw
         raw_topic = packet_bytes.topic ||= ''
-        raw_payload = packet_bytes.payload
+        raw_payload = packet_bytes.payload ||= ''
 
         begin
           disp = false
@@ -107,116 +244,45 @@ module Meshtastic
           message[:node_id_from] = "!#{message[:from].to_i.to_s(16)}"
           message[:node_id_to] = "!#{message[:to].to_i.to_s(16)}"
 
+          # If encrypted_message is not nil, then decrypt
+          # the message prior to decoding.
           encrypted_message = message[:encrypted]
-          # If encrypted_message is not nil, then decrypt the message
           if encrypted_message.to_s.length.positive?
             packet_id = message[:id]
             packet_from = message[:from]
+
             nonce_packet_id = [packet_id].pack('V').ljust(8, "\x00")
             nonce_from_node = [packet_from].pack('V').ljust(8, "\x00")
             nonce = "#{nonce_packet_id}#{nonce_from_node}".b
 
-            # Decrypt the message
-            # Key must be 32 bytes
-            # IV mustr be 16 bytes
+            psk = psks[:LongFast]
+            target_chanel = decoded_payload_hash[:channel_id].to_s.to_sym
+            psk = psks[target_chanel] if psks.keys.include?(target_chanel)
+            dec_psk = Base64.strict_decode64(psk)
+
+            cipher = OpenSSL::Cipher.new('AES-128-CTR')
+            cipher = OpenSSL::Cipher.new('AES-256-CTR') if dec_psk.length == 32
             cipher.decrypt
             cipher.key = dec_psk
             cipher.iv = nonce
 
             decrypted = cipher.update(encrypted_message) + cipher.final
-            message[:decrypted] = decrypted
+            message[:decoded] = Meshtastic::Data.decode(decrypted).to_h
+            message[:encrypted] = :decrypted
           end
 
           if message[:decoded]
+            # payload = Meshtastic::Data.decode(message[:decoded][:payload]).to_h
             payload = message[:decoded][:payload]
-
             msg_type = message[:decoded][:portnum]
-            case msg_type
-            when :ADMIN_APP
-              pb_obj = Meshtastic::AdminMessage.decode(payload)
-            when :ATAK_FORWARDER, :ATAK_PLUGIN
-              pb_obj = Meshtastic::TAKPacket.decode(payload)
-              # when :AUDIO_APP
-              # pb_obj = Meshtastic::Audio.decode(payload)
-            when :DETECTION_SENSOR_APP
-              pb_obj = Meshtastic::DeviceState.decode(payload)
-              # when :IP_TUNNEL_APP
-              # pb_obj = Meshtastic::IpTunnel.decode(payload)
-            when :MAP_REPORT_APP
-              pb_obj = Meshtastic::MapReport.decode(payload)
-              # when :MAX
-              # pb_obj = Meshtastic::Max.decode(payload)
-            when :NEIGHBORINFO_APP
-              pb_obj = Meshtastic::NeighborInfo.decode(payload)
-            when :NODEINFO_APP
-              pb_obj = Meshtastic::User.decode(payload)
-            when :PAXCOUNTER_APP
-              pb_obj = Meshtastic::Paxcount.decode(payload)
-            when :POSITION_APP
-              pb_obj = Meshtastic::Position.decode(payload)
-              # when :PRIVATE_APP
-              # pb_obj = Meshtastic::Private.decode(payload)
-            when :RANGE_TEST_APP
-              # Unsure if this is the correct protobuf object
-              pb_obj = Meshtastic::FromRadio.decode(payload)
-            when :REMOTE_HARDWARE_APP
-              pb_obj = Meshtastic::HardwareMessage.decode(payload)
-              # when :REPLY_APP
-              # pb_obj = Meshtastic::Reply.decode(payload)
-            when :ROUTING_APP
-              pb_obj = Meshtastic::Routing.decode(payload)
-            when :SERIAL_APP
-              pb_obj = Meshtastic::SerialConnectionStatus.decode(payload)
-            when :SIMULATOR_APP,
-                 :TEXT_MESSAGE_COMPRESSED_APP
-              # Unsure if this is the correct protobuf object
-              # for TEXT_MESSAGE_COMPRESSED_APP
-              pb_obj = Meshtastic::Compressed.decode(payload)
-            when :STORE_FORWARD_APP
-              pb_obj = Meshtastic::StoreAndForward.decode(payload)
-            when :TEXT_MESSAGE_APP
-              # Unsure if this is the correct protobuf object
-              # pb_obj = Meshtastic::MqttClientProxyMessage.decode(payload)
-              pb_obj = Meshtastic::Data.decode(payload)
-            when :TELEMETRY_APP
-              pb_obj = Meshtastic::Telemetry.decode(payload)
-            when :TRACEROUTE_APP
-              pb_obj = Meshtastic::RouteDiscovery.decode(payload)
-              # when :UNKNOWN_APP
-              # pb_obj = Meshtastic.Unknown.decode(payload)
-            when :WAYPOINT_APP
-              pb_obj = Meshtastic::Waypoint.decode(payload)
-              # when :ZPS_APP
-              # pb_obj = Meshtastic::Zps.decode(payload)
-            else
-              puts "WARNING: Unknown message type: #{msg_type}"
-            end
-            # Overwrite the payload with the decoded protobuf object
-            # message[:decoded][:payload] = pb_obj.to_h unless msg_type == :TRACEROUTE_APP
-            message[:decoded][:payload] = pb_obj.to_h
-            if message[:decoded][:payload].keys.include?(:latitude_i) &&
-               message[:decoded][:payload].keys.include?(:longitude_i) &&
-               gps_metadata
-
-              latitude = pb_obj.to_h[:latitude_i] * 0.0000001
-              longitude = pb_obj.to_h[:longitude_i] * 0.0000001
-              message[:decoded][:payload][:gps_metadata] = gps_search(
-                lat: latitude,
-                lon: longitude
-              ).first.data
-            end
-
-            # If we there's a mac address, make it look like one.
-            if message[:decoded][:payload].keys.include?(:macaddr)
-              macaddr = message[:decoded][:payload][:macaddr]
-              macaddr_fmt = macaddr.bytes.map { |byte| byte.to_s(16).rjust(2, '0') }.join(':')
-              message[:decoded][:payload][:macaddr] = macaddr_fmt
-            end
-            # puts pb_obj.public_methods
-            # message[:decoded][:pb_obj] = pb_obj
+            message[:decoded][:payload] = recursively_decode_payloads(
+              object: payload,
+              msg_type: msg_type,
+              gps_metadata: gps_metadata
+            )
           end
 
-          # message[:raw_packet] = raw_packet if block_given?
+          message[:raw_packet] = raw_packet if include_raw
           decoded_payload_hash[:packet] = message
           unless block_given?
             message[:stdout] = 'pretty'
@@ -227,8 +293,11 @@ module Meshtastic
                ArgumentError => e
 
           message[:decrypted] = e.message if e.message.include?('key must be')
+          message[:decrypted] = 'unable to decrypt - psk?' if e.message.include?('occurred during parsing')
           decoded_payload_hash[:packet] = message
           unless block_given?
+            puts "WARNING: #{e.inspect} - MSG IS >>>"
+            # puts e.backtrace
             message[:stdout] = 'inspect'
             stdout_message = decoded_payload_hash.inspect
           end
@@ -320,7 +389,7 @@ module Meshtastic
           root_topic: 'optional - root topic (default: msh)',
           region: 'optional - region e.g. 'US/VA', etc (default: US)',
           channel: 'optional - channel name e.g. '2/stat/#' (default: '2/e/LongFast/#')',
-          psk: 'optional - channel pre-shared key (default: AQ==)',
+          psks: 'optional - hash of :channel => psk key value pairs (default: { LongFast: 'AQ==' })',
           qos: 'optional - quality of service (default: 0)',
           json: 'optional - JSON output (default: false)',
           filter: 'optional - comma-delimited string(s) to filter on in message (default: nil)',

data/lib/meshtastic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Meshtastic
-  VERSION = '0.0.40'
+  VERSION = '0.0.42'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meshtastic
 version: !ruby/object:Gem::Version
-  version: 0.0.40
+  version: 0.0.42
 platform: ruby
 authors:
 - 0day Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-01 00:00:00.000000000 Z
+date: 2024-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 1.8.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.2
+        version: 1.8.3
 - !ruby/object:Gem::Dependency
   name: google-protobuf
   requirement: !ruby/object:Gem::Requirement
@@ -156,14 +156,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.29.1
+        version: 2.29.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.29.1
+        version: 2.29.2
 - !ruby/object:Gem::Dependency
   name: rvm
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +178,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.11.3.9
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.23.1
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement