meshtastic 0.0.41 → 0.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94567b95fcf287b1a47b7af7ea3efb4b6f15a5a0daf81137127b6f5dede9a8fd
-  data.tar.gz: aa07f4271ac1cb1953492ab508f2f8f4f2c7c0c51fb306195b096b950b917c25
+  metadata.gz: 105d223bd94e02d4473ac5fd66ed0b8dc7eef73d44578eb427fc3d55eb51ae21
+  data.tar.gz: 216a3957a439408579d1d7b48dd552d394885bbc09b8dc3410d776e4c1eb37d6
 SHA512:
-  metadata.gz: 77093a3977ef63ad7c15d255c679771e5fe02448741147acbc608f19c057d9b9f8f47fe214e0f0a2799cca331726450f978bbda99248fb5d3f592e4d37b09a43
-  data.tar.gz: 4c617b139c876db4b3fff9f4357fba3785972e47e88e85a9a9a1656db8c5ced40e42699b737aa7b84f3cc86ced3f66480a3def02e6e1a2272bdd23ac70d82858
+  metadata.gz: 1381a13cff943403ef269c5a349529ab9c2f12e3a3af5b3e88c589f7fd427a6e45b23543251449e1d520471fdf5f6c8a11c55c56bfc24553dc2b02db7ace28d9
+  data.tar.gz: 01d01863635a22c2d3c42ace2a34076c4094ece8ef9629f08ae0e8da7c0a98bbc5815db26e2e4063fa462619caf710938628a8cd086f62411d1cd885017665a4

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,7 +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

@@ -63,6 +63,96 @@ module Meshtastic
       raise e
     end
 
+    # Supported Method Parameters::
+    # Meshtastic::MQQT.decode_payload(
+    #   payload: 'required - payload to recursively decode',
+    #   msg_type: 'required - message type (e.g. :TEXT_MESSAGE_APP)',
+    #   gps_metadata: 'optional - include GPS metadata in output (default: false)',
+    # )
+
+    public_class_method def self.decode_payload(opts = {})
+      payload = opts[:payload]
+      msg_type = opts[:msg_type]
+      gps_metadata = opts[:gps_metadata]
+
+      case msg_type
+      when :ADMIN_APP
+        decoder = Meshtastic::AdminMessage
+      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 :WAYPOINT_APP
+        decoder = Meshtastic::Waypoint
+        # when :ZPS_APP
+        # decoder = Meshtastic::Zps
+      end
+      payload = decoder.decode(payload).to_h
+      if payload.keys.include?(:latitude_i) && payload.keys.include?(:longitude_i)
+        lat = payload[:latitude_i] * 0.0000001
+        lon = payload[:longitude_i] * 0.0000001
+        payload[:latitude] = lat
+        payload[:longitude] = lon
+        if gps_metadata
+          gps_search_resp = Meshtastic.gps_search(lat: lat, lon: lon)
+          payload[:gps_metadata] = gps_search_resp
+        end
+      end
+
+      if payload.keys.include?(:macaddr)
+        mac_hex_arr = payload[:macaddr].bytes.map { |byte| byte.to_s(16).rjust(2, '0') }
+        mac_str = mac_hex_arr.join(':')
+        payload[:macaddr] = mac_str
+      end
+
+      payload
+    rescue Google::Protobuf::ParseError
+      payload
+    rescue StandardError => e
+      raise e
+    end
+
     # Supported Method Parameters::
     # Meshtastic::MQQT.subscribe(
     #   mqtt_obj: 'required - mqtt_obj returned from #connect method'
@@ -72,7 +162,8 @@ module Meshtastic
     #   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 = {})
@@ -93,6 +184,7 @@ module Meshtastic
       json = opts[:json] ||= false
       filter = opts[:filter]
       gps_metadata = opts[:gps_metadata] ||= false
+      include_raw = opts[:include_raw] ||= false
 
       # NOTE: Use MQTT Explorer for topic discovery
       full_topic = "#{root_topic}/#{region}/#{channel}"
@@ -101,7 +193,7 @@ module Meshtastic
 
       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 ||= ''
 
@@ -123,10 +215,10 @@ 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]
 
@@ -135,8 +227,8 @@ module Meshtastic
             nonce = "#{nonce_packet_id}#{nonce_from_node}".b
 
             psk = psks[:LongFast]
-            target_chanel = decoded_payload_hash[:channel_id].to_s.to_sym
-            psk = psks[target_chanel] if psks.keys.include?(target_chanel)
+            target_channel = decoded_payload_hash[:channel_id].to_s.to_sym
+            psk = psks[target_channel] if psks.keys.include?(target_channel)
             dec_psk = Base64.strict_decode64(psk)
 
             cipher = OpenSSL::Cipher.new('AES-128-CTR')
