def __on_idle(self, udata):
        if self.type == FileOperation.TYPE_LOAD:
            ctx, rctx = udata

            self.loading_view = True

            log.debug('Creating a new session after loading for %s' % str(ctx))

            if ctx is backend.SequenceContext:
                from umit.pm.gui.sessions.sequencesession import SequenceSession

                ServiceBus().call('pm.sessions', 'bind_session',
                                  SequenceSession, rctx)

            elif ctx is backend.SniffContext or \
                 ctx is backend.StaticContext:

                from umit.pm.gui.sessions.sniffsession import SniffSession

                ServiceBus().call('pm.sessions', 'bind_session', SniffSession,
                                  rctx)

        else:
            from umit.pm.gui.sessions.sniffsession import SniffSession

            if isinstance(self.session, SniffSession):
                self.session.sniff_page.statusbar.label = '<b>%s</b>' % \
                                                          self.ctx.summary
        self.loading_view = False
        self.percentage = 100.0
        self.state = self.NOT_RUNNING

        # Force update.
        self.notify_parent()
        return False
예제 #2
0
    def __on_button_press(self, tree, event):
        self.last_pos = (event.x, event.y)

        if event.button != 3:
            return

        selected = self.get_selected_ips()

        if not selected:
            return

        info_str = len(selected) == 1 and \
                 selected[0] or _('%d IP') % len(selected)

        session = ServiceBus().call('pm.sessions', 'get_current_session')

        if session.session_name == 'AUDIT' and \
           session.get_current_page_name() == 'TARGETS':
            sensitive = True
        else:
            sensitive = False

        menu = gtk.Menu()

        act = gtk.Action('target1-add',
                         _("Add '%s' to target1") % info_str, None,
                         gtk.STOCK_ADD)
        act.connect('activate', lambda a, (s, ip): \
                    s.target_page.target1_tree.append(ip), (session, selected))

        item = act.create_menu_item()
        item.set_sensitive(sensitive)
        menu.append(item)

        act = gtk.Action('target2-add',
                         _("Add '%s' to target2") % info_str, None,
                         gtk.STOCK_ADD)
        act.connect('activate', lambda a, (s, ip): \
                    s.target_page.target2_tree.append(ip), (session, selected))

        item = act.create_menu_item()
        item.set_sensitive(sensitive)
        menu.append(item)

        menu.show_all()
        menu.popup(None, None, None, event.button, event.time)

        return True
예제 #3
0
    def bind_perspective(self, ptype, callback):
        """
        Bind the perspective 'type'

        The callback should be of the type
          def perspective_cb(perspective, type, already_present, added)

        @param type the perspective's type (see also PerspectiveType)
        @param callback the callback to execute when a new
               perspective of type 'type' is created
        """

        log.debug(
            "Binding method %s for perspective of type %s" % \
            (callback, PerspectiveType.types[ptype])
        )

        self.perspective_binder[ptype].append(callback)

        for page in ServiceBus().call('pm.sessions', 'get_sessions'):
            if not isinstance(page, Session):
                continue

            for perspective in page.perspectives:
                idx = PerspectiveType.types[type(perspective)]

                callback(perspective, idx, True, True)
예제 #4
0
    def unbind_session(self, ptype, persp_klass):
        try:
            for i in range(len(self.session_binder[ptype])):
                (klass, show, resize) = self.session_binder[ptype][i]

                if klass is not persp_klass:
                    continue

                del self.session_binder[ptype][i]

                klass = SessionType.types[ptype]

                for page in ServiceBus().call('pm.sessions', 'get_sessions'):
                    if isinstance(page, klass):
                        page.remove_perspective(persp_klass)

                log.debug(
                    "Binding method %s for perspective of type %s removed" % \
                    (persp_klass, SessionType.types[ptype])
                )

                return True
        except:
            log.error(
                "Failed to remove binding method %s for session of type %s" % \
                (persp_klass, SessionType.type[ptype])
            )

        return False
