meshtastic 0.0.42 → 0.0.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ffe0a1e8528090281aedce5b132f1f57aa82db0c8c46131cff53d00004e4dcd
-  data.tar.gz: 56bb82c58cdcbced0c401802180931aa4625e4314e4954ab30349811a614d399
+  metadata.gz: 5dec0934f3c9c639e3af0cf5f8b88447dd83a96c5ed8082ff954ce13c5b758dd
+  data.tar.gz: c4a3e692fdc5f92a8e1ddf997ae9d5f7c6e33915dd239546d52f3adcee690a44
 SHA512:
-  metadata.gz: dd84aa7e0607992de00be53a0f8ccb2d69077004dd21ebc2838be38582064a797c0f13317c0abd375ab67199dd494640187895384ea74110c77c9b478a218654
-  data.tar.gz: a1135c741f44f38765421ea2020173b40395478fffdbb24da760d75f8483920f99cf2f0d110f7173fb9617e7522a644dc418f937aef79a35f1b04d89ed94737c
+  metadata.gz: 8c20d4c63ffdf13b5903f2e5605d5296268613b7bd7cc3380f48e4405e7b4aabda8216775f6664b42e5886dffdac42cfcb66b13bc1a48068e19f3152e1fa9598
+  data.tar.gz: a2ff5b9076561cb0b43b798d4bc6471f7ee2a4387be99bd53b98b389b4344954fbf451ce41be341c6e3a945b12adc02ba531883466fbb46cde30d8f7e0651c02

data/lib/meshtastic/mqtt.rb

@@ -64,120 +64,108 @@ module Meshtastic
     end
 
     # Supported Method Parameters::
-    # Meshtastic::MQQT.recursively_decode_payloads(
-    #   object: 'required - object to recursively decode',
+    # 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)'
+    #   gps_metadata: 'optional - include GPS metadata in output (default: false)',
     # )
 
-    private_class_method def self.recursively_decode_payloads(opts = {})
-      object = opts[:object]
+    public_class_method def self.decode_payload(opts = {})
+      payload = opts[:payload]
       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
+      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
 
-          # 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
+      payload = decoder.decode(payload).to_h
 
-        end
+      if payload.keys.include?(:latitude_i)
+        lat = payload[:latitude_i] * 0.0000001
+        payload[:latitude] = lat
+      end
+
+      if payload.keys.include?(:longitude_i)
+        lon = payload[:longitude_i] * 0.0000001
+        payload[:longitude] = lon
+      end
 
-        next unless gps_metadata && object[:latitude] && object[:longitude]
+      if payload.keys.include?(:macaddr)
+        mac_raw = payload[:macaddr]
+        mac_hex_arr = mac_raw.bytes.map { |byte| byte.to_s(16).rjust(2, '0') }
+        mac_hex_str = mac_hex_arr.join(':')
+        payload[:macaddr_hex] = mac_hex_str
+      end
 
-        object[:gps_metadata] = gps_search(
-          lat: object[:latitude],
-          lon: object[:longitude]
-        ).first.data
+      if payload.keys.include?(:time)
+        time_int = payload[:time]
+        time_utc = Time.at(time_int).utc if time_int.is_a?(Integer)
+        payload[:time_utc] = time_utc
+      end
+
+      if gps_metadata && payload[:latitude] && payload[:longitude]
+        lat = payload[:latitude]
+        lon = payload[:longitude]
+        unless lat.zero? && lon.zero?
+          gps_search_resp = gps_search(lat: lat, lon: lon)
+          payload[:gps_metadata] = gps_search_resp
+        end
       end
 
-      object
+      payload
     rescue Google::Protobuf::ParseError
-      object
+      payload
     rescue StandardError => e
       raise e
     end
@@ -256,8 +244,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')
@@ -275,8 +263,8 @@ module Meshtastic
             # payload = Meshtastic::Data.decode(message[:decoded][:payload]).to_h
             payload = message[:decoded][:payload]
             msg_type = message[:decoded][:portnum]
-            message[:decoded][:payload] = recursively_decode_payloads(
-              object: payload,
+            message[:decoded][:payload] = decode_payload(
+              payload: payload,
               msg_type: msg_type,
               gps_metadata: gps_metadata
             )
@@ -347,7 +335,7 @@ module Meshtastic
 
       gps_arr = [lat.to_f, lon.to_f]
 
-      Geocoder.search(gps_arr)
+      Geocoder.search(gps_arr).first.data
     rescue StandardError => e
       raise e
     end

data/lib/meshtastic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Meshtastic
-  VERSION = '0.0.42'
+  VERSION = '0.0.44'
 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.42
+  version: 0.0.44
 platform: ruby
 authors:
 - 0day Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-03 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -348,7 +348,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
 summary: Ruby gem for Meshtastic