pwn 0.5.742 → 0.5.743

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aae26246e4b23381c5f727d27100f6a10d37d955f2c9a875ad63274d3397219b
-  data.tar.gz: 1a0abc7df30321bd4618a8db3d356fa72e9b6cc13f6055b5f71bf4fb1b4ec90a
+  metadata.gz: 8089c1c616fe3d19f70170b55204b0dd762a14faa40432e6acf421bd6d55197d
+  data.tar.gz: 6633cdc11ab8b811913d6b6e30608a79fa85c06c5bde599d4155c9c63d5a3884
 SHA512:
-  metadata.gz: 5b680d2d2d3eb756642d68a6309a36a5d551100131b58323954bd402c73f554515304ecfb005a42e96ab15a385f16d717495cf527c2bf17c87434567401d0dd0
-  data.tar.gz: 7b51570ad19e664e45ca69925619fdbdda6272f985d8627f4c247815b469de19cb11bdfa942433480bbc38792127a8b39e45e56c08c8c73ffe517318ad004396
+  metadata.gz: 83c1b09ae27724b7e5df7972f018f11b7bee7f77e38d295c45395bf4c828f6c57e9736306687ae243e1fc05dc4dd63e4b33407d4101b916c2e32a8b241f39958
+  data.tar.gz: 19ad087ec133a1194b2fd60d7348edff887b94940647b5a0e34792fa5084742dcb7a04f213ee17b404e4fffda5fc1b8db4821fd1bc6c047c0867c96a2752d8af

data/lib/pwn/plugins/jobs.rb

@@ -49,10 +49,12 @@ module PWN
                            'PWN::Plugins::Jobs.supervise(root: ARGV[0], id: ARGV[1])', root, id,
                            in: File::NULL, out: File::NULL, err: File::NULL, close_others: true)
             Process.detach(worker)
-            deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 2
+            row[:worker_pid] = worker
+            persist(root: root, row: row)
+            deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 8
             loop do
               row = load_job(id: id)
-              break if row[:worker_pid] || row[:status] != 'RUNNING' || Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+              break if row[:worker_identity] || row[:status] != 'RUNNING' || Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
 
               sleep 0.02
             end
@@ -372,7 +374,11 @@ module PWN
           next unless row[:status] == 'RUNNING'
 
           begin
-            Process.setsid
+            begin
+              Process.setsid
+            rescue Errno::EPERM
+              nil
+            end
             row.merge!(worker_pid: Process.pid, worker_identity: SecureRandom.hex(16), started_at: Time.now.utc.iso8601(6))
             pid = spawn(row[:env].transform_keys(&:to_s), '/bin/sh', '-c', row[:command], chdir: row[:cwd],
                                                                                           in: File::NULL, %i[out err] => [row[:log], 'ab'], pgroup: true, close_others: true)

data/lib/pwn/plugins/redb.rb

@@ -181,7 +181,7 @@ module PWN
         current = nil
         dump.each_line do |line|
           current = Regexp.last_match(1) if line =~ /<([^>]+)>:/
-          next unless current && (line =~ /call\w*\s+.*<([^>@]+)/ || line =~ /call\w*\s+([A-Za-z_]\w*)(?:@plt)?/)
+          next unless current && (line =~ /\b(?:call\w*|blx?r?|jalr?)\b.*<([^>@]+)/ || line =~ /\b(?:call\w*|blx?r?|jalr?)\s+([A-Za-z_]\w*)(?:@plt)?/)
 
           db.execute('INSERT INTO xrefs(src, dst) VALUES(?,?)', [current, Regexp.last_match(1)])
         end

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

@@ -614,31 +614,49 @@ module PWN
           end
 
           def mesh_tx_row_ready?(opts = {})
-            return false unless opts.is_a?(Hash)
+            mesh_tx_outcome(opts) == :ok
+          end
+
+          def mesh_tx_outcome(opts = {})
+            return :idle unless opts.is_a?(Hash)
 
             row = opts[:row]
-            return false unless row.is_a?(Hash)
+            return :idle unless row.is_a?(Hash)
 
             packet = row[:packet] || row['packet']
-            return false unless packet.is_a?(Hash)
+            return :idle unless packet.is_a?(Hash)
 
             decoded = packet[:decoded] || packet['decoded']
