meshtastic 0.0.115 → 0.0.116

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caa92569cfc04914d4775054daefc5382265ccdcde9791caa0c7efcb27322ce3
-  data.tar.gz: f06f9ec597ee5636fa7faed5bfaa6023f731d561b4d46341d9486e311eb29ea1
+  metadata.gz: 46e1db876551e7f78c1b28f5dbd0d066346890aa31ea7e5969165b8c9142d84b
+  data.tar.gz: fb7c1b7ee22e0cb7b86cdcaaefc5c89d49fcd7c36f2dbcc9ac5185424bc81276
 SHA512:
-  metadata.gz: 7ba94636af81ca286cdf239ed65249093457a666df9dd003975417e729c4179c8b010e28480424a2e263670174283326e40672ea591dbc11d50bad5a1b4043ec
-  data.tar.gz: 575743047507a3d99fbe9556c348f09b4606c3247565d50aaf668662dd0eec3f970640a4db19bddfcbf0e71d2981355ccc1125ea77ada3cae62d78267f1c7f61
+  metadata.gz: ffb5a5731c4d63e46816eec4de5538aa8b28637d00c79159811bea652757aa9260f3587bd8c9db7fed2842766e28fd17943a5bfe917d6d684ada85b4bef50592
+  data.tar.gz: 4145d728651ca25dfaffc8f99d2cfdc3ebd17904be545c5c395a1839287207a3fbd05696f90be8755982ca574be405f77f7377577bb0d6e8ab278c8f127e1601

data/Gemfile

@@ -18,5 +18,5 @@ gem 'rubocop', '>=1.72.1'
 gem 'rubocop-rake', '>=0.7.0'
 gem 'rubocop-rspec', '>=3.4.0'
 gem 'rvm', '1.11.3.9'
-gem 'tty-prompt', '0.23.1'
+gem 'uart', '1.0.0'
 gem 'yard', '0.9.37'

data/lib/meshtastic/mqtt.rb

@@ -6,7 +6,6 @@ require 'json'
 require 'mqtt'
 require 'openssl'
 require 'securerandom'
-require 'tty-prompt'
 
 # Avoiding Namespace Collisions
 MQTTClient = MQTT::Client
@@ -15,7 +14,7 @@ MQTTClient = MQTT::Client
 module Meshtastic
   module MQTT
     # Supported Method Parameters::
-    # mqtt_obj = Meshtastic::MQQT.connect(
+    # mqtt_obj = Meshtastic::MQTT.connect(
     #   host: 'optional - mqtt host (default: mqtt.meshtastic.org)',
     #   port: 'optional - mqtt port (defaults: 1883)',
     #   tls: 'optional - use TLS (default: false)',
@@ -58,7 +57,7 @@ module Meshtastic
     end
 
     # Supported Method Parameters::
-    # Meshtastic::MQQT.subscribe(
+    # Meshtastic::MQTT.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)',
@@ -145,6 +144,11 @@ module Meshtastic
           if encrypted_message.to_s.length.positive? &&
              message[:topic]
 
+            # if message[:pki_encrypted]
+            #   # TODO: Display Decrypted PKI Message
+            #   public_key = message[:public_key]
+            #   dec_public_key = Base64.strict_decode64(public_key)
+            # else
             packet_id = message[:id]
             packet_from = message[:from]
 
@@ -164,6 +168,7 @@ module Meshtastic
             cipher.iv = nonce
 
             decrypted = cipher.update(encrypted_message) + cipher.final
+            # end
             message[:decoded] = Meshtastic::Data.decode(decrypted).to_h
             message[:encrypted] = :decrypted
           end