예제 #5
0
    def debind_perspective(self, type, callback):
        """
        Remove the binding callback for perspective of type 'type'

        @param type the perspective type
        @param callback the callback to remove
        @return True if the callback is removed correctly
        """

        try:
            self.perspective_binder[type].remove(callback)

            for page in ServiceBus().call('pm.sessions', 'get_sessions'):
                if not isinstance(page, Session):
                    continue

                for perspective in page.perspectives:
                    idx = PerspectiveType.types[type(perspective)]

                    callback(perspective, idx, True, False)

            log.debug(
                "Binding method %s for perspective of type %s removed" % \
                (callback, PerspectiveType.types[type])
            )

            return True
        except:
            log.error(
                "Failed to remove binding method %s "
                "for perspective of type %s" % \
                (callback, PerspectiveType.types[type])
            )

        return False
예제 #6
0
    def __on_quit(self, *args):
        self.hide()

        # We need to stop the pending sniff threads
        lst = []

        for page in ServiceBus().call('pm.sessions', 'get_sessions'):
            if isinstance(page, Session) and \
               isinstance(page.context, backend.TimedContext):
                lst.append(page.context)

        for ctx in lst:
            ctx.stop()

        # Avoids joining all threads are daemon
        #for ctx in lst:
        #    ctx.join()

        errs = []

        try:
            log.debug('Saving options before exiting')
            Prefs().write_options()
        except IOError, err:
            errs.append(err)
예제 #7
0
    def __on_field_selected(self, tree, packet=None, proto=None, field=None):
        if not proto or not field:
            return

        if packet in self.notify:
            for cb in self.notify[packet]:
                cb(packet, proto, field, False)

        # We should select also the bounds in HexView
        page = ServiceBus().call('pm.sessions', 'get_current_session')

        if page:
            start = backend.get_field_offset(packet, proto, field)
            length = backend.get_field_size(proto, field)

            log.debug('Field %s start at %d and finish at %d' %
                      (field, start, length))

            if length == 0:
                # Deselect all
                page.packet_page.hexview.select_block(0, 0)
                return

            page.packet_page.hexview.select_block(start / 8,
                                                  max(length / 8, 1))
예제 #8
0
    def __on_button_press(self, tree, event):
        self.last_pos = (event.x, event.y)

        if event.button != 3:
            return

        selected = self.get_selected_ips()

        if not selected:
            return

        info_str = len(selected) == 1 and \
                 selected[0] or _('%d IP') % len(selected)

        session = ServiceBus().call('pm.sessions', 'get_current_session')

        if session.session_name == 'AUDIT' and \
           session.get_current_page_name() == 'TARGETS':
            sensitive = True
        else:
            sensitive = False

        menu = gtk.Menu()

        act = gtk.Action('target1-add', _("Add '%s' to target1") % info_str,
                         None, gtk.STOCK_ADD)
        act.connect('activate', lambda a, (s, ip): \
                    s.target_page.target1_tree.append(ip), (session, selected))

        item = act.create_menu_item()
        item.set_sensitive(sensitive)
        menu.append(item)

        act = gtk.Action('target2-add', _("Add '%s' to target2") % info_str,
                         None, gtk.STOCK_ADD)
        act.connect('activate', lambda a, (s, ip): \
                    s.target_page.target2_tree.append(ip), (session, selected))

        item = act.create_menu_item()
        item.set_sensitive(sensitive)
        menu.append(item)

        menu.show_all()
        menu.popup(None, None, None, event.button, event.time)

        return True
예제 #9
0
    def create_session(self, menu, tup):
        """
        Create a new session using ctxklass and sessklass

        @param menu gtk.MenuItem
        @param tuple a tuple containing (sessklass, ctxklass)
        """
        sessklass, ctxklass = tup
        ServiceBus().call('pm.sessions', 'create_session', sessklass, ctxklass)
