idb 1.3.1

data/lib/gui/url_handler_widget.rb

@@ -0,0 +1,26 @@
+require_relative '../lib/url_scheme_fuzzer'
+require_relative 'url_scheme_fuzz_widget'
+require_relative 'url_scheme_widget'
+
+module Idb
+  class URLHandlerWidget < Qt::TabWidget
+
+    def initialize *args
+      super *args
+
+      @tabs = Hash.new
+
+      @url_scheme = URLSchemeWidget.new self
+      @tabs[:scheme] = addTab(@url_scheme, "URL Schemes")
+
+      @url_fuzz = URLSchemeFuzzWidget.new self
+      @tabs[:fuzzer] = addTab(@url_fuzz, "Fuzzer")
+    end
+
+    def disable_for_simulator
+      @tabs[:fuzzer]
+
+    end
+
+  end
+end

data/lib/gui/url_scheme_fuzz_widget.rb

@@ -0,0 +1,103 @@
+module Idb
+  class URLSchemeFuzzWidget < Qt::Widget
+
+    def initialize *args
+      super *args
+
+      @fuzz_config_layout = Qt::GridLayout.new
+      setLayout @fuzz_config_layout
+
+      @fuzz_config_fuzz_strings = Qt::ListWidget.new self
+      @fuzz_config_fuzz_strings_label = Qt::Label.new "<b>Fuzz Strings:<b>"
+      @fuzzer = URLSchemeFuzzer.new
+      @fuzzer.default_fuzz_strings.each { |x|
+        @fuzz_config_fuzz_strings.addItem x
+      }
+
+      @fuzz_config_new_fuzz = Qt::LineEdit.new
+      @fuzz_config_add_fuzz = Qt::PushButton.new "Add"
+      @fuzz_config_add_fuzz.connect(SIGNAL :released) {
+        @fuzz_config_fuzz_strings.addItem @fuzz_config_new_fuzz.text
+        @fuzz_config_new_fuzz.text = ""
+        @fuzz_config_remove_fuzz.setEnabled(true)
+      }
+      @fuzz_config_remove_fuzz = Qt::PushButton.new "Remove"
+      @fuzz_config_remove_fuzz.connect(SIGNAL :released) {
+        row = @fuzz_config_fuzz_strings.current_row
+        @fuzz_config_fuzz_strings.takeItem  row unless row.nil?
+        if @fuzz_config_fuzz_strings.count == 0
+          @fuzz_config_remove_fuzz.setEnabled(false)
+        end
+      }
+
+
+      @fuzz_strings = Qt::GroupBox.new self
+      @fuzz_strings.setTitle "Fuzz Strings"
+      @fuzz_strings_layout = Qt::GridLayout.new
+      @fuzz_strings.setLayout @fuzz_strings_layout
+
+      @fuzz_strings_layout.addWidget @fuzz_config_fuzz_strings, 1,0, 1, 2
+      @fuzz_strings_layout.addWidget @fuzz_config_new_fuzz, 2,0, 1 ,2
+      @fuzz_strings_layout.addWidget @fuzz_config_add_fuzz, 3,0
+      @fuzz_strings_layout.addWidget @fuzz_config_remove_fuzz, 3,1
+
+
+
+      @fuzz_template = Qt::GroupBox.new self
+      @fuzz_template.setTitle "Fuzz Template"
+      @fuzz_template_layout = Qt::GridLayout.new
+      @fuzz_template.setLayout @fuzz_template_layout
+      @fuzz_config_template_label = Qt::Label.new "Use $@$ to mark injection fuzz points"
+      @fuzz_config_template = Qt::LineEdit.new
+
+
+      @fuzz_config_button = Qt::PushButton.new "Fuzz"
+      @fuzz_config_button.connect(SIGNAL :released) {
+        @fuzzer.delete_old_reports
+
+
+        fuzz_strings  = Array.new
+        0.upto(@fuzz_config_fuzz_strings.count-1) { |i|
+          fuzz_strings << @fuzz_config_fuzz_strings.item(i).text
+        }
+        input = @fuzzer.generate_inputs @fuzz_config_template.text, fuzz_strings
+        input.each { |url|
+          #TODO: progress bar
+          #TODO: kill app after each run
+          #TODO: check for crash report
+          crashed = @fuzzer.execute url
+          @log_window.append_message "#{url}\t#{crashed}"
+          break if crashed
+          Qt::CoreApplication.processEvents
+          sleep 2
+          Qt::CoreApplication.processEvents
+        }
+      }
+
+      @fuzz_template_layout.addWidget @fuzz_config_template_label, 0,0
+      @fuzz_template_layout.addWidget @fuzz_config_template, 1,0
+      @fuzz_template_layout.addWidget @fuzz_config_button, 2,0, 1, 2
+
+
+      @fuzz_result = Qt::GroupBox.new self
+      @fuzz_result.setTitle "Results"
+      @fuzz_result_layout = Qt::GridLayout.new
+      @fuzz_result.setLayout @fuzz_result_layout
+      @log_window = LogPlainTextEdit.new
+      @log_window.setReadOnly(true)
+      @fuzz_result_layout.addWidget @log_window, 0,0
+
+
+      @fuzz_config_layout.addWidget @fuzz_strings, 0,0
+      @fuzz_config_layout.addWidget @fuzz_template, 1, 0
+      @fuzz_config_layout.addWidget @fuzz_result, 0, 1, 2, 1
+
+
+
+
+
+  end
+
+
+  end
+end