data/lib/meshtastic/serial.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'geocoder'
+require 'io/wait'
+require 'json'
+require 'openssl'
+require 'securerandom'
+require 'uart'
+
+# Plugin used to interact with Meshtastic nodes
+module Meshtastic
+  module Serial
+    @session_data = []
+
+    # Supported Method Parameters::
+    # serial_obj = Meshtastic::Serial.connect(
+    #   block_dev: 'optional - serial block device path (defaults to /dev/ttyUSB0)',
+    #   baud: 'optional - (defaults to 9600)',
+    #   data_bits: 'optional - (defaults to 8)',
+    #   stop_bits: 'optional - (defaults to 1)',
+    #   parity: 'optional - :even|:mark|:odd|:space|:none (defaults to :none)'
+    # )
+
+    public_class_method def self.connect(opts = {})
+      block_dev = opts[:block_dev] ||= '/dev/ttyUSB0'
+      raise "Invalid block device: #{block_dev}" unless File.exist?(block_dev)
+
+      baud = opts[:baud] ||= 9_600
+      data_bits = opts[:data_bits] ||= 8
+      stop_bits = opts[:stop_bits] ||= 1
+      parity = opts[:parity] ||= :none
+
+      case parity.to_s.to_sym
+      when :even
+        parity = 'E'
+      when :odd
+        parity = 'O'
+      when :none
+        parity = 'N'
+      end
+      raise "Invalid parity: #{opts[:parity]}" if parity.nil?
+
+      mode = "#{data_bits}#{parity}#{stop_bits}"
+      puts mode
+
+      serial_conn = UART.open(
+        block_dev,
+        baud,
+        mode
+      )
+
+      serial_obj = {}
+      serial_obj[:serial_conn] = serial_conn
+      serial_obj[:session_thread] = init_session_thread(
+        serial_conn: serial_conn
+      )
+
+      serial_obj
+    rescue StandardError => e
+      disconnect(serial_obj: serial_obj) unless serial_obj.nil?
+      raise e
+    end
+
+    # Supported Method Parameters::
+    # Meshtastic::Serial.subscribe(
+    #   serial_obj: 'required - serial_obj returned from #connect method'
+    #   root_topic: 'optional - root topic (default: msh)',
+    #   region: 'optional - region e.g. 'US/VA', etc (default: US)',
+    #   channel_topic: 'optional - channel ID path e.g. "2/stat/#" (default: "2/e/LongFast/#")',
+    #   psks: 'optional - hash of :channel_id => psk key value pairs (default: { LongFast: "AQ==" })',
+    #   qos: 'optional - quality of service (default: 0)',
+    #   exclude: 'optional - comma-delimited string(s) to exclude in message (default: nil)',
+    #   include: 'optional - comma-delimited string(s) to include on in message (default: nil)',
+    #   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 = {})
+      serial_obj = opts[:serial_obj]
+      root_topic = opts[:root_topic] ||= 'msh'
+      region = opts[:region] ||= 'US'
+      channel_topic = opts[:channel_topic] ||= '2/e/LongFast/#'
+      # TODO: Support Array of PSKs and attempt each until decrypted
+
+      public_psk = '1PG7OiApB1nwvP+rz05pAQ=='
+      psks = opts[:psks] ||= { LongFast: public_psk }
+      raise 'ERROR: psks parameter must be a hash of :channel_id => psk key value pairs' unless psks.is_a?(Hash)
+
+      psks[:LongFast] = public_psk if psks[:LongFast] == 'AQ=='
+      psks = Meshtastic.get_cipher_keys(psks: psks)
+
+      qos = opts[:qos] ||= 0
+      json = opts[:json] ||= false
+      exclude = opts[:exclude]
+      include = opts[:include]
+      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_topic}"
+      full_topic = "#{root_topic}/#{region}" if region == '#'
+      puts "Subscribing to: #{full_topic}"
+      serial_obj.subscribe(full_topic, qos)
+
+      # MQTT::ProtocolException: No Ping Response received for 23 seconds (MQTT::ProtocolException)
+
+      include_arr = include.to_s.split(',').map(&:strip)
+      exclude_arr = exclude.to_s.split(',').map(&:strip)
+      serial_obj.get_packet do |packet_bytes|
+        raw_packet = packet_bytes.to_s if include_raw
+        raw_topic = packet_bytes.topic ||= ''
+        raw_payload = packet_bytes.payload ||= ''
+
+        begin
+          disp = false
+          decoded_payload_hash = {}
+          message = {}
+          stdout_message = ''
+
+          if json
+            decoded_payload_hash = JSON.parse(raw_payload, symbolize_names: true)
+          else
+            # decoded_payload = Meshtastic::ToRadio.decode(raw_payload)
+            decoded_payload = Meshtastic::FromRadio.decode(raw_payload)
+            decoded_payload_hash = decoded_payload.to_h
+          end
+
+          next unless decoded_payload_hash[:packet].is_a?(Hash)
+
+          message = decoded_payload_hash[:packet] if decoded_payload_hash.keys.include?(:packet)
+          message[:topic] = raw_topic
+          message[:node_id_from] = "!#{message[:from].to_i.to_s(16)}"
+          message[:node_id_to] = "!#{message[:to].to_i.to_s(16)}"
+          if message.keys.include?(:rx_time)
+            rx_time_int = message[:rx_time]
+            if rx_time_int.is_a?(Integer)
+              rx_time_utc = Time.at(rx_time_int).utc.to_s
+              message[:rx_time_utc] = rx_time_utc
+            end
+          end
+
+          if message.keys.include?(:public_key)
+            raw_public_key = message[:public_key]
+            message[:public_key] = Base64.strict_encode64(raw_public_key)
+          end
+
+          # If encrypted_message is not nil, then decrypt
+          # the message prior to decoding.
+          encrypted_message = message[:encrypted]
+          if encrypted_message.to_s.length.positive? &&
+             message[:topic]
+
+            # if message[:pki_encrypted]
+            #   # TODO: Display Decrypted PKI Message
+            #   public_key = message[:public_key]
+            #   dec_public_key = Base64.strict_decode64(public_key)
+            # else
+            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}"
+
+            psk = psks[:LongFast]
+            target_channel = message[:topic].split('/')[-2].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')
+            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
+            # end
+            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]
+            message[:decoded][:payload] = Meshtastic.decode_payload(
+              payload: payload,
+              msg_type: msg_type,
+              gps_metadata: gps_metadata
+            )
+          end
+
+          message[:raw_packet] = raw_packet if include_raw
+          decoded_payload_hash[:packet] = message
+          unless block_given?
+            message[:stdout] = 'pretty'
+            stdout_message = JSON.pretty_generate(decoded_payload_hash)
+          end
+        rescue Encoding::CompatibilityError,
+               Google::Protobuf::ParseError,
+               JSON::GeneratorError,
+               ArgumentError => e
+
+          unless e.is_a?(Encoding::CompatibilityError)
+            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
+          end
+
+          next
+        ensure
+          include_arr = [message[:id].to_s] if include_arr.empty?
+          if message.is_a?(Hash)
+            flat_message = message.values.join(' ')
+
+            disp = true if exclude_arr.none? { |exclude| flat_message.include?(exclude) } && (
+                             include_arr.first == message[:id] ||
+                             include_arr.all? { |include| flat_message.include?(include) }
+                           )
+
+            if disp
+              if block_given?
+                yield decoded_payload_hash
+              else
+                puts "\n"
+                puts '-' * 80
+                puts 'MSG:'
+                puts stdout_message
+                puts '-' * 80
+                puts "\n\n\n"
+              end
+              # else
+              # print '.'
+            end
+          end
+        end
+      end
+    rescue Interrupt
+      puts "\nCTRL+C detected. Exiting..."
+    rescue StandardError => e
+      raise e
+    ensure
+      serial_obj.disconnect if serial_obj
+    end
+
+    # Supported Method Parameters::
+    # Meshtastic.send_text(
+    #   serial_obj: 'required - serial_obj returned from #connect method',
+    #   from: 'required - From ID (String or Integer) (Default: "!00000b0b")',
+    #   to: 'optional - Destination ID (Default: "!ffffffff")',
+    #   topic: 'optional - topic to publish to (Default: "msh/US/2/e/LongFast/1")',
+    #   channel: 'optional - channel (Default: 6)',
+    #   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',
+    #   psks: 'optional - hash of :channel_id => psk key value pairs (default: { LongFast: "AQ==" })'
+    # )
+    public_class_method def self.send_text(opts = {})
+      serial_obj = opts[:serial_obj]
+      topic = opts[:topic] ||= 'msh/US/2/e/LongFast/#'
+      opts[:via] = :radio
+
+      # TODO: Implement chunked message to deal with large messages
+      protobuf_text = Meshtastic.send_text(opts)
+
+      serial_obj.publish(topic, protobuf_text)
+    rescue StandardError => e
+      raise e
+    end
+
+    # Supported Method Parameters::
+    # serial_obj = Meshtastic.disconnect(
+    #   serial_obj: 'required - serial_obj returned from #connect method'
+    # )
+    public_class_method def self.disconnect(opts = {})
+      serial_obj = opts[:serial_obj]
+
+      serial_obj.disconnect if serial_obj
+      nil
+    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 Usage for this Module
+
+    public_class_method def self.help
+      puts "USAGE:
+        serial_obj = #{self}.connect(
+          host: 'optional - mqtt host (default: mqtt.meshtastic.org)',
+          port: 'optional - mqtt port (defaults: 1883)',
+          tls: 'optional - use TLS (default: false)',
+          username: 'optional - mqtt username (default: meshdev)',
+          password: 'optional - (default: large4cats)',
+          client_id: 'optional - client ID (default: random 4-byte hex string)',
+          keep_alive: 'optional - keep alive interval (default: 15)',
+          ack_timeout: 'optional - acknowledgement timeout (default: 30)'
+        )
+
+        #{self}.subscribe(
+          serial_obj: 'required - serial_obj object returned from #connect method',
+          root_topic: 'optional - root topic (default: msh)',
+          region: 'optional - region e.g. 'US/VA', etc (default: US)',
+          channel_topic: 'optional - channel ID path e.g. '2/stat/#' (default: '2/e/LongFast/#')',
+          psks: 'optional - hash of :channel_id => psk key value pairs (default: { LongFast: 'AQ==' })',
+          qos: 'optional - quality of service (default: 0)',
+          json: 'optional - JSON output (default: false)',
+          exclude: 'optional - comma-delimited string(s) to exclude in message (default: nil)',
+          include: 'optional - comma-delimited string(s) to include on in message (default: nil)',
+          gps_metadata: 'optional - include GPS metadata in output (default: false)'
+        )
+
+        #{self}.send_text(
+          serial_obj: 'required - serial_obj returned from #connect method',
+          from: 'required - From ID (String or Integer) (Default: \"!00000b0b\")',
+          to: 'optional - Destination ID (Default: \"!ffffffff\")',
+          topic: 'optional - topic to publish to (default: 'msh/US/2/e/LongFast/1')',
+          channel: 'optional - channel (Default: 6)',
+          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',
+          psks: 'optional - hash of :channel => psk key value pairs (default: { LongFast: 'AQ==' })'
+        )
+
+        serial_obj = #{self}.disconnect(
+          serial_obj: 'required - serial_obj object returned from #connect method'
+        )
+
+        #{self}.authors
+      "
+    end
+  end
+end