예제 #10
0
    def _idle(self):

        if self.phase == 0:
            self.splash.text = _("Registering icons ...")

            from icons import register_icons
            register_icons()
        elif self.phase == 1:
            self.splash.text = _("Loading preferences ...")

            from umit.pm.manager.preferencemanager import Prefs
            self.prefs = Prefs()
        elif self.phase == 2:
            services_boot()
            self.splash.text = _("Creating main window ...")

            from mainwindow import MainWindow
            self.bus = ServiceBus()
            self.main_window = MainWindow()
            self.main_window.connect_tabs_signals()
            self.plugin_engine = PluginEngine()
            self.plugin_engine.load_selected_plugins()

            # Destroy the splash screen
            self.splash.hide()
            self.splash.destroy()
            self.splash.finished = True

            del self.splash

            # Now let's parse the args passed in the constructor
            parser = self._create_parser()
            options, args = parser.parse_args(self._args)

            if options.fread:
                self.main_window.open_generic_file_async(options.fread)

            if options.audit:
                dev1, dev2, bpf_filter = options.audit, '', ''

                try:
                    dev1, dev2 = options.audit.split(',', 1)
                    dev2, bpf_filter = other.split(':', 1)
                except:
                    pass

                self.main_window.start_new_audit(dev1, dev2, bpf_filter, False,
                                                 False)

            return False

        self.phase += 1
        return True
    def __init__(self, dev1, dev2, bpf_filter, skipfwd, unoffensive):
        capmethod = Prefs()['backend.system.audit.capmethod'].value

        if capmethod < 0 or capmethod > 2:
            Prefs()['backend.system.sendreceive.capmethod'].value = 0
            capmethod = 0

        Operation.__init__(self)
        backend.AuditContext.__init__(self, dev1, dev2, bpf_filter, capmethod)

        self.session = ServiceBus().call('pm.sessions', 'create_audit_session',
                                         self)
예제 #12
0
    def open_generic_file(self, fname):
        """
        Open a generic file (pcap/sequence and other supported file format)
        @param fname the path to the file to open
        @return a umit.pm.session.base.Session object or None on errors
        """

        if not os.path.isfile(fname):
            return None

        types = {}
        sessions = (backend.StaticContext, backend.SequenceContext,
                    backend.SniffContext)

        for ctx in sessions:
            for name, pattern in ctx.file_types:
                types[pattern] = (name, ctx)

        try:
            find = fname.split('.')[-1]

            for pattern in types:
                if pattern.split('.')[-1] == find:
                    ctx = types[pattern][1]
        except:
            pass

        if ctx is backend.SequenceContext:
            return ServiceBus().call('pm.sessions', 'load_sequence_session',
                                     fname)

        elif ctx is backend.SniffContext:
            return ServiceBus().call('pm.sessions', 'load_sniff_session',
                                     fname)

        elif ctx is backend.StaticContext:
            return ServiceBus().call('pm.sessions', 'load_static_session',
                                     fname)
예제 #13
0
    def populate(self):
        """
        Could be called to refresh the store.
        """
        intf = self.intf_combo.get_interface()

        self.store.clear()
        populate_cb = ServiceBus().get_function('pm.hostlist', 'populate')

        if not callable(populate_cb):
            return

        for ip, mac, desc in populate_cb(intf):
            self.store.append([ip, mac, desc])
예제 #14
0
    def __do_append_cur_sequence(self, selection=None, hier=False):
        sel = self.__get_selected()

        if sel:
            sess = ServiceBus().call('pm.sessions', 'get_current_session')

            if not isinstance(sess, SequenceSession):
                return False

            if not hier:
                sess.sequence_page.append_packet(sel, selection)
            else:
                sess.packet_page.proto_hierarchy.append_packet(sel, selection)

            return True

        return False
    def __init__(self, iface, filter=None, minsize=0, maxsize=0, capfile=None, \
                 scount=0, stime=0, ssize=0, real=True, scroll=True, \
                 resmac=True, resname=False, restransport=True, promisc=True, \
                 background=False, capmethod=0, audits=True):

        Operation.__init__(self)
        backend.SniffContext.__init__(self, iface, filter, minsize, maxsize,
                                      capfile, scount, stime, ssize, real,
                                      scroll, resmac, resname, restransport,
                                      promisc, background, capmethod, audits,
                                      self.__recv_callback, None)

        if not self.background:
            self.session = ServiceBus().call('pm.sessions',
                                             'create_sniff_session', self)
        else:
            self.session = None
    def __init__(self, seq, count, inter, iface=None, strict=True, \
                 report_recv=False, report_sent=True):

        capmethod = Prefs()['backend.system.sequence.capmethod'].value

        if capmethod < 0 or capmethod > 2:
            Prefs()['backend.system.sendreceive.capmethod'].value = 0
            capmethod = 0

        log.debug('Using %d as capmethod for SendReceiveContext' % capmethod)

        Operation.__init__(self)
        backend.SequenceContext.__init__(self, seq, count, inter, iface,   \
                                         strict, report_recv, report_sent, \
                                         capmethod,                        \
                                         self.__send_callback,             \
                                         self.__receive_callback)

        self.session = ServiceBus().call('pm.sessions', 'create_sniff_session',
                                         self)
