pwn 0.5.734 → 0.5.735

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35f85751c76226260916fb5b417180f8c10a1fe53eb8913295895aec83da8eaa
-  data.tar.gz: 7808ea07ce71dd2576b168acf9cb1c429c0f9f4dc098570c13ffa81d416e6ffc
+  metadata.gz: d8f7823f226f8196c1c33bda916bb5ffde0d6ca22b0c47b3d7b5518ca85e9a8b
+  data.tar.gz: f069d75fa0a0e678aff23e9255cdd5ea13e4b3821a93fa6a1a0fd86e5648171c
 SHA512:
-  metadata.gz: 933f35d3a0d28a1dfdb87eb826874e88b150738b333bfb2518a9366f61cd72b24c5fb7e64fe30e73a92086320d6d3df8bfb88b3d8047f9565eab9dd995780087
-  data.tar.gz: 5384de39a95c61302cd37f6a6bcdfbcd54f1f9b047a7588c990afef5b89a8e572007dab3abab3e35547d8dc35c6a43d4f2ec72997122e70ea86ea0a3cb21fc7d
+  metadata.gz: 4795ce1673e60efc6919b72aa25cd0d1058a740234fdccb55efb104708d9940a32ca77d0f600195662dd543d5d20403435313d7c3746266d01fc761b3af8e4ae
+  data.tar.gz: 1fb653643bcd942b89a7e220009a5b05714950382f1598581bd859e8c2f8c9f64c5c60e37570a02d2c6d4e31831a8978dead7793766c529a48373fe6acd5b31b

data/lib/pwn/plugins/repl/mesh.rb

@@ -536,10 +536,107 @@ module PWN
           end
 
           # Send a text frame on the active mesh transport.
+          def mesh_text_payload_max(opts = {})
+            return 0 unless opts.is_a?(Hash)
+
+            cap = opts[:max] || Meshtastic::Constants::DATA_PAYLOAD_LEN
+            # DATA_PAYLOAD_LEN is the protobuf Data.payload max. A MeshPacket
+            # around a full-size payload is ~260 bytes and will not fit a 256-byte
+            # LoRa frame, so the radio accepts ToRadio then silently drops TX.
+            lora = 256
+            overhead = 32
+            [cap, lora - overhead].min
+          end
+
+          def mesh_payload_fits?(opts = {})
+            return false unless opts.is_a?(Hash)
+
+            text = opts[:text].to_s
+            max = opts[:max] || mesh_text_payload_max
+            text.length <= max && text.bytesize <= max
+          end
+
+          def mesh_tx_row_ready?(opts = {})
+            return false unless opts.is_a?(Hash)
+
+            row = opts[:row]
+            return false unless row.is_a?(Hash)
+
+            packet = row[:packet] || row['packet']
+            return false unless packet.is_a?(Hash)
+
+            decoded = packet[:decoded] || packet['decoded']
+            return false unless decoded.is_a?(Hash)
+
+            port = decoded[:portnum] || decoded['portnum']
+            %w[5 ROUTING_APP].include?(port.to_s) || port == :ROUTING_APP
+          end
+
+          def mesh_wait_tx_slot(opts = {})
+            return unless opts.is_a?(Hash)
+
+            obj = opts[:obj]
+            return unless obj.is_a?(Hash)
+
+            timeout = opts[:timeout]
+            timeout = 8 if timeout.nil?
+            timeout = Float(timeout)
+            return if timeout <= 0
+
+            since = opts[:since].to_i
+            deadline = Time.now + timeout
+            loop do
+              rows = if obj[:rx_mutex]
+                       obj[:rx_mutex].synchronize { Array(obj[:proto_data]).dup }
+                     else
+                       Array(obj[:proto_data])
+                     end
+              ready = rows.drop(since).any? do |row|
+                mesh_tx_row_ready?(row: row)
+              end
+              return if ready
+              return if Time.now >= deadline
+
+              sleep 0.05
+            end
+          end
+
+          def mesh_text_chunks(opts = {})
+            return [] unless opts.is_a?(Hash)
+
+            text = opts[:text].to_s
+            max = mesh_text_payload_max
+            return [text] if mesh_payload_fits?(text: text, max: max)
+
+            n = 2
+            loop do
+              prefix = "(#{n}/#{n}) "
+              body_max = max - prefix.length
+              raise ArgumentError, "DATA_PAYLOAD_LEN #{max} cannot hold a chunk prefix" if body_max < 1
+
+              bodies = []
+              offset = 0
+              while offset < text.length
+                take = body_max
+                piece = text[offset, take].to_s
+                while !mesh_payload_fits?(text: "#{prefix}#{piece}", max: max) && take > 1
+                  take -= 1
+                  piece = text[offset, take].to_s
+                end
+                bodies << piece
+                offset += piece.length
+              end
+              if bodies.size <= n
+                total = bodies.size
+                return bodies.each_with_index.map { |body, i| "(#{i + 1}/#{total}) #{body}" }
+              end
+              n = bodies.size
+            end
+          end
+
           def mesh_send_text(opts = {})
             env = opts[:env] || {}
             obj = opts[:obj]
