SQL sessions have correct history manager support

Author: sjanusz-r7

lib/rex/post/sql/ui/console/interactive_sql_client.rb

@@ -67,8 +67,19 @@ def _winch
 
   # Try getting multi-line input support provided by Reline, fall back to Readline.
   def _multiline_with_fallback
-    query = _multiline
-    query = _fallback if query[:status] == :fail
+    name = session.type
+    query = {}
+
+    # Multiline (Reline) and fallback (Readline) have separate history contexts as they are two different libraries.
+    framework.history_manager.with_context(history_file: Msf::Config.send("#{name}_session_history_interactive"), name: name, input_library: :reline) do
+      query = _multiline
+    end
+
+    if query[:status] == :fail
+      framework.history_manager.with_context(history_file: Msf::Config.send("#{name}_session_history_interactive"), name: name, input_library: :readline) do
+        query = _fallback
+      end
+    end
 
     query
   end
@@ -163,6 +174,16 @@ def _fallback
 
   attr_accessor :on_log_proc, :client_dispatcher
 
+  private
+
+  def framework
+    client_dispatcher.shell.framework
+  end
+
+  def session
+    client_dispatcher.shell.session
+  end
+
 end
 end
 end

lib/rex/ui/text/shell/history_manager.rb

@@ -24,10 +24,12 @@ def initialize
   #
   # @param [String,nil] history_file The file to load and persist commands to
   # @param [String] name Human readable history context name
+  # @param [Symbol] input_library The input library to provide context for. :reline, :readline
   # @param [Proc] block
   # @return [nil]
-  def with_context(history_file: nil, name: nil, &block)
-    push_context(history_file: history_file, name: name)
+  def with_context(history_file: nil, name: nil, input_library: nil, &block)
+    input_library ||= :readline # Default to Readline for backwards compatibility.
+    push_context(history_file: history_file, name: name, input_library: input_library)
 
     begin
       block.call
@@ -65,9 +67,9 @@ def debug?
     @debug
   end
 
-  def push_context(history_file: nil, name: nil)
+  def push_context(history_file: nil, name: nil, input_library: nil)
     $stderr.puts("Push context before\n#{JSON.pretty_generate(_contexts)}") if debug?
-    new_context = { history_file: history_file, name: name }
+    new_context = { history_file: history_file, name: name, input_library: input_library }
 
     switch_context(new_context, @contexts.last)
     @contexts.push(new_context)
@@ -91,47 +93,91 @@ def readline_available?
     defined?(::Readline)
   end
 
+  def reline_available?
+    begin
+      require 'reline'
+      defined?(::Reline)
+    rescue ::LoadError => _e
+      false
+    end
+  end
+
   def clear_readline
     return unless readline_available?
 
     ::Readline::HISTORY.length.times { ::Readline::HISTORY.pop }
   end
 
-  def load_history_file(history_file)
-    return unless readline_available?
+  def clear_reline
+    return unless reline_available?
 
-    clear_readline
-    if File.exist?(history_file)
-      File.readlines(history_file).each do |e|
-        ::Readline::HISTORY << e.chomp
+    ::Reline::HISTORY.length.times { ::Reline::HISTORY.pop }
+  end
+
+  def load_history_file(context)
+    history_file = context[:history_file]
+    case context[:input_library]
+    when :readline
+      return unless readline_available?
+
+      clear_readline
+      if File.exist?(history_file)
+        File.readlines(history_file).each do |e|
+          ::Readline::HISTORY << safe_undump(e.chomp)
+        end
+      end
+    when :reline
+      return unless reline_available?
+
+      clear_reline
+      if File.exist?(history_file)
+        File.readlines(history_file).each do |e|
+          ::Reline::HISTORY << safe_undump(e.chomp)
+        end
       end
     end
   end
 
-  def store_history_file(history_file)
-    return unless readline_available?
+  def store_history_file(context)
     cmds = []
-    history_diff = ::Readline::HISTORY.length < MAX_HISTORY ? ::Readline::HISTORY.length : MAX_HISTORY
-    history_diff.times do
-      entry = ::Readline::HISTORY.pop
-      cmds.push(entry) unless entry.nil?
+    history_file = context[:history_file]
+
+    case context[:input_library]
+    when :readline
+      return unless readline_available?
+
+      history_diff = ::Readline::HISTORY.length < MAX_HISTORY ? ::Readline::HISTORY.length : MAX_HISTORY
+      history_diff.times do
+        entry = ::Readline::HISTORY.pop.dump
+        cmds.push(entry) unless entry.nil?
+      end
+    when :reline
+      return unless reline_available?
+
+      history_diff = ::Reline::HISTORY.length < MAX_HISTORY ? ::Reline::HISTORY.length : MAX_HISTORY
+      history_diff.times do
+        entry = ::Reline::HISTORY.pop.dump
+        cmds.push(entry) unless entry.nil?
+      end
     end
 
     write_history_file(history_file, cmds)
   end
 
   def switch_context(new_context, old_context=nil)
     if old_context && old_context[:history_file]
-      store_history_file(old_context[:history_file])
+      store_history_file(old_context)
     end
 
     if new_context && new_context[:history_file]
-      load_history_file(new_context[:history_file])
+      load_history_file(new_context)
     else
       clear_readline
+      clear_reline
     end
-  rescue SignalException => e
+  rescue SignalException => _e
     clear_readline
+    clear_reline
   end
 
   def write_history_file(history_file, cmds)
@@ -159,6 +205,16 @@ def write_history_file(history_file, cmds)
     @write_queue << event
     @remaining_work << event
   end
+
+  # @param [String] dumped A string that has been previously dumped
+  # @return [String] A string that is undumped if possible or the input if it can't be undumped.
+  def safe_undump(dumped)
+    begin
+      dumped.undump
+    rescue ::RuntimeError => _e
+      dumped
+    end
+  end
 end
 
 end