예제 #17
0
    def __redraw_hex_view(self, tree, entry_destroyed):
        # This is called when the user end the edit action on the PropertyGrid
        # and we could redraw the entire hexview to show changes
        # The tree argument is the PropertyGridTree object

        page = ServiceBus().call('pm.sessions', 'get_current_session')

        # FIXME: check if the packet page object is avaiable
        # within this session or use isinstance(SessionPage, SequencePage)
        if page:
            # No reload to avoid repopulating
            page.packet_page.redraw_hexview()

            packet, proto, field = self.grid.tree.get_selected_field()

            if packet in self.notify:
                for cb in self.notify[packet]:
                    cb(packet, proto, field, True)

            # Now reselect the blocks
            self.__on_field_selected(self.grid.tree, packet, proto, field)
예제 #18
0
    def __on_hierarchy_selection_changed(self, selection):
        packet, proto = \
            self.prev_page.packet_page.proto_hierarchy.get_active_protocol()

        if not proto:
            return

        self.grid.clear()
        self.grid.populate(packet, proto)

        # Let's select entire protocol in the hexview
        page = ServiceBus().call('pm.sessions', 'get_current_session')

        if page:
            bounds = packet.get_protocol_bounds(proto)

            if bounds:
                page.packet_page.hexview.select_block(bounds[0],
                                                      bounds[1] - bounds[0])

        self._main_widget.set_sensitive(True)