-            return false unless decoded.is_a?(Hash)
+            return :idle unless decoded.is_a?(Hash)
 
             port = decoded[:portnum] || decoded['portnum']
-            %w[5 ROUTING_APP].include?(port.to_s) || port == :ROUTING_APP
+            return :idle unless %w[5 ROUTING_APP].include?(port.to_s) || port == :ROUTING_APP
+
+            want = opts[:request_id]
+            got = decoded[:request_id] || decoded['request_id']
+            return :idle if want && got && want.to_i != got.to_i
+
+            routing = decoded[:payload] || 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)
+            name = reason.to_s
+            return :ok if reason.nil? || %w[0 NONE].include?(name)
+            return :rate_limited if name == 'RATE_LIMIT_EXCEEDED'
+
+            :error
           end
 
           def mesh_wait_tx_slot(opts = {})
-            return unless opts.is_a?(Hash)
+            return :ok unless opts.is_a?(Hash)
 
             obj = opts[:obj]
-            return unless obj.is_a?(Hash)
+            return :ok unless obj.is_a?(Hash)
 
             timeout = opts[:timeout]
             timeout = 8 if timeout.nil?
             timeout = Float(timeout)
-            return if timeout <= 0
+            return :ok if timeout <= 0
 
             since = opts[:since].to_i
             deadline = Time.now + timeout
@@ -648,11 +666,11 @@ module PWN
                      else
                        Array(obj[:proto_data])
                      end
-              ready = rows.drop(since).any? do |row|
-                mesh_tx_row_ready?(row: row)
+              rows.drop(since).each do |row|
+                outcome = mesh_tx_outcome(row: row, request_id: opts[:request_id])
+                return outcome unless outcome == :idle
               end
-              return if ready
-              return if Time.now >= deadline
+              return :timeout if Time.now >= deadline
 
               sleep 0.05
             end
@@ -682,6 +700,13 @@ module PWN
                 end
                 bodies << piece
                 offset += piece.length
+                next unless offset < text.length && piece.match?(/[^[:space:]]\z/)
+
+                cut = piece.rindex(/[[:space:]]/)
+                next unless cut&.positive?
+
+                bodies[-1] = piece[0, cut + 1]
+                offset = offset - piece.length + bodies[-1].length
               end
               if bodies.size <= n
                 total = bodies.size
@@ -772,69 +797,77 @@ module PWN
               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|
-              packet_id = Random.rand(2...0xffffffff)
-              since = obj.is_a?(Hash) ? Array(obj[:proto_data]).size : 0
-              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, last_packet_id: packet_id - 1)
-                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
-                case kind
-                when :serial
-                  tx = { serial_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
-                  tx[:channel] = radio unless radio.nil?
-                  Meshtastic::Serial.send_text(tx)
-                when :bluetooth
-                  tx = { bluetooth_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
-                  tx[:channel] = radio unless radio.nil?
-                  Meshtastic::Bluetooth.send_text(tx)
-                when :tcp
-                  tx = { tcp_obj: obj, to: dest, text: piece, last_packet_id: packet_id - 1 }
-                  tx[:channel] = radio unless radio.nil?
-                  Meshtastic::TCP.send_text(tx)
+            chunks.each_with_index do |piece, _idx|
+              echoed = false
+              attempts = 0
+              loop do
+                attempts += 1
+                packet_id = Random.rand(2...0xffffffff)
+                since = obj.is_a?(Hash) ? Array(obj[:proto_data]).size : 0
+                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, last_packet_id: packet_id - 1)
+                  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,
-                    last_packet_id: packet_id - 1,
-                    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, last_packet_id: packet_id - 1 }
+                    tx[:channel] = radio unless radio.nil?
+                    Meshtastic::Serial.send_text(tx)
+                  when :bluetooth
+                    tx = { bluetooth_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
+                    tx[:channel] = radio unless radio.nil?
+                    Meshtastic::Bluetooth.send_text(tx)
+                  when :tcp
+                    tx = { tcp_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
+                    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,
+                      last_packet_id: packet_id - 1,
+                      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
+                unless echoed
+                  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(
+                    local: true,
+                    channel_name: channel_name,
+                    msg: {
+                      packet: {
+                        id: packet_id,
+                        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 }
+                      }
+                    }
                   )
+                  echoed = true
                 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(
-                local: true,
-                channel_name: channel_name,
-                msg: {
-                  packet: {
-                    id: packet_id,
-                    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 }
-                  }
-                }
-              )
-              next unless idx + 1 < chunks.size
-              next unless %i[serial bluetooth tcp].include?(kind)
+                break unless %i[serial bluetooth tcp].include?(kind)
 
