pwn 0.5.735 → 0.5.737

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8f7823f226f8196c1c33bda916bb5ffde0d6ca22b0c47b3d7b5518ca85e9a8b
-  data.tar.gz: f069d75fa0a0e678aff23e9255cdd5ea13e4b3821a93fa6a1a0fd86e5648171c
+  metadata.gz: af2001b2546112668f86a37ec9ab15c0bea62dd138188fd47b0441e2101a8622
+  data.tar.gz: 9281f66b1e6563d1abe0cd057b3a8a7e6de5c9712dd58e72e188f24d51acfbfc
 SHA512:
-  metadata.gz: 4795ce1673e60efc6919b72aa25cd0d1058a740234fdccb55efb104708d9940a32ca77d0f600195662dd543d5d20403435313d7c3746266d01fc761b3af8e4ae
-  data.tar.gz: 1fb653643bcd942b89a7e220009a5b05714950382f1598581bd859e8c2f8c9f64c5c60e37570a02d2c6d4e31831a8978dead7793766c529a48373fe6acd5b31b
+  metadata.gz: e8f434c799f8cb9c67fb9d8f2f329e1e172fa1664ccfaea7bcb208febe9e3d8b42372b95210c3afb551cdb5648816f033fccdacb6897e36177a17d3b3be79a5a
+  data.tar.gz: 893e79ee5521e6c52558ea5cd69ac30c65b5a97e4a0cad3405da69bef72d48424714f971755880b8d7ca89168befe138d8edcc03636e124a09279ec7eb09c272

data/documentation/pwn-REPL.md

@@ -54,6 +54,33 @@ Typed at the mesh TX prompt (leading `/`). `/` or `/menu` opens a boxed curses m
 
 Typing `/` shows matching commands in the TX pane (ncurses hides Reline's dropdown). TAB still completes `/…` commands, channel names, transports, and device ids.
 
+In COMPOSE, Up recalls older submitted lines and Down recalls newer ones.
+Moving past the newest entry restores the draft and cursor position from before
+history browsing. Recalled lines can be edited without changing saved entries.
+History includes messages and slash commands, skips blank lines and consecutive
+duplicates, and keeps the latest 100 entries in memory for the current pwn-mesh
+session only; it is not written to disk.
+
+### Encrypted DMs and key discovery
+
+On serial, Bluetooth, or TCP, a DM checks the destination's public key in the
+connected radio's NodeInfo records. If missing, pwn-mesh sends its own public
+NodeInfo to that destination with a response requested and waits up to 15 seconds.
+Only after obtaining the destination key does it submit the text with PKI
+encryption explicitly required. Both radios must be reachable over the selected
+channel; this does not verify a peer's identity outside Meshtastic's key exchange.
+
+Discovery failure sends no DM text. The most recent failed attempt is retained
+in session memory; bare `/msg` retries it using the current connection and active
+channel. A new DM replaces that retained attempt, and exiting the process loses
+it. Retention ends after transport submission, not a delivery acknowledgement;
+later radio failures are displayed separately. There is no plaintext or
+channel-PSK downgrade. Missing local public-key metadata requires a reconnect.
+
+MQTT channel broadcasts remain supported, but PKI DMs are not implemented for
+the broker transport. MQTT DM attempts remain unsent with an explicit error;
+switch to serial, Bluetooth, or TCP and use `/msg` to retry.
+
 ## Multi-line input
 
 `pwn-ai` and `pwn-asm` use a custom `PWNMultiLineInput` reader. Plain

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]
@@ -230,11 +270,15 @@ module PWN
               next unless ch.is_a?(Hash)
 
               role = (ch[:role] || ch['role']).to_s.downcase
-              next if %w[disabled 0].include?(role)
-
               idx = (ch[:index] || ch['index'] || 0).to_i
               next unless (0..7).cover?(idx)
 
+              # Protobuf omits the default DISABLED role from to_h.
+              if role.empty? || %w[disabled 0].include?(role)
+                by_index.delete(idx)
+                next
+              end
+
               settings = ch[:settings] || ch['settings'] || {}
               settings = settings.to_h if !settings.is_a?(Hash) && settings.respond_to?(:to_h)
               settings = {} unless settings.is_a?(Hash)
@@ -634,6 +678,65 @@ module PWN
             end
           end
 