@@ -146,99 +238,22 @@ module Meshtastic
             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] = decode_payload(
+              payload: 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'
@@ -249,8 +264,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

data/lib/meshtastic/version.rb

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

data/lib/meshtastic.rb

@@ -2,6 +2,7 @@
 
 # Plugin used to interact with Meshtastic nodes
 module Meshtastic
+  require 'base64'
   # Protocol Buffers for Meshtastic
   require 'meshtastic/admin_pb'
   require 'nanopb_pb'
@@ -25,6 +26,7 @@ module Meshtastic
   require 'meshtastic/telemetry_pb'
   require 'meshtastic/version'
   require 'meshtastic/xmodem_pb'
+  require 'openssl'
 
   autoload :Admin, 'meshtastic/admin'
   autoload :Apponly, 'meshtastic/apponly'
@@ -47,6 +49,191 @@ module Meshtastic
   autoload :Telemetry, 'meshtastic/telemetry'
   autoload :Xmodem, 'meshtastic/xmodem'
 
+  # Supported Method Parameters::
+  # Meshtastic.send_text(
+  #   from_id: 'optional - Source ID (Default: 0)',
+  #   dest_id: 'optional - Destination ID (Default: 0xFFFFFFFF)',
+  #   text: 'optional - Text Message (Default: SYN)',
+  #   want_ack: 'optional - Want Acknowledgement (Default: false)',
+  #   want_response: 'optional - Want Response (Default: false)',
+  #   hop_limit: 'optional - Hop Limit (Default: 3)',
+  #   on_response: 'optional - Callback on Response',
+  #   psk: 'optional - Pre-Shared Key if Encrypted (Default: nil)'
+  # )
+  public_class_method def self.send_text(opts = {})
+    # Send a text message to a node
+    from_id = opts[:from_id].to_i
+    dest_id = opts[:dest_id] ||= 0xFFFFFFFF
+    text = opts[:text] ||= 'SYN'
+    want_ack = opts[:want_ack] ||= false
+    want_response = opts[:want_response] ||= false
+    hop_limit = opts[:hop_limit] ||= 3
+    on_response = opts[:on_response]
+    psk = opts[:psk]
+    
+    # TODO: verify text length validity
+    max_txt_len = Meshtastic::Constants::DATA_PAYLOAD_LEN
+    raise "ERROR: Text Length > #{max_txt_len} Bytes" if text.length > max_txt_len
+
+    port_num = Meshtastic::PortNum::TEXT_MESSAGE_APP
+
+    data = Meshtastic::Data.new
+    data.payload = text
+    data.portnum = port_num
+    data.want_response = want_response
+    puts data.to_h
+
+    send_data(
+      from_id: from_id,
+      dest_id: dest_id,
+      data: data,
+      want_ack: want_ack,
+      want_response: want_response,
+      hop_limit: hop_limit,
+      port_num: port_num,
+      on_response: on_response,
+      psk: psk
+    )
+  rescue StandardError => e
+    raise e
+  end
+
+  # Supported Method Parameters::
+  # Meshtastic.send_data(
+  #   from_id: 'optional - Source ID (Default: 0)',
+  #   dest_id: 'optional - Destination ID (Default: 0xFFFFFFFF)',
+  #   data: 'required - Data to Send',
+  #   want_ack: 'optional - Want Acknowledgement (Default: false)',
+  #   hop_limit: 'optional - Hop Limit (Default: 3)',
+  #   port_num: 'optional - (Default: Meshtastic::PortNum::PRIVATE_APP)',
+  #   psk: 'optional - Pre-Shared Key if Encrypted (Default: nil)'
+  # )
+  public_class_method def self.send_data(opts = {})
+    # Send a text message to a node
+    from_id = opts[:from_id].to_i
+    dest_id = opts[:dest_id] ||= 0xFFFFFFFF
+    data = opts[:data]
+    want_ack = opts[:want_ack] ||= false
+    hop_limit = opts[:hop_limit] ||= 3
+    port_num = opts[:port_num] ||= Meshtastic::PortNum::PRIVATE_APP
+    max_port_num = Meshtastic::PortNum::MAX
+    raise "ERROR: Invalid port_num" unless port_num.positive? && port_num < max_port_num
+
+    psk = opts[:psk]
+
+    data_len = data.payload.length
+    max_len = Meshtastic::Constants::DATA_PAYLOAD_LEN
+    raise "ERROR: Data Length > #{max_len} Bytes" if data_len > max_len
+
+    mesh_packet = Meshtastic::MeshPacket.new
+    mesh_packet.decoded = data
+
+    send_packet(
+      mesh_packet: mesh_packet,
+      from_id: from_id,
+      dest_id: dest_id,
+      want_ack: want_ack,
+      hop_limit: hop_limit,
+      psk: psk
+    )
+  rescue StandardError => e
+    raise e
+  end
+
+  # Supported Method Parameters::
+  # Meshtastic.send_packet(
+  #   mesh_packet: 'required - Mesh Packet to Send',
+  #   from_id: 'optional - Source ID (Default: 0)',
+  #   dest_id: 'optional - Destination ID (Default: 0xFFFFFFFF)',
+  #   want_ack: 'optional - Want Acknowledgement (Default: false)',
+  #   hop_limit: 'optional - Hop Limit (Default: 3)',
+  #   psk: 'optional - Pre-Shared Key if Encrypted (Default: nil)'
+  # )
+  public_class_method def self.send_packet(opts = {})
+    mesh_packet = opts[:mesh_packet]
+    from_id = opts[:from_id] ||= 0
+    dest_id = opts[:dest_id] ||= 0xFFFFFFFF
+    want_ack = opts[:want_ack] ||= false
+    hop_limit = opts[:hop_limit] ||= 3
+    psk = opts[:psk]
+
+    # my_info = Meshtastic::FromRadio.my_info
+    # wait_connected if dest_id != my_info.my_node_num && my_info.is_a(Meshtastic::Deviceonly::MyInfo)
+    
+    node_num = dest_id
+    node_num_hex = dest_id.bytes.map { |b| b.to_s(16).rjust(2, '0') }.join if dest_id.is_a?(String)
+    node_num = node_num_hex.to_i(16) if node_num_hex
+
+    mesh_packet.from = from_id
+    mesh_packet.to = node_num
+    mesh_packet.want_ack = want_ack
+    mesh_packet.hop_limit = hop_limit
+
+    mesh_packet.id = generate_packet_id if mesh_packet.id.zero?
+
+    if psk
+      nonce_packet_id = [mesh_packet.id].pack('V').ljust(8, "\x00")
+      nonce_from_node = [from_id].pack('V').ljust(8, "\x00")
+      nonce = "#{nonce_packet_id}#{nonce_from_node}".b
+
+      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.encrypt
+      cipher.key = dec_psk
+      cipher.iv = nonce
+
+      decrypted_payload = mesh_packet.decoded.to_s
+      encrypted_payload = cipher.update(decrypted_payload) + cipher.final
+
+      mesh_packet.encrypted = encrypted_payload
+    end
+    # puts mesh_packet.to_h
+
+    # to_radio = Meshtastic::ToRadio.new
+    # to_radio.packet = mesh_packet
+    # send_to_radio(to_radio: to_radio)
+
+    mesh_packet
+  rescue StandardError => e
+    raise e
+  end
+
+  # Supported Method Parameters::
+  # packet_id = Meshtastic.generate_packet_id(
+  #   last_packet_id: 'optional - Last Packet ID (Default: 0)'
+  # )
+  public_class_method def self.generate_packet_id(opts = {})
+    last_packet_id = opts[:last_packet_id] ||= 0
+
+    packet_id = last_packet_id + 1 if last_packet_id.positive?
+    packet_id = rand(2**32) if last_packet_id.zero?
+
+    packet_id
+  end
+
+  # Supported Method Parameters::
+  # Meshtastic.send_to_radio(
+  #   to_radio: 'required - ToRadio Message to Send'
+  # )
+  public_class_method def self.send_to_radio(opts = {})
+    to_radio = opts[:to_radio]
+
+    raise 'ERROR: Invalid ToRadio Message' unless to_radio.is_a?(Meshtastic::ToRadio)
+
+    to_radio.to_proto
+  rescue StandardError => e
+    raise e
+  end
+
+  # Author(s):: 0day Inc. <support@0dayinc.com>
+
+  public_class_method def self.authors
+    "AUTHOR(S):
+      0day Inc. <support@0dayinc.com>
+    "
+  end
+
   # Display a List of Every Meshtastic Module
 
   public_class_method def self.help

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meshtastic
 version: !ruby/object:Gem::Version
-  version: 0.0.41
+  version: 0.0.43
 platform: ruby
 authors:
 - 0day Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-02 00:00:00.000000000 Z
+date: 2024-05-07 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