data/lib/meshtastic/version.rb

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

data/lib/meshtastic.rb

@@ -45,6 +45,7 @@ module Meshtastic
   autoload :Portnums, 'meshtastic/portnums'
   autoload :RemoteHardware, 'meshtastic/remote_hardware'
   autoload :RTTTL, 'meshtastic/rtttl'
+  autoload :Serial, 'meshtastic/serial'
   autoload :Storeforward, 'meshtastic/storeforward'
   autoload :Telemetry, 'meshtastic/telemetry'
   autoload :Xmodem, 'meshtastic/xmodem'

data/spec/lib/meshtastic/serial_spec.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Meshtastic::Serial do
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: meshtastic
 version: !ruby/object:Gem::Version
-  version: 0.0.115
+  version: 0.0.116
 platform: ruby
 authors:
 - 0day Inc.
@@ -178,19 +178,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.11.3.9
 - !ruby/object:Gem::Dependency
-  name: tty-prompt
+  name: uart
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.23.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.23.1
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -267,6 +267,7 @@ files:
 - lib/meshtastic/remote_hardware_pb.rb
 - lib/meshtastic/rtttl.rb
 - lib/meshtastic/rtttl_pb.rb
+- lib/meshtastic/serial.rb
 - lib/meshtastic/storeforward.rb
 - lib/meshtastic/storeforward_pb.rb
 - lib/meshtastic/telemetry.rb
@@ -314,6 +315,7 @@ files:
 - spec/lib/meshtastic/remote_hardware_spec.rb
 - spec/lib/meshtastic/rtttl_pb_spec.rb
 - spec/lib/meshtastic/rtttl_spec.rb
+- spec/lib/meshtastic/serial_spec.rb
 - spec/lib/meshtastic/storeforward_pb_spec.rb
 - spec/lib/meshtastic/storeforward_spec.rb
 - spec/lib/meshtastic/telemetry_pb_spec.rb