+          def mesh_node_user(opts = {})
+            obj = opts[:obj]
+            return unless obj.is_a?(Hash)
+
+            rows = obj[:rx_mutex] ? obj[:rx_mutex].synchronize { Array(obj[:proto_data]).dup } : Array(obj[:proto_data]).dup
+            user = nil
+            rows.each do |row|
+              next unless row.is_a?(Hash)
+
+              info = row[:node_info] || row[:nodeInfo]
+              user = info[:user] if info.is_a?(Hash) && info[:num] == opts[:num]
+              packet = row[:packet]
+              next unless packet.is_a?(Hash) && packet[:from] == opts[:num]
+
+              data = packet[:decoded]
+              next unless data.is_a?(Hash) && %w[4 NODEINFO_APP].include?(data[:portnum].to_s)
+
+              payload = data[:payload]
+              user = payload.is_a?(String) ? Meshtastic::User.decode(payload).to_h : payload
+            end
+            user if user.is_a?(Hash)
+          end
+
+          def mesh_dm_key(opts = {})
+            kind = opts[:kind]
+            raise IOError, 'MQTT PKI DMs are unsupported; message remains unsent. Use a device transport.' if kind == :mqtt
+
+            obj = opts[:obj]
+            raise IOError, 'No connected radio; message remains unsent.' unless obj.is_a?(Hash)
+
+            num = opts[:to].delete_prefix('!').to_i(16)
+            user = mesh_node_user(obj: obj, num: num)
+            return user[:public_key] if user && user[:public_key].to_s.bytesize == 32
+
+            own = mesh_node_user(obj: obj, num: obj[:my_node_num])
+            raise IOError, 'Local radio public key unavailable; reconnect to refresh NodeInfo. Message remains unsent.' unless own && own[:public_key].to_s.bytesize == 32
+
+            timeout = Float(opts.fetch(:timeout, 15))
+            raise ArgumentError, 'key timeout must be between 0 and 60 seconds' unless timeout.finite? && (0..60).cover?(timeout)
+
+            mesh_ui_puts(text: "Discovering public key for #{opts[:to]} (up to #{timeout}s); DM text is held locally.")
+            data = Meshtastic::Data.new(portnum: :NODEINFO_APP, payload: Meshtastic::User.new(own).to_proto, want_response: true)
+            transport = { serial: Meshtastic::Serial, bluetooth: Meshtastic::Bluetooth, tcp: Meshtastic::TCP }.fetch(kind)
+            transport.send_data({ "#{kind}_obj": obj, to: opts[:to], channel: opts[:radio] || 0,
+                                  data: data, port_num: Meshtastic::PortNum::NODEINFO_APP, want_ack: true })
+            deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+            loop do
+              user = mesh_node_user(obj: obj, num: num)
+              return user[:public_key] if user && user[:public_key].to_s.bytesize == 32
+
+              break if obj[:closing] || Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+              sleep 0.05
+            end
+            raise IOError, 'Destination public key discovery timed out; message remains unsent. Retry with /msg.'
+          end
+
+          private :mesh_node_user, :mesh_dm_key
+
           def mesh_send_text(opts = {})
             env = opts[:env] || {}
             obj = opts[:obj]
@@ -647,38 +750,56 @@ 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)
+            dm_key = nil
+            unless mesh_broadcast?(to: dest)
+              raise ArgumentError, 'DM destination must be ! followed by eight hex digits' unless dest.match?(/\A![0-9a-fA-F]{8}\z/)
+
+              PWN.send(:remove_const, :MeshPendingDm) if PWN.const_defined?(:MeshPendingDm)
+              PWN.const_set(:MeshPendingDm, { to: dest, text: opts[:text].to_s, channel_name: channel_name })
+              dm_key = mesh_dm_key(obj: obj, kind: kind, to: dest, radio: radio, timeout: opts.fetch(:key_timeout, 15))
+            end
             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)
+              if dm_key
+                bytes = Meshtastic::MeshInterface.new.send_text(from: obj[:my_node_num] || 0, to: dest, channel: radio || 0, text: piece, want_ack: true, psks: nil)
+                packet = Meshtastic::ToRadio.decode(bytes)
+                packet.packet.pki_encrypted = true
+                packet.packet.public_key = dm_key
+                transport = { serial: Meshtastic::Serial, bluetooth: Meshtastic::Bluetooth, tcp: Meshtastic::TCP }.fetch(kind)
+                transport.send_to_radio({ "#{kind}_obj": obj, to_radio: packet.to_proto })
               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
-                )
+                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
               end
               from_id = from.to_s
               from_id = mesh_self_node_id(env: env, obj: obj) if from_id.empty?