data/lib/gui/url_scheme_widget.rb

@@ -0,0 +1,60 @@
+module Idb
+  class URLSchemeWidget < Qt::Widget
+    def initialize *args
+      super *args
+
+      @url_handler_list = Qt::GroupBox.new self
+      @url_handler_list.setTitle "List of registered URL Handlers"
+      @url_handler_list_layout = Qt::GridLayout.new
+      @url_handler_list.setLayout @url_handler_list_layout
+
+      @refresh = Qt::PushButton.new "Refresh"
+      @refresh.connect(SIGNAL :released) {
+        refresh
+      }
+
+      @list = Qt::ListWidget.new self
+      @list.connect(SIGNAL('itemClicked(QListWidgetItem*)')) { |item|
+        @url_open_string.text = item.text + "://"
+      }
+
+      @url_handler_list_layout.add_widget @list, 0, 0
+      @url_handler_list_layout.add_widget @refresh, 1, 0
+
+
+
+      @url_open = Qt::GroupBox.new self
+      @url_open.setTitle "Open URL"
+      @url_open_layout = Qt::GridLayout.new
+      @url_open.setLayout @url_open_layout
+
+      @url_open_string = Qt::LineEdit.new
+      @url_open_button = Qt::PushButton.new "Open"
+      @url_open_button.connect(SIGNAL :released) {
+        $device.open_url @url_open_string.text
+      }
+      @url_open_layout.addWidget @url_open_string, 0,0
+      @url_open_layout.addWidget @url_open_button, 1,0
+
+      layout = Qt::GridLayout.new do |v|
+        v.add_widget @url_handler_list, 0, 0
+        v.add_widget @url_open, 0, 1
+        v.add_widget @fuzz_config, 1, 0, 2, 2
+
+      end
+      setLayout(layout)
+    end
+
+    def refresh
+      @list.clear
+      url_handlers = $selected_app.get_url_handlers
+      url_handlers.each { |x|
+        @list.addItem x
+      }
+    end
+
+    def clear
+      @list.clear
+    end
+  end
+end

data/lib/gui/weak_class_dump_widget.rb

@@ -0,0 +1,89 @@
+require_relative '../lib/weak_class_dump_wrapper'
+
+module Idb
+  class WeakClassDumpWidget < Qt::Widget
+    def initialize *args
+      super  *args
+
+
+
+      @layout = Qt::GridLayout.new
+      setLayout @layout
+
+      @run = Qt::PushButton.new "Dump Classes"
+      @layout.addWidget @run, 0,0
+      @run.connect(SIGNAL :released) {
+        run_cycript
+      }
+
+
+      @results = Qt::PushButton.new "List Results"
+      @layout.addWidget @results, 0,1
+
+      @results.connect(SIGNAL :released) {
+        @weak_class_dump_wrapper.pull_header_files
+        refresh_header_list
+      }
+
+      @open_folder = Qt::PushButton.new "Open Folder"
+      @layout.addWidget @open_folder, 0,2
+
+      @open_folder.connect(SIGNAL :released) {
+        Launchy.open @local_path
+      }
+
+
+      @header_list = Qt::ListWidget.new self
+      @header_list_label = Qt::Label.new "<b>Header Files:<b>"
+      @header_list.connect(SIGNAL('itemClicked(QListWidgetItem*)')) { |item|
+        @content.clear
+        @content.appendHtml(CodeRay.scan_file(@local_path + "/" + item.text).page(
+          :line_numbers => nil,
+          :css => :style
+        ))
+      }
+
+      @header_list.connect(SIGNAL('itemDoubleClicked(QListWidgetItem*)')) { |item|
+        $device.ops.open @local_path + "/" + item.text
+      }
+
+      @content = Qt::PlainTextEdit.new
+      @content.setReadOnly(true)
+
+      @splitter = Qt::Splitter.new
+      @splitter.addWidget @header_list
+      @splitter.addWidget @content
+      @splitter.setStretchFactor 1, 1.5
+      @splitter.setSizePolicy(Qt::SizePolicy::Expanding, Qt::SizePolicy::Expanding)
+      @layout.addWidget @splitter, 1, 0, 1, 3
+
+    end
+
+    def run_cycript
+      @local_path  = "#{$selected_app.cache_dir}/weak_class_dump_headers"
+      @weak_class_dump_wrapper = WeakClassDumpWrapper.new @local_path
+      @weak_class_dump_wrapper.execute_cycript
+
+      error = Qt::MessageBox.new
+      error.setInformativeText("Cycript dumping the class information... This may take some time. On success the device will play the lock sound. You can then list the header files and view them.")
+      error.setIcon(Qt::MessageBox::Information)
+      error.exec
+
+    end
+
+    def refresh_header_list
+        @header_list.clear
+        @weak_class_dump_wrapper.get_header_files.each { |x|
+          @header_list.addItem x
+        }
+    end
+
+
+    def refresh
+      unless $selected_app.cache_dir.nil?
+        @local_path  = "#{$selected_app.cache_dir}/weak_class_dump_headers"
+        @weak_class_dump_wrapper = WeakClassDumpWrapper.new @local_path
+        end
+    end
+  end
+end

