pwn 0.5.480 → 0.5.481

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be16c14d474f80d808e7389475a17ec6d7dc52cb4da44395ef516810a7054ae2
-  data.tar.gz: 4e33ef6a047b000581e6fa1aa94ac177f00324ef011f60b43ad0fa2a01435c11
+  metadata.gz: f8f0ace17ae36a1a8e60fd015ad3c0a37dcaa22fd3490806b4fc033bd974ae70
+  data.tar.gz: 4a3b5eb17658a0a7c63e6e49bd87cad5740112ed1c2d77207fd0cde9949a50d6
 SHA512:
-  metadata.gz: 1c561adc55354180fc0d53ca294e83693ee8ddcd625fe75f99b357e5cfb697bc95fdb9326c01e939c22f2cf2f80ff1bc00fe8a4b111e3eb889bffa02992dd248
-  data.tar.gz: 841188de9b7921592cf1baa653e74eab49a7039468506930d095cdbe6076bfcd55071c99554d010ce1642e88d9730bf623fa912d67ee05a30ae4902c4790d7ef
+  metadata.gz: d97493c22667ef54489045fd1bdd5ff8940701fa266e923849f8784feacc546be605154bc215a15823b9c424a4ba025e6bd95d3a1b3e86eba3d70987bc55c6c0
+  data.tar.gz: 0636daf478dff9780efe1b14478d40d06e109927c955d8d8c50f8c1c8e5c1bd7faaad9cfc8f98254084f4f384cdaa90c4698d563e57d386be38449193600c2e4

data/.rubocop.yml

@@ -6,7 +6,7 @@ Layout/LineLength:
 Lint/UselessRescue:
   Enabled: false
 Metrics/AbcSize:
-  Max: 537.6
+  Max: 552.3
 Metrics/BlockLength:
   Max: 292
 Metrics/BlockNesting:

data/README.md

@@ -37,7 +37,7 @@ $ cd /opt/pwn
 $ ./install.sh
 $ ./install.sh ruby-gem
 $ pwn
-pwn[v0.5.480]:001 >>> PWN.help
+pwn[v0.5.481]:001 >>> PWN.help
 ```
 
 [![Installing the pwn Security Automation Framework](https://raw.githubusercontent.com/0dayInc/pwn/master/documentation/pwn_install.png)](https://youtu.be/G7iLUY4FzsI)
@@ -52,7 +52,7 @@ $ rvm use ruby-3.4.4@pwn
 $ gem uninstall --all --executables pwn
 $ gem install --verbose pwn
 $ pwn
-pwn[v0.5.480]:001 >>> PWN.help
+pwn[v0.5.481]:001 >>> PWN.help
 ```
 
 If you're using a multi-user install of RVM do:
@@ -62,7 +62,7 @@ $ rvm use ruby-3.4.4@pwn
 $ rvmsudo gem uninstall --all --executables pwn
 $ rvmsudo gem install --verbose pwn
 $ pwn