-              mesh_wait_tx_slot(obj: obj, since: since)
+                slot = mesh_wait_tx_slot(obj: obj, since: since, request_id: packet_id)
+                break if slot == :ok || slot == :timeout || slot == :error || attempts >= 8
+              end
             end
             return unless dm_key && PWN.const_defined?(:MeshPendingDm)
 
@@ -1016,7 +1049,8 @@ module PWN
               next if event[:obj] && (!PWN.const_defined?(:MeshObj) || !event[:obj].equal?(PWN::MeshObj))
 
               if event[:notice]
-                mesh_notice(text: event[:notice])
+                notice = mesh_notice_text(text: event[:notice])
+                mesh_notice(text: notice) if notice
               elsif event[:msg]
                 mesh_handle_rx(msg: event[:msg])
               else
@@ -1102,6 +1136,14 @@ module PWN
             text
           end
 
+          def mesh_notice_text(opts = {})
+            text = opts[:text].to_s.dup.force_encoding(Encoding::UTF_8).scrub
+            text.gsub!(/\e\[[0-9;?]*[A-Za-z]/, '')
+            text.gsub!(/[\x00-\x08\x0b\x0c\x0e-\x1f]/, '')
+            text.strip!
+            text.empty? ? nil : text
+          end
+
           def mesh_capture_output(opts = {})
             original_out = $stdout
             original_err = $stderr
@@ -1116,7 +1158,8 @@ module PWN
                 rescue EOFError
                   # Flush the last diagnostic even when the TUI is closing.
                 end
-                events << { notice: text.force_encoding(Encoding::UTF_8).scrub }
+                notice = mesh_notice_text(text: text)
+                events << { notice: notice } if notice
               end
             rescue IOError
               nil
@@ -1173,7 +1216,7 @@ module PWN
             end
           end
 
-          private :mesh_capture_output, :mesh_notice
+          private :mesh_capture_output, :mesh_notice, :mesh_notice_text
 
           # Drop the submitted TX buffer so the next prompt is empty (Reline keeps the old line).
           def mesh_reset_input!(opts = {})
@@ -1551,7 +1594,7 @@ module PWN
               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)
+              mesh_ui_puts(text: "TX failed: packet #{decoded[:request_id]}: #{reason}") if reason && !%w[0 NONE RATE_LIMIT_EXCEEDED].include?(reason.to_s)
               return
             end
             return unless mesh_text_app?(portnum: decoded[:portnum])
@@ -2185,7 +2228,7 @@ module PWN
 
           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_connect_one, :mesh_connect, :mesh_mqtt_tls?, :mesh_subscribe, :mesh_text_payload_max, :mesh_payload_fits?, :mesh_text_chunks, :mesh_tx_row_ready?, :mesh_tx_outcome, :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.742'
+  VERSION = '0.5.743'
 end

data/spec/lib/pwn/ai/agent/tools/exploitdev_spec.rb

@@ -15,7 +15,7 @@ describe 'PWN::AI::Agent::Tools exploitdev' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'exploitdev')).not_to be_nil
   end
 
-  it 'builds a ret2libc chain end-to-end through Dispatch' do
+  it 'builds a ret2libc chain end-to-end through Dispatch', :x86_64_binary do
     Dir.mktmpdir('pwn-ret2libc-tool-') do |dir|
       src = File.join(dir, 'vuln.c')
       bin = File.join(dir, 'vuln')

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

@@ -60,7 +60,7 @@ describe PWN::Plugins::ExploitDev do
     expect(row[:gadgets].map { |g| g[:gadget] }).to include(a_string_matching(/pop rdi/i))
   end
 
-  it 'ret2libc builds a packed chain from ELF resolve + pop rdi' do
+  it 'ret2libc builds a packed chain from ELF resolve + pop rdi', :x86_64_binary do
     Dir.mktmpdir('pwn-ret2libc-') do |dir|
       src = File.join(dir, 'vuln.c')
       bin = File.join(dir, 'vuln')

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

