def create_ui(self):
self.locator = GeoIP.new(GeoIP.GEOIP_MEMORY_CACHE)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Country / IP
self.store = gtk.ListStore(str, str)
self.tree = gtk.TreeView(self.store)
self.tree.append_column(
gtk.TreeViewColumn('Country', gtk.CellRendererText(), text=0))
self.tree.append_column(
gtk.TreeViewColumn('Hits', gtk.CellRendererText(), text=1))
sw.add(self.tree)
btn = gtk.Button(stock=gtk.STOCK_REFRESH)
btn.connect('clicked', self.__on_refresh)
self._main_widget.pack_start(sw)
self._main_widget.pack_end(btn, False, False)
self._main_widget.show_all()
tab = PMApp().main_window.get_tab("MainTab")
tab.session_notebook.connect('switch-page', self.__on_switch_page)
def __init__(self, ctx):
super(Session, self).__init__(False, 2)
if self.session_orientation == gtk.ORIENTATION_HORIZONTAL:
self.paneds = [HMultiPaned()]
else:
self.paneds = [VMultiPaned()]
self.paned_nb = gtk.Notebook()
self.paned_nb.set_show_tabs(False)
self.paned_nb.set_show_border(False)
self.paned_nb.append_page(self.paneds[0], gtk.Label('Main'))
self.pages = ['Main']
self.perspectives = []
self.container_cbs = []
self.editor_cbs = []
self.packet = None
self.context = ctx
self.context.title_callback = self.__on_change_title
self._label = ClosableLabel(ctx.title)
self._label.connect('context-menu', self.__on_popup)
self.set_border_width(4)
self.create_ui()
# Now apply the bindings for this Session
PMApp().main_window.apply_bindings(self, self.session_id)
def __on_activate_plugin(self, cell, path):
model = self.tree.get_model()
iter = model.get_iter(path)
plugin = model.get_value(iter, COLUMN_OBJECT)
if not plugin:
return
if not plugin.enabled:
func = self.p_window.engine.load_plugin
else:
func = self.p_window.engine.unload_plugin
ret, errmsg = func(plugin)
if not ret:
dialog = HIGAlertDialog(PMApp().main_window,
gtk.DIALOG_MODAL,
gtk.MESSAGE_ERROR,
message_format=errmsg,
secondary_text=errmsg.summary)
dialog.run()
dialog.hide()
dialog.destroy()
def __on_open(self, act):
dialog = gtk.FileChooserDialog(_('Select a query file'),
PMApp().main_window,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_OPEN, gtk.RESPONSE_ACCEPT,
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT))
if dialog.run() == gtk.RESPONSE_ACCEPT:
fname = dialog.get_filename()
if fname:
fd = open(fname, 'r')
contents = fd.read()
fd.close()
self.store.clear()
for line in contents.splitlines():
line = line.strip()
if line:
self.store.append((False, line, 0))
dialog.hide()
dialog.destroy()
def __on_run(self, action):
# We have to construct a sequence and run our operation :D
tree = Node()
def complete_sequence(model, path, iter, tree):
path = list(path)[:-1]
node = Node(SequencePacket(model.get_value(iter, 0)))
if path:
tree = tree.get_from_path(path)
tree.append_node(node)
self.store.foreach(complete_sequence, tree)
count = self.packet_count.get_value_as_int()
inter = self.packet_interval.get_value_as_int()
operation = SequenceOperation(tree, count, inter,
self.intf_combo.get_interface(),
self.check_strict.get_active(),
self.check_received.get_active(),
self.check_sent.get_active())
tab = PMApp().main_window.get_tab("OperationsTab")
tab.tree.append_operation(operation)
def connect_tab_signals(self):
# I need to connect the session-notebook
# signals from main tab here so we have
# overriden this method to avoid errors
tab = PMApp().main_window.get_tab("MainTab")
tab.session_notebook.connect('switch-page', self.__on_repopulate)
tab.session_notebook.connect('page-removed', self.__on_clear)
def start(self, reader):
if reader:
catalog = reader.bind_translation("geostats")
if catalog:
global _
_ = catalog.gettext
self.geo_tab = GeoTab()
PMApp().main_window.register_tab(self.geo_tab, True)
def start(self, reader):
log.info('HTTP Analyzer plugin started')
PMApp().main_window.bind_session(SessionType.SNIFF_SESSION, HTTPage)
if reader:
contents = reader.file.read('data/protovis.js')
else:
contents = "alert('Protovis not loaded!');"
global g_js_graph
g_js_graph = g_js_graph.replace('$script$', contents)
def __on_open(self, btn, entry):
dialog = gtk.FileChooserDialog(_('Select a file to inject'),
PMApp().main_window,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OPEN, gtk.RESPONSE_ACCEPT))
if dialog.run() == gtk.RESPONSE_ACCEPT:
entry.set_text(dialog.get_filename())
dialog.hide()
dialog.destroy()
def __init__(self, cookies):
gtk.Dialog.__init__(self, 'Cookie selector',
PMApp().main_window,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
self.store = gtk.ListStore(str, int, str)
self.tree = gtk.TreeView(self.store)
rend = gtk.CellRendererText()
col = gtk.TreeViewColumn('Cookie', rend, text=0, cell_background=2)
col.set_expand(True)
self.tree.append_column(col)
col = gtk.TreeViewColumn('Count', rend, text=1, cell_background=2)
self.tree.append_column(col)
self.store.set_sort_column_id(1, gtk.SORT_DESCENDING)
self.tree.set_headers_clickable(True)
self.tree.get_selection().connect('changed', self.__on_sel_changed)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.add(self.tree)
for k, v in cookies.items():
found = False
for i in v:
if i.isdigit():
found = True
break
if found:
self.store.append([k, len(v), '#8DFF7F'])
else:
self.store.append([k, len(v), '#FFE3E5'])
self.tree.get_selection().select_path((0, ))
self.vbox.pack_start(sw)
sw.show_all()
self.vbox.set_border_width(4)
self.set_size_request(350, 200)
self.get_action_area().get_children()[0].set_sensitive(False)
def __on_send(self, action):
packet = self.session.packet
if not packet:
return
# We start a background process in Operations tab
count = self.packet_count.get_value_as_int()
inter = self.packet_interval.get_value_as_int()
tab = PMApp().main_window.get_tab("OperationsTab")
tab.tree.append_operation(
SendOperation(packet, count, inter,
self.intf_combo.get_interface()))
def start(self, reader):
if reader:
catalog = reader.bind_translation("traceroute")
if catalog:
global _
_ = catalog.gettext
ret = reader.extract_file('data/GeoLiteCity.dat')
global glocator
glocator = Locator(os.path.dirname(ret))
log.debug(glocator)
id = PMApp().main_window.register_session(TracerouteSession,
TracerouteContext)
log.debug("Traceroute session binded with id %d" % id)
def __init__(self, conn, inj_file=False):
gtk.Dialog.__init__(self, _('Active connections'),
PMApp().main_window,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
tbl = gtk.Table(2, 2, False)
self.rsrc = gtk.RadioButton(None,
'%s:%d' % (conn.l3_addr1, conn.l4_addr1))
self.rdst = gtk.RadioButton(self.rsrc,
'%s:%d' % (conn.l3_addr2, conn.l4_addr2))
self.rdst.set_active(True)
lbl = gtk.Label(_('Send to:'))
lbl.set_alignment(.0, .5)
tbl.attach(lbl, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
tbl.attach(self.rsrc, 1, 2, 0, 1, gtk.FILL, gtk.FILL)
tbl.attach(self.rdst, 2, 3, 0, 1, gtk.FILL, gtk.FILL)
if inj_file:
self.entry = gtk.Entry()
btn = gtk.Button(stock=gtk.STOCK_OPEN)
btn.connect('clicked', self.__on_open, self.entry)
tbl.attach(self.entry, 0, 2, 1, 2, yoptions=gtk.FILL)
tbl.attach(btn, 2, 3, 1, 2, gtk.FILL, gtk.FILL)
else:
self.view = gtk.TextView()
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.add(self.view)
tbl.attach(sw, 0, 3, 1, 2)
tbl.show_all()
self.vbox.pack_start(tbl, False, False)
def __on_send_receive(self, action):
packet = self.session.packet
if not packet:
return
# We start a background process in Operations tab
count = self.packet_count.get_value_as_int()
inter = self.packet_interval.get_value_as_int()
strict = self.check_strict.get_active()
recv = self.check_received.get_active()
sent = self.check_sent.get_active()
tab = PMApp().main_window.get_tab("OperationsTab")
tab.tree.append_operation(
SendReceiveOperation(packet, count, inter,
self.intf_combo.get_interface(), strict, recv,
sent))
def __on_merge(self, action):
tab = PMApp().main_window.get_tab('PropertyTab')
if self.active_diff:
tab.remove_notify_for(self.active_diff, self.__diff_editing)
self.active_diff = None
if not self.active_layer or not self.active_packets:
return
log.debug("Merging %d packets" % len(self.active_packets))
self.active_diff = backend.MetaPacket(self.active_layer())
self.session.set_active_packet(self.active_diff)
# Now we should connect the property tree signals to our
# but we should check if the packet edited is our or not
# because the property manages the edit phase of multiple
# packets in multiple changes.
tab.register_notify_for(self.active_diff, self.__diff_editing)
def __on_filter(self, combo):
self.active_layer = self.combo.get_active_protocol()
if self.active_layer:
self.merging = True
self.tree.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.refilter()
self.tree.set_model(self.filter_store)
else:
self.merging = False
self.tree.get_selection().set_mode(gtk.SELECTION_SINGLE)
self.tree.set_model(self.store)
if self.active_diff:
tab = PMApp().main_window.get_tab('PropertyTab')
tab.remove_notify_for(self.active_diff, self.__diff_editing)
self.active_diff = None
self.active_packets = []
self.active_layer = None
self.tree.get_selection().select_path((0, ))
def stop(self):
PMApp().main_window.deregister_tab(self.snoop_tab)
def stop(self):
PMApp().main_window.unbind_session(SessionType.SNIFF_SESSION, HTTPage)
def __on_refresh(self, btn):
self.__load_session(PMApp().bus.call('pm.sessions',
'get_current_session'))
def stop(self):
PMApp().main_window.deregister_session(TracerouteSession)
def start(self, reader):
self.status = PMApp().main_window.get_tab('StatusTab').status
a, self.item = self.add_menu_entry('ARPPoison', 'ARP cache poisoning ...',
_('Poison the ARP cache of an host.'),
gtk.STOCK_EXECUTE)
class Session(gtk.VBox):
session_id = 0 # Setted automatically
session_name = "" # Shoud be setted
session_menu = None # Set it if you want a menu item added in main window
session_menu_object = None
session_orientation = [gtk.ORIENTATION_VERTICAL]
def __init__(self, ctx):
super(Session, self).__init__(False, 2)
if self.session_orientation == gtk.ORIENTATION_HORIZONTAL:
self.paneds = [HMultiPaned()]
else:
self.paneds = [VMultiPaned()]
self.paned_nb = gtk.Notebook()
self.paned_nb.set_show_tabs(False)
self.paned_nb.set_show_border(False)
self.paned_nb.append_page(self.paneds[0], gtk.Label('Main'))
self.pages = ['Main']
self.perspectives = []
self.container_cbs = []
self.editor_cbs = []
self.packet = None
self.context = ctx
self.context.title_callback = self.__on_change_title
self._label = ClosableLabel(ctx.title)
self._label.connect('context-menu', self.__on_popup)
self.set_border_width(4)
self.create_ui()
# Now apply the bindings for this Session
PMApp().main_window.apply_bindings(self, self.session_id)
def create_ui(self):
self.paned_nb.set_current_page(0)
self.pack_start(self.paned_nb)
self.show_all()
def remove_perspective(self, klass):
"""
Remove the perspective from the current session
@param klass the perspective klass to remove
@return True if everything is ok
"""
for paned in self.paneds:
for persp in self.perspectives:
if isinstance(persp, klass):
widget = persp
while not isinstance(widget.get_parent(), gtk.Paned):
widget = widget.get_parent()
widget.hide()
self.perspectives.remove(persp)
paned.remove_child(widget)
def add_perspective(self, klass, show_pers=True, resize=False, page=0):
"""
Add the perspective to the current session
@param klass a Perspective base class of the perspective to add
@param show_pers choose to show the perspective
@param resize if True child should resize when the paned is resized
@param page page index where the perspective will be inserted
@return the perspective instance
"""
pers = klass(self)
self.perspectives.append(pers)
if Prefs()['gui.expander.standard'].value:
widget = gtk.Expander(pers.title)
widget.add(pers)
widget.set_expanded(True)
else:
widget = AnimatedExpander(pers.title, pers.icon,
self.session_orientation[page])
widget.add_widget(pers, show_pers)
self.paneds[page].add_child(widget, resize)
widget.show()
return pers
def append_page(self, page_name, orientation=gtk.ORIENTATION_VERTICAL):
self.session_orientation.append(orientation)
page_id = len(self.session_orientation) - 1
child = orientation is gtk.ORIENTATION_HORIZONTAL and \
HMultiPaned() or VMultiPaned()
self.pages.append(page_name)
self.paneds.append(child)
child.show()
self.paned_nb.append_page(child, gtk.Label(page_name))
self._label.set_menu_active(True)
def get_current_page(self):
return self.paned_nb.get_current_page()
def get_current_page_name(self):
return self.pages[self.paned_nb.get_current_page()].upper()
def reload(self):
self.reload_containers()
self.reload_editors()
def save(self):
"@return True if the content is saved or False"
return self._on_save(None)
def save_as(self):
return self._on_save_as(None)
def save_session(self, fname, async=True):
"""
Override this method to do the real save phase
@param fname the filename on witch save the context will be saved
@param async specify if you want to have an async saving in a separate
thread (new FileOperation) without freezing the gui.
@return True if the content is saved or False (if async is False)
"""
if not self.context.file_types:
log.debug("Saving is disabled (%s)" % self.context)
return False
self.context.cap_file = fname
if not async:
return self.context.save()
else:
tab = PMApp().main_window.get_tab("OperationsTab")
tab.tree.append_operation(FileOperation(self,
FileOperation.TYPE_SAVE))
def start(self, reader):
self.snoop_tab = SnoopTab()
PMApp().main_window.register_tab(self.snoop_tab, True)
def connect_tab_signals(self):
PMApp().main_window.add_accel_group(self.tree.accel_group)
def start(self, reader):
PMApp().main_window.bind_session(SessionType.SNIFF_SESSION, Explorer)
def __init__(self, session):
self.session = session
self.following = {}
gtk.Dialog.__init__(self, _('Active connections'),
PMApp().main_window,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
self.vbox.set_border_width(4)
vbox = gtk.VBox(False, 2)
vbox.set_border_width(4)
self.notebook = gtk.Notebook()
self.notebook.set_scrollable(True)
self.notebook.append_page(vbox, gtk.Label(_('Connections')))
self.store = gtk.ListStore(str, int, str, int, str, int, int, object)
self.tree = gtk.TreeView(self.store)
idx = 0
rend = gtk.CellRendererText()
for lbl in (_('Host'), _('Port'), _('Host'), _('Port'), \
_('Protocol'), _('Status'), _('Bytes')):
col = gtk.TreeViewColumn(lbl, rend, text=idx)
if idx == COLUMN_STATUS:
col.set_cell_data_func(rend, self.__status_data_func)
self.tree.append_column(col)
idx += 1
self.tree.set_rules_hint(True)
self.tree.set_search_column(0)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.add(self.tree)
vbox.pack_start(sw)
self.vbox.pack_start(self.notebook)
self.notebook.show_all()
self.menu = gtk.Menu()
lbls = (('details', _('Details'), gtk.STOCK_INFO, self.__on_details),
('kill', _('Kill connection'), gtk.STOCK_CLEAR,
self.__on_kill), ('clear', _('Clear'), gtk.STOCK_CLEAR,
self.__on_clear))
for name, lbl, stock, callback in lbls:
act = gtk.Action(name, lbl, None, stock)
act.connect('activate', callback)
item = act.create_menu_item()
item.show()
self.menu.append(item)
self.connect('response', self.__on_response)
self.tree.connect('button-press-event', self.__on_button_pressed)
self.update_id = None
self.last_conn = None
self.set_size_request(400, 200)
def on_save_log(self, action, selection=False):
if selection:
model, rows = self.get_selection().get_selected_rows()
if not rows:
return
dialog = gtk.FileChooserDialog(_('Save log file'), PMApp().main_window,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_SAVE, gtk.RESPONSE_ACCEPT,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
afilter = gtk.FileFilter()
afilter.add_pattern('*.txt')
afilter.add_pattern('*.log')
afilter.add_mime_type('text/plain')
afilter.set_name('ASCII log file')
dialog.add_filter(afilter)
xfilter = gtk.FileFilter()
xfilter.add_pattern('*.xml')
xfilter.add_mime_type('text/html')
xfilter.set_name('XML log file')
dialog.add_filter(xfilter)
if dialog.run() == gtk.RESPONSE_ACCEPT:
outname = dialog.get_filename()
type = (dialog.get_filter() is xfilter and 1 or 0)
if exists(outname):
d = gtk.MessageDialog(PMApp().main_window,
gtk.DIALOG_MODAL,
gtk.BUTTONS_YES_NO,
_('A file named %s already exists. Do '
'want overwrite it?') % outname)
ret = d.run()
d.hide()
d.destroy()
if ret == gtk.RESPONSE_NO:
dialog.hide()
dialog.destroy()
return
try:
f = open(outname, 'w')
if type == 1:
f.write('<?xml version="1.0"?>\n<auditlog>\n')
sep = ' '
else:
sep = ''
if selection:
for path in rows:
iter = model.get_iter(path)
f.write(sep + \
self.get_row_txt(model, iter, type) + \
'\n')
else:
def dump(model, path, iter, f):
f.write(sep + \
self.get_row_txt(model, iter, type) + \
'\n')
self.store.foreach(dump, f)
if type == 1:
f.write('</auditlog>\n')
f.close()
except Exception, err:
try:
unlink(outname)
except:
pass
d = HIGAlertDialog(PMApp().main_window, gtk.DIALOG_MODAL,
gtk.MESSAGE_ERROR,
message_format=_('Error while saving log '
'file to %s') % outname,
secondary_text=str(err))
d.run()
d.hide()
d.destroy()