예제 #19
0
    def __on_info(self, button):
        import umit.pm.gui.core.app

        ips = []
        intf = self.intf_combo.get_interface()
        info_cb = ServiceBus().get_function('pm.hostlist', 'info')

        # Doesn't test for null info_cb. If we are here the button is enabled
        # and the test is already done.

        def add_to_string(model, path, iter, selected):
            ips.append((model.get_value(iter, 0), model.get_value(iter, 1)))

        self.tree.get_selection().selected_foreach(add_to_string, ips)

        for ip, mac in ips:
            ret = info_cb(intf, ip, mac)

            d = gtk.Dialog(_('Informations for %s - PacketManipulator') % \
                           ret.l3_addr,
                           umit.pm.gui.core.app.PMApp().main_window,
                           gtk.DIALOG_DESTROY_WITH_PARENT,
                           (gtk.STOCK_COPY, gtk.RESPONSE_ACCEPT,
                            gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
            d.set_size_request(460, 300)

            sw = gtk.ScrolledWindow()
            sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
            sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

            details = HostListDetails()
            details.populate(ret)

            sw.add(details)
            sw.show_all()

            d.vbox.pack_start(sw)
            d.connect('response', self.__on_dialog_response)

            d.show()
예제 #20
0
    def bind_session(self, ptype, persp_klass, show_pers=True, resize=False):
        """
        Bind the perspective 'pers_klass' to Session 'ptype'

        @param ptype the Session type to customize
        @param persp_klass the perspective class to add to the selected Session
        @param show_pers choose to show the perspective
        @param resize if True child should resize when the paned is resized
        """

        log.debug(
            "Binding perspective %s to Session %s" % \
            (persp_klass, SessionType.types[ptype])
        )

        self.session_binder[ptype].append((persp_klass, show_pers, resize))

        klass = SessionType.types[ptype]

        for page in ServiceBus().call('pm.sessions', 'get_sessions'):
            if isinstance(page, klass):
                self.apply_bindings(page, ptype, persp_klass)
예제 #21
0
    def __on_dialog_response(self, dialog, rid):
        import gtk
        import umit.pm.gui.core.app

        if rid != gtk.RESPONSE_ACCEPT:
            dialog.hide()
            dialog.destroy()
            return

        table = dialog.vbox.get_children()[0]

        assert isinstance(table, gtk.Table)

        inp_dict = {}

        for widget in table:
            if isinstance(widget, gtk.Label):
                continue

            if isinstance(widget, gtk.SpinButton):
                if widget.get_digits() == 0:
                    value = widget.get_value_as_int()
                else:
                    value = widget.get_value()

            elif isinstance(widget, gtk.ToggleButton):
                value = widget.get_active()
            else:
                value = widget.get_text()

            inp_dict[widget.get_name()] = value

        dialog.hide()
        dialog.destroy()

        audit_sess = ServiceBus().call('pm.sessions', 'get_current_session')

        self.__start_audit(audit_sess, inp_dict)
 def __create_session(self):
     self.session = ServiceBus().call('pm.sessions', 'create_sniff_session',
                                      self)
예제 #23
0
    def create_ui(self):
        self._main_widget.set_border_width(4)
        self._main_widget.set_spacing(2)

        self.intf_combo = InterfacesCombo()

        self._main_widget.pack_start(self.intf_combo, False, False)

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)

        self.store = gtk.ListStore(str, str, str)
        self.tree = gtk.TreeView(self.store)

        rend = gtk.CellRendererText()

        self.tree.append_column(gtk.TreeViewColumn(_('IP'), rend, text=0))
        self.tree.append_column(gtk.TreeViewColumn(_('MAC'), rend, text=1))
        self.tree.append_column(
            gtk.TreeViewColumn(_('Description'), rend, text=2))

        self.tree.get_column(2).set_resizable(True)
        self.tree.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
                                           [('text/plain', 0, 0)],
                                           gtk.gdk.ACTION_DEFAULT | \
                                           gtk.gdk.ACTION_COPY)

        # Enable multiple selection
        self.tree.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
        self.tree.set_rubber_banding(True)

        self.last_pos = (0, 0)
        self.tree.connect("drag-begin", self.__on_drag_begin)
        self.tree.connect("drag-data-get", self.__on_drag_data_get)
        self.tree.connect("button-press-event", self.__on_button_press)

        self.tree.set_rules_hint(True)
        self.tree.set_search_column(0)
        self.tree.set_enable_search(True)

        sw.add(self.tree)
        self._main_widget.pack_start(sw)

        bb = gtk.HButtonBox()
        bb.set_layout(gtk.BUTTONBOX_END)

        self.btn_refresh = new_button(gtk.STOCK_REFRESH, _('Refresh the list'))
        self.btn_refresh.connect('clicked', self.__on_refresh)

        self.btn_info = new_button(gtk.STOCK_INFO,
                                   _('Information for selected host'))
        self.btn_info.connect('clicked', self.__on_info)

        bb.pack_start(self.btn_refresh, False, False)
        bb.pack_end(self.btn_info, False, False)

        self._main_widget.pack_end(bb, False, False)
        self._main_widget.show_all()

        self.btn_info.set_sensitive(False)
        self.btn_refresh.set_sensitive(False)

        svc = ServiceBus().get_service('pm.hostlist')
        svc.connect('func-binded', self.__on_func_assigned)
        svc.connect('func-unbinded', self.__on_func_assigned)

        self.populate()
 def activate(self):
     if not self.session:
         self.session = ServiceBus().call('pm.sessions',
                                          'create_sniff_session', self)
예제 #25
0
    def __add_to_new_sequence(self, action):
        sel = self.__get_selected()

        if sel:
            ServiceBus().call('pm.sessions', 'create_edit_session', sel)
            return True