-            text = opts[:text]
             from = opts[:from]
             channel = opts[:channel]
             psks = opts[:psks]
@@ -550,49 +647,57 @@ module PWN
             radio = opts[:radio]
             radio = mesh_radio_index_for_name(env: env, obj: obj, name: channel_name) if radio.nil? && !channel_name.empty?
             radio = mesh_radio_channel(env: env, obj: obj) if radio.nil? && %i[serial bluetooth tcp].include?(kind)
-            case kind
-            when :serial
-              tx = { serial_obj: obj, to: dest, text: text, want_ack: true }
-              tx[:channel] = radio unless radio.nil?
-              Meshtastic::Serial.send_text(tx)
-            when :bluetooth
-              tx = { bluetooth_obj: obj, to: dest, text: text, want_ack: true }
-              tx[:channel] = radio unless radio.nil?
-              Meshtastic::Bluetooth.send_text(tx)
-            when :tcp
-              tx = { tcp_obj: obj, to: dest, text: text }
-              tx[:channel] = radio unless radio.nil?
-              Meshtastic::TCP.send_text(tx)
-            else
-              send_psks = psks
-              send_psks = mesh_channel_psks(env: env) if send_psks.nil? || send_psks.empty?
-              Meshtastic::MQTT.send_text(
-                mqtt_obj: obj,
-                from: from,
-                to: dest,
-                region: mesh_mqtt_region(region: opts[:region], env: env),
-                topic: mesh_mqtt_topic(env: env, topic: opts[:topic]),
-                channel: channel,
-                text: text,
-                psks: send_psks
+            chunks = mesh_text_chunks(text: opts[:text])
+            chunks.each_with_index do |piece, idx|
+              since = obj.is_a?(Hash) ? Array(obj[:proto_data]).size : 0
+              case kind
+              when :serial
+                tx = { serial_obj: obj, to: dest, text: piece, want_ack: true }
+                tx[:channel] = radio unless radio.nil?
+                Meshtastic::Serial.send_text(tx)
+              when :bluetooth
+                tx = { bluetooth_obj: obj, to: dest, text: piece, want_ack: true }
+                tx[:channel] = radio unless radio.nil?
+                Meshtastic::Bluetooth.send_text(tx)
+              when :tcp
+                tx = { tcp_obj: obj, to: dest, text: piece }
+                tx[:channel] = radio unless radio.nil?
+                Meshtastic::TCP.send_text(tx)
+              else
+                send_psks = psks
+                send_psks = mesh_channel_psks(env: env) if send_psks.nil? || send_psks.empty?
+                Meshtastic::MQTT.send_text(
+                  mqtt_obj: obj,
+                  from: from,
+                  to: dest,
+                  region: mesh_mqtt_region(region: opts[:region], env: env),
+                  topic: mesh_mqtt_topic(env: env, topic: opts[:topic]),
+                  channel: channel,
+                  text: piece,
+                  psks: send_psks
+                )
+              end
+              from_id = from.to_s
+              from_id = mesh_self_node_id(env: env, obj: obj) if from_id.empty?
+              PWN.send(:remove_const, :MeshLastTx) if PWN.const_defined?(:MeshLastTx)
+              PWN.const_set(:MeshLastTx, { from: from_id, to: dest, text: piece.to_s, at: Time.now })
+              mesh_handle_rx(
+                local: true,
+                channel_name: channel_name,
+                msg: {
+                  packet: {
+                    channel: radio,
+                    node_id_from: from_id,
+                    node_id_to: dest,
+                    decoded: { portnum: :TEXT_MESSAGE_APP, payload: piece.to_s }
+                  }
+                }
               )
+              next unless idx + 1 < chunks.size
+              next unless %i[serial bluetooth tcp].include?(kind)
+
+              mesh_wait_tx_slot(obj: obj, since: since)
             end
-            from_id = from.to_s
-            from_id = mesh_self_node_id(env: env, obj: obj) if from_id.empty?
-            PWN.send(:remove_const, :MeshLastTx) if PWN.const_defined?(:MeshLastTx)
-            PWN.const_set(:MeshLastTx, { from: from_id, to: dest, text: text.to_s, at: Time.now })
-            mesh_handle_rx(
-              local: true,
-              channel_name: channel_name,
-              msg: {
-                packet: {
-                  channel: radio,
-                  node_id_from: from_id,
-                  node_id_to: dest,
-                  decoded: { portnum: :TEXT_MESSAGE_APP, payload: text.to_s }
-                }
-              }
-            )
           end
 
           # Close the Meshtastic session opened by #mesh_connect.
@@ -1268,8 +1373,8 @@ module PWN
                 channel: slot[:channel_num] || channel_name,
                 psks: mesh_channel_psks(env: env)
               )
