pwn 0.5.734 → 0.5.736

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35f85751c76226260916fb5b417180f8c10a1fe53eb8913295895aec83da8eaa
-  data.tar.gz: 7808ea07ce71dd2576b168acf9cb1c429c0f9f4dc098570c13ffa81d416e6ffc
+  metadata.gz: f20a2bcbd4611945405ce166826e978eabfe051ee9b1d5bc51ab07f9dde2e5d2
+  data.tar.gz: 894c5e39df14c75ce020427d0ea9294550b17dee242c728aaa1067fadfd1d683
 SHA512:
-  metadata.gz: 933f35d3a0d28a1dfdb87eb826874e88b150738b333bfb2518a9366f61cd72b24c5fb7e64fe30e73a92086320d6d3df8bfb88b3d8047f9565eab9dd995780087
-  data.tar.gz: 5384de39a95c61302cd37f6a6bcdfbcd54f1f9b047a7588c990afef5b89a8e572007dab3abab3e35547d8dc35c6a43d4f2ec72997122e70ea86ea0a3cb21fc7d
+  metadata.gz: c512159a8249c30b3ae191d3e4d159d8f30da33b48dbc99fdb2d6e753c4811444f5db70492b8ca712a7dd26396818365c0940d225d9c9011247109a7cfd3a47f
+  data.tar.gz: 0a9bff32912c36b10baca436caf72a18f132f9f9e4779df8f823b0aa66f785e3c905473762b85953916dbc20b51bfcae1989697ed6a57282f2d9da1d114761de

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

@@ -88,9 +88,10 @@ module PWN
               PWN.const_set(:MeshColors, [20, 23, 21])
               PWN.const_set(:MeshLastColor, 20)
 
-              mesh_tx_rows = 5
-              mesh_header_rows = 5
-              body_height = [Curses.lines - mesh_tx_rows - mesh_header_rows, 4].max
+              layout = PWN::Plugins::REPL.send(:mesh_layout, lines: Curses.lines, cols: Curses.cols)
+              mesh_tx_rows = layout[:tx]
+              mesh_header_rows = layout[:header]
+              body_height = layout[:body]
               rx_header_win = Curses::Window.new(mesh_header_rows, Curses.cols, 0, 0)
               rx_header_win.scrollok(false)
               rx_header_win.nodelay = true
@@ -111,14 +112,18 @@ module PWN
               frame.addstr(' CONVERSATION ')
               frame.refresh
               PWN.const_set(:MeshRxFrameWin, frame)
-              rx_body_win = Curses::Window.new(body_height - 2, Curses.cols - 4, body_start_row + 1, 2)
+              rx_body_win = Curses::Window.new(
+                [body_height - 2, 1].max,
+                [Curses.cols - 4, 1].max,
+                body_start_row + (body_height > 2 ? 1 : 0),
+                Curses.cols > 4 ? 2 : 0
+              )
               rx_body_win.scrollok(true)
               rx_body_win.nodelay = true
               rx_body_win.refresh
               PWN.const_set(:MeshRxBodyWin, rx_body_win)
 
-              tx_height = mesh_header_rows + body_height
-              tx_win = Curses::Window.new(mesh_tx_rows, Curses.cols, tx_height, 0)
+              tx_win = Curses::Window.new(mesh_tx_rows, Curses.cols, layout[:tx_top], 0)
               tx_win.scrollok(false)
               tx_win.nodelay = true
               PWN::Plugins::REPL.send(:mesh_box!, win: tx_win)
@@ -165,6 +170,41 @@ module PWN
             t == :auto ? PWN_MESH_TRANSPORTS.first : t
           end
 
+          # Row counts for header, CONVERSATION, and COMPOSE so the TUI fits the terminal.
+          def mesh_layout(opts = {})
+            lines = opts[:lines]
+            cols = opts[:cols]
+            lines = lines.nil? ? Curses.lines : Integer(lines)
+            cols = cols.nil? ? Curses.cols : Integer(cols)
+            lines = 1 if lines < 1
+            cols = 1 if cols < 1
+            header = 5
+            tx = 5
+            min_header = 3
+            min_tx = 3
+            min_body = 3
+            body = lines - header - tx
+            while body < min_body && header > min_header
+              header -= 1
+              body = lines - header - tx
+            end
+            while body < min_body && tx > min_tx
+              tx -= 1
+              body = lines - header - tx
+            end
+            body = [body, 1].max
+            overflow = header + body + tx - lines
+            body -= overflow if overflow.positive? && body > 1
+            body = 1 if body < 1
+            {
+              header: header,
+              body: body,
+              tx: tx,
+              cols: cols,
+              tx_top: header + body
+            }
+          end
+
           # Explicit Unicode avoids ACS falling back to ASCII on some terminals.
           def mesh_box!(opts = {})
             win = opts[:win]
@@ -536,10 +576,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 +687,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 +1413,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
@@ -1703,9 +1848,9 @@ module PWN
             false
           end
 
-          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_transport, :mesh_bound_transport, :mesh_layout, :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.736'
 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

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Plugins::REPL, 'mesh terminal layout' do
+  it 'keeps a 5-row header and 5-row compose on a 24-line terminal' do
+    layout = described_class.send(:mesh_layout, lines: 24, cols: 80)
+    expect(layout[:header]).to eq(5)
+    expect(layout[:tx]).to eq(5)
+    expect(layout[:body]).to eq(14)
+    expect(layout[:tx_top]).to eq(19)
+  end
+
+  it 'shrinks conversation so header, conversation and compose fit a 12-line terminal' do
+    layout = described_class.send(:mesh_layout, lines: 12, cols: 40)
+    expect(layout[:header] + layout[:body] + layout[:tx]).to eq(12)
+    expect(layout[:tx_top] + layout[:tx]).to eq(12)
+    expect(layout[:header]).to be >= 3
+    expect(layout[:tx]).to be >= 3
+    expect(layout[:body]).to be >= 3
+  end
+
+  it 'keeps compose on-screen on a 10-line terminal by shrinking conversation first' do
+    layout = described_class.send(:mesh_layout, lines: 10, cols: 40)
+    expect(layout[:header] + layout[:body] + layout[:tx]).to eq(10)
+    expect(layout[:tx_top]).to be < 10
+    expect(layout[:tx_top] + layout[:tx]).to eq(10)
+  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.736
 platform: ruby
 authors:
 - 0day Inc.
@@ -6911,9 +6911,11 @@ 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
+- spec/lib/pwn/plugins/repl_mesh_layout_spec.rb
 - spec/lib/pwn/plugins/repl_mesh_rx_paint_spec.rb
 - spec/lib/pwn/plugins/repl_pwn_vault_spec.rb
 - spec/lib/pwn/plugins/repl_spec.rb