예제 #26
0
    def on_input_request(self, action):
        import gtk
        import umit.pm.gui.core.app

        if not self.__inputs__:
            audit_sess = ServiceBus().call('pm.sessions',
                                           'get_current_session')

            self.__start_audit(audit_sess, {})
            return

        dialog = gtk.Dialog(_('Inputs for %s - PacketManipulator') % \
                            self.__class__.__name__,
                            umit.pm.gui.core.app.PMApp().main_window,
                            gtk.DIALOG_DESTROY_WITH_PARENT,
                            (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
                             gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))

        tbl = gtk.Table(2, 1, False)

        tbl.set_border_width(4)
        tbl.set_col_spacings(4)
        tbl.set_row_spacings(4)

        dialog.vbox.pack_start(tbl)

        idx = 0

        for txt, (opt_val, desc) in self.__inputs__:
            lbl = gtk.Label('')
            lbl.set_alignment(.0, .5)
            lbl.set_markup('<b>%s:</b>' % txt.capitalize())

            if isinstance(opt_val, bool):
                widget = gtk.ToggleButton('')
                widget.set_active(opt_val)

                widget.get_child().set_text(widget.get_active() \
                                            and _('Enabled') \
                                            or _('Disabled'))

                widget.connect('toggled', lambda w: w.get_child().set_text( \
                    w.get_active() and _('Enabled') or _('Disabled')))

            elif isinstance(opt_val, str):
                widget = gtk.Entry()
                widget.set_text(opt_val)

            elif isinstance(opt_val, int):
                widget = gtk.SpinButton(gtk.Adjustment(opt_val, -sys.maxint,
                                                       sys.maxint, 1, 10),
                                        digits=0)

            elif isinstance(opt_val, float):
                widget = gtk.SpinButton(gtk.Adjustment(opt_val, -sys.maxint,
                                                       sys.maxint, 1, 10),
                                        digits=4)

            lbl.props.has_tooltip = True
            widget.props.has_tooltip = True

            lbl.set_tooltip_markup(desc)
            widget.set_tooltip_markup(desc)
            widget.set_name(txt)

            tbl.attach(lbl, 0, 1, idx, idx + 1, gtk.FILL, gtk.FILL)
            tbl.attach(widget, 1, 2, idx, idx + 1, yoptions=gtk.FILL)
            idx += 1

        tbl.show_all()
        dialog.connect('response', self.__on_dialog_response)
        dialog.show()
    def create_targets(self):
        """
        Update targets structure appropriately by looking at target{1,2}_tree.
        @return True if the list is filled right or False
        """
        func = ServiceBus().get_function('pm.hostlist', 'get_target')

        if not func:
            dialog = gtk.MessageDialog(self.get_toplevel(), gtk.DIALOG_MODAL,
                                       gtk.MESSAGE_WARNING, gtk.BUTTONS_OK,
                                       "No class implements `get_target method'"
                                       " of pm.hostlist interface. Please load "
                                       "an appropriate plugin.")
            dialog.run()
            dialog.hide()
            dialog.destroy()
        else:
            netmask = Netmask(self.session.context.get_netmask1(),
                              self.session.context.get_ip1())

        def add_host_entry(target, targets_idx):
            entry = None

            if is_mac(target):
                entry = HostEntry(l2_addr=target)

            elif func:
                if is_ip(target) and netmask.match_strict(target):
                    profs = filter(lambda p: p.l2_addr is not None,
                                   func(l3_addr=target, netmask=netmask) or \
                                   [])

                    if profs:
                        entry = HostEntry(l2_addr=profs[0].l2_addr,
                                          l3_addr=target,
                                          hostname=profs[0].hostname)
                else:
                    profs = filter(lambda p: p.l2_addr is not None,
                                   func(hostname=target, netmask=netmask) or \
                                   [])

                    if profs:
                        entry = HostEntry(l2_addr=profs[0].l2_addr,
                                          l3_addr=profs[0].l3_addr,
                                          hostname=target)

            if entry:
                log.info('Group %d -> %s' % (targets_idx + 1, entry))
                self.targets[targets_idx].append(entry)

        # Ok. Now let's create the target list
        if not self.targets[0] and not self.targets[1]:
            log.info('Creating targets list for the MITM attack')

            for target in self.target1_tree.get_targets():
                add_host_entry(target, 0)

            for target in self.target2_tree.get_targets():
                add_host_entry(target, 1)

            errs = []

            if func:
                netmask = None

                if not self.targets[0]:
                    netmask = Netmask(self.session.context.get_netmask1(),
                                      self.session.context.get_ip1())

                    for prof in filter(lambda p: p.l2_addr is not None,
                                       func(netmask=netmask) or []):

                        entry = HostEntry(l2_addr=prof.l2_addr,
                                          l3_addr=prof.l3_addr,
                                          hostname=prof.hostname)

                        self.targets[0].append(entry)
                        log.info('[AUTOADD] Group 1 -> %s' % entry)

                if not self.targets[1]:
                    if not netmask:
                        netmask = Netmask(self.session.context.get_netmask1(),
                                          self.session.context.get_ip1())

                    for prof in filter(lambda p: p.l2_addr is not None,
                                       func(netmask=netmask) or []):

                        entry = HostEntry(l2_addr=prof.l2_addr,
                                          l3_addr=prof.l3_addr,
                                          hostname=prof.hostname)

                        self.targets[1].append(entry)
                        log.info('[AUTOADD] Group 2 -> %s' % entry)

            if not self.targets[0]:
                errs.append(
                    _('Could not set any targets for the first group.'))

            if not self.targets[1]:
                errs.append(
                    _('Could not set any targets for the second group.'))

            if errs and not func:
                errs.append(
                    _('Neither get_target can be used to autopopulate the targ'
                      'ets. Please load at least an appropriate plugin (like '
                      'Profiler) and make an ARP scan, or add targets MAC by '
                      'hand.'))

            if errs:
                dialog = gtk.MessageDialog(self.get_toplevel(),
                                           gtk.DIALOG_MODAL,
                                           gtk.MESSAGE_WARNING, gtk.BUTTONS_OK,
                                           "Some errors found:\n\n" + \
                                           '\n'.join(errs))
                dialog.run()
                dialog.hide()
                dialog.destroy()

                return False

            return True