data/lib/helper/ssh_port_forwarder.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+require_relative '../lib/ssh_port_forwarder'
+require_relative '../lib/settings'
+require_relative '../lib/usb_muxd_wrapper'
+require 'log4r'
+
+module Idb
+  class SSHPortForwarderHelper
+    def self.run
+
+      # initialize log
+      $log = Log4r::Logger.new 'port_forward'
+      outputter = Log4r::Outputter.stdout
+      outputter.formatter =  Log4r::PatternFormatter.new(:pattern => "[%l] %d :: %c ::  %m")
+      $log.outputters = [ outputter ]
+
+      # load settings
+      settings_path = File.dirname(ENV['HOME'] + "/.idb/config/")
+      settings_filename = "settings.yml"
+      settings = Settings.new "#{settings_path}/#{settings_filename}"
+
+      if settings['device_connection_mode'] == "ssh"
+        $log.debug "Connecting via SSH"
+
+        # setup forwards
+        $ssh_forwards = SSHPortForwarder.new settings['ssh_username'], settings['ssh_password'], settings['ssh_host'], settings['ssh_port']
+      else
+        $log.debug "Connecting via USB"
+
+        $usbmuxd = USBMuxdWrapper.new
+        proxy_port = $usbmuxd.find_available_port
+        $log.debug "Using port #{proxy_port} for SSH forwarding"
+
+        $usbmuxd.proxy proxy_port, settings['ssh_port']
+        # setup forwards
+        $ssh_forwards = SSHPortForwarder.new settings['ssh_username'], settings['ssh_password'], 'localhost', proxy_port
+      end
+
+
+      $log.info 'Setting up port forwarding...'
+
+      # Special idb internal port
+      $ssh_forwards.add_remote_forward Integer(settings['idb_utility_port']), 'localhost', Integer(settings['idb_utility_port'])
+
+      unless settings['remote_forwards'].nil?
+        settings['remote_forwards'].each { |x|
+          $ssh_forwards.add_remote_forward Integer(x['remote_port']), x['local_host'], Integer(x['local_port'])
+        }
+      end
+
+      unless settings['local_forwards'].nil?
+        settings['local_forwards'].each { |x|
+          $ssh_forwards.add_local_forward Integer(x['local_port']), x['remote_host'], Integer(x['remote_port'])
+        }
+      end
+
+      # start event loop
+      $ssh_forwards.start
+    end
+  end
+
+  begin
+    SSHPortForwarderHelper.run
+  rescue SystemExit, Interrupt
+    $log.info "Cleaning up before exiting"
+    $log.info "Closing SSH connection"
+    $ssh_forwards.stop
+    $log.info "Stopping any SSH via USB forwarding"
+    $usbmuxd.stop_all
+  end
+
+end

data/lib/idb.rb

