def __create_command_toolbar(self):
self.command_toolbar = ScanCommandToolbar()
self.command_toolbar.command_entry.connect(
'activate', lambda x: self.toolbar.scan_button.clicked())
self.command_entry_changed_handler = \
self.command_toolbar.command_entry.connect(
'changed', self._command_entry_changed)
def __create_command_toolbar(self):
"""Assigns several events to the command toolbar, including activate
on scan button being clicked."""
self.command_toolbar = ScanCommandToolbar()
self.command_toolbar.command_entry.connect(
'activate', lambda x: self.toolbar.scan_button.clicked())
# If you modify the command field entry at all, it will clear the profile, target fields
# so as to not use a profile when you change the command manually, but instead just run
# the command given in the field.
self.command_toolbar.command_entry.connect('key-press-event',
self.clear_profile_target)
class ScanInterface(HIGVBox):
"""ScanInterface contains the scan toolbar and the scan results. Each
ScanInterface represents a single NetworkInventory as well as a set of
running scans."""
# The time delay between when you stop typing a filter string and filtering
# actually begins, in milliseconds.
FILTER_DELAY = 1000
def __init__(self):
HIGVBox.__init__(self)
# The borders are consuming too much space on Maemo. Setting it to
# 0 pixels while on Maemo
if is_maemo():
self.set_border_width(0)
self.set_spacing(0)
# True if nothing has happened here page yet, i.e., it's okay to load a
# scan from a file here.
self.empty = True
# The most recent name the inventory on this page has been saved under.
self.saved_filename = None
# The network inventory shown by this page. It may consist of multiple
# scans.
self.inventory = FilteredNetworkInventory()
# The list of currently running scans (NmapCommand objects).
self.jobs = []
# The list of running and finished scans shown on the Nmap Output page.
self.scans_store = ScansListStore()
self.top_box = HIGVBox()
self.__create_toolbar()
self.__create_command_toolbar()
self.select_default_profile()
self.scan_result = ScanResult(self.inventory, self.scans_store,
scan_interface=self)
self.host_view_selection = self.scan_result.get_host_selection()
self.service_view_selection = self.scan_result.get_service_selection()
self.host_view_selection.connect(
'changed', self.host_selection_changed)
self.service_view_selection.connect(
'changed', self.service_selection_changed)
host_page = self.scan_result.scan_result_notebook.open_ports.host
host_page.host_view.get_selection().connect(
'changed', self.service_host_selection_changed)
self.host_view_selection.connect(
'changed', self.host_selection_changed)
self.scan_result.scan_result_notebook.nmap_output.connect(
"changed", self._displayed_scan_change_cb)
self.scan_result.scan_result_notebook.scans_list.remove_button.connect(
"clicked", self._remove_scan_cb)
# The hosts dict maps hostnames (as returned by HostInfo.get_hostname)
# to HostInfo objects.
self.hosts = {}
# The services dict maps service names ("http") to lists of dicts of
# the form
# {'host': <HostInfo object>, 'hostname': u'example.com',
# 'port_state': u'open', 'portid': u'22', 'protocol': u'tcp',
# 'service_conf': u'10', 'service_extrainfo': u'protocol 2.0',
# 'service_method': u'probed', 'service_name': u'ssh',
# 'service_product': u'OpenSSH', 'service_version': u'4.3'}
# In other words each dict has the same keys as an entry in
# HostInfo.ports, with the addition of "host" and "hostname" keys.
self.services = {}
self.top_box.set_border_width(6)
self.top_box.set_spacing(5)
self.top_box._pack_noexpand_nofill(self.toolbar)
self.top_box._pack_noexpand_nofill(self.command_toolbar)
self._pack_noexpand_nofill(self.top_box)
self._pack_expand_fill(self.scan_result)
self.scan_result.scan_result_notebook.scans_list.cancel_button.connect(
"clicked", self._cancel_scans_list_cb)
self.update_cancel_button()
# Create the filter GUI
self.filter_bar = FilterBar()
self.pack_start(self.filter_bar, False, True, 0)
self.filter_bar.set_no_show_all(True)
self.filter_timeout_id = None
self.filter_bar.connect("changed", self.filter_changed)
self.scan_result.filter_toggle_button.connect("toggled",
self.filter_toggle_toggled)
self.scan_result.filter_toggle_button.show()
def toggle_filter_bar(self):
self.scan_result.filter_toggle_button.clicked()
def filter_toggle_toggled(self, widget):
if self.scan_result.filter_toggle_button.get_active():
# Show the filter bar
self.filter_bar.show()
self.filter_bar.grab_focus()
self.filter_hosts(self.filter_bar.get_filter_string())
else:
# Hide the filter bar
self.filter_bar.hide()
self.filter_hosts("")
self.update_ui()
def filter_changed(self, filter_bar):
# Restart the timer to start the filter.
if self.filter_timeout_id:
gobject.source_remove(self.filter_timeout_id)
self.filter_timeout_id = gobject.timeout_add(
self.FILTER_DELAY, self.filter_hosts,
filter_bar.get_filter_string())
def filter_hosts(self, filter_string):
start = time.clock()
self.inventory.apply_filter(filter_string)
filter_time = time.clock() - start
# Update the gui
start = time.clock()
self.update_ui()
gui_time = time.clock() - start
if filter_time + gui_time > 0.0:
log.debug("apply_filter %g ms update_ui %g ms (%.0f%% filter)" %
(filter_time * 1000.0, gui_time * 1000.0,
100.0 * filter_time / (filter_time + gui_time)))
self.filter_timeout_id = None
return False
def is_changed(self):
"""Return true if this window has unsaved changes."""
for scan in self.inventory.get_scans():
if scan.unsaved:
return True
return False
changed = property(is_changed)
def num_scans_running(self):
return len(self.jobs)
def select_default_profile(self):
"""Select a "default" profile. Currently this is defined to be the
first profile."""
if len(self.toolbar.profile_entry.get_model()) > 0:
self.toolbar.profile_entry.set_active(0)
def go_to_host(self, hostname):
"""Scroll the text output to the appearance of the named host."""
self.scan_result.scan_result_notebook.nmap_output.nmap_output.go_to_host(hostname) # noqa
def __create_toolbar(self):
self.toolbar = ScanToolbar()
self.target_entry_changed_handler = self.toolbar.target_entry.connect(
'changed', self._target_entry_changed)
self.profile_entry_changed_handler = \
self.toolbar.profile_entry.connect(
'changed', self._profile_entry_changed)
self.toolbar.scan_button.connect('clicked', self.start_scan_cb)
self.toolbar.cancel_button.connect('clicked', self._cancel_scan_cb)
def __create_command_toolbar(self):
self.command_toolbar = ScanCommandToolbar()
self.command_toolbar.command_entry.connect(
'activate', lambda x: self.toolbar.scan_button.clicked())
self.command_entry_changed_handler = \
self.command_toolbar.command_entry.connect(
'changed', self._command_entry_changed)
def _command_entry_changed(self, editable):
ops = NmapOptions()
ops.parse_string(self.command_toolbar.get_command())
# Set the target and profile without propagating the "changed" signal
# back to the command entry.
self.set_target_quiet(join_quoted(ops.target_specs))
self.set_profile_name_quiet("")
def _target_entry_changed(self, editable):
target_string = self.toolbar.get_selected_target()
targets = split_quoted(target_string)
ops = NmapOptions()
ops.parse_string(self.command_toolbar.get_command())
ops.target_specs = targets
self.set_command_quiet(ops.render_string())
def _profile_entry_changed(self, widget):
"""Update the command based on the contents of the target and profile
entries. If the command corresponding to the current profile is not
blank, use it. Otherwise use the current contents of the command
entry."""
profile_name = self.toolbar.get_selected_profile()
target_string = self.toolbar.get_selected_target()
cmd_profile = CommandProfile()
command_string = cmd_profile.get_command(profile_name)
del(cmd_profile)
if command_string == "":
command_string = self.command_toolbar.get_command()
ops = NmapOptions()
ops.parse_string(command_string)
# Use the targets from the command entry, if there are any, otherwise
# use any targets from the profile.
targets = split_quoted(target_string)
if len(targets) > 0:
ops.target_specs = targets
else:
self.toolbar.set_selected_target(join_quoted(ops.target_specs))
self.set_command_quiet(ops.render_string())
def set_command_quiet(self, command_string):
"""Set the command used by this scan interface, ignoring any further
"changed" signals."""
self.command_toolbar.command_entry.handler_block(
self.command_entry_changed_handler)
self.command_toolbar.set_command(command_string)
self.command_toolbar.command_entry.handler_unblock(
self.command_entry_changed_handler)
def set_target_quiet(self, target_string):
"""Set the target string used by this scan interface, ignoring any
further "changed" signals."""
self.toolbar.target_entry.handler_block(
self.target_entry_changed_handler)
self.toolbar.set_selected_target(target_string)
self.toolbar.target_entry.handler_unblock(
self.target_entry_changed_handler)
def set_profile_name_quiet(self, profile_name):
"""Set the profile name used by this scan interface, ignoring any
further "changed" signals."""
self.toolbar.profile_entry.handler_block(
self.profile_entry_changed_handler)
self.toolbar.set_selected_profile(profile_name)
self.toolbar.profile_entry.handler_unblock(
self.profile_entry_changed_handler)
def start_scan_cb(self, widget=None):
target = self.toolbar.selected_target
command = self.command_toolbar.command
profile = self.toolbar.selected_profile
log.debug(">>> Start Scan:")
log.debug(">>> Target: '%s'" % target)
log.debug(">>> Profile: '%s'" % profile)
log.debug(">>> Command: '%s'" % command)
if target != '':
try:
self.toolbar.add_new_target(target)
except IOError, e:
# We failed to save target_list.txt; treat it as read-only.
# Probably it's owned by root and this is a normal user.
log.debug(">>> Error saving %s: %s" % (
Path.target_list, str(e)))
if command == '':
warn_dialog = HIGAlertDialog(
message_format=_("Empty Nmap Command"),
secondary_text=_("There is no command to execute. "
"Maybe the selected/typed profile doesn't exist. "
"Please check the profile name or type the nmap "
"command you would like to execute."),
type=gtk.MESSAGE_ERROR)
warn_dialog.run()
warn_dialog.destroy()
return
self.execute_command(command, target, profile)