예제 #28
0
    def create_ui(self):
        self._main_widget.set_border_width(4)
        self._main_widget.set_spacing(2)

        self.intf_combo = InterfacesCombo()

        self._main_widget.pack_start(self.intf_combo, False, False)

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)

        self.store = gtk.ListStore(str, str, str)
        self.tree = gtk.TreeView(self.store)

        rend = gtk.CellRendererText()

        self.tree.append_column(gtk.TreeViewColumn(_('IP'), rend, text=0))
        self.tree.append_column(gtk.TreeViewColumn(_('MAC'), rend, text=1))
        self.tree.append_column(gtk.TreeViewColumn(_('Description'), rend,
                                                   text=2))

        self.tree.get_column(2).set_resizable(True)
        self.tree.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
                                           [('text/plain', 0, 0)],
                                           gtk.gdk.ACTION_DEFAULT | \
                                           gtk.gdk.ACTION_COPY)

        # Enable multiple selection
        self.tree.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
        self.tree.set_rubber_banding(True)

        self.last_pos = (0, 0)
        self.tree.connect("drag-begin", self.__on_drag_begin)
        self.tree.connect("drag-data-get", self.__on_drag_data_get)
        self.tree.connect("button-press-event", self.__on_button_press)

        self.tree.set_rules_hint(True)
        self.tree.set_search_column(0)
        self.tree.set_enable_search(True)

        sw.add(self.tree)
        self._main_widget.pack_start(sw)

        bb = gtk.HButtonBox()
        bb.set_layout(gtk.BUTTONBOX_END)

        self.btn_refresh = new_button(gtk.STOCK_REFRESH, _('Refresh the list'))
        self.btn_refresh.connect('clicked', self.__on_refresh)

        self.btn_info = new_button(gtk.STOCK_INFO,
                                   _('Information for selected host'))
        self.btn_info.connect('clicked', self.__on_info)

        bb.pack_start(self.btn_refresh, False, False)
        bb.pack_end(self.btn_info, False, False)

        self._main_widget.pack_end(bb, False, False)
        self._main_widget.show_all()

        self.btn_info.set_sensitive(False)
        self.btn_refresh.set_sensitive(False)

        svc = ServiceBus().get_service('pm.hostlist')
        svc.connect('func-binded', self.__on_func_assigned)
        svc.connect('func-unbinded', self.__on_func_assigned)

        self.populate()
예제 #29
0
    def __on_save_session_as(self, action):
        session = ServiceBus().call('pm.sessions', 'get_current_session')

        if session:
            session.save_as()
예제 #30
0
    def __on_save_session_as(self, action):
        session = ServiceBus().call('pm.sessions', 'get_current_session')

        if session:
            session.save_as()
예제 #31
0
 def __on_new_sequence(self, action):
     ServiceBus().call('pm.sessions', 'create_sequence_session', [])
예제 #32
0
 def __on_create_seq(self, action):
     ServiceBus().call('pm.sessions', 'create_sequence_session',
                       self.get_selected_packets(True))
예제 #33
0
    def __init__(self):
        gobject.GObject.__init__(self)

        self.mainwindow = None
        self.bus = ServiceBus()
        gtk.about_dialog_set_url_hook(self.__about_dialog_url, None)