@@ -0,0 +1,295 @@
+require 'Qt'
+require 'awesome_print'
+require_relative 'lib/settings'
+require_relative 'lib/simulator'
+require_relative 'lib/device'
+require_relative 'lib/qt_thread_fix'
+require_relative 'gui/app_list_widget_item'
+require_relative 'gui/screenshot_wizard'
+require_relative 'gui/app_details_group_box'
+require_relative 'gui/app_list_dialog'
+require_relative 'gui/main_tab_widget'
+require_relative 'gui/settings_dialog'
+require_relative 'gui/device_info_group_box'
+require_relative 'gui/ca_manager_dialog'
+
+module Idb
+  TARGET = "Hello"
+
+  # logging
+  require 'log4r'
+
+  $width = 1024
+  $height = 768
+
+  class Idb < Qt::MainWindow
+
+      def initialize
+        super
+
+
+        # initialize log
+        $log = Log4r::Logger.new 'idb'
+        outputter = Log4r::Outputter.stdout
+        outputter.formatter =  Log4r::PatternFormatter.new(:pattern => "[%l] %d :: %c ::  %m")
+
+        $log.outputters = [ outputter ]
+
+        if RUBY_VERSION.start_with? "2.0"
+          error = Qt::MessageBox.new
+          error.setInformativeText("You are using ruby 2.0 which does not work well with QT bindings: custom signals don't work. It is very likely that idb will not function as intended. Consider using ruby 1.9 or 2.1 instead.")
+          error.setIcon(Qt::MessageBox::Critical)
+          error.exec
+        end
+
+
+
+        # enable threading. See https://github.com/ryanmelt/qtbindings/issues/63
+        @thread_fix = QtThreadFix.new
+        settings_path = File.dirname(ENV['HOME'] + "/.idb/config/")
+        $tmp_path = ENV['HOME'] + "/.idb/tmp/"
+        puts $tmp_path
+        unless File.directory?(settings_path)
+          $log.info "Creating settings directory: #{settings_path}"
+          FileUtils.mkdir_p(settings_path)
+        end
+
+        settings_filename = "settings.yml"
+        $settings = Settings.new "#{settings_path}/#{settings_filename}"
+
+        setWindowTitle "idb"
+        Qt::CoreApplication::setApplicationName("idb")
+        setWindowIconText('idb')
+        init_ui
+
+  #      size = Qt::Size.new($width, $height)
+  #      size = size.expandedTo(self.minimumSizeHint())
+  #      resize(size)
+  #        resize $width, $height
+
+  #      center
+
+  #      showMaximized();
+  #      show
+  #      self.raise
+      end
+
+     def self.execute_in_main_thread(blocking = false, sleep_period = 0.001)
+      if Thread.current != Thread.main
+        complete = false
+        QtThreadFix.ruby_thread_queue << lambda {|| yield; complete = true}
+        if blocking
+          until complete
+            sleep(sleep_period)
+          end
+        end
+      else
+        yield
+      end
+    end
+
+      def init_ui
+        # setup central widget and grid layout
+        @central_widget = Qt::Widget.new self
+        self.setCentralWidget @central_widget
+        @grid = Qt::GridLayout.new @central_widget
+
+        @grid.setColumnMinimumWidth(0,450)
+
+
+        # Box for App details
+        @app_details = AppDetailsGroupBox.new @central_widget
+        @app_details.connect(SIGNAL(:app_changed)) {
+          @main_tabs.app_changed
+          @app_binary.app_changed
+          @menu_item_screenshot.setEnabled(true)
+        }
+        @app_details.connect(SIGNAL(:show_device_status)) {
+          @device_status = DeviceStatusDialog.new
+          @device_status.exec
+        }
+
+
+        @grid.addWidget @app_details, 0,0
+
+        # App Binary Details
+        @app_binary = AppBinaryGroupBox.new @central_widget
+        @grid.addWidget @app_binary, 1,0
+        @app_binary.connect(SIGNAL('binary_analyzed()')) {
+          @main_tabs.refresh_app_binary
+        }
+
+        @spacer = Qt::SpacerItem.new 0,1, Qt::SizePolicy::Fixed, Qt::SizePolicy::Expanding
+        @grid.addItem @spacer, 2,0
+
+        # Main Tab Widget
+        @main_tabs = MainTabWidget.new @central_widget
+        @grid.addWidget @main_tabs, 0,1,3,1
+
+        # device Details
+        @device_details = DeviceInfoGroupBox.new @central_widget
+        @device_details.connect(SIGNAL :disconnect) {
+          @main_tabs.disable_all
+          @app_binary.clear
+          @app_binary.disable_analyze_binary
+          @app_details.clear
+          @app_details.disable_select_app
+          @usb_device.setChecked(false)
+        }
+        @grid.addWidget @device_details, 3,0,2,2
+
+        menu
+
+      end
+
+
+      def menu
+
+        ##########################################
+        # MENU
+        ##########################################
+        # File
+        menu_item_settings = Qt::Action.new "&Settings", self
+        menu_item_settings.connect(SIGNAL :triggered) {
+          setting = SettingsDialog.new self
+          setting.connect(SIGNAL :accepted) {
+            if $settings['device_connection_mode'] == "ssh"
+              @usb_device.setText("SSH Device")
+            else
+              @usb_device.setText("USB Device")
+            end
+          }
+          setting.exec
+        }
+        @menu_file = menuBar().addMenu "&File"
+        @menu_file.addAction menu_item_settings
+
+        @menu_item_screenshot = Qt::Action.new "&Screenshot", self
+        @menu_item_screenshot.setEnabled(false)
+        @menu_item_screenshot.connect(SIGNAL :triggered) {
+          tool = ScreenShotWizard::ScreenShotWizard.new_with_app $selected_app
+        }
+        @menu_item_cert = Qt::Action.new "&Certificate Manager", self
+        @menu_item_cert.setEnabled(false)
+        @menu_item_cert.connect(SIGNAL :triggered) {
+          ca = CAManagerDialog.new self
+          ca.exec
+        }
+        @menu_tools = menuBar().addMenu "&Tools"
+        @menu_tools.addAction @menu_item_screenshot
+        @menu_tools.addAction @menu_item_cert
+
+
+        #Devices
+        @sim_group = Qt::ActionGroup.new @menu_devices
+
+        @menu_devices = menuBar().addMenu "&Devices"
+        @usb_device = Qt::Action.new "USB Device", self
+        if $settings['device_connection_mode'] == "ssh"
+          @usb_device.setText("SSH Device")
+        else
+          @usb_device.setText("USB Device")
+        end
+
+        @usb_device.setCheckable(true)
+        @usb_device.connect(SIGNAL(:triggered)) { |x|
+          $device.disconnect unless $device.nil?
+
+          progress = Qt::ProgressDialog.new "Connecting to device. Please wait...", nil, 0, 2, @central_widget
+          progress.setWindowModality(Qt::WindowModal);
+          progress.setValue 1
+          progress.show
+          progress.raise
+
+          begin
+            $device = Device.new $settings.ssh_username,
+                                 $settings.ssh_password,
+                                 $settings.ssh_host,
+                                 $settings.ssh_port
+          rescue
+
+          end
+          unless $device.nil?
+            unless $device.configured?
+              puts "Y"
+              $log.info "Device not seen before. Opening status page."
+              error = Qt::MessageBox.new self
+              error.setInformativeText("This device has not been configured yet. Opening Status page to verify all required tools are installed on the device.")
+              error.setIcon(Qt::MessageBox::Warning)
+              error.exec
+              @device_status = DeviceStatusDialog.new
+              @device_status.exec
+            end
+
+
+
+
+            @app_details.enable_select_app
+            @device_details.update_device
+            @menu_item_cert.setEnabled(true)
+            @main_tabs.enableDeviceFunctions
+
+          end
+
+          progress.reset
+        }
+        menu_item = @menu_devices.addAction @usb_device
+        @sim_group.addAction @usb_device
+
+
+        x = @menu_devices.addSeparator
+        x.setText("Simulators")
+
+        Simulator.get_simulators.each { |s|
+          action = @menu_devices.addAction s
+          @sim_group.addAction action
+          action.setCheckable(true)
+          action.connect(SIGNAL(:triggered)) { |x|
+            $device = Simulator.new s
+            @app_details.enable_select_app
+            @device_details.update_device
+            @menu_item_cert.setEnabled(true)
+          }
+
+          @menu_devices.addAction action
+        }
+
+
+
+
+      end
+
+
+     def center
+          qdw = Qt::DesktopWidget.new
+
+          screenWidth = qdw.width
+          screenHeight = qdw.height
+
+          x = (screenWidth - $width) / 2
+          y = (screenHeight - $height) / 2
+
+          move x, y
+     end
+
+    def self.run
+      app = Qt::Application.new ARGV
+      app.setWindowIcon(Qt::Icon.new File.join(File.dirname(File.expand_path(__FILE__)), '/gui/images/iphone.ico'))
+
+      app.setApplicationName("idb")
+
+      idb = Idb.new
+      idb.setWindowState Qt::WindowActive
+      idb.showMaximized
+      idb.raise
+      app.exec
+
+      $log.info "Performing cleanup before exiting."
+      $device.close unless $device.nil?
+      $log.info "Thanks for using idb."
+
+    end
+  end
+
+
+end