-            rescue StandardError
-              nil
+            rescue StandardError => e
+              mesh_ui_puts(text: "TX failed: #{e.class}: #{e.message}")
             ensure
               PWN.send(:remove_const, :MeshDispatchLock) if PWN.const_defined?(:MeshDispatchLock)
             end
@@ -1705,7 +1810,7 @@ module PWN
 
           private :mesh_transport, :mesh_bound_transport, :mesh_box!, :mesh_mqtt_region, :mesh_mqtt_topic, :mesh_active_psks, :mesh_device_channel_meta, :mesh_device_channels
           private :mesh_radio_channel, :mesh_radio_index_for_name, :mesh_channel_name_for_index, :mesh_unassigned_slot_map, :mesh_psk_b64, :mesh_psk_same?, :mesh_env_channel_name_for_psk, :mesh_whitelist_name_for_index, :mesh_channel_name_from_topic, :mesh_link_label
-          private :mesh_connect_one, :mesh_connect, :mesh_mqtt_tls?, :mesh_subscribe, :mesh_send_text, :mesh_disconnect, :mesh_compose_send, :mesh_channel_names, :mesh_env_hash
+          private :mesh_connect_one, :mesh_connect, :mesh_mqtt_tls?, :mesh_subscribe, :mesh_text_payload_max, :mesh_payload_fits?, :mesh_text_chunks, :mesh_tx_row_ready?, :mesh_wait_tx_slot, :mesh_send_text, :mesh_disconnect, :mesh_compose_send, :mesh_channel_names, :mesh_env_hash
           private :mesh_submit, :mesh_console_loop, :mesh_drain_events, :mesh_draw_input, :mesh_wrap_text, :mesh_ui_puts, :mesh_menu_root, :mesh_list_devices
           private :mesh_start_rx!, :mesh_channel_psks, :mesh_text_app?, :mesh_rx_text, :mesh_self_node_id, :mesh_decorate_local_id, :mesh_public_psk?, :mesh_channel_securely_encrypted?
           private :mesh_ai_whitelisted?, :mesh_ai_prompt, :mesh_broadcast?, :mesh_reply_target_label, :mesh_handle_rx, :mesh_maybe_dispatch_to_pwn_ai, :mesh_refresh_ui!, :mesh_reconnect!

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.734'
+  VERSION = '0.5.735'
 end