@@ -64,7 +64,16 @@ describe PWN::Plugins::Jobs do
 
   it 'pages binary logs with byte offsets and distinguishes EOF from completion' do
     row = described_class.start(command: "printf 'abc\\377def'; sleep 1", max_runtime: 5)
-    first = described_class.job_tail(handle: row[:id], offset: 0, length: 4)
+    first = Timeout.timeout(8) do
+      loop do
+        page = described_class.job_tail(handle: row[:id], offset: 0, length: 4)
+        break page if page[:bytes].to_i.positive?
+
+        raise 'job ended before log bytes' unless page[:status] == 'RUNNING'
+
+        sleep 0.05
+      end
+    end
     expect(first).to include(bytes: 4, next_offset: 4, encoding: 'base64', eof: false, status: 'RUNNING')
     expect(Base64.strict_decode64(first[:data])).to eq("abc\xFF".b)
     last = described_class.tail(id: row[:id], offset: 4, length: 100)

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

@@ -13,13 +13,31 @@ describe PWN::Plugins::REDB do
     expect(described_class).to respond_to :help
   end
 
+  it 'records ARM bl strcpy xrefs from objdump' do
+    Dir.mktmpdir('redb-arm') do |dir|
+      stub_const('PWN::Plugins::REDB::ROOT', File.join(dir, 'redb'))
+      bin = File.join(dir, 'x')
+      File.write(bin, 'fake')
+      dump = <<~ASM
+        0000000000000000 <caller>:
+           0:	d10043ff 	sub	sp, sp, #0x10
+           4:	94000000 	bl	8 <strcpy@plt>
+      ASM
+      allow(Open3).to receive(:capture2).with('nm', '-C', bin).and_return(['', 1])
+      allow(Open3).to receive(:capture2).with('objdump', '-d', bin).and_return([dump, 1])
+      allow(Open3).to receive(:capture2).with('strings', '-a', bin).and_return(['', 1])
+      described_class.open(bin: bin)
+      expect(described_class.xrefs_to(bin: bin, sym: 'strcpy').map { |row| row['dst'] || row[:dst] }).to include('strcpy')
+    end
+  end
+
   it 'answers who calls strcpy from cache on a second open' do
     Dir.mktmpdir('redb') do |dir|
       stub_const('PWN::Plugins::REDB::ROOT', File.join(dir, 'redb'))
       src = File.join(dir, 'x.c')
       bin = File.join(dir, 'x')
       File.write(src, "#include <string.h>\nvoid caller(void){ char b[8]; strcpy(b, \"x\"); }\nint main(void){ caller(); return 0; }\n")
-      system('cc', '-O0', '-g', '-fno-builtin', '-fno-inline', '-o', bin, src)
+      expect(system('cc', '-O0', '-g', '-fno-builtin', '-fno-inline', '-o', bin, src)).to be(true)
       described_class.open(bin: bin)
       t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       described_class.open(bin: bin)

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

@@ -113,6 +113,7 @@ describe PWN::Plugins::REPL, 'mesh packet channel routing' do
       sent = Meshtastic::ToRadio.decode(args[:to_radio]).packet
     end
     allow(described_class).to receive(:mesh_maybe_dispatch_to_pwn_ai)
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:ok)
     described_class.send(:mesh_send_text, env: mesh_env, obj: radio, text: 'Local message', channel_name: 'LongFast')
     expect(sent.decoded.payload).to eq('Local message')
     packet = { decoded: { emoji: 1, reply_id: sent.id } }

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

@@ -40,6 +40,47 @@ describe PWN::Plugins::REPL, 'mesh payload chunking' do
     expect(reconstructed).to eq(body)
   end
 
