def delete_profile(self, widget=None, extra=None): if self.deletable: dialog = HIGDialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) alert = HIGEntryLabel('<b>'+_("Deleting Profile")+'</b>') text = HIGEntryLabel(_('Your profile is going to be deleted! Click\ Ok to continue, or Cancel to go back to Profile Editor.')) hbox = HIGHBox() hbox.set_border_width(5) hbox.set_spacing(12) vbox = HIGVBox() vbox.set_border_width(5) vbox.set_spacing(12) image = gtk.Image() image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG) vbox.pack_start(alert) vbox.pack_start(text) hbox.pack_start(image) hbox.pack_start(vbox) dialog.vbox.pack_start(hbox) dialog.vbox.show_all() response = dialog.run() dialog.destroy() if response == gtk.RESPONSE_CANCEL: return True self.profile.remove_profile(self.profile_name) self.update_profile_entry() self.destroy()
def delete_profile(self, widget=None, extra=None): if self.deletable: dialog = HIGDialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) alert = HIGEntryLabel('<b>'+_("Deleting Profile")+'</b>') text = HIGEntryLabel(_('Your profile is going to be deleted! Click\ Ok to continue, or Cancel to go back to Profile Editor.')) hbox = HIGHBox() hbox.set_border_width(5) hbox.set_spacing(12) vbox = HIGVBox() vbox.set_border_width(5) vbox.set_spacing(12) image = gtk.Image() image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG) vbox.pack_start(alert) vbox.pack_start(text) hbox.pack_start(image) hbox.pack_start(vbox) dialog.vbox.pack_start(hbox) dialog.vbox.show_all() response = dialog.run() dialog.destroy() if response == gtk.RESPONSE_CANCEL: return True self.profile.remove_profile(self.profile_name) self.update_profile_entry() self.destroy()
class TopologyPage(HIGVBox): def __init__(self, inventory): HIGVBox.__init__(self) self.set_border_width(6) self.set_spacing(4) self.network_inventory = inventory self._create_widgets() self._pack_widgets() def _create_widgets(self): # The second toolbar: command entry field + buttons self.second_toolbar = HIGHBox() self.rn_hbox = gtk.HBox() self.rn_hbox.set_spacing(4) self.rn_vbox = gtk.VBox() # RadialNet's widgets self.radialnet = RadialNet(LAYOUT_WEIGHTED) self.control = ControlWidget(self.radialnet) self.fisheye = ControlFisheye(self.radialnet) self.rn_toolbar = Toolbar(self.radialnet, self, self.control, self.fisheye) def _pack_widgets(self): self.second_toolbar.pack_start(self.rn_toolbar, False) self.rn_hbox.pack_start(self.radialnet, True, True) self.rn_hbox.pack_start(self.control, False) self.rn_vbox.pack_start(self.rn_hbox, True, True) self.rn_vbox.pack_start(self.fisheye, False) self.pack_start(self.second_toolbar, False, False) self.pack_start(self.rn_vbox, True, True) def add_scan(self, scan): """Parses a given XML file and adds the parsed result to the network inventory.""" self.network_inventory.add_scan(scan) self.update_radialnet() def update_radialnet(self): """Creates a graph from network inventory's host list and displays it.""" graph = make_graph_from_hosts(self.network_inventory.get_hosts()) self.radialnet.set_empty() self.radialnet.set_graph(graph) self.radialnet.show()
def __init__(self, scans_store): HIGVBox.__init__(self) self.set_spacing(4) scans_store.connect("row-changed", self._row_changed) self.scans_list = gtk.TreeView(scans_store) self.scans_list.get_selection().connect( "changed", self._selection_changed) status_col = gtk.TreeViewColumn(_("Status")) cell = gtk.CellRendererText() status_col.pack_start(cell) status_col.set_cell_data_func(cell, status_data_func) self.scans_list.append_column(status_col) command_col = gtk.TreeViewColumn(_("Command")) cell = gtk.CellRendererText() command_col.pack_start(cell) command_col.set_cell_data_func(cell, command_data_func) self.scans_list.append_column(command_col) scrolled_window = HIGScrolledWindow() scrolled_window.set_border_width(0) scrolled_window.add(self.scans_list) self.pack_start(scrolled_window, True, True) hbox = HIGHBox() buttonbox = gtk.HButtonBox() buttonbox.set_layout(gtk.BUTTONBOX_START) buttonbox.set_spacing(4) self.append_button = HIGButton(_("Append Scan"), gtk.STOCK_ADD) buttonbox.pack_start(self.append_button, False) self.remove_button = HIGButton(_("Remove Scan"), gtk.STOCK_REMOVE) buttonbox.pack_start(self.remove_button, False) self.cancel_button = HIGButton(_("Cancel Scan"), gtk.STOCK_CANCEL) buttonbox.pack_start(self.cancel_button, False) hbox.pack_start(buttonbox, padding=4) self.pack_start(hbox, False, padding=4) self._update()
def __init__(self, scans_store): HIGVBox.__init__(self) self.set_spacing(4) scans_store.connect("row-changed", self._row_changed) self.scans_list = gtk.TreeView(scans_store) self.scans_list.get_selection().connect("changed", self._selection_changed) status_col = gtk.TreeViewColumn(_("Status")) cell = gtk.CellRendererText() status_col.pack_start(cell) status_col.set_cell_data_func(cell, status_data_func) self.scans_list.append_column(status_col) command_col = gtk.TreeViewColumn(_("Command")) cell = gtk.CellRendererText() command_col.pack_start(cell) command_col.set_cell_data_func(cell, command_data_func) self.scans_list.append_column(command_col) scrolled_window = HIGScrolledWindow() scrolled_window.set_border_width(0) scrolled_window.add(self.scans_list) self.pack_start(scrolled_window, True, True) hbox = HIGHBox() buttonbox = gtk.HButtonBox() buttonbox.set_layout(gtk.BUTTONBOX_START) buttonbox.set_spacing(4) self.append_button = HIGButton(_("Append Scan"), gtk.STOCK_ADD) buttonbox.pack_start(self.append_button, False) self.remove_button = HIGButton(_("Remove Scan"), gtk.STOCK_REMOVE) buttonbox.pack_start(self.remove_button, False) self.cancel_button = HIGButton(_("Cancel Scan"), gtk.STOCK_CANCEL) buttonbox.pack_start(self.cancel_button, False) hbox.pack_start(buttonbox, padding=4) self.pack_start(hbox, False, padding=4) self._update()
class DiffWindow(gtk.Window): def __init__(self, scans): gtk.Window.__init__(self) self.set_title(_("Compare Results")) self.ndiff_process = None # We allow the user to start a new diff before the old one has # finished. We have to keep references to old processes until they # finish to avoid problems when tearing down the Python interpreter at # program exit. self.old_processes = [] self.timer_id = None self.main_vbox = HIGVBox() self.diff_view = DiffView() self.diff_view.set_size_request(-1, 100) self.hbox_buttons = HIGHBox() self.progress = gtk.ProgressBar() self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.hbox_selection = HIGHBox() self.scan_chooser_a = ScanChooser(scans, _(u"A Scan")) self.scan_chooser_b = ScanChooser(scans, _(u"B Scan")) self._pack_widgets() self._connect_widgets() self.set_default_size(-1, 500) # Initial Size Request self.initial_size = self.get_size() def _pack_widgets(self): self.main_vbox.set_border_width(6) self.hbox_selection.pack_start(self.scan_chooser_a, True, True) self.hbox_selection.pack_start(self.scan_chooser_b, True, True) self.main_vbox.pack_start(self.hbox_selection, False) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(self.diff_view) self.main_vbox.pack_start(scroll, True, True) self.progress.hide() self.progress.set_no_show_all(True) self.hbox_buttons.pack_start(self.progress, False) self.hbox_buttons.pack_end(self.btn_close, False) self.main_vbox._pack_noexpand_nofill(self.hbox_buttons) self.add(self.main_vbox) def _connect_widgets(self): self.connect("delete-event", self.close) self.btn_close.connect("clicked", self.close) self.scan_chooser_a.connect('changed', self.refresh_diff) self.scan_chooser_b.connect('changed', self.refresh_diff) def refresh_diff(self, widget): """This method is called whenever the diff output might have changed, such as when a different scan was selected in one of the choosers.""" log.debug("Refresh diff.") if (self.ndiff_process is not None and self.ndiff_process.poll() is None): # Put this in the list of old processes we keep track of. self.old_processes.append(self.ndiff_process) self.ndiff_process = None scan_a = self.scan_chooser_a.parsed_scan scan_b = self.scan_chooser_b.parsed_scan if scan_a is None or scan_b is None: self.diff_view.clear() else: try: self.ndiff_process = zenmapCore.Diff.ndiff(scan_a, scan_b) except OSError, e: alert = HIGAlertDialog( message_format=_("Error running ndiff"), secondary_text=_( "There was an error running the ndiff program.\n\n" ) + str(e).decode(sys.getdefaultencoding(), "replace")) alert.run() alert.destroy() else:
class DiffWindow(gtk.Window): def __init__(self, scans): gtk.Window.__init__(self) self.set_title(_("Compare Results")) self.ndiff_process = None # We allow the user to start a new diff before the old one has # finished. We have to keep references to old processes until they # finish to avoid problems when tearing down the Python interpreter at # program exit. self.old_processes = [] self.timer_id = None self.main_vbox = HIGVBox() self.diff_view = DiffView() self.diff_view.set_size_request(-1, 100) self.hbox_buttons = HIGHBox() self.progress = gtk.ProgressBar() self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.hbox_selection = HIGHBox() self.scan_chooser_a = ScanChooser(scans, _(u"A Scan")) self.scan_chooser_b = ScanChooser(scans, _(u"B Scan")) self._pack_widgets() self._connect_widgets() self.set_default_size(-1, 500) # Initial Size Request self.initial_size = self.get_size() def _pack_widgets(self): self.main_vbox.set_border_width(6) self.hbox_selection.pack_start(self.scan_chooser_a, True, True) self.hbox_selection.pack_start(self.scan_chooser_b, True, True) self.main_vbox.pack_start(self.hbox_selection, False) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(self.diff_view) self.main_vbox.pack_start(scroll, True, True) self.progress.hide() self.progress.set_no_show_all(True) self.hbox_buttons.pack_start(self.progress, False) self.hbox_buttons.pack_end(self.btn_close, False) self.main_vbox._pack_noexpand_nofill(self.hbox_buttons) self.add(self.main_vbox) def _connect_widgets(self): self.connect("delete-event", self.close) self.btn_close.connect("clicked", self.close) self.scan_chooser_a.connect('changed', self.refresh_diff) self.scan_chooser_b.connect('changed', self.refresh_diff) def refresh_diff(self, widget): """This method is called whenever the diff output might have changed, such as when a different scan was selected in one of the choosers.""" log.debug("Refresh diff.") if (self.ndiff_process is not None and self.ndiff_process.poll() is None): # Put this in the list of old processes we keep track of. self.old_processes.append(self.ndiff_process) self.ndiff_process = None scan_a = self.scan_chooser_a.parsed_scan scan_b = self.scan_chooser_b.parsed_scan if scan_a is None or scan_b is None: self.diff_view.clear() else: try: self.ndiff_process = zenmapCore.Diff.ndiff(scan_a, scan_b) except OSError as e: alert = HIGAlertDialog( message_format=_("Error running ndiff"), secondary_text=_( "There was an error running the ndiff program.\n\n") + str(e).decode(sys.getdefaultencoding(), "replace")) alert.run() alert.destroy() else: self.progress.show() if self.timer_id is None: self.timer_id = gobject.timeout_add( NDIFF_CHECK_TIMEOUT, self.check_ndiff_process) def check_ndiff_process(self): """Check if the ndiff subprocess is done and show the diff if it is. Also remove any finished processes from the old process list.""" # Check if any old background processes have finished. for p in self.old_processes[:]: if p.poll() is not None: p.close() self.old_processes.remove(p) if self.ndiff_process is not None: # We're running the most recent scan. Check if it's done. status = self.ndiff_process.poll() if status is None: # Keep calling this function on a timer until the process # finishes. self.progress.pulse() return True if status == 0 or status == 1: # Successful completion. try: diff = self.ndiff_process.get_scan_diff() except zenmapCore.Diff.NdiffParseException as e: alert = HIGAlertDialog( message_format=_("Error parsing ndiff output"), secondary_text=str(e)) alert.run() alert.destroy() else: self.diff_view.show_diff(diff) else: # Unsuccessful completion. error_text = _( "The ndiff process terminated with status code %d." ) % status stderr = self.ndiff_process.stderr.read() if len(stderr) > 0: error_text += "\n\n" + stderr alert = HIGAlertDialog(message_format=_("Error running ndiff"), secondary_text=error_text) alert.run() alert.destroy() self.progress.hide() self.ndiff_process.close() self.ndiff_process = None if len(self.old_processes) > 0: # Keep calling this callback. return True else: # All done. self.timer_id = None return False def close(self, widget=None, extra=None): self.destroy()
def _exit_cb(self, *args): """Closes the window, prompting for confirmation if necessary. If one of the tabs couldn't be closed, the function returns True and doesn't exit the application.""" if self.scan_interface.changed: log.debug("Found changes on closing window") dialog = HIGDialog( buttons=(_('Close anyway').encode('utf-8'), gtk.RESPONSE_CLOSE, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) alert = HIGEntryLabel('<b>%s</b>' % _("Unsaved changes")) text = HIGEntryLabel(_("The given scan has unsaved changes.\n" "What do you want to do?")) hbox = HIGHBox() hbox.set_border_width(5) hbox.set_spacing(12) vbox = HIGVBox() vbox.set_border_width(5) vbox.set_spacing(12) image = gtk.Image() image.set_from_stock( gtk.STOCK_DIALOG_QUESTION, gtk.ICON_SIZE_DIALOG) vbox.pack_start(alert) vbox.pack_start(text) hbox.pack_start(image) hbox.pack_start(vbox) dialog.vbox.pack_start(hbox) dialog.vbox.show_all() response = dialog.run() dialog.destroy() if response == gtk.RESPONSE_CANCEL: return True search_config = SearchConfig() if search_config.store_results: self.store_result(self.scan_interface) elif self.scan_interface.num_scans_running() > 0: log.debug("Trying to close a window with a running scan") dialog = HIGDialog( buttons=(_('Close anyway').encode('utf-8'), gtk.RESPONSE_CLOSE, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) alert = HIGEntryLabel('<b>%s</b>' % _("Trying to close")) text = HIGEntryLabel(_( "The window you are trying to close has a scan running in " "the background.\nWhat do you want to do?")) hbox = HIGHBox() hbox.set_border_width(5) hbox.set_spacing(12) vbox = HIGVBox() vbox.set_border_width(5) vbox.set_spacing(12) image = gtk.Image() image.set_from_stock( gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG) vbox.pack_start(alert) vbox.pack_start(text) hbox.pack_start(image) hbox.pack_start(vbox) dialog.vbox.pack_start(hbox) dialog.vbox.show_all() response = dialog.run() dialog.destroy() if response == gtk.RESPONSE_CLOSE: self.scan_interface.kill_all_scans() elif response == gtk.RESPONSE_CANCEL: return True window = WindowConfig() window.x, window.y = self.get_position() window.width, window.height = self.get_size() window.save_changes() if config_parser.failed: alert = HIGAlertDialog( message_format=_("Can't save Zenmap configuration"), # newline before path to help avoid weird line wrapping secondary_text=_( 'An error occurred when saving to\n%s' '\nThe error was: %s.' ) % (Path.user_config_file, config_parser.failed)) alert.run() alert.destroy() self.destroy() return False
class DiffWindow(gtk.Window): def __init__(self, scans): gtk.Window.__init__(self) self.set_title(_("Compare Results")) self.ndiff_process = None # We allow the user to start a new diff before the old one has # finished. We have to keep references to old processes until they # finish to avoid problems when tearing down the Python interpreter at # program exit. self.old_processes = [] self.timer_id = None self.main_vbox = HIGVBox() self.diff_view = DiffView() self.diff_view.set_size_request(-1, 100) self.hbox_buttons = HIGHBox() self.progress = gtk.ProgressBar() self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.hbox_selection = HIGHBox() self.scan_chooser_a = ScanChooser(scans, _(u"A Scan")) self.scan_chooser_b = ScanChooser(scans, _(u"B Scan")) self._pack_widgets() self._connect_widgets() self.set_default_size(-1, 500) # Initial Size Request self.initial_size = self.get_size() def _pack_widgets(self): self.main_vbox.set_border_width(6) self.hbox_selection.pack_start(self.scan_chooser_a, True, True) self.hbox_selection.pack_start(self.scan_chooser_b, True, True) self.main_vbox.pack_start(self.hbox_selection, False) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(self.diff_view) self.main_vbox.pack_start(scroll, True, True) self.progress.hide() self.progress.set_no_show_all(True) self.hbox_buttons.pack_start(self.progress, False) self.hbox_buttons.pack_end(self.btn_close, False) self.main_vbox._pack_noexpand_nofill(self.hbox_buttons) self.add(self.main_vbox) def _connect_widgets(self): self.connect("delete-event", self.close) self.btn_close.connect("clicked", self.close) self.scan_chooser_a.connect('changed', self.refresh_diff) self.scan_chooser_b.connect('changed', self.refresh_diff) def refresh_diff(self, widget): """This method is called whenever the diff output might have changed, such as when a different scan was selected in one of the choosers.""" log.debug("Refresh diff.") if (self.ndiff_process is not None and self.ndiff_process.poll() is None): # Put this in the list of old processes we keep track of. self.old_processes.append(self.ndiff_process) self.ndiff_process = None scan_a = self.scan_chooser_a.parsed_scan scan_b = self.scan_chooser_b.parsed_scan if scan_a is None or scan_b is None: self.diff_view.clear() else: try: self.ndiff_process = zenmapCore.Diff.ndiff(scan_a, scan_b) except OSError, e: alert = HIGAlertDialog( message_format=_("Error running ndiff"), secondary_text=_( "There was an error running the ndiff program.\n\n") + str(e).decode(sys.getdefaultencoding(), "replace")) alert.run() alert.destroy() else:
class SearchGUI(gtk.VBox, object): """This class is a VBox that holds the search entry field and buttons on top, and the results list on the bottom. The "Cancel" and "Open" buttons are a part of the SearchWindow class, not SearchGUI.""" def __init__(self, search_window): gtk.VBox.__init__(self) self._create_widgets() self._pack_widgets() self._connect_events() # Search options self.options = {} self.options["file_extension"] = search_config.file_extension self.options["directory"] = search_config.directory self.options["search_db"] = search_config.search_db self.parsed_results = {} self._set_result_view() self.id = 0 self.search_window = search_window # The Search* objects are created once per Search Window invocation, so that # they get a list of scans only once, not whenever the search conditions change if self.options["search_db"]: self.search_db = SearchDB() # Search directories can be added via the "dir:" operator, so it needs to be a map self.search_dirs = {} self.init_search_dirs() # We create an empty search dictionary, since SearchParser will fill it # with keywords as it encounters different operators in the search string. self.search_dict = dict() self.search_parser = SearchParser(self) # This list holds the (operator, argument) tuples, parsed from the GUI criteria rows self.gui_criteria_list = [] # Do an initial "empty" search, so that the results window initially holds # all scans in the database self.search_parser.update("") self.start_search() def init_search_dirs(self, dirs=[]): # Start fresh self.search_dirs.clear() # If specified, add the search directory from the Zenmap config file to the map conf_dir = self.options["directory"] if conf_dir: self.search_dirs[conf_dir] = SearchDir( conf_dir, self.options["file_extension"]) # Process any other dirs (as added by the dir: operator) for dir in dirs: self.search_dirs[dir] = SearchDir(dir, self.options["file_extension"]) def _create_widgets(self): # Search box and buttons self.search_top_hbox = HIGHBox() self.search_label = HIGSectionLabel(_("Search:")) self.search_entry = gtk.Entry() self.expressions_btn = HIGToggleButton(_("Expressions "), gtk.STOCK_EDIT) # The quick reference tooltip button self.search_tooltip_btn = HIGButton(" ", gtk.STOCK_INFO) # The expression VBox. This is only visible once the user clicks on "Expressions" self.expr_vbox = gtk.VBox() # Results section self.result_list = gtk.ListStore(str, str, int) # title, date, id self.result_view = gtk.TreeView(self.result_list) self.result_scrolled = gtk.ScrolledWindow() self.result_title_column = gtk.TreeViewColumn(_("Scan")) self.result_date_column = gtk.TreeViewColumn(_("Date")) self.expr_window = None def _pack_widgets(self): # Packing label, search box and buttons self.search_top_hbox.set_spacing(4) self.search_top_hbox.pack_start(self.search_label, False) self.search_top_hbox.pack_start(self.search_entry, True) self.search_top_hbox.pack_start(self.expressions_btn, False) self.search_top_hbox.pack_start(self.search_tooltip_btn, False) # The expressions (if any) should be tightly packed so that they don't take # too much screen real-estate self.expr_vbox.set_spacing(0) # Packing the result section self.result_scrolled.add(self.result_view) self.result_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) # Packing it all together self.set_spacing(4) self.pack_start(self.search_top_hbox, False) self.pack_start(self.expr_vbox, False) self.pack_start(self.result_scrolled, True) def _connect_events(self): self.search_entry.connect("changed", self.update_search_entry) self.search_tooltip_btn.connect("clicked", self.show_quick_help) self.expressions_btn.connect("toggled", self.expressions_clicked) def show_quick_help(self, widget=None, extra=None): quick_help = """Entering the text into the search performs a <b>keyword search</b> - \ the search string is matched against the entire output of each scan. To refine the search, you can use <b>operators</b> to search only within a specific part of \ a scan. Operators can be added to the search interactively if you click on the \ <b>Expressions</b> button, or you can enter them manually into the search field. \ You can also use <b>operator aliases</b> if you're an experienced user who likes to \ type in his searches quickly. <b>profile: (pr:)</b> - Profile used. <b>target: (t:)</b> - User-supplied target, or a rDNS result. <b>option: (o:)</b> - Scan options. <b>date: (d:)</b> - The date when scan was performed. Fuzzy matching is possible using the \ "~" suffix. Each "~" broadens the search by one day on "each side" of the date. In addition, \ it is possible to use the \"date:-n\" notation which means "n days ago". <b>after: (a:)</b> - Matches scans made after the supplied date (<i>YYYY-MM-DD</i> or <i>-n</i>). <b>before (b:)</b> - Matches scans made before the supplied date(<i>YYYY-MM-DD</i> or <i>-n</i>). <b>os:</b> - All OS-related fields. <b>scanned: (sp:)</b> - Matches a port if it was among those scanned. <b>open: (op:)</b> - Open ports discovered in a scan. <b>closed: (cp:)</b> - Closed ports discovered in a scan. <b>filtered: (fp:)</b> - Filtered ports discovered in scan. <b>unfiltered: (ufp:)</b> - Unfiltered ports found in a scan (using, for example, an ACK scan). <b>open|filtered: (ofp:)</b> - Ports in the \"open|filtered\" state. <b>closed|filtered: (cfp:)</b> - Ports in the \"closed|filtered\" state. <b>service: (s:)</b> - All service-related fields. <b>inroute: (ir:)</b> - Matches a router in the scan's traceroute output. """ hint_window = HintWindow(quick_help) hint_window.show_all() def expressions_clicked(self, widget=None, extra=None): if len(self.expr_vbox.get_children() ) == 0 and self.search_entry.get_text() == "": # This is the first time the user has clicked on "Show Expressions" # and the search entry box is empty, so we add a single Criterion row self.expr_vbox.pack_start(Criterion(self)) if self.expressions_btn.get_active(): # The Expressions GUI is about to be displayed. It needs to reflect all the # conditions in the search entry field, so a comparison between the entry field # and the GUI needs to be performed. # Make the search entry field insensitive while expressions are visible self.search_entry.set_sensitive(False) # Get a map of operator => argument from the Expressions GUI so that # we can compare them with the ones in the search entry field gui_ops = {} for criterion in self.expr_vbox.get_children(): if criterion.operator in gui_ops: gui_ops[criterion.operator].append(criterion.argument) else: gui_ops[criterion.operator] = [criterion.argument] # We compare the search entry field to the Expressions GUI. Every # (operator, value) pair must be present in the GUI after this loop is done. for op, args in self.search_dict.iteritems(): for arg in args: if (op not in gui_ops) or (arg not in gui_ops[op]): # We need to add this pair to the GUI self.expr_vbox.pack_start(Criterion(self, op, arg), False) # Now we check if there are any leftover criterion rows that aren't present # in the search_dict (for example, if a user has deleted something from the # search entry field) for criterion in self.expr_vbox.get_children(): if criterion.operator not in self.search_dict or \ criterion.argument not in self.search_dict[criterion.operator]: criterion.destroy() # If we have deleted all rows, add an empty one if len(self.expr_vbox.get_children()) == 0: self.expr_vbox.pack_start(Criterion(self)) # Display all elements self.expr_vbox.show_all() else: # The Expressions GUI is about to be hidden. No updates to the search entry field # are necessary, since it gets updated on every change in one of the criterion rows. self.expr_vbox.hide_all() self.search_entry.set_sensitive(True) def close(self): if self.expr_window != None: self.expr_window.close() def add_criterion(self, caller): # We need to find where the caller (Criteria object) is located among # all the rows, so that we can insert the new row after it caller_index = self.expr_vbox.get_children().index(caller) # Make a new Criteria row and insert it after the calling row criteria = Criterion(self, "keyword") self.expr_vbox.pack_start(criteria, False) self.expr_vbox.reorder_child(criteria, caller_index + 1) criteria.show_all() def remove_criterion(self, c): if len(self.expr_vbox.get_children()) > 1: c.destroy() self.criterion_changed() def criterion_changed(self): # We go through all criteria rows and make a new search string search_string = "" for criterion in self.expr_vbox.get_children(): if criterion.operator != "keyword": search_string += criterion.operator + ":" search_string += criterion.argument.replace(" ", "") + " " self.search_entry.set_text(search_string.strip()) self.search_parser.update(self.search_entry.get_text()) self.start_search() def add_search_dir(self, dir): if dir not in self.search_dirs: self.search_dirs[dir] = SearchDir(dir, self.options["file_extension"]) def update_search_entry(self, widget, extra=None): """Called when the search entry field is modified.""" self.search_parser.update(widget.get_text()) self.start_search() def start_search(self): if not self.options["search_db"] and not self.options["directory"]: d = HIGAlertDialog( message_format=_("No search method selected!"), secondary_text=_("%s can search results on directories or \ inside it's own database. Please, select a method by choosing a directory or by checking \ the search data base option at the 'Search options' tab before start the search" % APP_DISPLAY_NAME)) d.run() d.destroy() return self.clear_result_list() matched = 0 total = 0 if self.options["search_db"]: total += len(self.search_db.get_scan_results()) for result in self.search_db.search(**self.search_dict): self.append_result(result) matched += 1 for search_dir in self.search_dirs.itervalues(): total += len(search_dir.get_scan_results()) for result in search_dir.search(**self.search_dict): self.append_result(result) matched += 1 #total += len(self.search_tabs.get_scan_results()) #for result in self.search_tabs.search(**self.search_dict): # self.append_result(result) # matched += 1 self.search_window.set_label_text("Matched <b>%s</b> out of <b>%s</b> scans." % \ (str(matched), str(total))) def clear_result_list(self): for i in range(len(self.result_list)): iter = self.result_list.get_iter_root() del (self.result_list[iter]) def append_result(self, parsed_result): title = "" if parsed_result.scan_name: title = parsed_result.scan_name elif parsed_result.filename: title = os.path.split(parsed_result.filename)[-1] elif parsed_result.profile_name and parsed_result.target: title = "%s on %s" % (parsed_result.profile_name, parsed_result.target) else: title = parsed_result.get_nmap_command() try: date = localtime(float(parsed_result.start)) #date_field = "%02d %s %04d" % (date[2], months[date[1]][:3], date[0]) date_field = "%04d-%02d-%02d %02d:%02d" % ( date[0], date[1], date[2], date[3], date[4]) except ValueError: date_field = _("Unknown") self.parsed_results[self.id] = [title, parsed_result] self.result_list.append([title, date_field, self.id]) self.id += 1 def get_selected_results(self): selection = self.result_view.get_selection() rows = selection.get_selected_rows() list_store = rows[0] results = {} for row in rows[1]: r = row[0] results[list_store[r][2]] = self.parsed_results[list_store[r][2]] return results def _set_result_view(self): self.result_view.set_enable_search(True) self.result_view.set_search_column(0) selection = self.result_view.get_selection() selection.set_mode(gtk.SELECTION_MULTIPLE) self.result_view.append_column(self.result_title_column) self.result_view.append_column(self.result_date_column) self.result_title_column.set_resizable(True) self.result_title_column.set_min_width(200) self.result_date_column.set_resizable(True) self.result_title_column.set_sort_column_id(0) self.result_date_column.set_sort_column_id(1) self.result_title_column.set_reorderable(True) self.result_date_column.set_reorderable(True) cell = gtk.CellRendererText() self.result_title_column.pack_start(cell, True) self.result_date_column.pack_start(cell, True) self.result_title_column.set_attributes(cell, text=0) self.result_date_column.set_attributes(cell, text=1) selected_results = property(get_selected_results)
class ScriptInterface: # Timeout, in milliseconds, after the user stops typing and we update the # interface from --script. SCRIPT_LIST_DELAY = 500 # Timeout, in milliseconds, between polls of the Nmap subprocess. NMAP_DELAY = 200 def __init__(self, root_tabs, ops, update_command, help_buf): self.hmainbox = HIGHBox(False, 0) self.notscripttab = False # show profile editor it is a script tab self.nmap_process = None self.script_list_timeout_id = None self.nmap_timeout_id = None self.chk_nmap_timeout_id = None self.script_file_chooser = None self.ops = ops self.update_command = update_command self.help_buf = help_buf self.arg_values = {} self.current_arguments = [] self.set_help_texts() self.prev_script_spec = None self.focusedentry = None self.liststore = gtk.ListStore(str, "gboolean", object) self.file_liststore = gtk.ListStore(str, "gboolean") # Arg name, arg value, (name, desc) tuple. self.arg_liststore = gtk.ListStore(str, str, object) # This is what is shown initially. After the initial Nmap run to get # the list of script is finished, this will be replaced with a TreeView # showing the scripts or an error message. self.script_list_container = gtk.VBox() self.script_list_container.pack_start(self.make_please_wait_widget()) self.hmainbox.pack_start(self.script_list_container, False, False, 0) self.nmap_error_widget = gtk.Label( _("There was an error getting the list of scripts from Nmap. " "Try upgrading Nmap.")) self.nmap_error_widget.set_line_wrap(True) self.nmap_error_widget.show_all() self.script_list_widget = self.make_script_list_widget() self.script_list_widget.show_all() vbox = HIGVBox(False, 5) vbox.pack_start(self.make_description_widget(), True, True, 0) vbox.pack_start(self.make_arguments_widget(), True, True, 0) self.hmainbox.pack_end(vbox, True, True, 0) self.update_argument_values(self.ops["--script-args"]) # Start the initial backgrounded Nmap run to get the list of all # available scripts. self.get_script_list("all", self.initial_script_list_cb) def get_script_list(self, rules, callback): """Start an Nmap subprocess in the background with "--script-help=<rules> -oX -", and set it up to call the given callback when finished.""" ops = NmapOptions() ops.executable = paths_config.nmap_command_path ops["--script-help"] = rules ops["-oX"] = "-" command_string = ops.render_string() # Separate stderr to avoid breaking XML parsing with "Warning: File # ./nse_main.lua exists, but Nmap is using...". stderr = tempfile.TemporaryFile(mode="rb", prefix=APP_NAME + "-script-help-stderr-") log.debug("Script interface: running %s" % repr(command_string)) nmap_process = NmapCommand(command_string) try: nmap_process.run_scan(stderr=stderr) except Exception as e: callback(False, None) stderr.close() return stderr.close() self.script_list_widget.set_sensitive(False) gobject.timeout_add(self.NMAP_DELAY, self.script_list_timer_callback, nmap_process, callback) def script_list_timer_callback(self, process, callback): try: status = process.scan_state() except Exception: status = None log.debug("Script interface: script_list_timer_callback %s" % repr(status)) if status is True: # Still running, schedule this timer to check again. return True self.script_list_widget.set_sensitive(True) if status is False: # Finished with success. callback(True, process) else: # Finished with error. callback(False, process) def initial_script_list_cb(self, status, process): log.debug("Script interface: initial_script_list_cb %s" % repr(status)) for child in self.script_list_container.get_children(): self.script_list_container.remove(child) if status and self.handle_initial_script_list_output(process): self.script_list_container.pack_start(self.script_list_widget) else: self.script_list_container.pack_start(self.nmap_error_widget) def handle_initial_script_list_output(self, process): process.stdout_file.seek(0) try: handler = ScriptHelpXMLContentHandler.parse_nmap_script_help( process.stdout_file) except (ValueError, xml.sax.SAXParseException) as e: log.debug("--script-help parse exception: %s" % str(e)) return False # Check if any scripts were output; if not, Nmap is probably too old. if len(handler.script_filenames) == 0: return False if not handler.scripts_dir: log.debug("--script-help error: no scripts directory") return False if not handler.nselib_dir: log.debug("--script-help error: no nselib directory") return False log.debug("Script interface: scripts dir %s" % repr(handler.scripts_dir)) log.debug("Script interface: nselib dir %s" % repr(handler.nselib_dir)) # Make a dict of script metadata entries. entries = {} for entry in get_script_entries(handler.scripts_dir, handler.nselib_dir): entries[entry.filename] = entry self.liststore.clear() for filename in handler.script_filenames: basename = os.path.basename(filename) entry = entries.get(basename) if entry: script_id = self.strip_file_name(basename) self.liststore.append([script_id, False, entry]) else: # ScriptMetadata found nothing for this script? self.file_liststore.append([filename, False]) # Now figure out which scripts are selected. self.update_script_list_from_spec(self.ops["--script"]) return True def update_script_list_from_spec(self, spec): """Callback method for user edit delay.""" log.debug("Script interface: update_script_list_from_spec %s" % repr(spec)) if spec: self.get_script_list(spec, self.update_script_list_cb) else: self.refresh_list_scripts([]) def update_script_list_cb(self, status, process): log.debug("Script interface: update_script_list_cb %s" % repr(status)) if status: self.handle_update_script_list_output(process) else: self.refresh_list_scripts([]) def handle_update_script_list_output(self, process): process.stdout_file.seek(0) try: handler = ScriptHelpXMLContentHandler.parse_nmap_script_help( process.stdout_file) except (ValueError, xml.sax.SAXParseException) as e: log.debug("--script-help parse exception: %s" % str(e)) return False self.refresh_list_scripts(handler.script_filenames) def get_hmain_box(self): """Returns main Hbox to ProfileEditor.""" return self.hmainbox def update(self): """Updates the interface when the command entry is changed.""" # updates list of scripts rules = self.ops["--script"] if (self.prev_script_spec != rules): self.renew_script_list_timer(rules) self.prev_script_spec = rules # updates arguments.. raw_argument = self.ops["--script-args"] if raw_argument is not None: self.parse_script_args(raw_argument) self.arg_liststore.clear() for arg in self.current_arguments: arg_name, arg_desc = arg value = self.arg_values.get(arg_name) if not value: self.arg_liststore.append([arg_name, None, arg]) else: self.arg_liststore.append([arg_name, value, arg]) def renew_script_list_timer(self, spec): """Restart the timer to update the script list when the user edits the command. Because updating the script list is an expensive operation involving the creation of a subprocess, we don't do it for every typed character.""" if self.script_list_timeout_id: gobject.source_remove(self.script_list_timeout_id) self.script_list_timeout_id = gobject.timeout_add( self.SCRIPT_LIST_DELAY, self.update_script_list_from_spec, spec) def parse_script_args(self, raw_argument): """When the command line is edited, this function is called to update the script arguments display according to the value of --script-args.""" arg_dict = parse_script_args_dict(raw_argument) if arg_dict is None: # if there is parsing error args_dict holds none self.arg_values.clear() else: self.arg_values.update(arg_dict) def update_argument_values(self, raw_argument): """When scripting tab starts up, argument values are updated.""" if raw_argument is not None: self.parse_script_args(raw_argument) def set_help_texts(self): """Sets the help texts to be displayed.""" self.list_scripts_help = _("""List of scripts A list of all installed scripts. Activate or deactivate a script \ by clicking the box next to the script name.""") self.description_help = _("""Description This box shows the categories a script belongs to. In addition, it gives a \ detailed description of the script which is present in script. A URL points \ to online NSEDoc documentation.""") self.argument_help = _("""Arguments A list of arguments that affect the selected script. Enter a value by \ clicking in the value field beside the argument name.""") def make_please_wait_widget(self): vbox = gtk.VBox() label = gtk.Label(_("Please wait.")) label.set_line_wrap(True) vbox.pack_start(label) return vbox def make_script_list_widget(self): """Creates and packs widgets associated with left hand side of Interface.""" vbox = gtk.VBox() scrolled_window = HIGScrolledWindow() scrolled_window.set_policy(gtk.POLICY_ALWAYS, gtk.POLICY_ALWAYS) # Expand only vertically. scrolled_window.set_size_request(175, -1) listview = gtk.TreeView(self.liststore) listview.set_headers_visible(False) listview.connect("enter-notify-event", self.update_help_ls_cb) selection = listview.get_selection() selection.connect("changed", self.selection_changed_cb) cell = gtk.CellRendererText() togglecell = gtk.CellRendererToggle() togglecell.set_property("activatable", True) togglecell.connect("toggled", self.toggled_cb, self.liststore) col = gtk.TreeViewColumn(_('Names')) col.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY) col.set_resizable(True) togglecol = gtk.TreeViewColumn(None, togglecell) togglecol.add_attribute(togglecell, "active", 1) listview.append_column(togglecol) listview.append_column(col) col.pack_start(cell, True) col.add_attribute(cell, "text", 0) scrolled_window.add(listview) scrolled_window.show() vbox.pack_start(scrolled_window, True, True, 0) self.file_scrolled_window = HIGScrolledWindow() self.file_scrolled_window.set_policy(gtk.POLICY_ALWAYS, gtk.POLICY_ALWAYS) self.file_scrolled_window.set_size_request(175, -1) self.file_scrolled_window.hide() self.file_scrolled_window.set_no_show_all(True) self.file_listview = gtk.TreeView(self.file_liststore) self.file_listview.set_headers_visible(False) col = gtk.TreeViewColumn(None) self.file_listview.append_column(col) cell = gtk.CellRendererToggle() col.pack_start(cell, True) cell.set_property("activatable", True) col.add_attribute(cell, "active", 1) cell.connect("toggled", self.toggled_cb, self.file_liststore) col = gtk.TreeViewColumn(None) self.file_listview.append_column(col) cell = gtk.CellRendererText() col.pack_start(cell) col.add_attribute(cell, "text", 0) self.file_listview.show_all() self.file_scrolled_window.add(self.file_listview) vbox.pack_start(self.file_scrolled_window, False) hbox = HIGHBox(False, 2) self.remove_file_button = HIGButton(stock=gtk.STOCK_REMOVE) self.remove_file_button.connect("clicked", self.remove_file_button_clicked_cb) self.remove_file_button.set_sensitive(False) hbox.pack_end(self.remove_file_button) add_file_button = HIGButton(stock=gtk.STOCK_ADD) add_file_button.connect("clicked", self.add_file_button_clicked_cb) hbox.pack_end(add_file_button) vbox.pack_start(hbox, False, False, 0) return vbox def refresh_list_scripts(self, selected_scripts): """The list of selected scripts is refreshed in the list store.""" for row in self.liststore: row[1] = False for row in self.file_liststore: row[1] = False for filename in selected_scripts: for row in self.liststore: if row[0] == self.strip_file_name(os.path.basename(filename)): row[1] = True break else: for row in self.file_liststore: if row[0] == filename: row[1] = True break else: self.file_liststore.append([filename, True]) def strip_file_name(self, filename): """Removes a ".nse" extension from filename if present.""" if (filename.endswith(".nse")): return filename[:-4] else: return filename def set_script_from_selection(self): scriptsname = [] for entry in self.liststore: if entry[1]: scriptsname.append(self.strip_file_name(entry[0])) for entry in self.file_liststore: if entry[1]: scriptsname.append(entry[0]) if len(scriptsname) == 0: self.ops["--script"] = None else: self.ops["--script"] = ",".join(scriptsname) self.update_command() def toggled_cb(self, cell, path, model): """Callback method, called when the check box in list of scripts is toggled.""" model[path][1] = not model[path][1] self.set_script_from_selection() def make_description_widget(self): """Creates and packs widgets related to displaying the description box.""" sw = HIGScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) sw.set_shadow_type(gtk.SHADOW_OUT) sw.set_border_width(5) text_view = gtk.TextView() text_view.connect("enter-notify-event", self.update_help_desc_cb) self.text_buffer = text_view.get_buffer() self.text_buffer.create_tag("Usage", font="Monospace") self.text_buffer.create_tag("Output", font="Monospace") text_view.set_wrap_mode(gtk.WRAP_WORD) text_view.set_editable(False) text_view.set_justification(gtk.JUSTIFY_LEFT) sw.add(text_view) return sw def make_arguments_widget(self): """Creates and packs widgets related to arguments box.""" vbox = gtk.VBox() vbox.pack_start(gtk.Label(_("Arguments")), False, False, 0) arg_window = HIGScrolledWindow() arg_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) arg_window.set_shadow_type(gtk.SHADOW_OUT) arg_listview = gtk.TreeView(self.arg_liststore) arg_listview.connect("motion-notify-event", self.update_help_arg_cb) argument = gtk.CellRendererText() self.value = gtk.CellRendererText() self.value.connect("edited", self.value_edited_cb, self.arg_liststore) arg_col = gtk.TreeViewColumn("Arguments\t") val_col = gtk.TreeViewColumn("values") arg_listview.append_column(arg_col) arg_listview.append_column(val_col) arg_col.pack_start(argument, True) arg_col.add_attribute(argument, "text", 0) val_col.pack_start(self.value, True) val_col.add_attribute(self.value, "text", 1) arg_window.add(arg_listview) vbox.pack_start(arg_window, True, True, 0) return vbox def value_edited_cb(self, cell, path, new_text, model): """Called when the argument cell is edited.""" self.arg_list = [] model[path][1] = new_text argument_name = model[path][0] self.arg_values[argument_name] = new_text self.update_arg_values() def update_arg_values(self): """When the widget is updated with argument value, correspondingly update the command line.""" for key in self.arg_values: if len(self.arg_values[key]) == 0: del self.arg_values[key] else: self.arg_list.append(key + "=" + self.arg_values[key]) if len(self.arg_list) == 0: self.ops["--script-args"] = None self.arg_values.clear() else: self.ops["--script-args"] = ",".join(self.arg_list) self.update_command() def selection_changed_cb(self, selection): """Called back when the list of scripts is selected.""" model, selection = selection.get_selected_rows() for path in selection: entry = model.get_value(model.get_iter(path), 2) self.set_description(entry) self.populate_arg_list(entry) # Remember the currently pointing script entry self.focusedentry = entry def update_help_ls_cb(self, widget, extra): # list of scripts """Callback method to display the help for the list of scripts.""" self.help_buf.set_text(self.list_scripts_help) def update_help_desc_cb(self, widget, extra): """Callback method for displaying description.""" self.help_buf.set_text(self.description_help) def update_help_arg_cb(self, treeview, event): """Callback method for displaying argument help.""" wx, wy = treeview.get_pointer() try: x, y = treeview.convert_widget_to_bin_window_coords(wx, wy) except AttributeError: # convert_widget_to_bin_window_coords was introduced in PyGTK 2.12. return path = treeview.get_path_at_pos(x, y) if not path or not self.focusedentry: self.help_buf.set_text("") return path = path[0] model, selected = treeview.get_selection().get_selected() arg_name, arg_desc = model.get_value(model.get_iter(path), 2) if arg_desc is not None: self.help_buf.set_text("") self.help_buf.insert(self.help_buf.get_end_iter(), text="%s\n" % arg_name) text_buffer_insert_nsedoc(self.help_buf, arg_desc) else: self.help_buf.set_text("") def add_file_button_clicked_cb(self, button): if self.script_file_chooser is None: self.script_file_chooser = \ zenmapGUI.FileChoosers.ScriptFileChooserDialog( title=_("Select script files")) response = self.script_file_chooser.run() filenames = self.script_file_chooser.get_filenames() self.script_file_chooser.hide() if response != gtk.RESPONSE_OK: return for filename in filenames: self.file_liststore.append([filename, True]) if len(self.file_liststore) > 0: self.file_scrolled_window.show() self.remove_file_button.set_sensitive(True) self.set_script_from_selection() def remove_file_button_clicked_cb(self, button): selection = self.file_listview.get_selection() model, selection = selection.get_selected_rows() for path in selection: self.file_liststore.remove(model.get_iter(path)) if len(self.file_liststore) == 0: self.file_scrolled_window.hide() self.remove_file_button.set_sensitive(False) self.set_script_from_selection() def set_description(self, entry): """Sets the content that is to be displayed in the description box.""" self.text_buffer.set_text(u"") self.text_buffer.insert( self.text_buffer.get_end_iter(), """\ Categories: %(cats)s """ % {"cats": ", ".join(entry.categories)}) text_buffer_insert_nsedoc(self.text_buffer, entry.description) if entry.usage: self.text_buffer.insert(self.text_buffer.get_end_iter(), "\nUsage\n") self.text_buffer.insert_with_tags_by_name( self.text_buffer.get_end_iter(), entry.usage, "Usage") if entry.output: self.text_buffer.insert(self.text_buffer.get_end_iter(), "\nOutput\n") self.text_buffer.insert_with_tags_by_name( self.text_buffer.get_end_iter(), entry.output, "Output") if entry.url: self.text_buffer.insert(self.text_buffer.get_end_iter(), "\n" + entry.url) def populate_arg_list(self, entry): """Called when a particular script is hovered over to display its arguments and values (if any).""" self.arg_liststore.clear() self.current_arguments = [] self.value.set_property('editable', True) for arg in entry.arguments: arg_name, arg_desc = arg self.current_arguments.append(arg) value = self.arg_values.get(arg_name) if not value: self.arg_liststore.append([arg_name, None, arg]) else: self.arg_liststore.append([arg_name, value, arg])
class DiffWindow(gtk.Window): def __init__(self, scans): gtk.Window.__init__(self) self.set_title(_("Compare Results")) self.ndiff_process = None # We allow the user to start a new diff before the old one has # finished. We have to keep references to old processes until they # finish to avoid problems when tearing down the Python interpreter at # program exit. self.old_processes = [] self.timer_id = None self.main_vbox = HIGVBox() self.diff_view = DiffView() self.diff_view.set_size_request(-1, 100) self.hbox_buttons = HIGHBox() self.progress = gtk.ProgressBar() self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.hbox_selection = HIGHBox() self.scan_chooser_a = ScanChooser(scans, _(u"A Scan")) self.scan_chooser_b = ScanChooser(scans, _(u"B Scan")) self._pack_widgets() self._connect_widgets() self.set_default_size(-1, 500) # Initial Size Request self.initial_size = self.get_size() def _pack_widgets(self): self.main_vbox.set_border_width(6) self.hbox_selection.pack_start(self.scan_chooser_a, True, True) self.hbox_selection.pack_start(self.scan_chooser_b, True, True) self.main_vbox.pack_start(self.hbox_selection, False) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(self.diff_view) self.main_vbox.pack_start(scroll, True, True) self.progress.hide() self.progress.set_no_show_all(True) self.hbox_buttons.pack_start(self.progress, False) self.hbox_buttons.pack_end(self.btn_close, False) self.main_vbox._pack_noexpand_nofill(self.hbox_buttons) self.add(self.main_vbox) def _connect_widgets(self): self.connect("delete-event", self.close) self.btn_close.connect("clicked", self.close) self.scan_chooser_a.connect('changed', self.refresh_diff) self.scan_chooser_b.connect('changed', self.refresh_diff) def refresh_diff(self, widget): """This method is called whenever the diff output might have changed, such as when a different scan was selected in one of the choosers.""" log.debug("Refresh diff.") if (self.ndiff_process is not None and self.ndiff_process.poll() is None): # Put this in the list of old processes we keep track of. self.old_processes.append(self.ndiff_process) self.ndiff_process = None scan_a = self.scan_chooser_a.parsed_scan scan_b = self.scan_chooser_b.parsed_scan if scan_a is None or scan_b is None: self.diff_view.clear() else: try: self.ndiff_process = zenmapCore.Diff.ndiff(scan_a, scan_b) except OSError as e: alert = HIGAlertDialog( message_format=_("Error running ndiff"), secondary_text=_( "There was an error running the ndiff program.\n\n" ) + str(e).decode(sys.getdefaultencoding(), "replace")) alert.run() alert.destroy() else: self.progress.show() if self.timer_id is None: self.timer_id = gobject.timeout_add( NDIFF_CHECK_TIMEOUT, self.check_ndiff_process) def check_ndiff_process(self): """Check if the ndiff subprocess is done and show the diff if it is. Also remove any finished processes from the old process list.""" # Check if any old background processes have finished. for p in self.old_processes[:]: if p.poll() is not None: p.close() self.old_processes.remove(p) if self.ndiff_process is not None: # We're running the most recent scan. Check if it's done. status = self.ndiff_process.poll() if status is None: # Keep calling this function on a timer until the process # finishes. self.progress.pulse() return True if status == 0 or status == 1: # Successful completion. try: diff = self.ndiff_process.get_scan_diff() except zenmapCore.Diff.NdiffParseException as e: alert = HIGAlertDialog( message_format=_("Error parsing ndiff output"), secondary_text=str(e)) alert.run() alert.destroy() else: self.diff_view.show_diff(diff) else: # Unsuccessful completion. error_text = _( "The ndiff process terminated with status code %d." ) % status stderr = self.ndiff_process.stderr.read() if len(stderr) > 0: error_text += "\n\n" + stderr alert = HIGAlertDialog( message_format=_("Error running ndiff"), secondary_text=error_text) alert.run() alert.destroy() self.progress.hide() self.ndiff_process.close() self.ndiff_process = None if len(self.old_processes) > 0: # Keep calling this callback. return True else: # All done. self.timer_id = None return False def close(self, widget=None, extra=None): self.destroy()
class DiffWindow(gtk.Window): def __init__(self, scans): """scans in the format: {"scan_title":parsed_scan} """ gtk.Window.__init__(self) self.set_title(_("Compare Results")) self.scans = scans self.umit_conf = UmitConf() self.colors = Colors() # Diff views self.text_view = DiffText(self.colors, self.umit_conf.colored_diff) self.compare_view = DiffTree(self.colors) self.temp_html_file = None self._create_widgets() self._pack_widgets() self._connect_widgets() # Settings if self.umit_conf.diff_mode == "text": self.text_mode.set_active(True) else: self.compare_mode.set_active(True) self.check_color.set_active(self.umit_conf.colored_diff) # Initial Size Request self.initial_size = self.size_request() def _show_help(self, action): webbrowser.open("file://%s" % os.path.join(Path.docs_dir, "help.html"), new=2) def _create_widgets(self): self.main_vbox = HIGVBox() self.hbox_mode = HIGHBox() self.hbox_settings = HIGHBox() self.hbox_buttons = HIGHBox() self.hbox_result = HIGHBox() self.btn_open_browser = HIGButton(_("Open in Browser"), stock=gtk.STOCK_EXECUTE) self.btn_help = HIGButton(stock=gtk.STOCK_HELP) self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.check_color = gtk.CheckButton(_("Enable colored diffies")) self.btn_legend = HIGButton(_("Color Descriptions"), stock=gtk.STOCK_SELECT_COLOR) self.text_mode = gtk.ToggleButton(_("Text Mode")) self.compare_mode = gtk.ToggleButton(_("Compare Mode")) self.vpaned = gtk.VPaned() self.hpaned = gtk.HPaned() self.scan_chooser1 = ScanChooser(self.scans, "1") self.scan_chooser2 = ScanChooser(self.scans, "2") self.scan_buffer1 = self.scan_chooser1.get_buffer() self.scan_buffer2 = self.scan_chooser2.get_buffer() def _pack_widgets(self): self.main_vbox.set_border_width(6) self.vpaned.pack1(self.hpaned, True, False) self.vpaned.pack2(self.hbox_result) self.hpaned.pack1(self.scan_chooser1, True, False) self.hpaned.pack2(self.scan_chooser2, True, False) self.hbox_buttons._pack_expand_fill(self.btn_help) self.hbox_buttons._pack_expand_fill(self.btn_legend) self.hbox_buttons._pack_expand_fill(self.btn_open_browser) self.hbox_buttons._pack_expand_fill(self.btn_close) self.hbox_buttons.set_homogeneous(True) self.hbox_mode.set_homogeneous(True) self.hbox_mode.pack_start(self.text_mode) self.hbox_mode.pack_start(self.compare_mode) self.hbox_settings._pack_noexpand_nofill(self.hbox_mode) self.hbox_settings._pack_expand_fill(self.check_color) self.main_vbox._pack_expand_fill(self.vpaned) self.main_vbox._pack_noexpand_nofill(self.hbox_settings) self.main_vbox._pack_noexpand_nofill(self.hbox_buttons) self.add(self.main_vbox) def _connect_widgets(self): self.connect("delete-event", self.close) self.btn_legend.connect("clicked", self.show_legend_window) self.btn_help.connect("clicked", self._show_help) self.btn_close.connect("clicked", self.close) self.btn_open_browser.connect("clicked", self.open_browser) self.check_color.connect("toggled", self._set_color) self.text_mode.connect("clicked", self._change_to_text) self.compare_mode.connect("clicked", self._change_to_compare) self.scan_chooser1.exp_scan.connect('activate', self.resize_vpane) self.scan_chooser2.exp_scan.connect('activate', self.resize_vpane) self.scan_chooser1.connect('changed', self.refresh_diff) self.scan_chooser2.connect('changed', self.refresh_diff) def open_browser(self, widget): text1 = self.scan_chooser1.nmap_output text2 = self.scan_chooser2.nmap_output if text1 is None or text2 is None: alert = HIGAlertDialog( message_format='<b>'+_('Select Scan')+'</b>', secondary_text=_("You must select two different scans to \ generate diff.")) alert.run() alert.destroy() return False if text1 == '' and text2 == '': alert = HIGAlertDialog( message_format='<b>'+_('No Text Output')+'</b>', secondary_text=_("Neither of the scans you selected has \ any text output. (Scans loaded from plain Nmap XML output files do not contain \ text output.) The HTML diff shows only differences between text output, so \ there is nothing to show.")) alert.run() alert.destroy() return False # True tells splitlines to keep line endings. text1 = text1.splitlines(True) text2 = text2.splitlines(True) if self.temp_html_file is not None: self.temp_html_file.close() # A NamedTemporaryFile is deleted when it is closed. self.temp_html_file = tempfile.NamedTemporaryFile(suffix = ".html", prefix = "zenmap-diff-") if use_html: diff = DiffHtml(text1, text2) diff = diff.generate() self.temp_html_file.write(''.join(diff)) else: diff = Diff(text1, text2) diff = diff.generate () diff.insert(0, '''<pre>(This diff is been shown in pure text \ because you dont have Python 2.4 or higher.)\n''') diff.append('</pre>') self.temp_html_file.writelines(diff) self.temp_html_file.flush() webbrowser.open("file://" + self.temp_html_file.name, autoraise=1) def show_legend_window(self, widget): legend_window = DiffLegendWindow(self.colors) legend_window.run() legend_window.destroy() self.refresh_diff(None) def refresh_diff (self, widget): """This method is called whenever the diff output might have changed, such as when a different scan was selected in one of the choosers.""" if self.compare_mode.get_active(): # Graphical comparison mode. parsed1 = self.scan_chooser1.parsed_scan parsed2 = self.scan_chooser2.parsed_scan if parsed1 is not None and parsed2 is not None: self.compare_view.make_diff(parsed1, parsed2) else: self.compare_view.clear_diff_tree() self.compare_view.activate_color(self.check_color.get_active()) else: # Text comparison mode. text1 = self.scan_chooser1.nmap_output text2 = self.scan_chooser2.nmap_output if text1 is not None and text2 is not None: diff = Diff(text1.split('\n'), text2.split('\n')) self.text_view.set_text('\n'.join(diff.generate_without_banner())) else: self.text_view.clear() self.text_view.activate_color(self.check_color.get_active()) def resize_vpane(self, widget): exp1 = not widget.get_expanded() if widget == self.scan_chooser1.exp_scan: exp2 = self.scan_chooser2.exp_scan.get_expanded() else: exp2 = self.scan_chooser1.exp_scan.get_expanded() if not exp1 and not exp2: self.vpaned.compute_position(-1, 0, 500) self.size_allocate(gtk.gdk.Rectangle(width=self.initial_size[0], height=self.initial_size[1])) self.queue_resize() def _change_to_text(self, widget): if not widget.get_active(): return self.umit_conf.diff_mode = "text" children = self.hbox_result.get_children() if children: self.hbox_result.remove(children[0]) self.compare_view.hide() self.hbox_result._pack_expand_fill(self.text_view) self.text_view.show_all() self.compare_mode.set_active(False) self.refresh_diff(None) def _change_to_compare(self, widget): if not widget.get_active(): return self.umit_conf.diff_mode = "compare" children = self.hbox_result.get_children() if children: self.hbox_result.remove(children[0]) self.text_view.hide() self.hbox_result._pack_expand_fill(self.compare_view) self.compare_view.show_all() self.text_mode.set_active(False) self.refresh_diff(None) def _set_color(self, widget): activate = widget.get_active() self.umit_conf.colored_diff = activate self.compare_view.activate_color(activate) self.text_view.activate_color(activate) def close(self, widget=None, extra=None): if self.temp_html_file is not None: self.temp_html_file.close() self.destroy()
class SearchGUI(gtk.VBox, object): """This class is a VBox that holds the search entry field and buttons on top, and the results list on the bottom. The "Cancel" and "Open" buttons are a part of the SearchWindow class, not SearchGUI.""" def __init__(self, search_window): gtk.VBox.__init__(self) self._create_widgets() self._pack_widgets() self._connect_events() # Search options self.options = {} self.options["file_extension"] = search_config.file_extension self.options["directory"] = search_config.directory self.options["search_db"] = search_config.search_db self.parsed_results = {} self._set_result_view() self.id = 0 self.search_window = search_window # The Search* objects are created once per Search Window invocation, so # that they get a list of scans only once, not whenever the search # conditions change if self.options["search_db"]: try: self.search_db = SearchDB() except ImportError as e: self.search_db = SearchDummy() self.no_db_warning.show() self.no_db_warning.set_text( 'Warning: The database of saved scans is not ' 'available. (%s.) Use "Include Directory" under ' '"Expressions" to search a directory.' % str(e)) # Search directories can be added via the "dir:" operator, so it needs # to be a map self.search_dirs = {} self.init_search_dirs() # We create an empty search dictionary, since SearchParser will fill it # with keywords as it encounters different operators in the search # string. self.search_dict = dict() # We need to define our own keyword search dictionary search_keywords = dict() search_keywords["keyword"] = "keyword" search_keywords["profile"] = "profile" search_keywords["pr"] = "profile" search_keywords["target"] = "target" search_keywords["t"] = "target" search_keywords["option"] = "option" search_keywords["o"] = "option" search_keywords["date"] = "date" search_keywords["d"] = "date" search_keywords["after"] = "after" search_keywords["a"] = "after" search_keywords["before"] = "before" search_keywords["b"] = "before" search_keywords["os"] = "os" search_keywords["scanned"] = "scanned" search_keywords["sp"] = "scanned" search_keywords["open"] = "open" search_keywords["op"] = "open" search_keywords["closed"] = "closed" search_keywords["cp"] = "closed" search_keywords["filtered"] = "filtered" search_keywords["fp"] = "filtered" search_keywords["unfiltered"] = "unfiltered" search_keywords["ufp"] = "unfiltered" search_keywords["open|filtered"] = "open_filtered" search_keywords["ofp"] = "open_filtered" search_keywords["closed|filtered"] = "closed_filtered" search_keywords["cfp"] = "closed_filtered" search_keywords["service"] = "service" search_keywords["s"] = "service" search_keywords["inroute"] = "in_route" search_keywords["ir"] = "in_route" self.search_parser = SearchParser(self, search_keywords) # This list holds the (operator, argument) tuples, parsed from the GUI # criteria rows self.gui_criteria_list = [] # Do an initial "empty" search, so that the results window initially # holds all scans in the database self.search_parser.update("") self.start_search() def init_search_dirs(self, dirs=[]): # Start fresh self.search_dirs.clear() # If specified, add the search directory from the Zenmap config file to # the map conf_dir = self.options["directory"] if conf_dir: self.search_dirs[conf_dir] = SearchDir( conf_dir, self.options["file_extension"]) # Process any other dirs (as added by the dir: operator) for dir in dirs: self.search_dirs[dir] = SearchDir(dir, self.options["file_extension"]) def _create_widgets(self): # Search box and buttons self.search_top_hbox = HIGHBox() self.search_label = HIGSectionLabel(_("Search:")) self.search_entry = gtk.Entry() self.expressions_btn = HIGToggleButton(_("Expressions "), gtk.STOCK_EDIT) # The quick reference tooltip button self.search_tooltip_btn = HIGButton(" ", gtk.STOCK_INFO) # The expression VBox. This is only visible once the user clicks on # "Expressions" self.expr_vbox = gtk.VBox() # Results section self.result_list = gtk.ListStore(str, str, int) # title, date, id self.result_view = gtk.TreeView(self.result_list) self.result_scrolled = gtk.ScrolledWindow() self.result_title_column = gtk.TreeViewColumn(_("Scan")) self.result_date_column = gtk.TreeViewColumn(_("Date")) self.no_db_warning = gtk.Label() self.no_db_warning.set_line_wrap(True) self.no_db_warning.set_no_show_all(True) self.expr_window = None def _pack_widgets(self): # Packing label, search box and buttons self.search_top_hbox.set_spacing(4) self.search_top_hbox.pack_start(self.search_label, False) self.search_top_hbox.pack_start(self.search_entry, True) self.search_top_hbox.pack_start(self.expressions_btn, False) self.search_top_hbox.pack_start(self.search_tooltip_btn, False) # The expressions (if any) should be tightly packed so that they don't # take too much screen real-estate self.expr_vbox.set_spacing(0) # Packing the result section self.result_scrolled.add(self.result_view) self.result_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) # Packing it all together self.set_spacing(4) self.pack_start(self.search_top_hbox, False) self.pack_start(self.expr_vbox, False) self.pack_start(self.result_scrolled, True) self.pack_start(self.no_db_warning, False) def _connect_events(self): self.search_entry.connect("changed", self.update_search_entry) self.search_tooltip_btn.connect("clicked", self.show_quick_help) self.expressions_btn.connect("toggled", self.expressions_clicked) def show_quick_help(self, widget=None, extra=None): hint_window = HintWindow(QUICK_HELP_TEXT) hint_window.show_all() def expressions_clicked(self, widget=None, extra=None): if (len(self.expr_vbox.get_children()) == 0 and self.search_entry.get_text() == ""): # This is the first time the user has clicked on "Show Expressions" # and the search entry box is empty, so we add a single Criterion # row self.expr_vbox.pack_start(Criterion(self)) if self.expressions_btn.get_active(): # The Expressions GUI is about to be displayed. It needs to reflect # all the conditions in the search entry field, so a comparison # between the entry field and the GUI needs to be performed. # Make the search entry field insensitive while expressions are # visible self.search_entry.set_sensitive(False) # Get a map of operator => argument from the Expressions GUI so # that we can compare them with the ones in the search entry field gui_ops = {} for criterion in self.expr_vbox.get_children(): if criterion.operator in gui_ops: gui_ops[criterion.operator].append(criterion.argument) else: gui_ops[criterion.operator] = [criterion.argument] # We compare the search entry field to the Expressions GUI. Every # (operator, value) pair must be present in the GUI after this loop # is done. for op, args in six.iteritems(self.search_dict): for arg in args: if (op not in gui_ops) or (arg not in gui_ops[op]): # We need to add this pair to the GUI self.expr_vbox.pack_start(Criterion(self, op, arg), False) # Now we check if there are any leftover criterion rows that aren't # present in the search_dict (for example, if a user has deleted # something from the search entry field) for criterion in self.expr_vbox.get_children(): if (criterion.operator not in self.search_dict or criterion.argument not in self.search_dict[criterion.operator]): criterion.destroy() # If we have deleted all rows, add an empty one if len(self.expr_vbox.get_children()) == 0: self.expr_vbox.pack_start(Criterion(self)) # Display all elements self.expr_vbox.show_all() else: # The Expressions GUI is about to be hidden. No updates to the # search entry field are necessary, since it gets updated on every # change in one of the criterion rows. self.expr_vbox.hide_all() self.search_entry.set_sensitive(True) def close(self): if self.expr_window is not None: self.expr_window.close() def add_criterion(self, caller): # We need to find where the caller (Criteria object) is located among # all the rows, so that we can insert the new row after it caller_index = self.expr_vbox.get_children().index(caller) # Make a new Criteria row and insert it after the calling row criteria = Criterion(self, "keyword") self.expr_vbox.pack_start(criteria, False) self.expr_vbox.reorder_child(criteria, caller_index + 1) criteria.show_all() def remove_criterion(self, c): if len(self.expr_vbox.get_children()) > 1: c.destroy() self.criterion_changed() def criterion_changed(self): # We go through all criteria rows and make a new search string search_string = "" for criterion in self.expr_vbox.get_children(): if criterion.operator != "keyword": search_string += criterion.operator + ":" search_string += criterion.argument.replace(" ", "") + " " self.search_entry.set_text(search_string.strip()) self.search_parser.update(self.search_entry.get_text()) self.start_search() def add_search_dir(self, dir): if dir not in self.search_dirs: self.search_dirs[dir] = SearchDir(dir, self.options["file_extension"]) def update_search_entry(self, widget, extra=None): """Called when the search entry field is modified.""" self.search_parser.update(widget.get_text()) self.start_search() def start_search(self): if not self.options["search_db"] and not self.options["directory"]: d = HIGAlertDialog( message_format=_("No search method selected!"), secondary_text=_( "%s can search results on directories or inside its " "own database. Please select a method by choosing a " "directory or by checking the search data base option " "in the 'Search options' tab before starting a search") % APP_DISPLAY_NAME) d.run() d.destroy() return self.clear_result_list() matched = 0 total = 0 if self.options["search_db"]: total += len(self.search_db.get_scan_results()) for result in self.search_db.search(**self.search_dict): self.append_result(result) matched += 1 for search_dir in six.itervalues(self.search_dirs): total += len(search_dir.get_scan_results()) for result in search_dir.search(**self.search_dict): self.append_result(result) matched += 1 #total += len(self.search_tabs.get_scan_results()) #for result in self.search_tabs.search(**self.search_dict): # self.append_result(result) # matched += 1 self.search_window.set_label_text( "Matched <b>%s</b> out of <b>%s</b> scans." % (str(matched), str(total))) def clear_result_list(self): for i in range(len(self.result_list)): iter = self.result_list.get_iter_root() del (self.result_list[iter]) def append_result(self, parsed_result): title = parsed_result.scan_name try: date = datetime.datetime.fromtimestamp(float(parsed_result.start)) date_field = date.strftime("%Y-%m-%d %H:%M") except ValueError: date_field = _("Unknown") self.parsed_results[self.id] = [title, parsed_result] self.result_list.append([title, date_field, self.id]) self.id += 1 def get_selected_results(self): selection = self.result_view.get_selection() rows = selection.get_selected_rows() list_store = rows[0] results = {} for row in rows[1]: r = row[0] results[list_store[r][2]] = self.parsed_results[list_store[r][2]] return results def _set_result_view(self): self.result_view.set_enable_search(True) self.result_view.set_search_column(0) selection = self.result_view.get_selection() selection.set_mode(gtk.SELECTION_MULTIPLE) self.result_view.append_column(self.result_title_column) self.result_view.append_column(self.result_date_column) self.result_title_column.set_resizable(True) self.result_title_column.set_min_width(200) self.result_date_column.set_resizable(True) self.result_title_column.set_sort_column_id(0) self.result_date_column.set_sort_column_id(1) self.result_title_column.set_reorderable(True) self.result_date_column.set_reorderable(True) cell = gtk.CellRendererText() self.result_title_column.pack_start(cell, True) self.result_date_column.pack_start(cell, True) self.result_title_column.set_attributes(cell, text=0) self.result_date_column.set_attributes(cell, text=1) selected_results = property(get_selected_results)