data/spec/lib/pwn/plugins/repl_mesh_chunk_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'meshtastic'
+
+describe PWN::Plugins::REPL, 'mesh payload chunking' do
+  let(:max) { Meshtastic::Constants::DATA_PAYLOAD_LEN }
+  let(:env) { { transport: 'serial' } }
+
+  before do
+    PWN.send(:remove_const, :MeshTransport) if PWN.const_defined?(:MeshTransport)
+    PWN.const_set(:MeshTransport, :serial)
+    allow(described_class).to receive(:mesh_handle_rx)
+  end
+
+  after do
+    PWN.send(:remove_const, :MeshTransport) if PWN.const_defined?(:MeshTransport)
+  end
+
+  it 'sends text that fits DATA_PAYLOAD_LEN as a single unprefixed payload' do
+    expect(Meshtastic::Serial).to receive(:send_text).once.with(
+      hash_including(text: 'hi', to: '!ffffffff')
+    )
+    described_class.send(:mesh_send_text, env: env, obj: :serial_obj, text: 'hi', to: '!ffffffff')
+  end
+
+  it 'chunks text longer than DATA_PAYLOAD_LEN as (i/N) payloads until complete' do
+    body = 'A' * (max + 10)
+    sent = []
+    allow(Meshtastic::Serial).to receive(:send_text) { |h| sent << h[:text] }
+
+    described_class.send(:mesh_send_text, env: env, obj: :serial_obj, text: body, to: '!ffffffff')
+
+    expect(sent.size).to be > 1
+    n = sent.size
+    expect(sent[0]).to start_with("(1/#{n}) ")
+    expect(sent[-1]).to start_with("(#{n}/#{n}) ")
+    expect(sent).to all(satisfy { |piece| piece.length <= max && piece.bytesize <= max })
+    reconstructed = sent.map { |piece| piece.sub(%r{\A\(\d+/\d+\) }, '') }.join
+    expect(reconstructed).to eq(body)
+  end
+
+  it 'keeps each chunk small enough that the encoded ToRadio fits a 256-byte LoRa frame' do
+    body = 'A' * max
+    chunks = described_class.send(:mesh_text_chunks, text: body)
+    expect(chunks.size).to be > 1
+    mui = Meshtastic::MeshInterface.new
+    chunks.each do |piece|
+      expect(piece.bytesize).to be <= max
+      proto = mui.send_text(
+        from: '!00000b0b',
+        to: '!ffffffff',
+        channel: 0,
+        text: piece,
+        want_ack: true,
+        psks: nil,
+        via: :radio
+      )
+      body_bytes = proto.is_a?(String) ? proto.b.bytesize : proto.to_proto.bytesize
+      expect(body_bytes).to be <= 256
+    end
+    reconstructed = chunks.map { |piece| piece.sub(%r{\A\(\d+/\d+\) }, '') }.join
+    expect(reconstructed).to eq(body)
+  end
+
+  it 'sends chunked frames with want_ack so the radio reports when each chunk is on the air' do
+    body = 'A' * (max + 10)
+    sent = []
+    allow(Meshtastic::Serial).to receive(:send_text) { |h| sent << h[:want_ack] }
+    described_class.send(:mesh_send_text, env: env, obj: :serial_obj, text: body, to: '!ffffffff')
+    expect(sent.size).to be > 1
+    expect(sent).to all(eq(true))
+  end
+
+  it 'waits for a free device TX slot before sending the next chunk' do
+    body = 'A' * (max + 10)
+    obj = { proto_data: [], rx_mutex: Mutex.new }
+    allow(Meshtastic::Serial).to receive(:send_text)
+    allow(described_class).to receive(:mesh_wait_tx_slot)
+    described_class.send(:mesh_send_text, env: env, obj: obj, text: body, to: '!ffffffff')
+    n = described_class.send(:mesh_text_chunks, text: body).size
+    expect(described_class).to have_received(:mesh_wait_tx_slot).exactly(n - 1).times
+  end
+
+  it 'does not wait for a TX slot after a single payload' do
+    allow(Meshtastic::Serial).to receive(:send_text)
+    allow(described_class).to receive(:mesh_wait_tx_slot)
+    described_class.send(:mesh_send_text, env: env, obj: { proto_data: [] }, text: 'hi', to: '!ffffffff')
+    expect(described_class).not_to have_received(:mesh_wait_tx_slot)
+  end
+
+  it 'does not treat QueueStatus free as the chunk being on the air' do
+    obj = { proto_data: [{ queueStatus: { free: 15, maxlen: 16 } }], rx_mutex: Mutex.new }
+    t = Time.now
+    described_class.send(:mesh_wait_tx_slot, obj: obj, since: 0, timeout: 0.25)
+    expect(Time.now - t).to be >= 0.2
+  end
+
+  it 'treats a ROUTING_APP FromRadio as a TX slot without a fixed sleep' do
+    obj = { proto_data: [], rx_mutex: Mutex.new }
+    Thread.new do
+      sleep 0.05
+      obj[:rx_mutex].synchronize do
+        obj[:proto_data] << { packet: { decoded: { portnum: :ROUTING_APP, request_id: 1 } } }
+      end
+    end
+    t = Time.now
+    described_class.send(:mesh_wait_tx_slot, obj: obj, since: 0, timeout: 1)
+    expect(Time.now - t).to be < 0.5
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.734
+  version: 0.5.735
 platform: ruby
 authors:
 - 0day Inc.
@@ -6911,6 +6911,7 @@ files:
 - spec/lib/pwn/plugins/repl/mesh_spec.rb
 - spec/lib/pwn/plugins/repl/vault_spec.rb
 - spec/lib/pwn/plugins/repl_mesh_channel_route_spec.rb
+- spec/lib/pwn/plugins/repl_mesh_chunk_spec.rb
 - spec/lib/pwn/plugins/repl_mesh_console_spec.rb
 - spec/lib/pwn/plugins/repl_mesh_dispatch_spec.rb
 - spec/lib/pwn/plugins/repl_mesh_dm_spec.rb