+              from_id = mesh_format_node_id(id: from_id)
               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(
@@ -687,6 +808,7 @@ module PWN
                 msg: {
                   packet: {
                     channel: radio,
+                    pki_encrypted: !dm_key.nil?,
                     node_id_from: from_id,
                     node_id_to: dest,
                     decoded: { portnum: :TEXT_MESSAGE_APP, payload: piece.to_s }
@@ -698,6 +820,10 @@ module PWN
 
               mesh_wait_tx_slot(obj: obj, since: since)
             end
+            return unless dm_key && PWN.const_defined?(:MeshPendingDm)
+
+            PWN.send(:remove_const, :MeshPendingDm)
+            PWN.const_set(:MeshPendingDm, nil)
           end
 
           # Close the Meshtastic session opened by #mesh_connect.
@@ -790,6 +916,10 @@ module PWN
             end
             text = +''
             cursor = 0
+            history = []
+            history_index = 0
+            draft = +''
+            draft_cursor = 0
             while pi.config.pwn_mesh
               mesh_drain_events
               mesh_draw_input(text: text, cursor: cursor)
@@ -799,10 +929,33 @@ module PWN
                 break if text.empty?
               when "\n", "\r", 10, 13, Curses::KEY_ENTER
                 submitted = text.dup
+                unless submitted.strip.empty? || history.last == submitted
+                  history << submitted.dup
+                  history.shift if history.length > 100
+                end
+                history_index = history.length
+                draft = +''
+                draft_cursor = 0
                 text.clear
                 cursor = 0
                 mesh_draw_input(text: text, cursor: cursor)
                 mesh_submit(request: submitted, pry: pi)
+              when Curses::KEY_UP
+                next if history.empty? || history_index.zero?
+
+                if history_index == history.length
+                  draft = text.dup
+                  draft_cursor = cursor
+                end
+                history_index -= 1
+                text = history[history_index].dup
+                cursor = text.length
+              when Curses::KEY_DOWN
+                next if history_index >= history.length
+
+                history_index += 1
+                text = history_index == history.length ? draft.dup : history[history_index].dup
+                cursor = history_index == history.length ? draft_cursor : text.length
               when "\u007f", "\b", 127, 8, Curses::KEY_BACKSPACE
                 if cursor.positive?
                   cursor -= 1
@@ -878,7 +1031,7 @@ module PWN
               end
             end
             win.setpos(3, 2)
-            win.addstr('Enter send   Tab complete   /menu settings   Ctrl+D back'[0, win.maxx - 4])
+            win.addstr('Enter send   Up/Down history   Tab complete   /menu settings   Ctrl+D back'[0, win.maxx - 4])
             win.refresh
           end
 
@@ -1159,12 +1312,24 @@ module PWN
             ''
           end
 
+          def mesh_format_node_id(opts = {})
+            id = opts[:id]
+            return format('!%08x', id) if id.is_a?(Integer) && (0..0xffffffff).cover?(id)
+
+            text = id.to_s
+            return text unless text.match?(/\A![0-9a-fA-F]{1,8}\z/)
+
+            format('!%08x', text.delete_prefix('!').to_i(16))
+          end
+
+          private :mesh_format_node_id
+
           def mesh_self_node_id(opts = {})
             return '!00000b0b' unless opts.is_a?(Hash)
 
             obj = opts[:obj]
             obj = PWN.const_get(:MeshObj) if obj.nil? && PWN.const_defined?(:MeshObj)
-            return "!#{obj[:my_node_num].to_i.to_s(16)}" if obj.is_a?(Hash) && !obj[:my_node_num].nil?
+            return mesh_format_node_id(id: obj[:my_node_num].to_i) if obj.is_a?(Hash) && !obj[:my_node_num].nil?
 
             '!00000b0b'
           end
@@ -1172,7 +1337,7 @@ module PWN
           def mesh_decorate_local_id(opts = {})
             return '' unless opts.is_a?(Hash)
 
-            id = opts[:id].to_s
+            id = mesh_format_node_id(id: opts[:id])
             return id if id.empty?
 
             self_id = mesh_self_node_id(env: opts[:env], obj: opts[:obj])
@@ -1185,7 +1350,7 @@ module PWN
             return true unless opts.is_a?(Hash)
 
             psk = opts[:psk].to_s.strip
-            psk.empty? || %w[none default aq==].include?(psk.downcase)
+            psk.empty? || %w[none default aq==].include?(psk.downcase) || psk == '1PG7OiApB1nwvP+rz05pAQ=='
           end
 
           def mesh_channel_securely_encrypted?(opts = {})
@@ -1241,7 +1406,17 @@ module PWN
 
             packet = msg[:packet].is_a?(Hash) ? msg[:packet] : msg
             decoded = packet[:decoded]
-            return unless decoded.is_a?(Hash) && mesh_text_app?(portnum: decoded[:portnum])
+            return unless decoded.is_a?(Hash)
+
+            if %w[5 ROUTING_APP].include?(decoded[:portnum].to_s)
+              routing = decoded[:payload]
+              routing = Meshtastic::Routing.decode(routing).to_h if routing.is_a?(String)
+              reason = routing[:error_reason] if routing.is_a?(Hash)
+              reason = Meshtastic::Routing::Error.lookup(reason) || reason if reason.is_a?(Integer)
+              mesh_ui_puts(text: "TX failed: packet #{decoded[:request_id]}: #{reason}") if reason && !%w[0 NONE].include?(reason.to_s)
+              return
+            end
+            return unless mesh_text_app?(portnum: decoded[:portnum])
 
             env = mesh_env_hash
             idx = packet[:channel] || packet['channel']
@@ -1260,9 +1435,11 @@ module PWN
             return if rx_text.strip.empty?
 
             from_id = packet[:node_id_from].to_s
-            from_id = "!#{packet[:from].to_i.to_s(16)}" if from_id.empty? && packet[:from]
+            from_id = packet[:from] if from_id.empty? && packet[:from]
+            from_id = mesh_format_node_id(id: from_id)
             to = packet[:node_id_to].to_s
-            to = "!#{packet[:to].to_i.to_s(16)}" if to.empty? && packet[:to]
+            to = packet[:to] if to.empty? && packet[:to]
+            to = mesh_format_node_id(id: to)
             unless opts[:local]
               last = PWN.const_defined?(:MeshLastTx) ? PWN.const_get(:MeshLastTx) : nil
               if last.is_a?(Hash) &&
@@ -1292,13 +1469,15 @@ module PWN
               state = PWN.const_defined?(:MeshRxState) ? PWN.const_get(:MeshRxState) : {}
               ts = Time.now.strftime('%H:%M:%S')
               color = opts[:local] ? 23 : 21
-              current_line = "#{ts}  #{from.strip}  #{dest_label}\n#{rx_text}"
+              secure = packet[:pki_encrypted] == true || mesh_channel_securely_encrypted?(env: env, channel: channel_name)
+              security_icon = secure ? '🔒' : '🔍'
+              current_line = "#{ts}  #{security_icon}  #{from.strip}  #{dest_label}\n#{rx_text}"
               unless state[:last_line] == current_line
                 rx_body_win = PWN.const_get(:MeshRxBodyWin)
                 mutex.synchronize do
                   width = [rx_body_win.maxx - 2, 1].max
                   rx_body_win.attron(Curses.color_pair(color) | Curses::A_BOLD)
-                  rx_body_win.addstr(" #{ts}  #{from.strip}  ·  #{dest_label}\n")
+                  rx_body_win.addstr(" #{ts}  #{security_icon}  #{from.strip}  ·  #{dest_label}\n")
                   rx_body_win.attroff(Curses.color_pair(color) | Curses::A_BOLD)
                   rx_body_win.attron(Curses.color_pair(24))
                   mesh_wrap_text(text: rx_text, width: width - 1).each do |line|
@@ -1629,11 +1808,16 @@ module PWN
           def pwn_mesh_run_msg(opts = {})
             env = opts[:env] || mesh_env_hash
             tokens = Array(opts[:args]).map(&:to_s)
+            if tokens.empty? && PWN.const_defined?(:MeshPendingDm) && PWN::MeshPendingDm
+              pending = PWN::MeshPendingDm
+              tokens = [pending[:to], pending[:text]]
+            end
             names = mesh_channel_names(env: env)
             dest = nil
             channel_name = ''
             if tokens[0].to_s.match?(/\A![0-9a-fA-F]{8}\z/)
               dest = tokens.shift
+              channel_name = env.dig(:channel, :active).to_s
             elsif names.any? { |n| n.casecmp?(tokens[0].to_s) }
               channel_name = names.find { |n| n.casecmp?(tokens[0].to_s) }.to_s
               tokens.shift
@@ -1648,6 +1832,7 @@ module PWN
             raise ArgumentError, 'usage: /msg [!nodeid|channel] <text>' if dest.to_s.empty? || text.empty?
 
             channel_name = PWN.const_get(:MeshLastChannel).to_s if channel_name.empty? && PWN.const_defined?(:MeshLastChannel)
+            channel_name = env.dig(:channel, :active).to_s if channel_name.empty?
             ch = env[:channel] || {}
             slot = ch[channel_name.to_sym] || ch[channel_name] || {}
             obj = PWN.const_defined?(:MeshObj) ? PWN.const_get(:MeshObj) : nil
@@ -1808,7 +1993,7 @@ 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_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

data/lib/pwn/version.rb

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

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'meshtastic'
 
 describe PWN::Plugins::REPL, 'mesh packet channel routing' do
   let(:mesh_env) do
@@ -42,6 +43,18 @@ describe PWN::Plugins::REPL, 'mesh packet channel routing' do
     end
   end
 
+  it 'does not route LongFast to disabled protobuf slots with omitted roles' do
+    mesh_env[:channel][:LongFast].delete(:radio_index)
+    radio[:proto_data] = [
+      Meshtastic::FromRadio.new(channel: Meshtastic::Channel.new(index: 1, role: :SECONDARY, settings: { name: 'LongFast' })).to_h,
+      Meshtastic::FromRadio.new(channel: Meshtastic::Channel.new(index: 7, role: :DISABLED)).to_h
+    ]
+    expect(described_class.send(:mesh_radio_index_for_name, env: mesh_env, obj: radio, name: 'LongFast')).to eq(1)
+    expect(described_class.send(:mesh_device_channel_meta, obj: radio).keys).to eq([1])
+    radio[:proto_data] << Meshtastic::FromRadio.new(channel: Meshtastic::Channel.new(index: 1, role: :DISABLED)).to_h
+    expect(described_class.send(:mesh_device_channel_meta, obj: radio)).to be_empty
+  end
+
   it 'paints and replies on the packet radio slot instead of the selected channel' do
     win = double('rx', maxx: 80)
     allow(win).to receive(:attron)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'meshtastic'
 
 describe PWN::Plugins::REPL, 'mesh msg command' do
   let(:mesh_env) do
@@ -51,6 +52,22 @@ describe PWN::Plugins::REPL, 'mesh msg command' do
     expect(described_class.pwn_mesh_complete(target: '/', line: '/')).not_to include('/dm')
   end
 
+  it 'encodes a named MQTT channel message before receiving anything' do
+    broker = double('broker', client_id: '!00000b0b')
+    PWN.send(:remove_const, :MeshObj)
+    PWN.const_set(:MeshObj, broker)
+    envelope = nil
+    allow(broker).to receive(:publish) do |_topic, bytes|
+      envelope = Meshtastic::ServiceEnvelope.decode(bytes)
+    end
+
+    described_class.send(:pwn_mesh_run_msg, env: mesh_env, args: %w[LongFast hello])
+
+    expect(envelope.packet.to).to eq(0xffffffff)
+    expect(envelope.packet.channel).to eq(8)
+    expect(envelope.channel_id).to eq('LongFast')
+  end
+
   it 'addresses a named channel with /msg <channel> text' do
     mesh_env[:channel][:LongFast] = { psk: 'cHdu', radio_index: 1, topic: '2/e/LongFast/#' }
     allow(described_class).to receive(:mesh_send_text)

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'meshtastic'
+
+describe PWN::Plugins::REPL, 'mesh DM transport replay' do
+  it 'encodes /msg on the active slot and paints a decoded receiver packet through Serial.subscribe' do
+    env = { transport: 'serial', channel: { active: 'LongFast', LongFast: { radio_index: 1, psk: 'AQ==' } } }
+    sender = { my_node_num: 0xaabbccdd, proto_data: [{ node_info: { num: 0xbbccddee, user: { public_key: 'b' * 32 } } }] }
+    stub_const('PWN::MeshPendingDm', nil)
+    receiver = { my_node_num: 0xbbccddee, from_radio_queue: Queue.new }
+    stub_const('PWN::MeshTransport', :serial)
+    stub_const('PWN::MeshObj', sender)
+    stub_const('PWN::MeshLastChannel', '')
+    stub_const('PWN::MeshLastTx', nil)
+    stub_const('PWN::MeshLastDm', nil)
+    allow(described_class).to receive(:mesh_env_hash).and_return(env)
+    packet = nil
+    allow(Meshtastic::Serial).to receive(:send_to_radio) do |opts|
+      packet = Meshtastic::ToRadio.decode(opts[:to_radio]).packet
+    end
+
+    described_class.pwn_mesh_dispatch_slash!(request: '/msg !bbccddee hello receiver', env: env, pry: :fixture)
+    expect(packet.to).to eq(receiver[:my_node_num])
+    expect(packet.channel).to eq(1)
+    expect(packet.decoded.payload).to eq('hello receiver')
+
+    # Replay the firmware's decoded FromRadio boundary, not RF delivery.
+    receiver[:from_radio_queue] << Meshtastic::FromRadio.decode(Meshtastic::FromRadio.new(packet: packet).to_proto)
+    receiver[:from_radio_queue].close
+    PWN.send(:remove_const, :MeshObj)
+    PWN.const_set(:MeshObj, receiver)
+    PWN.send(:remove_const, :MeshLastTx)
+    PWN.const_set(:MeshLastTx, nil)
+    win = double('conversation', maxx: 60, attron: nil, attroff: nil, addstr: nil, refresh: nil)
+    stub_const('PWN::MeshRxBodyWin', win)
+    stub_const('PWN::MeshMutex', Mutex.new)
+    stub_const('PWN::MeshRxState', {})
+    allow(Curses).to receive(:color_pair).and_return(0)
+
+    described_class.send(
+      :mesh_subscribe,
+      env: env, obj: receiver, psks: {},
+      on_message: proc { |msg| described_class.send(:mesh_handle_rx, msg: msg) }
+    )
+
+    expect(win).to have_received(:addstr).with(" hello receiver\n")
+    expect(win).to have_received(:addstr).with(a_string_including('!aabbccdd', '!bbccddee (ME)'))
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Plugins::REPL, 'mesh compose history' do
+  it 'recalls submissions with Up/Down and restores the unfinished draft and cursor' do
+    config = double('config', pwn_mesh: true)
+    pry = double('pry', config: config)
+    keys = ['first', "\n", '/status', "\n", 'draft', Curses::KEY_LEFT,
+            Curses::KEY_UP, Curses::KEY_UP, Curses::KEY_UP,
+            Curses::KEY_DOWN, Curses::KEY_DOWN, Curses::KEY_DOWN]
+    frames = []
+    allow(described_class).to receive(:mesh_drain_events)
+    allow(described_class).to receive(:mesh_submit)
+    allow(described_class).to receive(:mesh_draw_input) { |opts| frames << [opts[:text].dup, opts[:cursor]] }
+    reader = proc do
+      allow(config).to receive(:pwn_mesh).and_return(false) if keys.empty?
+      keys.shift
+    end
+    described_class.send(:mesh_console_loop, pry: pry, getch: reader)
+    expected = [
+      ['/status', 7], ['first', 5], ['first', 5],
+      ['/status', 7], ['draft', 4], ['draft', 4]
+    ]
+    expect(frames.last(6)).to eq(expected)
+    expect(described_class).to have_received(:mesh_submit).with(request: 'first', pry: pry)
+    expect(described_class).to have_received(:mesh_submit).with(request: '/status', pry: pry)
+  end
+
+  it 'edits recalled text without mutating history and skips empty submissions' do
+    config = double('config', pwn_mesh: true)
+    pry = double('pry', config: config)
+    keys = [Curses::KEY_UP, Curses::KEY_DOWN, 'hello', "\n", "\n",
+            Curses::KEY_UP, '!', Curses::KEY_DOWN, Curses::KEY_UP]
+    frames = []
+    allow(described_class).to receive(:mesh_drain_events)
+    allow(described_class).to receive(:mesh_submit)
+    allow(described_class).to receive(:mesh_draw_input) { |opts| frames << opts[:text].dup }
+    reader = proc do
+      allow(config).to receive(:pwn_mesh).and_return(false) if keys.empty?
+      keys.shift
+    end
+    described_class.send(:mesh_console_loop, pry: pry, getch: reader)
+    expect(frames).to include('hello!')
+    expect(frames.last).to eq('hello')
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'meshtastic'
+
+describe PWN::Plugins::REPL, 'mesh DM key exchange' do
+  let(:local_user) { { id: '!aabbccdd', public_key: 'a' * 32 } }
+  let(:remote_user) { { id: '!bbccddee', public_key: 'b' * 32 } }
+  let(:obj) { { my_node_num: 0xaabbccdd, proto_data: [{ node_info: { num: 0xaabbccdd, user: local_user } }] } }
+  let(:env) { { transport: 'auto', channel: { active: 'LongFast', LongFast: { radio_index: 1, psk: 'AQ==' } } } }
+
+  before do
+    stub_const('PWN::MeshPendingDm', nil)
+    allow(described_class).to receive(:mesh_ui_puts)
+    allow(described_class).to receive(:mesh_handle_rx)
+  end
+
+  %i[serial bluetooth tcp].each do |kind|
+    it "exchanges NodeInfo then sends a PKI-enforced DM over #{kind}" do
+      stub_const('PWN::MeshTransport', kind)
+      transport = kind == :bluetooth ? Meshtastic::Bluetooth : Meshtastic::Serial
+      packets = []
+      allow(transport).to receive(:send_to_radio) do |opts|
+        packet = Meshtastic::ToRadio.decode(opts[:to_radio]).packet
+        packets << packet
+        if packet.decoded.portnum == :NODEINFO_APP
+          expect(packet.decoded.want_response).to eq(true)
+          expect(Meshtastic::User.decode(packet.decoded.payload).public_key).to eq('a' * 32)
+          obj[:proto_data] << { packet: { from: 0xbbccddee, decoded: { portnum: 4, payload: Meshtastic::User.new(remote_user).to_proto } } }
+        end
+      end
+      described_class.send(:mesh_send_text, env: env, obj: obj, to: '!bbccddee', text: 'private', channel_name: 'LongFast')
+      expect(packets.map { |p| p.decoded.portnum }).to eq(%i[NODEINFO_APP TEXT_MESSAGE_APP])
+      expect(packets.last.pki_encrypted).to eq(true)
+      expect(packets.last.public_key).to eq('b' * 32)
+      expect(packets.last.to).to eq(0xbbccddee)
+      expect(PWN::MeshPendingDm).to be_nil
+    end
+  end
+
+  it 'retains the unsent text and never transmits it after discovery times out' do
+    stub_const('PWN::MeshTransport', :serial)
+    allow(Meshtastic::Serial).to receive(:send_data)
+    expect(Meshtastic::Serial).not_to receive(:send_text)
+    expect(Meshtastic::Serial).not_to receive(:send_to_radio)
+    expect do
+      described_class.send(:mesh_send_text, env: env, obj: obj, to: '!bbccddee', text: 'private', key_timeout: 0)
+    end.to raise_error(IOError, /public key.*unsent/i)
+    expect(PWN::MeshPendingDm[:text]).to eq('private')
+  end
+
+  it 'retries the retained message with bare /msg after the key becomes available' do
+    stub_const('PWN::MeshTransport', :serial)
+    stub_const('PWN::MeshObj', obj)
+    stub_const('PWN::MeshPendingDm', { to: '!bbccddee', text: 'retained text' })
+    stub_const('PWN::MeshLastTx', nil)
+    obj[:proto_data] << { node_info: { num: 0xbbccddee, user: remote_user } }
+    expect(Meshtastic::Serial).not_to receive(:send_data)
+    expect(Meshtastic::Serial).to receive(:send_to_radio) do |opts|
+      packet = Meshtastic::ToRadio.decode(opts[:to_radio]).packet
+      expect(packet.pki_encrypted).to eq(true)
+      expect(packet.decoded.payload).to eq('retained text')
+    end
+    described_class.send(:pwn_mesh_run_msg, env: env, args: [])
+    expect(PWN::MeshPendingDm).to be_nil
+  end
+
+  it 'does not use another node public key as the destination key' do
+    stub_const('PWN::MeshTransport', :serial)
+    obj[:proto_data] << { node_info: { num: 0xccddeeff, user: remote_user } }
+    allow(Meshtastic::Serial).to receive(:send_data)
+    expect do
+      described_class.send(:mesh_send_text, env: env, obj: obj, to: '!bbccddee', text: 'private', key_timeout: 0)
+    end.to raise_error(IOError, /timed out/)
+  end
+
+  it 'refuses MQTT DMs without publishing a legacy encrypted or plaintext fallback' do
+    stub_const('PWN::MeshTransport', :mqtt)
+    expect(Meshtastic::MQTT).not_to receive(:send_text)
+    expect do
+      described_class.send(:mesh_send_text, env: env, obj: double('broker'), to: '!bbccddee', text: 'private')
+    end.to raise_error(IOError, /MQTT.*PKI/)
+    expect(PWN::MeshPendingDm[:text]).to eq('private')
+  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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Plugins::REPL, 'mesh node ID formatting' do
+  it 'preserves broadcast and non-node labels while formatting valid node values' do
+    { 0 => '!00000000', 0xffffffff => '!ffffffff', '!ABCDEF1' => '!0abcdef1',
+      '!ffffffff' => '!ffffffff', 'LongFast' => 'LongFast', '!nothex' => '!nothex' }.each do |id, expected|
+      expect(described_class.send(:mesh_format_node_id, id: id)).to eq(expected)
+    end
+  end
+
+  it 'pads the local numeric node ID to eight hex digits' do
+    expect(described_class.send(:mesh_self_node_id, obj: { my_node_num: 0xabcdef1 })).to eq('!0abcdef1')
+    expect(described_class.send(:mesh_self_node_id, obj: { my_node_num: 0xb0b })).to eq('!00000b0b')
+  end
+
+  it 'pads transport-enriched IDs before painting and remembering a DM sender' do
+    stub_const('PWN::MeshObj', { my_node_num: 0xb0b })
+    stub_const('PWN::MeshLastDm', nil)
+    stub_const('PWN::MeshLastTx', nil)
+    stub_const('PWN::MeshRxState', {})
+    stub_const('PWN::MeshMutex', Mutex.new)
+    win = double('conversation', maxx: 80, attron: nil, attroff: nil, addstr: nil, refresh: nil)
+    stub_const('PWN::MeshRxBodyWin', win)
+    allow(Curses).to receive(:color_pair).and_return(0)
+    allow(described_class).to receive(:mesh_maybe_dispatch_to_pwn_ai)
+    allow(described_class).to receive(:mesh_env_hash).and_return({ transport: 'mqtt', channel: {} })
+    described_class.send(:mesh_handle_rx, msg: { packet: {
+                           node_id_from: '!abcdef1', node_id_to: '!b0b',
+                           decoded: { portnum: 1, payload: 'hello' }
+                         } })
+    expect(win).to have_received(:addstr).with(a_string_including('!0abcdef1', '!00000b0b (ME)'))
+    expect(PWN::MeshLastDm).to eq('!0abcdef1')
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'meshtastic'
 
 describe PWN::Plugins::REPL, 'mesh incoming paint' do
   let(:mesh_env) do
@@ -23,6 +24,28 @@ describe PWN::Plugins::REPL, 'mesh incoming paint' do
     PWN::Env[:plugins][:meshtastic] = @prev_mesh if PWN::Env[:plugins].is_a?(Hash)
   end
 
+  [5, :ROUTING_APP].each do |port|
+    it "shows a radio DM failure for routing port #{port} instead of silently dropping it" do
+      allow(described_class).to receive(:mesh_ui_puts)
+      routing = Meshtastic::Routing.new(error_reason: :PKI_SEND_FAIL_PUBLIC_KEY)
+      payload = port == 5 ? routing.to_proto : routing.to_h
+      described_class.send(:mesh_handle_rx, msg: {
+                             packet: { decoded: { portnum: port, request_id: 42, payload: payload } }
+                           })
+      expect(described_class).to have_received(:mesh_ui_puts).with(
+        text: a_string_including('TX failed', '42', 'PKI_SEND_FAIL_PUBLIC_KEY')
+      )
+    end
+  end
+
+  it 'does not label a successful routing response as a transmission failure' do
+    allow(described_class).to receive(:mesh_ui_puts)
+    described_class.send(:mesh_handle_rx, msg: {
+                           packet: { decoded: { portnum: 5, request_id: 42, payload: Meshtastic::Routing.new.to_proto } }
+                         })
+    expect(described_class).not_to have_received(:mesh_ui_puts)
+  end
+
   it 'paints incoming RX in yellow with sender id and channel name or DM destination id' do
     win = double('rx', maxx: 80)
     allow(win).to receive(:attron)

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Plugins::REPL, 'mesh message security indicators' do
+  [true, false].each do |local|
+    [
+      ['private channel', 'cHdu', false, '🔒'],
+      ['public channel', 'AQ==', false, '🔍'],
+      ['expanded public key', '1PG7OiApB1nwvP+rz05pAQ==', false, '🔍'],
+      ['unknown encryption', '', false, '🔍'],
+      ['PKI packet', 'AQ==', true, '🔒']
+    ].each do |label, psk, pki, icon|
+      it "paints #{icon} for #{local ? 'sent' : 'received'} #{label}" do
+        env = { transport: 'mqtt', channel: { active: 'LongFast', LongFast: { psk: psk } } }
+        allow(described_class).to receive(:mesh_env_hash).and_return(env)
+        allow(described_class).to receive(:mesh_maybe_dispatch_to_pwn_ai)
+        stub_const('PWN::MeshLastTx', nil)
+        stub_const('PWN::MeshLastChannel', nil)
+        stub_const('PWN::MeshMutex', Mutex.new)
+        stub_const('PWN::MeshRxState', {})
+        win = double('conversation', maxx: 80, attron: nil, attroff: nil, addstr: nil, refresh: nil)
+        stub_const('PWN::MeshRxBodyWin', win)
+        allow(Curses).to receive(:color_pair).and_return(0)
+        described_class.send(
+          :mesh_handle_rx,
+          local: local, channel_name: 'LongFast',
+          msg: { packet: { node_id_from: '!aabbccdd', node_id_to: '!ffffffff', pki_encrypted: pki,
+                           decoded: { portnum: 1, payload: 'security test' } } }
+        )
+        expect(win).to have_received(:addstr).with(a_string_including(icon, '!aabbccdd', 'LongFast'))
+        expect(Curses).to have_received(:color_pair).with(local ? 23 : 21).twice
+      end
+    end
+  end
+end

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

@@ -497,7 +497,7 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
 
     it 'uses the named device channel index instead of forcing slot zero' do
       require 'meshtastic'
-      obj = { proto_data: [{ channel: { index: 3, settings: { name: 'LongFast' } } }] }
+      obj = { proto_data: [{ channel: { index: 3, role: :SECONDARY, settings: { name: 'LongFast' } } }] }
       env = { transport: 'serial', channel: { active: 'LongFast', LongFast: { channel_num: 99 } } }
       expect(Meshtastic::Serial).to receive(:send_text).with(hash_including(channel: 3))
       described_class.send(:mesh_send_text, env: env, obj: obj, channel: 99, text: 'slot three')
@@ -507,8 +507,8 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       require 'meshtastic'
       obj = {
         proto_data: [
-          { channel: { index: 0, settings: { name: '' } } },
-          { channel: { index: 2, settings: { name: 'LongFast' } } }
+          { channel: { index: 0, role: :PRIMARY, settings: { name: '' } } },
+          { channel: { index: 2, role: :SECONDARY, settings: { name: 'LongFast' } } }
         ]
       }
       env = {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.735
+  version: 0.5.737
 platform: ruby
 authors:
 - 0day Inc.
@@ -6915,7 +6915,13 @@ files:
 - 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_dm_transport_spec.rb
+- spec/lib/pwn/plugins/repl_mesh_history_spec.rb
+- spec/lib/pwn/plugins/repl_mesh_key_exchange_spec.rb
+- spec/lib/pwn/plugins/repl_mesh_layout_spec.rb
+- spec/lib/pwn/plugins/repl_mesh_node_id_spec.rb
 - spec/lib/pwn/plugins/repl_mesh_rx_paint_spec.rb
+- spec/lib/pwn/plugins/repl_mesh_security_paint_spec.rb
 - spec/lib/pwn/plugins/repl_pwn_vault_spec.rb
 - spec/lib/pwn/plugins/repl_spec.rb
 - spec/lib/pwn/plugins/rop_spec.rb