+  it 'does not split a word across chunk boundaries' do
+    words = (1..80).map { |i| "token#{i}" }
+    body = words.join(' ')
+    chunks = described_class.send(:mesh_text_chunks, text: body)
+    bodies = chunks.map { |piece| piece.sub(%r{\A\(\d+/\d+\) }, '') }
+    expect(bodies.join).to eq(body)
+    expect(chunks.size).to be > 1
+    bodies[0..-2].each do |piece|
+      expect(piece).to match(/[[:space:]]\z/)
+    end
+    expect(bodies.join.split).to eq(words)
+  end
+
+  it 'still splits a single word that cannot fit in one payload' do
+    body = 'A' * (max + 10)
+    chunks = described_class.send(:mesh_text_chunks, text: body)
+    expect(chunks.size).to be > 1
+    expect(chunks.map { |piece| piece.sub(%r{\A\(\d+/\d+\) }, '') }.join).to eq(body)
+  end
+
+  it 'does not treat RATE_LIMIT_EXCEEDED as a free TX slot' do
+    obj = {
+      proto_data: [{ packet: { decoded: { portnum: :ROUTING_APP, request_id: 7, payload: { error_reason: :RATE_LIMIT_EXCEEDED } } } }],
+      rx_mutex: Mutex.new
+    }
+    t = Time.now
+    expect(described_class.send(:mesh_wait_tx_slot, obj: obj, since: 0, timeout: 0.25, request_id: 7)).to eq(:rate_limited)
+    expect(Time.now - t).to be < 0.2
+  end
+
+  it 'retries a rate-limited chunk instead of sending the next one' do
+    body = 'A' * (max + 10)
+    sent = []
+    allow(Meshtastic::Serial).to receive(:send_text) { |h| sent << h[:text] }
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:rate_limited, :ok, :ok)
+    described_class.send(:mesh_send_text, env: env, obj: { proto_data: [] }, text: body, to: '!ffffffff')
+    expect(sent.size).to be > 2
+    expect(sent[0]).to eq(sent[1])
+    expect(sent[2]).not_to eq(sent[0])
+  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)
@@ -76,17 +117,17 @@ describe PWN::Plugins::REPL, 'mesh payload chunking' 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)
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:ok)
     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
+    expect(described_class).to have_received(:mesh_wait_tx_slot).exactly(n).times
   end
 
-  it 'does not wait for a TX slot after a single payload' do
+  it 'waits for a TX slot after a single radio payload' do
     allow(Meshtastic::Serial).to receive(:send_text)
-    allow(described_class).to receive(:mesh_wait_tx_slot)
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:ok)
     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)
+    expect(described_class).to have_received(:mesh_wait_tx_slot).once
   end
 
   it 'does not treat QueueStatus free as the chunk being on the air' do

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

@@ -40,6 +40,35 @@ describe PWN::Plugins::REPL, 'mesh compose history' do
     described_class.send(:mesh_drain_events)
   end
 
+  it 'does not turn spinner cursor restores into a notice overlay' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    described_class.send(:mesh_capture_output, run: proc {
+      3.times { $stdout.write("\e[?25h") }
+      $stderr.write("\e[?25h")
+    })
+    expect(events).to be_empty
+  end
+
+  it 'does not notice TTYSpinner cursor restore during capture' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    described_class.send(:mesh_capture_output, run: proc {
+      PWN::Plugins::TTYSpinner.send(:show_cursor, spin: nil)
+    })
+    expect(events).to be_empty
+  end
+
+  it 'keeps real warnings after stripping cursor sequences' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    described_class.send(:mesh_capture_output, run: proc {
+      $stderr.write("\e[?25hWARNING: decoder fixture\e[?25h\n")
+    })
+    expect(events.pop(true)[:notice]).to eq('WARNING: decoder fixture')
+    expect(events).to be_empty
+  end
+
   it 'captures dependency stdout and stderr and restores both streams on failure' do
     events = Queue.new
     stub_const('PWN::MeshEvents', events)

data/spec/spec_helper.rb

@@ -31,6 +31,7 @@ RSpec.configure do |config|
   end
   config.filter_run_excluding :rtl_sdr_hardware unless ENV['PWN_TEST_RTL_SDR_HARDWARE'] == '1'
   config.filter_run_excluding :combo_nation_mcp unless ENV['PWN_TEST_COMBO_NATION_MCP'] == '1'
+  config.filter_run_excluding :x86_64_binary unless RbConfig::CONFIG['host_cpu'].to_s.match?(/amd64|x86_64/)
 
   next if ENV['PWN_SPEC_VERBOSE']
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.742
+  version: 0.5.743
 platform: ruby
 authors:
 - 0day Inc.