-pwn[v0.5.480]:001 >>> PWN.help
+pwn[v0.5.481]:001 >>> PWN.help
 ```
 
 PWN periodically upgrades to the latest version of Ruby which is reflected in `/opt/pwn/.ruby-version`.  The easiest way to upgrade to the latest version of Ruby from a previous PWN installation is to run the following script:

data/lib/pwn/plugins/repl.rb

@@ -64,19 +64,10 @@ module PWN
             end
           end
 
-          if pi.config.pwn_mesh
-            active_channel = PWN::Env[:plugins][:meshtastic][:channel][:active].to_s.to_sym
-            region = PWN::Env[:plugins][:meshtastic][:channel][active_channel][:region]
-            topic = PWN::Env[:plugins][:meshtastic][:channel][active_channel][:topic]
-            channel_num = PWN::Env[:plugins][:meshtastic][:channel][active_channel][:channel_num]
+          ps1_proc = "#{name}[#{version}]:#{line_count} #{dchars} ".to_s.scrub
+          ps1_proc = '' if pi.config.pwn_mesh
 
-            pi.config.prompt_name = "pwn.mesh:#{region}/#{topic}:#{channel_num}"
-            name = "\001\e[1m\002\001\e[32m\002#{pi.config.prompt_name}\001\e[0m\002"
-            dchars = "\001\e[32m\002>>>\001\e[33m\002"
-            dchars = "\001\e[33m\002***\001\e[33m\002" if mode == :splat
-          end
-
-          "#{name}[#{version}]:#{line_count} #{dchars} ".to_s.scrub
+          ps1_proc
         end
       rescue StandardError => e
         raise e
@@ -472,24 +463,77 @@ module PWN
             # Init ncurses UI (idempotent) with separate RX (top) and TX (bottom) panes
             Curses.init_screen
             Curses.curs_set(0)
-            # Curses.crmode
-            # Curses.ESCDELAY = 0
+            Curses.noecho
+            Curses.cbreak
+            Curses.crmode
+            Curses.ESCDELAY = 0
             Curses.start_color
             Curses.use_default_colors
 
+            mesh_highlight_colors = [
+              { fg: Curses::COLOR_RED, bg: Curses::COLOR_WHITE },
+              { fg: Curses::COLOR_GREEN, bg: Curses::COLOR_BLACK },
+              { fg: Curses::COLOR_YELLOW, bg: Curses::COLOR_BLACK },
+              { fg: Curses::COLOR_BLUE, bg: Curses::COLOR_WHITE },
+              { fg: Curses::COLOR_CYAN, bg: Curses::COLOR_BLACK },
+              { fg: Curses::COLOR_MAGENTA, bg: Curses::COLOR_WHITE },
+              { fg: Curses::COLOR_WHITE, bg: Curses::COLOR_BLUE }
+            ]
+            mesh_highlight_colors.each_with_index do |hash, idx|
+              color_id = idx + 1
+              color_fg = hash[:fg]
+              color_bg = hash[:bg]
+              Curses.init_pair(color_id, color_fg, color_bg)
+            end
+            PWN.const_set(:MeshColors, (1..mesh_highlight_colors.length).to_a)
+            PWN.const_set(:MeshLastPair, PWN::MeshColors.sample)
+
+            mesh_ui_colors = []
+            mesh_highlight_colors.each_with_index do |hl_hash, idx|
+              ui_hash = {
+                color_id: idx + 10,
+                fg: hl_hash[:fg],
+                bg: -1
+              }
+              Curses.init_pair(ui_hash[:color_id], ui_hash[:fg], ui_hash[:bg])
+              mesh_ui_colors.push(ui_hash)
+            end
+
+            red = mesh_ui_colors[0][:color_id]
+            green = mesh_ui_colors[1][:color_id]
+            yellow = mesh_ui_colors[2][:color_id]
+            blue = mesh_ui_colors[3][:color_id]
+            cyan = mesh_ui_colors[4][:color_id]
+            magenta = mesh_ui_colors[5][:color_id]
+            white = mesh_ui_colors[6][:color_id]
+
             rx_height = Curses.lines - 4
-            rx_win = Curses::Window.new(rx_height, Curses.cols, 2, 0)
+            rx_win = Curses::Window.new(rx_height, Curses.cols, 0, 0)
             rx_win.scrollok(true)
             rx_win.nodelay = true
-            rx_win.box('|', "\u2500")
-            rx_win.addstr("<<< #{host}:#{port} | #{region}/#{topic} | ch:#{channel_num} >>>\n")
+            rx_win.attron(Curses.color_pair(cyan) | Curses::A_BOLD)
+
+            # Make rx_header bold and green
+            rx_win.attron(Curses.color_pair(green) | Curses::A_BOLD)
+            rx_header = "<<< #{host}:#{port} | #{region}/#{topic} | ch:#{channel_num} >>>"
+            rx_header_len = rx_header.length
+            rx_header_pos = (Curses.cols / 2) - (rx_header_len / 2)
+            rx_win.setpos(1, rx_header_pos)
+            rx_win.addstr(rx_header)
+            rx_win.attroff(Curses.color_pair(green) | Curses::A_BOLD)
+            # Jump two lines below header before messages begin
+            rx_win.setpos(2, 1)
+            rx_win.attron(Curses.color_pair(cyan) | Curses::A_BOLD)
+            rx_header_bottom_line = "\u2014" * (Curses.cols - 2)
+            rx_header_bottom_line_pos = (Curses.cols / 2) - (rx_header_bottom_line.length / 2)
+            rx_win.addstr(rx_header_bottom_line)
+            rx_win.attroff(Curses.color_pair(cyan) | Curses::A_BOLD)
+
             rx_win.refresh
 
             tx_win = Curses::Window.new(4, Curses.cols, rx_height, 0)
             tx_win.scrollok(false)
             tx_win.nodelay = true
-            tx_win.box('|', "\u2500")
-            tx_win.addstr("TX Pane (echo while typing, last sent shown after Enter)\n")
             tx_win.refresh
 
             PWN.const_set(:MeshRxWin, rx_win)
@@ -498,24 +542,61 @@ module PWN
             PWN.const_set(:MeshPi, pi)
 
             # Live typing echo thread (idempotent)
-            tx_prompt = "#{region}/#{topic}:#{channel_num} >>> "
+            tx_prompt = "#{region}/#{topic} >>>"
             echo_thread = Thread.new do
+              last_drawn = nil
               loop do
                 break unless pi.config.pwn_mesh
 
                 tx_win = PWN.const_get(:MeshTxWin)
                 mutex = PWN.const_get(:MeshMutex)
                 msg_input = pi.input.line_buffer.to_s
-                ts = Time.now.strftime('%H:%M:%S')
-                mutex.synchronize do
-                  # Only show draft if after_read hook hasn't just written final TX (heuristic)
-                  tx_win.clear
-                  tx_win.box('|', "\u2500")
-                  tx_win.setpos(1, 1)
-                  tx_win.addstr("[#{ts}] [TX] #{tx_prompt} #{msg_input}")
-                  tx_win.refresh
+                ts = Time.now.strftime('%H:%M:%S%z')
+                cursor_pos = (Readline.respond_to?(:point) ? Readline.point : msg_input.length)
+                prefix = "[#{ts}] [TX] #{tx_prompt} "
+                base_line = "#{prefix}#{msg_input}"
+                cursor_abs_index = prefix.length + cursor_pos
+                current_line = base_line
+                if current_line != last_drawn
+                  mutex.synchronize do
+                    # Only show draft if after_read hook hasn't just written final TX (heuristic)
+                    tx_win.clear
+                    tx_win.attron(Curses.color_pair(red) | Curses::A_BOLD)
+                    tx_header_bottom_line = "\u2014" * (Curses.cols - 2)
+                    tx_header_bottom_line_pos = (Curses.cols / 2) - (rx_header_bottom_line.length / 2)
+                    tx_win.addstr(rx_header_bottom_line)
+                    tx_win.attroff(Curses.color_pair(red) | Curses::A_BOLD)
+                    tx_win.attron(Curses.color_pair(yellow) | Curses::A_BOLD)
+
+                    inner_width = Curses.cols - 2
+                    segments = current_line.chars.each_slice(inner_width).map(&:join)
+                    available_rows = tx_win.maxy - 2
+                    segments.first(available_rows).each_with_index do |seg, idx|
+                      tx_win.setpos(1 + idx, 1)
+                      start_index = idx * inner_width
+                      end_index = start_index + inner_width - 1
+                      if cursor_abs_index.between?(start_index, end_index)
+                        cursor_col = cursor_abs_index - start_index
+                        (0..inner_width).each do |col|
+                          ch = seg[col] || ' '
+                          if col == cursor_col
+                            tx_win.attron(Curses.color_pair(red) | Curses::A_REVERSE | Curses::A_BOLD)
+                            tx_win.addch(ch)
+                            tx_win.attroff(Curses.color_pair(red) | Curses::A_REVERSE | Curses::A_BOLD)
+                          else
+                            tx_win.addch(ch)
+                          end
+                        end
+                      else
+                        tx_win.addstr(seg.ljust(inner_width))
+                      end
+                    end
+                    tx_win.attroff(Curses.color_pair(yellow) | Curses::A_BOLD)
+                    tx_win.refresh
+                  end
+                  last_drawn = current_line
                 end
-                sleep 0.01
+                sleep 0.005
               end
             end
             echo_thread.abort_on_exception = false
@@ -545,22 +626,38 @@ module PWN
                 mutex = PWN.const_get(:MeshMutex)
 
                 from = packet[:node_id_from]
-                absolute_topic = "#{region}/#{topic.gsub('#', from)}:#{channel_num}"
+                absolute_topic = "#{region}/#{topic.gsub('#', from)}"
                 to = packet[:node_id_to]
                 rx_text = decoded[:payload]
-                ts = Time.now.strftime('%H:%M:%S')
+                ts = Time.now.strftime('%H:%M:%S%z')
+
+                # Select a random color pair different from the last used one
+                colors_arr = PWN.const_get(:MeshColors)
+                last_pair = PWN.const_get(:MeshLastPair)
+                PWN.send(:remove_const, :MeshLastPair)
+                pair_choices = colors_arr.reject { |c| c == last_pair }
+                pair = pair_choices.sample
+                PWN.const_set(:MeshLastPair, pair)
+                rx_win.attron(Curses.color_pair(pair) | Curses::A_REVERSE)
+
+                current_line = "\n[#{ts}] [RX] #{absolute_topic} >>> #{rx_text}"
+                current_line = "\n[#{ts}] [RX][DM INTERCEPTED] #{absolute_topic} to: #{to} >>> #{rx_text}" unless to == '!ffffffff'
+
                 mutex.synchronize do
-                  if to == '!ffffffff'
-                    rx_win.addstr("[#{ts}] [RX] #{absolute_topic}: #{rx_text}\n")
-                  else
-                    rx_win.addstr("[#{ts}] [RX][DM INTERCEPTED] #{absolute_topic} >>> #{to}: #{rx_text}\n")
+                  inner_width = Curses.cols - 2
+                  content = current_line.sub(/\A\n/, '')
+                  segments = content.scan(/.{1,#{inner_width}}/)
+                  segments.each do |seg|
+                    rx_win.addstr("\n")
+                    rx_win.setpos(rx_win.cury, 1)
+                    line = seg.ljust(inner_width)
+                    rx_win.addstr(line)
                   end
-                  # rx_win.addstr("#{msg.inspect}\n\n\n")
                   rx_win.refresh
                 end
+                rx_win.attroff(Curses.color_pair(pair) | Curses::A_REVERSE)
               end
             end
-            PWN.const_set(:MqttSubThread, true)
           rescue StandardError => e
             raise e
           end
@@ -648,6 +745,8 @@ module PWN
               PWN.const_get(:MeshTxWin).close
               PWN.send(:remove_const, :MeshTxWin)
             end
+            PWN.send(:remove_const, :MeshColors) if PWN.const_defined?(:MeshColors)
+            PWN.send(:remove_const, :MeshLastPair) if PWN.const_defined?(:MeshLastPair)
             PWN.send(:remove_const, :MeshPi) if PWN.const_defined?(:MeshPi)
             PWN.send(:remove_const, :MeshMutex) if PWN.const_defined?(:MeshMutex)
             PWN.send(:remove_const, :MqttSubThread) if PWN.const_defined?(:MqttSubThread)
@@ -805,21 +904,6 @@ module PWN
               text: tx_text,
               psks: psks
             )
-
-            # Update TX pane (bottom) with last sent message
-            if PWN.const_defined?(:MeshTxWin)
-              tx_win = PWN.const_get(:MeshTxWin)
-              mutex = PWN.const_get(:MeshMutex)
-              absolute_topic = "#{region}/#{topic.gsub('#', from)}:#{channel_num}"
-              ts = Time.now.strftime('%H:%M:%S')
-              mutex.synchronize do
-                tx_win.clear
-                tx_win.box('|', "\u2500")
-                tx_win.setpos(1, 1)
-                tx_win.addstr("[#{ts}] [TX] #{absolute_topic} >>> #{to}: #{tx_text}")
-                tx_win.refresh
-              end
-            end
           end
         end
       rescue StandardError => e

data/lib/pwn/version.rb

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

metadata

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